github/acrn-hypervisor
1
0
Fork 0
mirror of https://github.com/projectacrn/acrn-hypervisor.git synced 2025-08-10 04:28:31 +00:00
Code Issues Projects Releases Wiki Activity

HV: common: cleanup of remaining integral-type issues

Browse Source 
This is the final cleanup of the integral type related issues, reported by the
static checker, under common/, mostly including

    * make explicit the narrowings of vm_ids passed by register.
    * work around the confusion of the static checker by abstracting
      sub-expressions to local variables.

The remaining reports that are not trivial to suppress will be in the scope of a
separate document.

v1 -> v2:

    * Instead of converting vm_ids inside hcall_xxx, update the prototypes of
      these functions and do the conversion in vmcall_vmexit_handler.

Signed-off-by: Junjie Mao <junjie.mao@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>
This commit is contained in:
Junjie Mao 2018-07-19 23:35:34 +08:00 committed by lijinxia
parent 112b5b820c
commit f0a3585ebf
7 changed files with 154 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
hypervisor/arch/x86/guest/vmcall.c
View File

@ -55,47 +55,60 @@ int vmcall_vmexit_handler(struct vcpu *vcpu)
break; break;
case HC_DESTROY_VM: case HC_DESTROY_VM:
ret = hcall_destroy_vm(param1); /* param1: vmid */
ret = hcall_destroy_vm((uint16_t)param1);
break; break;
case HC_START_VM: case HC_START_VM:
ret = hcall_resume_vm(param1); /* param1: vmid */
ret = hcall_resume_vm((uint16_t)param1);
break; break;
case HC_PAUSE_VM: case HC_PAUSE_VM:
ret = hcall_pause_vm(param1); /* param1: vmid */
ret = hcall_pause_vm((uint16_t)param1);
break; break;
case HC_CREATE_VCPU: case HC_CREATE_VCPU:
ret = hcall_create_vcpu(vm, param1, param2); /* param1: vmid */
ret = hcall_create_vcpu(vm, (uint16_t)param1, param2);
break; break;
case HC_ASSERT_IRQLINE: case HC_ASSERT_IRQLINE:
ret = hcall_assert_irqline(vm, param1, param2); /* param1: vmid */
ret = hcall_assert_irqline(vm, (uint16_t)param1, param2);
break; break;
case HC_DEASSERT_IRQLINE: case HC_DEASSERT_IRQLINE:
ret = hcall_deassert_irqline(vm, param1, param2); /* param1: vmid */
ret = hcall_deassert_irqline(vm, (uint16_t)param1, param2);
break; break;
case HC_PULSE_IRQLINE: case HC_PULSE_IRQLINE:
ret = hcall_pulse_irqline(vm, param1, param2); /* param1: vmid */
ret = hcall_pulse_irqline(vm, (uint16_t)param1, param2);
break; break;
case HC_INJECT_MSI: case HC_INJECT_MSI:
ret = hcall_inject_msi(vm, param1, param2); /* param1: vmid */
ret = hcall_inject_msi(vm, (uint16_t)param1, param2);
break; break;
case HC_SET_IOREQ_BUFFER: case HC_SET_IOREQ_BUFFER:
ret = hcall_set_ioreq_buffer(vm, param1, param2); /* param1: vmid */
ret = hcall_set_ioreq_buffer(vm, (uint16_t)param1, param2);
break; break;
case HC_NOTIFY_REQUEST_FINISH: case HC_NOTIFY_REQUEST_FINISH:
ret = hcall_notify_req_finish(param1, param2); /* param1: vmid
* param2: vcpu_id */
ret = hcall_notify_req_finish((uint16_t)param1,
(uint16_t)param2);
break; break;
case HC_VM_SET_MEMMAP: case HC_VM_SET_MEMMAP:
ret = hcall_set_vm_memmap(vm, param1, param2); /* param1: vmid */
ret = hcall_set_vm_memmap(vm, (uint16_t)param1, param2);
break; break;
case HC_VM_SET_MEMMAPS: case HC_VM_SET_MEMMAPS:
@ -103,27 +116,33 @@ int vmcall_vmexit_handler(struct vcpu *vcpu)
break; break;
case HC_VM_PCI_MSIX_REMAP: case HC_VM_PCI_MSIX_REMAP:
ret = hcall_remap_pci_msix(vm, param1, param2); /* param1: vmid */
ret = hcall_remap_pci_msix(vm, (uint16_t)param1, param2);
break; break;
case HC_VM_GPA2HPA: case HC_VM_GPA2HPA:
ret = hcall_gpa_to_hpa(vm, param1, param2); /* param1: vmid */
ret = hcall_gpa_to_hpa(vm, (uint16_t)param1, param2);
break; break;
case HC_ASSIGN_PTDEV: case HC_ASSIGN_PTDEV:
ret = hcall_assign_ptdev(vm, param1, param2); /* param1: vmid */
ret = hcall_assign_ptdev(vm, (uint16_t)param1, param2);
break; break;
case HC_DEASSIGN_PTDEV: case HC_DEASSIGN_PTDEV:
ret = hcall_deassign_ptdev(vm, param1, param2); /* param1: vmid */
ret = hcall_deassign_ptdev(vm, (uint16_t)param1, param2);
break; break;
case HC_SET_PTDEV_INTR_INFO: case HC_SET_PTDEV_INTR_INFO:
ret = hcall_set_ptdev_intr_info(vm, param1, param2); /* param1: vmid */
ret = hcall_set_ptdev_intr_info(vm, (uint16_t)param1, param2);
break; break;
case HC_RESET_PTDEV_INTR_INFO: case HC_RESET_PTDEV_INTR_INFO:
ret = hcall_reset_ptdev_intr_info(vm, param1, param2); /* param1: vmid */
ret = hcall_reset_ptdev_intr_info(vm, (uint16_t)param1, param2);
break; break;
case HC_SETUP_SBUF: case HC_SETUP_SBUF:

53
hypervisor/common/hypercall.c
View File

@ -113,8 +113,8 @@ handle_virt_irqline(struct vm *vm, uint16_t target_vmid,
/* Call vpic for pic injection */ /* Call vpic for pic injection */
ret = handle_vpic_irqline(target_vm, param->pic_irq, mode); ret = handle_vpic_irqline(target_vm, param->pic_irq, mode);
/* call vioapic for ioapic injection if ioapic_irq != ~0UL*/ /* call vioapic for ioapic injection if ioapic_irq != ~0U*/
if (param->ioapic_irq != (~0UL)) { if (param->ioapic_irq != (~0U)) {
/* handle IOAPIC irqline */ /* handle IOAPIC irqline */
ret = handle_vioapic_irqline(target_vm, ret = handle_vioapic_irqline(target_vm,
param->ioapic_irq, mode); param->ioapic_irq, mode);
@ -172,7 +172,7 @@ int32_t hcall_create_vm(struct vm *vm, uint64_t param)
return ret; return ret;
} }
int32_t hcall_destroy_vm(uint64_t vmid) int32_t hcall_destroy_vm(uint16_t vmid)
{ {
int32_t ret = 0; int32_t ret = 0;
struct vm *target_vm = get_vm_from_vmid(vmid); struct vm *target_vm = get_vm_from_vmid(vmid);
@ -185,7 +185,7 @@ int32_t hcall_destroy_vm(uint64_t vmid)
return ret; return ret;
} }
int32_t hcall_resume_vm(uint64_t vmid) int32_t hcall_resume_vm(uint16_t vmid)
{ {
int32_t ret = 0; int32_t ret = 0;
struct vm *target_vm = get_vm_from_vmid(vmid); struct vm *target_vm = get_vm_from_vmid(vmid);
@ -202,7 +202,7 @@ int32_t hcall_resume_vm(uint64_t vmid)
return ret; return ret;
} }
int32_t hcall_pause_vm(uint64_t vmid) int32_t hcall_pause_vm(uint16_t vmid)
{ {
struct vm *target_vm = get_vm_from_vmid(vmid); struct vm *target_vm = get_vm_from_vmid(vmid);
@ -215,7 +215,7 @@ int32_t hcall_pause_vm(uint64_t vmid)
return 0; return 0;
} }
int32_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_create_vcpu(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret; int32_t ret;
uint16_t pcpu_id; uint16_t pcpu_id;
@ -242,7 +242,7 @@ int32_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_assert_irqline(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_assert_irqline(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct acrn_irqline irqline; struct acrn_irqline irqline;
@ -251,12 +251,12 @@ int32_t hcall_assert_irqline(struct vm *vm, uint64_t vmid, uint64_t param)
pr_err("%s: Unable copy param to vm\n", __func__); pr_err("%s: Unable copy param to vm\n", __func__);
return -1; return -1;
} }
ret = handle_virt_irqline(vm, (uint16_t)vmid, &irqline, IRQ_ASSERT); ret = handle_virt_irqline(vm, vmid, &irqline, IRQ_ASSERT);
return ret; return ret;
} }
int32_t hcall_deassert_irqline(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_deassert_irqline(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct acrn_irqline irqline; struct acrn_irqline irqline;
@ -265,12 +265,12 @@ int32_t hcall_deassert_irqline(struct vm *vm, uint64_t vmid, uint64_t param)
pr_err("%s: Unable copy param to vm\n", __func__); pr_err("%s: Unable copy param to vm\n", __func__);
return -1; return -1;
} }
ret = handle_virt_irqline(vm, (uint16_t)vmid, &irqline, IRQ_DEASSERT); ret = handle_virt_irqline(vm, vmid, &irqline, IRQ_DEASSERT);
return ret; return ret;
} }
int32_t hcall_pulse_irqline(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_pulse_irqline(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct acrn_irqline irqline; struct acrn_irqline irqline;
@ -279,12 +279,12 @@ int32_t hcall_pulse_irqline(struct vm *vm, uint64_t vmid, uint64_t param)
pr_err("%s: Unable copy param to vm\n", __func__); pr_err("%s: Unable copy param to vm\n", __func__);
return -1; return -1;
} }
ret = handle_virt_irqline(vm, (uint16_t)vmid, &irqline, IRQ_PULSE); ret = handle_virt_irqline(vm, vmid, &irqline, IRQ_PULSE);
return ret; return ret;
} }
int32_t hcall_inject_msi(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_inject_msi(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct acrn_msi_entry msi; struct acrn_msi_entry msi;
@ -304,7 +304,7 @@ int32_t hcall_inject_msi(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_set_ioreq_buffer(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_set_ioreq_buffer(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
uint64_t hpa = 0UL; uint64_t hpa = 0UL;
@ -370,7 +370,7 @@ static void complete_request(struct vcpu *vcpu)
resume_vcpu(vcpu); resume_vcpu(vcpu);
} }
int32_t hcall_notify_req_finish(uint64_t vmid, uint64_t vcpu_id) int32_t hcall_notify_req_finish(uint16_t vmid, uint16_t vcpu_id)
{ {
union vhm_request_buffer *req_buf; union vhm_request_buffer *req_buf;
struct vhm_request *req; struct vhm_request *req;
@ -386,7 +386,7 @@ int32_t hcall_notify_req_finish(uint64_t vmid, uint64_t vcpu_id)
dev_dbg(ACRN_DBG_HYCALL, "[%d] NOTIFY_FINISH for vcpu %d", dev_dbg(ACRN_DBG_HYCALL, "[%d] NOTIFY_FINISH for vcpu %d",
vmid, vcpu_id); vmid, vcpu_id);
vcpu = vcpu_from_vid(target_vm, (uint16_t)vcpu_id); vcpu = vcpu_from_vid(target_vm, vcpu_id);
if (vcpu == NULL) { if (vcpu == NULL) {
pr_err("%s, failed to get VCPU %d context from VM %d\n", pr_err("%s, failed to get VCPU %d context from VM %d\n",
__func__, vcpu_id, target_vm->attr.id); __func__, vcpu_id, target_vm->attr.id);
@ -410,7 +410,7 @@ _set_vm_memmap(struct vm *vm, struct vm *target_vm,
struct vm_set_memmap *memmap) struct vm_set_memmap *memmap)
{ {
uint64_t hpa, base_paddr; uint64_t hpa, base_paddr;
uint32_t attr, prot; uint64_t attr, prot;
if ((memmap->length & 0xFFFUL) != 0UL) { if ((memmap->length & 0xFFFUL) != 0UL) {
pr_err("%s: ERROR! [vm%d] map size 0x%x is not page aligned", pr_err("%s: ERROR! [vm%d] map size 0x%x is not page aligned",
@ -462,7 +462,7 @@ _set_vm_memmap(struct vm *vm, struct vm *target_vm,
memmap->remote_gpa, memmap->length, memmap->type, attr); memmap->remote_gpa, memmap->length, memmap->type, attr);
} }
int32_t hcall_set_vm_memmap(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_set_vm_memmap(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
struct vm_set_memmap memmap; struct vm_set_memmap memmap;
struct vm *target_vm = get_vm_from_vmid(vmid); struct vm *target_vm = get_vm_from_vmid(vmid);
@ -534,7 +534,7 @@ int32_t hcall_set_vm_memmaps(struct vm *vm, uint64_t param)
return 0; return 0;
} }
int32_t hcall_remap_pci_msix(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_remap_pci_msix(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct acrn_vm_pci_msix_remap remap; struct acrn_vm_pci_msix_remap remap;
@ -575,7 +575,7 @@ int32_t hcall_remap_pci_msix(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_gpa_to_hpa(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_gpa_to_hpa(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct vm_gpa2hpa v_gpa2hpa; struct vm_gpa2hpa v_gpa2hpa;
@ -600,7 +600,7 @@ int32_t hcall_gpa_to_hpa(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_assign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_assign_ptdev(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret; int32_t ret;
uint16_t bdf; uint16_t bdf;
@ -638,7 +638,7 @@ int32_t hcall_assign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_deassign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_deassign_ptdev(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
uint16_t bdf; uint16_t bdf;
@ -658,7 +658,7 @@ int32_t hcall_deassign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param)
return ret; return ret;
} }
int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint64_t vmid, uint64_t param) int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct hc_ptdev_irq irq; struct hc_ptdev_irq irq;
@ -693,7 +693,7 @@ int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint64_t vmid, uint64_t param)
} }
int32_t int32_t
hcall_reset_ptdev_intr_info(struct vm *vm, uint64_t vmid, uint64_t param) hcall_reset_ptdev_intr_info(struct vm *vm, uint16_t vmid, uint64_t param)
{ {
int32_t ret = 0; int32_t ret = 0;
struct hc_ptdev_irq irq; struct hc_ptdev_irq irq;
@ -752,7 +752,7 @@ int32_t hcall_get_cpu_pm_state(struct vm *vm, uint64_t cmd, uint64_t param)
uint16_t target_vm_id; uint16_t target_vm_id;
struct vm *target_vm; struct vm *target_vm;
target_vm_id = (cmd & PMCMD_VMID_MASK) >> PMCMD_VMID_SHIFT; target_vm_id = (uint16_t)((cmd & PMCMD_VMID_MASK) >> PMCMD_VMID_SHIFT);
target_vm = get_vm_from_vmid(target_vm_id); target_vm = get_vm_from_vmid(target_vm_id);
if (target_vm == NULL) { if (target_vm == NULL) {
@ -820,7 +820,8 @@ int32_t hcall_get_cpu_pm_state(struct vm *vm, uint64_t cmd, uint64_t param)
return -1; return -1;
} }
cx_idx = (cmd & PMCMD_STATE_NUM_MASK) >> PMCMD_STATE_NUM_SHIFT; cx_idx = (uint8_t)
((cmd & PMCMD_STATE_NUM_MASK) >> PMCMD_STATE_NUM_SHIFT);
if ((cx_idx == 0U) || (cx_idx > target_vm->pm.cx_cnt)) { if ((cx_idx == 0U) || (cx_idx > target_vm->pm.cx_cnt)) {
return -1; return -1;
} }

12
hypervisor/common/io_request.c
View File

@ -87,9 +87,9 @@ int32_t acrn_insert_request_wait(struct vcpu *vcpu, struct vhm_request *req)
* before we perform upcall. * before we perform upcall.
* because VHM can work in pulling mode without wait for upcall * because VHM can work in pulling mode without wait for upcall
*/ */
req_buf->req_queue[cur].valid = true; req_buf->req_queue[cur].valid = 1;
acrn_print_request(vcpu->vcpu_id, req_buf->req_queue + cur); acrn_print_request(vcpu->vcpu_id, &req_buf->req_queue[cur]);
/* signal VHM */ /* signal VHM */
fire_vhm_interrupt(); fire_vhm_interrupt();
@ -99,11 +99,11 @@ int32_t acrn_insert_request_wait(struct vcpu *vcpu, struct vhm_request *req)
#ifdef HV_DEBUG #ifdef HV_DEBUG
static void _get_req_info_(struct vhm_request *req, int *id, char *type, static void _get_req_info_(struct vhm_request *req, int *id, char *type,
char *state, char *dir, int64_t *addr, long *val) char *state, char *dir, uint64_t *addr, uint64_t *val)
{ {
(void)strcpy_s(dir, 16U, "NONE"); (void)strcpy_s(dir, 16U, "NONE");
*addr = 0; *addr = 0UL;
*val = 0; *val = 0UL;
*id = req->client; *id = req->client;
switch (req->type) { switch (req->type) {
@ -158,7 +158,7 @@ void get_req_info(char *str, int str_max)
union vhm_request_buffer *req_buf; union vhm_request_buffer *req_buf;
struct vhm_request *req; struct vhm_request *req;
char type[16], state[16], dir[16]; char type[16], state[16], dir[16];
int64_t addr, val; uint64_t addr, val;
struct list_head *pos; struct list_head *pos;
struct vm *vm; struct vm *vm;

2
hypervisor/common/ptdev.c
View File

@ -177,5 +177,3 @@ void ptdev_release_all_entries(struct vm *vm)
release_all_entries(vm); release_all_entries(vm);
spinlock_release(&ptdev_lock); spinlock_release(&ptdev_lock);
} }

66
hypervisor/common/schedule.c
View File

@ -11,25 +11,30 @@ static unsigned long pcpu_used_bitmap;
void init_scheduler(void) void init_scheduler(void)
{ {
struct sched_context *ctx;
uint32_t i; uint32_t i;
for (i = 0U; i < phys_cpu_num; i++) { for (i = 0U; i < phys_cpu_num; i++) {
spinlock_init(&per_cpu(sched_ctx, i).runqueue_lock); ctx = &per_cpu(sched_ctx, i);
spinlock_init(&per_cpu(sched_ctx, i).scheduler_lock);
INIT_LIST_HEAD(&per_cpu(sched_ctx, i).runqueue); spinlock_init(&ctx->runqueue_lock);
per_cpu(sched_ctx, i).flags = 0UL; spinlock_init(&ctx->scheduler_lock);
per_cpu(sched_ctx, i).curr_vcpu = NULL; INIT_LIST_HEAD(&ctx->runqueue);
ctx->flags = 0UL;
ctx->curr_vcpu = NULL;
} }
} }
void get_schedule_lock(uint16_t pcpu_id) void get_schedule_lock(uint16_t pcpu_id)
{ {
spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).scheduler_lock); struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
spinlock_obtain(&ctx->scheduler_lock);
} }
void release_schedule_lock(uint16_t pcpu_id) void release_schedule_lock(uint16_t pcpu_id)
{ {
spinlock_release(&per_cpu(sched_ctx, pcpu_id).scheduler_lock); struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
spinlock_release(&ctx->scheduler_lock);
} }
uint16_t allocate_pcpu(void) uint16_t allocate_pcpu(void)
@ -57,50 +62,53 @@ void free_pcpu(uint16_t pcpu_id)
void add_vcpu_to_runqueue(struct vcpu *vcpu) void add_vcpu_to_runqueue(struct vcpu *vcpu)
{ {
int pcpu_id = vcpu->pcpu_id; uint16_t pcpu_id = vcpu->pcpu_id;
struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_obtain(&ctx->runqueue_lock);
if (list_empty(&vcpu->run_list)) { if (list_empty(&vcpu->run_list)) {
list_add_tail(&vcpu->run_list, list_add_tail(&vcpu->run_list, &ctx->runqueue);
&per_cpu(sched_ctx, pcpu_id).runqueue);
} }
spinlock_release(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_release(&ctx->runqueue_lock);
} }
void remove_vcpu_from_runqueue(struct vcpu *vcpu) void remove_vcpu_from_runqueue(struct vcpu *vcpu)
{ {
int pcpu_id = vcpu->pcpu_id; uint16_t pcpu_id = vcpu->pcpu_id;
struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_obtain(&ctx->runqueue_lock);
list_del_init(&vcpu->run_list); list_del_init(&vcpu->run_list);
spinlock_release(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_release(&ctx->runqueue_lock);
} }
static struct vcpu *select_next_vcpu(uint16_t pcpu_id) static struct vcpu *select_next_vcpu(uint16_t pcpu_id)
{ {
struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
struct vcpu *vcpu = NULL; struct vcpu *vcpu = NULL;
spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_obtain(&ctx->runqueue_lock);
if (!list_empty(&per_cpu(sched_ctx, pcpu_id).runqueue)) { if (!list_empty(&ctx->runqueue)) {
vcpu = get_first_item(&per_cpu(sched_ctx, pcpu_id).runqueue, vcpu = get_first_item(&ctx->runqueue, struct vcpu, run_list);
struct vcpu, run_list);
} }
spinlock_release(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_release(&ctx->runqueue_lock);
return vcpu; return vcpu;
} }
void make_reschedule_request(struct vcpu *vcpu) void make_reschedule_request(struct vcpu *vcpu)
{ {
bitmap_set(NEED_RESCHEDULE, struct sched_context *ctx = &per_cpu(sched_ctx, vcpu->pcpu_id);
&per_cpu(sched_ctx, vcpu->pcpu_id).flags);
bitmap_set(NEED_RESCHEDULE, &ctx->flags);
send_single_ipi(vcpu->pcpu_id, VECTOR_NOTIFY_VCPU); send_single_ipi(vcpu->pcpu_id, VECTOR_NOTIFY_VCPU);
} }
int need_reschedule(uint16_t pcpu_id) int need_reschedule(uint16_t pcpu_id)
{ {
return bitmap_test_and_clear(NEED_RESCHEDULE, struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
&per_cpu(sched_ctx, pcpu_id).flags);
return bitmap_test_and_clear(NEED_RESCHEDULE, &ctx->flags);
} }
static void context_switch_out(struct vcpu *vcpu) static void context_switch_out(struct vcpu *vcpu)
@ -142,15 +150,17 @@ static void context_switch_in(struct vcpu *vcpu)
void make_pcpu_offline(uint16_t pcpu_id) void make_pcpu_offline(uint16_t pcpu_id)
{ {
bitmap_set(NEED_OFFLINE, struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
&per_cpu(sched_ctx, pcpu_id).flags);
bitmap_set(NEED_OFFLINE, &ctx->flags);
send_single_ipi(pcpu_id, VECTOR_NOTIFY_VCPU); send_single_ipi(pcpu_id, VECTOR_NOTIFY_VCPU);
} }
int need_offline(uint16_t pcpu_id) int need_offline(uint16_t pcpu_id)
{ {
return bitmap_test_and_clear(NEED_OFFLINE, struct sched_context *ctx = &per_cpu(sched_ctx, pcpu_id);
&per_cpu(sched_ctx, pcpu_id).flags);
return bitmap_test_and_clear(NEED_OFFLINE, &ctx->flags);
} }
void default_idle(void) void default_idle(void)

56
hypervisor/common/vm_load.c
View File

@ -27,8 +27,9 @@ static uint64_t create_zero_page(struct vm *vm)
{ {
struct zero_page *zeropage; struct zero_page *zeropage;
struct sw_linux *sw_linux = &(vm->sw.linux_info); struct sw_linux *sw_linux = &(vm->sw.linux_info);
struct sw_kernel_info *sw_kernel = &(vm->sw.kernel_info);
struct zero_page *hva; struct zero_page *hva;
uint64_t gpa; uint64_t gpa, addr;
/* Set zeropage in Linux Guest RAM region just past boot args */ /* Set zeropage in Linux Guest RAM region just past boot args */
hva = GPA2HVA(vm, (uint64_t)sw_linux->bootargs_load_addr); hva = GPA2HVA(vm, (uint64_t)sw_linux->bootargs_load_addr);
@ -38,7 +39,7 @@ static uint64_t create_zero_page(struct vm *vm)
(void)memset(zeropage, 0U, MEM_2K); (void)memset(zeropage, 0U, MEM_2K);
/* copy part of the header into the zero page */ /* copy part of the header into the zero page */
hva = GPA2HVA(vm, (uint64_t)vm->sw.kernel_info.kernel_load_addr); hva = GPA2HVA(vm, (uint64_t)sw_kernel->kernel_load_addr);
(void)memcpy_s(&(zeropage->hdr), sizeof(zeropage->hdr), (void)memcpy_s(&(zeropage->hdr), sizeof(zeropage->hdr),
&(hva->hdr), sizeof(hva->hdr)); &(hva->hdr), sizeof(hva->hdr));
@ -46,21 +47,21 @@ static uint64_t create_zero_page(struct vm *vm)
if (sw_linux->ramdisk_src_addr != NULL) { if (sw_linux->ramdisk_src_addr != NULL) {
/* Copy ramdisk load_addr and size in zeropage header structure /* Copy ramdisk load_addr and size in zeropage header structure
*/ */
zeropage->hdr.ramdisk_addr = addr = (uint64_t)sw_linux->ramdisk_load_addr;
(uint32_t)(uint64_t)sw_linux->ramdisk_load_addr; zeropage->hdr.ramdisk_addr = (uint32_t)addr;
zeropage->hdr.ramdisk_size = (uint32_t)sw_linux->ramdisk_size; zeropage->hdr.ramdisk_size = (uint32_t)sw_linux->ramdisk_size;
} }
/* Copy bootargs load_addr in zeropage header structure */ /* Copy bootargs load_addr in zeropage header structure */
zeropage->hdr.bootargs_addr = addr = (uint64_t)sw_linux->bootargs_load_addr;
(uint32_t)(uint64_t)sw_linux->bootargs_load_addr; zeropage->hdr.bootargs_addr = (uint32_t)addr;
/* set constant arguments in zero page */ /* set constant arguments in zero page */
zeropage->hdr.loader_type = 0xffU; zeropage->hdr.loader_type = 0xffU;
zeropage->hdr.load_flags |= (1U << 5U); /* quiet */ zeropage->hdr.load_flags |= (1U << 5U); /* quiet */
/* Create/add e820 table entries in zeropage */ /* Create/add e820 table entries in zeropage */
zeropage->e820_nentries = create_e820_table(zeropage->e820); zeropage->e820_nentries = (uint8_t)create_e820_table(zeropage->e820);
/* Get the host physical address of the zeropage */ /* Get the host physical address of the zeropage */
gpa = hpa2gpa(vm, HVA2HPA((uint64_t)zeropage)); gpa = hpa2gpa(vm, HVA2HPA((uint64_t)zeropage));
@ -81,7 +82,7 @@ int load_guest(struct vm *vm, struct vcpu *vcpu)
lowmem_gpa_top = *(uint64_t *)hva; lowmem_gpa_top = *(uint64_t *)hva;
/* hardcode vcpu entry addr(kernel entry) & rsi (zeropage)*/ /* hardcode vcpu entry addr(kernel entry) & rsi (zeropage)*/
(void)memset(cur_context->guest_cpu_regs.longs, (void)memset((void*)cur_context->guest_cpu_regs.longs,
0U, sizeof(uint64_t)*NUM_GPRS); 0U, sizeof(uint64_t)*NUM_GPRS);
hva = GPA2HVA(vm, lowmem_gpa_top - hva = GPA2HVA(vm, lowmem_gpa_top -
@ -109,6 +110,8 @@ int general_sw_loader(struct vm *vm, struct vcpu *vcpu)
char dyn_bootargs[100] = {0}; char dyn_bootargs[100] = {0};
uint32_t kernel_entry_offset; uint32_t kernel_entry_offset;
struct zero_page *zeropage; struct zero_page *zeropage;
struct sw_linux *sw_linux = &(vm->sw.linux_info);
struct sw_kernel_info *sw_kernel = &(vm->sw.kernel_info);
ASSERT(vm != NULL, "Incorrect argument"); ASSERT(vm != NULL, "Incorrect argument");
@ -120,31 +123,30 @@ int general_sw_loader(struct vm *vm, struct vcpu *vcpu)
} }
/* calculate the kernel entry point */ /* calculate the kernel entry point */
zeropage = (struct zero_page *) zeropage = (struct zero_page *)sw_kernel->kernel_src_addr;
vm->sw.kernel_info.kernel_src_addr;
kernel_entry_offset = (uint32_t)(zeropage->hdr.setup_sects + 1U) * 512U; kernel_entry_offset = (uint32_t)(zeropage->hdr.setup_sects + 1U) * 512U;
if (vcpu->arch_vcpu.cpu_mode == CPU_MODE_64BIT) { if (vcpu->arch_vcpu.cpu_mode == CPU_MODE_64BIT) {
/* 64bit entry is the 512bytes after the start */ /* 64bit entry is the 512bytes after the start */
kernel_entry_offset += 512U; kernel_entry_offset += 512U;
} }
vm->sw.kernel_info.kernel_entry_addr = sw_kernel->kernel_entry_addr =
(void *)((uint64_t)vm->sw.kernel_info.kernel_load_addr (void *)((uint64_t)sw_kernel->kernel_load_addr
+ kernel_entry_offset); + kernel_entry_offset);
if (is_vcpu_bsp(vcpu)) { if (is_vcpu_bsp(vcpu)) {
/* Set VCPU entry point to kernel entry */ /* Set VCPU entry point to kernel entry */
vcpu->entry_addr = vm->sw.kernel_info.kernel_entry_addr; vcpu->entry_addr = sw_kernel->kernel_entry_addr;
pr_info("%s, VM *d VCPU %hu Entry: 0x%016llx ", pr_info("%s, VM *d VCPU %hu Entry: 0x%016llx ",
__func__, vm->attr.id, vcpu->vcpu_id, vcpu->entry_addr); __func__, vm->attr.id, vcpu->vcpu_id, vcpu->entry_addr);
} }
/* Calculate the host-physical address where the guest will be loaded */ /* Calculate the host-physical address where the guest will be loaded */
hva = GPA2HVA(vm, (uint64_t)vm->sw.kernel_info.kernel_load_addr); hva = GPA2HVA(vm, (uint64_t)sw_kernel->kernel_load_addr);
/* Copy the guest kernel image to its run-time location */ /* Copy the guest kernel image to its run-time location */
(void)memcpy_s((void *)hva, vm->sw.kernel_info.kernel_size, (void)memcpy_s((void *)hva, sw_kernel->kernel_size,
vm->sw.kernel_info.kernel_src_addr, sw_kernel->kernel_src_addr,
vm->sw.kernel_info.kernel_size); sw_kernel->kernel_size);
/* See if guest is a Linux guest */ /* See if guest is a Linux guest */
if (vm->sw.kernel_type == VM_LINUX_GUEST) { if (vm->sw.kernel_type == VM_LINUX_GUEST) {
@ -156,11 +158,11 @@ int general_sw_loader(struct vm *vm, struct vcpu *vcpu)
/* Get host-physical address for guest bootargs */ /* Get host-physical address for guest bootargs */
hva = GPA2HVA(vm, hva = GPA2HVA(vm,
(uint64_t)vm->sw.linux_info.bootargs_load_addr); (uint64_t)sw_linux->bootargs_load_addr);
/* Copy Guest OS bootargs to its load location */ /* Copy Guest OS bootargs to its load location */
(void)strcpy_s((char *)hva, MEM_2K, (void)strcpy_s((char *)hva, MEM_2K,
vm->sw.linux_info.bootargs_src_addr); sw_linux->bootargs_src_addr);
#ifdef CONFIG_CMA #ifdef CONFIG_CMA
/* add "cma=XXXXM@0xXXXXXXXX" to cmdline*/ /* add "cma=XXXXM@0xXXXXXXXX" to cmdline*/
@ -169,8 +171,8 @@ int general_sw_loader(struct vm *vm, struct vcpu *vcpu)
(e820_mem.max_ram_blk_size >> 20), (e820_mem.max_ram_blk_size >> 20),
e820_mem.max_ram_blk_base); e820_mem.max_ram_blk_base);
(void)strcpy_s((char *)hva (void)strcpy_s((char *)hva
+vm->sw.linux_info.bootargs_size, + sw_linux->bootargs_size,
100, dyn_bootargs); 100U, dyn_bootargs);
} }
#else #else
/* add "hugepagesz=1G hugepages=x" to cmdline for 1G hugepage /* add "hugepagesz=1G hugepages=x" to cmdline for 1G hugepage
@ -192,23 +194,23 @@ int general_sw_loader(struct vm *vm, struct vcpu *vcpu)
" hugepagesz=1G hugepages=%d", " hugepagesz=1G hugepages=%d",
reserving_1g_pages); reserving_1g_pages);
(void)strcpy_s((char *)hva (void)strcpy_s((char *)hva
+vm->sw.linux_info.bootargs_size, + sw_linux->bootargs_size,
100U, dyn_bootargs); 100U, dyn_bootargs);
} }
} }
#endif #endif
/* Check if a RAM disk is present with Linux guest */ /* Check if a RAM disk is present with Linux guest */
if (vm->sw.linux_info.ramdisk_src_addr != NULL) { if (sw_linux->ramdisk_src_addr != NULL) {
/* Get host-physical address for guest RAM disk */ /* Get host-physical address for guest RAM disk */
hva = GPA2HVA(vm, hva = GPA2HVA(vm,
(uint64_t)vm->sw.linux_info.ramdisk_load_addr); (uint64_t)sw_linux->ramdisk_load_addr);
/* Copy RAM disk to its load location */ /* Copy RAM disk to its load location */
(void)memcpy_s((void *)hva, (void)memcpy_s((void *)hva,
vm->sw.linux_info.ramdisk_size, sw_linux->ramdisk_size,
vm->sw.linux_info.ramdisk_src_addr, sw_linux->ramdisk_src_addr,
vm->sw.linux_info.ramdisk_size); sw_linux->ramdisk_size);
} }

36
hypervisor/include/common/hypercall.h
View File

@ -62,7 +62,7 @@ int32_t hcall_create_vm(struct vm *vm, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_destroy_vm(uint64_t vmid); int32_t hcall_destroy_vm(uint16_t vmid);
/** /**
* @brief resume virtual machine * @brief resume virtual machine
@ -75,7 +75,7 @@ int32_t hcall_destroy_vm(uint64_t vmid);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_resume_vm(uint64_t vmid); int32_t hcall_resume_vm(uint16_t vmid);
/** /**
* @brief pause virtual machine * @brief pause virtual machine
@ -88,7 +88,7 @@ int32_t hcall_resume_vm(uint64_t vmid);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_pause_vm(uint64_t vmid); int32_t hcall_pause_vm(uint16_t vmid);
/** /**
* @brief create vcpu * @brief create vcpu
@ -104,7 +104,7 @@ int32_t hcall_pause_vm(uint64_t vmid);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_create_vcpu(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief assert IRQ line * @brief assert IRQ line
@ -119,7 +119,7 @@ int32_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_assert_irqline(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_assert_irqline(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief deassert IRQ line * @brief deassert IRQ line
@ -134,7 +134,7 @@ int32_t hcall_assert_irqline(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_deassert_irqline(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_deassert_irqline(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief trigger a pulse on IRQ line * @brief trigger a pulse on IRQ line
@ -149,7 +149,7 @@ int32_t hcall_deassert_irqline(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_pulse_irqline(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_pulse_irqline(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief inject MSI interrupt * @brief inject MSI interrupt
@ -163,7 +163,7 @@ int32_t hcall_pulse_irqline(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_inject_msi(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_inject_msi(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief set ioreq shared buffer * @brief set ioreq shared buffer
@ -178,7 +178,7 @@ int32_t hcall_inject_msi(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_set_ioreq_buffer(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_set_ioreq_buffer(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief notify request done * @brief notify request done
@ -187,11 +187,11 @@ int32_t hcall_set_ioreq_buffer(struct vm *vm, uint64_t vmid, uint64_t param);
* The function will return -1 if the target VM does not exist. * The function will return -1 if the target VM does not exist.
* *
* @param vmid ID of the VM * @param vmid ID of the VM
* @param param vcpu ID of the requestor * @param vcpu_id vcpu ID of the requestor
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_notify_req_finish(uint64_t vmid, uint64_t param); int32_t hcall_notify_req_finish(uint16_t vmid, uint16_t vcpu_id);
/** /**
* @brief setup ept memory mapping * @brief setup ept memory mapping
@ -206,7 +206,7 @@ int32_t hcall_notify_req_finish(uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_set_vm_memmap(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_set_vm_memmap(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief setup ept memory mapping for multi regions * @brief setup ept memory mapping for multi regions
@ -232,7 +232,7 @@ int32_t hcall_set_vm_memmaps(struct vm *vm, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_remap_pci_msix(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_remap_pci_msix(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief translate guest physical address to host physical address * @brief translate guest physical address to host physical address
@ -246,7 +246,7 @@ int32_t hcall_remap_pci_msix(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_gpa_to_hpa(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_gpa_to_hpa(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief Assign one passthrough dev to VM. * @brief Assign one passthrough dev to VM.
@ -258,7 +258,7 @@ int32_t hcall_gpa_to_hpa(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_assign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_assign_ptdev(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief Deassign one passthrough dev from VM. * @brief Deassign one passthrough dev from VM.
@ -270,7 +270,7 @@ int32_t hcall_assign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_deassign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_deassign_ptdev(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief Set interrupt mapping info of ptdev. * @brief Set interrupt mapping info of ptdev.
@ -282,7 +282,7 @@ int32_t hcall_deassign_ptdev(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint64_t vmid, uint64_t param); int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint16_t vmid, uint64_t param);
/** /**
* @brief Clear interrupt mapping info of ptdev. * @brief Clear interrupt mapping info of ptdev.
@ -294,7 +294,7 @@ int32_t hcall_set_ptdev_intr_info(struct vm *vm, uint64_t vmid, uint64_t param);
* *
* @return 0 on success, non-zero on error. * @return 0 on success, non-zero on error.
*/ */
int32_t hcall_reset_ptdev_intr_info(struct vm *vm, uint64_t vmid, int32_t hcall_reset_ptdev_intr_info(struct vm *vm, uint16_t vmid,
uint64_t param); uint64_t param);
/** /**