github/acrn-hypervisor
1
0
Fork 0
mirror of https://github.com/projectacrn/acrn-hypervisor.git synced 2025-06-17 03:07:27 +00:00
Code Issues Projects Releases Wiki Activity

HV: treewide: enforce unsignedness of pcpu_id

Browse Source 
In the hypervisor, physical cpu id is defined as "int" or "uint32_t"
type in the hypervisor. So there are some sign conversion issues
about  physical cpu id (pcpu_id) reported by static analysis tool.
Sign conversion violates the rules of MISRA C:2012.

In this patch, define physical cpu id as "uint16_t" type for all
modules in the hypervisor and change related codes. The valid
range of pcpu_id is 0~65534, INVALID_PCPU_ID is defined to the
invalid pcpu_id for error detection, BROADCAST_PCPU_ID is
broadcast pcpu_id used to notify all valid pcpu.

The type of pcpu_id in the struct vcpu and vcpu_id is "int" type,
this will be fixed in another patch.

V1-->V2:
    *  Change the type of pcpu_id from uint32_t to uint16_t;
    *  Define INVALID_PCPU_ID for error detection;
    *  Define BROADCAST_PCPU_ID to notify all valid pcpu.

V2-->V3:
    *  Update comments for INVALID_PCPU_ID and BROADCAST_PCPU_ID;
    *  Update addtional pcpu_id;
    *  Convert hexadecimals to unsigned to meet the type of pcpu_id;
    *  Clean up for MIN_PCPU_ID and MAX_PCPU_ID, they will be
       defined by configuration.
Note: fix bug in the init_lapic(), the pcpu_id shall be less than 8,
this is constraint by implement in the init_lapic().
Signed-off-by: Xiangyang Wu <xiangyang.wu@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>
This commit is contained in:
Xiangyang Wu 2018-06-20 15:42:52 +08:00 committed by lijinxia
parent 2922a657c9
commit 3027bfab10
37 changed files with 110 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
devicemodel/include/public/acrn_common.h
View File

@ -167,10 +167,10 @@ struct acrn_create_vm {
*/ */
struct acrn_create_vcpu { struct acrn_create_vcpu {
/** the virtual CPU ID for the VCPU created */ /** the virtual CPU ID for the VCPU created */
uint32_t vcpu_id; uint16_t vcpu_id;
/** the physical CPU ID for the VCPU created */ /** the physical CPU ID for the VCPU created */
uint32_t pcpu_id; uint16_t pcpu_id;
} __aligned(8); } __aligned(8);
/** /**

2
hypervisor/arch/x86/assign.c
View File

@ -506,7 +506,7 @@ static void ptdev_intr_handle_irq(struct vm *vm,
} }
} }
void ptdev_softirq(__unused int cpu) void ptdev_softirq(__unused uint16_t cpu_id)
{ {
while (1) { while (1) {
struct ptdev_remapping_info *entry = ptdev_dequeue_softirq(); struct ptdev_remapping_info *entry = ptdev_dequeue_softirq();

7
hypervisor/arch/x86/cpu.c
View File

@ -23,7 +23,7 @@ spinlock_t up_count_spinlock = {
}; };
struct per_cpu_region *per_cpu_data_base_ptr; struct per_cpu_region *per_cpu_data_base_ptr;
int phy_cpu_num = 0; uint16_t phy_cpu_num = 0U;
unsigned long pcpu_sync = 0; unsigned long pcpu_sync = 0;
volatile uint32_t up_count = 0; volatile uint32_t up_count = 0;
@ -224,7 +224,7 @@ static int hardware_detect_support(void)
return 0; return 0;
} }
static void alloc_phy_cpu_data(int pcpu_num) static void alloc_phy_cpu_data(uint16_t pcpu_num)
{ {
phy_cpu_num = pcpu_num; phy_cpu_num = pcpu_num;
@ -245,7 +245,8 @@ int __attribute__((weak)) parse_madt(uint8_t *lapic_id_base)
static int init_phy_cpu_storage(void) static int init_phy_cpu_storage(void)
{ {
int i, pcpu_num = 0; int i;
uint16_t pcpu_num=0U;
int bsp_cpu_id; int bsp_cpu_id;
uint8_t bsp_lapic_id = 0; uint8_t bsp_lapic_id = 0;
uint8_t *lapic_id_base; uint8_t *lapic_id_base;

2
hypervisor/arch/x86/guest/guest.c
View File

@ -47,7 +47,7 @@ inline struct vcpu *vcpu_from_vid(struct vm *vm, int vcpu_id)
return NULL; return NULL;
} }
inline struct vcpu *vcpu_from_pid(struct vm *vm, int pcpu_id) inline struct vcpu *vcpu_from_pid(struct vm *vm, uint16_t pcpu_id)
{ {
int i; int i;
struct vcpu *vcpu; struct vcpu *vcpu;

8
hypervisor/arch/x86/guest/vcpu.c
View File

@ -14,7 +14,7 @@ extern struct efi_ctx* efi_ctx;
vm_sw_loader_t vm_sw_loader; vm_sw_loader_t vm_sw_loader;
struct vcpu *get_ever_run_vcpu(int pcpu_id) struct vcpu *get_ever_run_vcpu(uint16_t pcpu_id)
{ {
return per_cpu(ever_run_vcpu, pcpu_id); return per_cpu(ever_run_vcpu, pcpu_id);
} }
@ -31,7 +31,7 @@ struct vcpu *get_ever_run_vcpu(int pcpu_id)
* for physical CPU 1 : vcpu->pcpu_id = 1, vcpu->vcpu_id = 1, vmid = 1; * for physical CPU 1 : vcpu->pcpu_id = 1, vcpu->vcpu_id = 1, vmid = 1;
* *
***********************************************************************/ ***********************************************************************/
int create_vcpu(int cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle) int create_vcpu(uint16_t cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle)
{ {
struct vcpu *vcpu; struct vcpu *vcpu;
@ -284,7 +284,7 @@ void reset_vcpu(struct vcpu *vcpu)
void pause_vcpu(struct vcpu *vcpu, enum vcpu_state new_state) void pause_vcpu(struct vcpu *vcpu, enum vcpu_state new_state)
{ {
int pcpu_id = get_cpu_id(); uint16_t pcpu_id = get_cpu_id();
pr_dbg("vcpu%d paused, new state: %d", pr_dbg("vcpu%d paused, new state: %d",
vcpu->vcpu_id, new_state); vcpu->vcpu_id, new_state);
@ -334,7 +334,7 @@ void schedule_vcpu(struct vcpu *vcpu)
} }
/* help function for vcpu create */ /* help function for vcpu create */
int prepare_vcpu(struct vm *vm, int pcpu_id) int prepare_vcpu(struct vm *vm, uint16_t pcpu_id)
{ {
int ret = 0; int ret = 0;
struct vcpu *vcpu = NULL; struct vcpu *vcpu = NULL;

4
hypervisor/arch/x86/guest/vlapic.c
View File

@ -115,7 +115,7 @@ vm_lapic_from_vcpu_id(struct vm *vm, int vcpu_id)
} }
struct vlapic * struct vlapic *
vm_lapic_from_pcpuid(struct vm *vm, int pcpu_id) vm_lapic_from_pcpuid(struct vm *vm, uint16_t pcpu_id)
{ {
struct vcpu *vcpu; struct vcpu *vcpu;
@ -125,7 +125,7 @@ vm_lapic_from_pcpuid(struct vm *vm, int pcpu_id)
return vcpu->arch_vcpu.vlapic; return vcpu->arch_vcpu.vlapic;
} }
static int vm_apicid2vcpu_id(struct vm *vm, uint8_t lapicid) static uint16_t vm_apicid2vcpu_id(struct vm *vm, uint8_t lapicid)
{ {
int i; int i;
struct vcpu *vcpu; struct vcpu *vcpu;

2
hypervisor/arch/x86/guest/vpic.c
View File

@ -232,7 +232,7 @@ static void vpic_notify_intr(struct vpic *vpic)
ASSERT(vcpu != NULL, "vm%d, vcpu0", vpic->vm->attr.id); ASSERT(vcpu != NULL, "vm%d, vcpu0", vpic->vm->attr.id);
vcpu_inject_extint(vcpu); vcpu_inject_extint(vcpu);
} else { } else {
vlapic_set_local_intr(vpic->vm, -1, APIC_LVT_LINT0); vlapic_set_local_intr(vpic->vm, BROADCAST_PCPU_ID, APIC_LVT_LINT0);
/* notify vioapic pin0 if existing /* notify vioapic pin0 if existing
* For vPIC + vIOAPIC mode, vpic master irq connected * For vPIC + vIOAPIC mode, vpic master irq connected
* to vioapic pin0 (irq2) * to vioapic pin0 (irq2)

6
hypervisor/arch/x86/intr_lapic.c
View File

@ -211,11 +211,11 @@ int early_init_lapic(void)
return 0; return 0;
} }
int init_lapic(uint32_t cpu_id) int init_lapic(uint16_t cpu_id)
{ {
/* Set the Logical Destination Register */ /* Set the Logical Destination Register */
write_lapic_reg32(LAPIC_LOGICAL_DESTINATION_REGISTER, write_lapic_reg32(LAPIC_LOGICAL_DESTINATION_REGISTER,
(1 << cpu_id) << 24); ((1U << cpu_id) << 24));
/* Set the Destination Format Register */ /* Set the Destination Format Register */
write_lapic_reg32(LAPIC_DESTINATION_FORMAT_REGISTER, 0xf << 28); write_lapic_reg32(LAPIC_DESTINATION_FORMAT_REGISTER, 0xf << 28);
@ -408,7 +408,7 @@ send_startup_ipi(enum intr_cpu_startup_shorthand cpu_startup_shorthand,
return status; return status;
} }
void send_single_ipi(uint32_t pcpu_id, uint32_t vector) void send_single_ipi(uint16_t pcpu_id, uint32_t vector)
{ {
uint32_t dest_lapic_id, hi_32, lo_32; uint32_t dest_lapic_id, hi_32, lo_32;

4
hypervisor/arch/x86/irq.c
View File

@ -385,7 +385,7 @@ uint32_t dev_to_vector(struct dev_handler_node *node)
return node->desc->vector; return node->desc->vector;
} }
int init_default_irqs(unsigned int cpu_id) int init_default_irqs(uint16_t cpu_id)
{ {
if (cpu_id > 0) if (cpu_id > 0)
return 0; return 0;
@ -692,7 +692,7 @@ pri_register_handler(uint32_t irq,
void get_cpu_interrupt_info(char *str, int str_max) void get_cpu_interrupt_info(char *str, int str_max)
{ {
int pcpu_id; uint16_t pcpu_id;
uint32_t irq, vector, len, size = str_max; uint32_t irq, vector, len, size = str_max;
struct irq_desc *desc; struct irq_desc *desc;

2
hypervisor/arch/x86/notify.c
View File

@ -42,7 +42,7 @@ static int request_notification_irq(dev_handler_t func, void *data,
void setup_notification(void) void setup_notification(void)
{ {
int cpu; uint16_t cpu;
char name[32] = {0}; char name[32] = {0};
cpu = get_cpu_id(); cpu = get_cpu_id();

10
hypervisor/arch/x86/softirq.c
View File

@ -6,19 +6,19 @@
#include <hypervisor.h> #include <hypervisor.h>
void disable_softirq(int cpu_id) void disable_softirq(uint16_t cpu_id)
{ {
bitmap_clear(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id)); bitmap_clear(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id));
} }
void enable_softirq(int cpu_id) void enable_softirq(uint16_t cpu_id)
{ {
bitmap_set(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id)); bitmap_set(SOFTIRQ_ATOMIC, &per_cpu(softirq_pending, cpu_id));
} }
void init_softirq(void) void init_softirq(void)
{ {
int cpu_id; uint16_t cpu_id;
for (cpu_id = 0; cpu_id < phy_cpu_num; cpu_id++) { for (cpu_id = 0; cpu_id < phy_cpu_num; cpu_id++) {
per_cpu(softirq_pending, cpu_id) = 0; per_cpu(softirq_pending, cpu_id) = 0;
@ -28,7 +28,7 @@ void init_softirq(void)
void raise_softirq(int softirq_id) void raise_softirq(int softirq_id)
{ {
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id); uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id);
if (cpu_id >= phy_cpu_num) if (cpu_id >= phy_cpu_num)
@ -39,7 +39,7 @@ void raise_softirq(int softirq_id)
void exec_softirq(void) void exec_softirq(void)
{ {
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
volatile uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id); volatile uint64_t *bitmap = &per_cpu(softirq_pending, cpu_id);
int softirq_id; int softirq_id;

12
hypervisor/arch/x86/timer.c
View File

@ -70,7 +70,7 @@ static void __add_timer(struct per_cpu_timers *cpu_timer,
int add_timer(struct timer *timer) int add_timer(struct timer *timer)
{ {
struct per_cpu_timers *cpu_timer; struct per_cpu_timers *cpu_timer;
int pcpu_id; uint16_t pcpu_id;
bool need_update; bool need_update;
if (timer == NULL || timer->func == NULL || timer->fire_tsc == 0) if (timer == NULL || timer->func == NULL || timer->fire_tsc == 0)
@ -99,7 +99,7 @@ void del_timer(struct timer *timer)
list_del_init(&timer->node); list_del_init(&timer->node);
} }
static int request_timer_irq(int pcpu_id, static int request_timer_irq(uint16_t pcpu_id,
dev_handler_t func, void *data, dev_handler_t func, void *data,
const char *name) const char *name)
{ {
@ -125,7 +125,7 @@ static int request_timer_irq(int pcpu_id,
return 0; return 0;
} }
static void init_percpu_timer(int pcpu_id) static void init_percpu_timer(uint16_t pcpu_id)
{ {
struct per_cpu_timers *cpu_timer; struct per_cpu_timers *cpu_timer;
@ -149,7 +149,7 @@ static void init_tsc_deadline_timer(void)
void timer_init(void) void timer_init(void)
{ {
char name[32] = {0}; char name[32] = {0};
int pcpu_id = get_cpu_id(); uint16_t pcpu_id = get_cpu_id();
snprintf(name, 32, "timer_tick[%d]", pcpu_id); snprintf(name, 32, "timer_tick[%d]", pcpu_id);
if (request_timer_irq(pcpu_id, tsc_deadline_handler, NULL, name) < 0) { if (request_timer_irq(pcpu_id, tsc_deadline_handler, NULL, name) < 0) {
@ -163,7 +163,7 @@ void timer_init(void)
void timer_cleanup(void) void timer_cleanup(void)
{ {
int pcpu_id = get_cpu_id(); uint16_t pcpu_id = get_cpu_id();
if (per_cpu(timer_node, pcpu_id) != NULL) if (per_cpu(timer_node, pcpu_id) != NULL)
unregister_handler_common(per_cpu(timer_node, pcpu_id)); unregister_handler_common(per_cpu(timer_node, pcpu_id));
@ -171,7 +171,7 @@ void timer_cleanup(void)
per_cpu(timer_node, pcpu_id) = NULL; per_cpu(timer_node, pcpu_id) = NULL;
} }
void timer_softirq(int pcpu_id) void timer_softirq(uint16_t pcpu_id)
{ {
struct per_cpu_timers *cpu_timer; struct per_cpu_timers *cpu_timer;
struct timer *timer; struct timer *timer;

4
hypervisor/arch/x86/vmx.c
View File

@ -86,7 +86,7 @@ static inline int exec_vmxon(void *addr)
* It will be used again when we start a pcpu after the pcpu was down. * It will be used again when we start a pcpu after the pcpu was down.
* S3 enter/exit will use it. * S3 enter/exit will use it.
*/ */
int exec_vmxon_instr(uint32_t pcpu_id) int exec_vmxon_instr(uint16_t pcpu_id)
{ {
uint64_t tmp64, vmcs_pa; uint64_t tmp64, vmcs_pa;
uint32_t tmp32; uint32_t tmp32;
@ -128,7 +128,7 @@ int exec_vmxon_instr(uint32_t pcpu_id)
return ret; return ret;
} }
int vmx_off(int pcpu_id) int vmx_off(uint16_t pcpu_id)
{ {
int ret = 0; int ret = 0;

6
hypervisor/boot/acpi.c
View File

@ -215,9 +215,9 @@ void *get_acpi_tbl(char *sig)
return HPA2HVA(addr); return HPA2HVA(addr);
} }
static int _parse_madt(void *madt, uint8_t *lapic_id_base) static uint16_t _parse_madt(void *madt, uint8_t *lapic_id_base)
{ {
int pcpu_id = 0; uint16_t pcpu_id = 0;
struct acpi_madt_local_apic *processor; struct acpi_madt_local_apic *processor;
struct acpi_table_madt *madt_ptr; struct acpi_table_madt *madt_ptr;
void *first; void *first;
@ -249,7 +249,7 @@ static int _parse_madt(void *madt, uint8_t *lapic_id_base)
} }
/* The lapic_id info gotten from madt will be returned in lapic_id_base */ /* The lapic_id info gotten from madt will be returned in lapic_id_base */
int parse_madt(uint8_t *lapic_id_base) uint16_t parse_madt(uint8_t *lapic_id_base)
{ {
void *madt; void *madt;

2
hypervisor/boot/include/acpi.h
View File

@ -28,7 +28,7 @@ struct acpi_table_header {
uint32_t asl_compiler_revision; uint32_t asl_compiler_revision;
}; };
int parse_madt(uint8_t *lapic_id_base); uint16_t parse_madt(uint8_t *lapic_id_base);
void *get_dmar_table(void); void *get_dmar_table(void);
#endif /* !ACPI_H */ #endif /* !ACPI_H */

6
hypervisor/common/hv_main.c
View File

@ -99,12 +99,12 @@ void vcpu_thread(struct vcpu *vcpu)
} while (1); } while (1);
} }
static bool is_vm0_bsp(int pcpu_id) static bool is_vm0_bsp(uint16_t pcpu_id)
{ {
return pcpu_id == vm0_desc.vm_hw_logical_core_ids[0]; return pcpu_id == vm0_desc.vm_hw_logical_core_ids[0];
} }
int hv_main(int cpu_id) int hv_main(uint16_t cpu_id)
{ {
int ret; int ret;
@ -117,7 +117,7 @@ int hv_main(int cpu_id)
return -EINVAL; return -EINVAL;
} }
if ((uint32_t) cpu_id != get_cpu_id()) { if (cpu_id != get_cpu_id()) {
pr_err("%s, cpu_id %d mismatch\n", __func__, cpu_id); pr_err("%s, cpu_id %d mismatch\n", __func__, cpu_id);
return -EINVAL; return -EINVAL;
} }

5
hypervisor/common/hypercall.c
View File

@ -205,7 +205,8 @@ int64_t hcall_pause_vm(uint64_t vmid)
int64_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param) int64_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param)
{ {
int ret, pcpu_id; int ret;
uint16_t pcpu_id;
struct acrn_create_vcpu cv; struct acrn_create_vcpu cv;
struct vm *target_vm = get_vm_from_vmid(vmid); struct vm *target_vm = get_vm_from_vmid(vmid);
@ -219,7 +220,7 @@ int64_t hcall_create_vcpu(struct vm *vm, uint64_t vmid, uint64_t param)
} }
pcpu_id = allocate_pcpu(); pcpu_id = allocate_pcpu();
if (-1 == pcpu_id) { if (INVALID_PCPU_ID == pcpu_id) {
pr_err("%s: No physical available\n", __func__); pr_err("%s: No physical available\n", __func__);
return -1; return -1;
} }

22
hypervisor/common/schedule.c
View File

@ -22,12 +22,12 @@ void init_scheduler(void)
} }
} }
void get_schedule_lock(int pcpu_id) void get_schedule_lock(uint16_t pcpu_id)
{ {
spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).scheduler_lock); spinlock_obtain(&per_cpu(sched_ctx, pcpu_id).scheduler_lock);
} }
void release_schedule_lock(int pcpu_id) void release_schedule_lock(uint16_t pcpu_id)
{ {
spinlock_release(&per_cpu(sched_ctx, pcpu_id).scheduler_lock); spinlock_release(&per_cpu(sched_ctx, pcpu_id).scheduler_lock);
} }
@ -41,15 +41,15 @@ int allocate_pcpu(void)
return i; return i;
} }
return -1; return INVALID_PCPU_ID;
} }
void set_pcpu_used(int pcpu_id) void set_pcpu_used(uint16_t pcpu_id)
{ {
bitmap_set(pcpu_id, &pcpu_used_bitmap); bitmap_set(pcpu_id, &pcpu_used_bitmap);
} }
void free_pcpu(int pcpu_id) void free_pcpu(uint16_t pcpu_id)
{ {
bitmap_clear(pcpu_id, &pcpu_used_bitmap); bitmap_clear(pcpu_id, &pcpu_used_bitmap);
} }
@ -74,7 +74,7 @@ void remove_vcpu_from_runqueue(struct vcpu *vcpu)
spinlock_release(&per_cpu(sched_ctx, pcpu_id).runqueue_lock); spinlock_release(&per_cpu(sched_ctx, pcpu_id).runqueue_lock);
} }
static struct vcpu *select_next_vcpu(int pcpu_id) static struct vcpu *select_next_vcpu(uint16_t pcpu_id)
{ {
struct vcpu *vcpu = NULL; struct vcpu *vcpu = NULL;
@ -95,7 +95,7 @@ void make_reschedule_request(struct vcpu *vcpu)
send_single_ipi(vcpu->pcpu_id, VECTOR_NOTIFY_VCPU); send_single_ipi(vcpu->pcpu_id, VECTOR_NOTIFY_VCPU);
} }
int need_reschedule(int pcpu_id) int need_reschedule(uint16_t pcpu_id)
{ {
return bitmap_test_and_clear(NEED_RESCHEDULE, return bitmap_test_and_clear(NEED_RESCHEDULE,
&per_cpu(sched_ctx, pcpu_id).flags); &per_cpu(sched_ctx, pcpu_id).flags);
@ -136,14 +136,14 @@ static void context_switch_in(struct vcpu *vcpu)
*/ */
} }
void make_pcpu_offline(int pcpu_id) void make_pcpu_offline(uint16_t pcpu_id)
{ {
bitmap_set(NEED_OFFLINE, bitmap_set(NEED_OFFLINE,
&per_cpu(sched_ctx, pcpu_id).flags); &per_cpu(sched_ctx, pcpu_id).flags);
send_single_ipi(pcpu_id, VECTOR_NOTIFY_VCPU); send_single_ipi(pcpu_id, VECTOR_NOTIFY_VCPU);
} }
int need_offline(int pcpu_id) int need_offline(uint16_t pcpu_id)
{ {
return bitmap_test_and_clear(NEED_OFFLINE, return bitmap_test_and_clear(NEED_OFFLINE,
&per_cpu(sched_ctx, pcpu_id).flags); &per_cpu(sched_ctx, pcpu_id).flags);
@ -151,7 +151,7 @@ int need_offline(int pcpu_id)
void default_idle(void) void default_idle(void)
{ {
int pcpu_id = get_cpu_id(); uint16_t pcpu_id = get_cpu_id();
while (1) { while (1) {
if (need_reschedule(pcpu_id) != 0) if (need_reschedule(pcpu_id) != 0)
@ -202,7 +202,7 @@ static void switch_to(struct vcpu *curr)
void schedule(void) void schedule(void)
{ {
int pcpu_id = get_cpu_id(); uint16_t pcpu_id = get_cpu_id();
struct vcpu *next = NULL; struct vcpu *next = NULL;
struct vcpu *prev = per_cpu(sched_ctx, pcpu_id).curr_vcpu; struct vcpu *prev = per_cpu(sched_ctx, pcpu_id).curr_vcpu;

4
hypervisor/debug/sbuf.c
View File

@ -153,9 +153,9 @@ int sbuf_put(struct shared_buf *sbuf, uint8_t *data)
return sbuf->ele_size; return sbuf->ele_size;
} }
int sbuf_share_setup(uint32_t pcpu_id, uint32_t sbuf_id, uint64_t *hva) int sbuf_share_setup(uint16_t pcpu_id, uint32_t sbuf_id, uint64_t *hva)
{ {
if (pcpu_id >= (uint32_t) phy_cpu_num || if (pcpu_id >= phy_cpu_num ||
sbuf_id >= ACRN_SBUF_ID_MAX) sbuf_id >= ACRN_SBUF_ID_MAX)
return -EINVAL; return -EINVAL;

8
hypervisor/debug/shell_internal.c
View File

@ -978,11 +978,15 @@ int shell_show_vmexit_profile(struct shell *p_shell,
int shell_dump_logbuf(__unused struct shell *p_shell, int shell_dump_logbuf(__unused struct shell *p_shell,
int argc, char **argv) int argc, char **argv)
{ {
uint32_t pcpu_id; uint16_t pcpu_id;
int val;
int status = -EINVAL; int status = -EINVAL;
if (argc == 2) { if (argc == 2) {
pcpu_id = atoi(argv[1]); val = atoi(argv[1]);
if (val < 0)
return status;
pcpu_id = (uint16_t)val;
print_logmsg_buffer(pcpu_id); print_logmsg_buffer(pcpu_id);
return 0; return 0;
} }

6
hypervisor/include/arch/x86/cpu.h
View File

@ -253,7 +253,7 @@ extern struct cpuinfo_x86 boot_cpu_data;
/* Function prototypes */ /* Function prototypes */
void cpu_dead(uint32_t logical_id); void cpu_dead(uint32_t logical_id);
void trampoline_start16(void); void trampoline_start16(void);
int hv_main(int cpu_id); int hv_main(uint16_t cpu_id);
bool is_vapic_supported(void); bool is_vapic_supported(void);
bool is_vapic_intr_delivery_supported(void); bool is_vapic_intr_delivery_supported(void);
bool is_vapic_virt_reg_supported(void); bool is_vapic_virt_reg_supported(void);
@ -398,12 +398,12 @@ void start_cpus();
} }
/* Macro to get CPU ID */ /* Macro to get CPU ID */
static inline uint32_t get_cpu_id(void) static inline uint16_t get_cpu_id(void)
{ {
uint32_t tsl, tsh, cpu_id; uint32_t tsl, tsh, cpu_id;
asm volatile ("rdtscp":"=a" (tsl), "=d"(tsh), "=c"(cpu_id)::); asm volatile ("rdtscp":"=a" (tsl), "=d"(tsh), "=c"(cpu_id)::);
return cpu_id; return (uint16_t)cpu_id;
} }
static inline uint64_t cpu_rsp_get(void) static inline uint64_t cpu_rsp_get(void)

10
hypervisor/include/arch/x86/cpuid.h
View File

@ -96,6 +96,16 @@
#define CPUID_EXTEND_FUNCTION_4 0x80000004 #define CPUID_EXTEND_FUNCTION_4 0x80000004
#define CPUID_EXTEND_ADDRESS_SIZE 0x80000008 #define CPUID_EXTEND_ADDRESS_SIZE 0x80000008
/**pcpu id type is uint16_t,
*The broadcast id (BROADCAST_PCPU_ID)
* used to notify all valid pcpu,
*the invalid pcpu id (INVALID_PCPU_ID) is error
*code for error handling.
*/
#define INVALID_PCPU_ID 0xffffU
#define BROADCAST_PCPU_ID 0xfffeU
static inline void __cpuid(uint32_t *eax, uint32_t *ebx, static inline void __cpuid(uint32_t *eax, uint32_t *ebx,
uint32_t *ecx, uint32_t *edx) uint32_t *ecx, uint32_t *edx)
{ {

2
hypervisor/include/arch/x86/guest/guest.h
View File

@ -97,7 +97,7 @@ int gva2gpa(struct vcpu *vcpu, uint64_t gva, uint64_t *gpa, uint32_t *err_code);
struct vcpu *get_primary_vcpu(struct vm *vm); struct vcpu *get_primary_vcpu(struct vm *vm);
struct vcpu *vcpu_from_vid(struct vm *vm, int vcpu_id); struct vcpu *vcpu_from_vid(struct vm *vm, int vcpu_id);
struct vcpu *vcpu_from_pid(struct vm *vm, int pcpu_id); struct vcpu *vcpu_from_pid(struct vm *vm, uint16_t pcpu_id);
enum vm_paging_mode get_vcpu_paging_mode(struct vcpu *vcpu); enum vm_paging_mode get_vcpu_paging_mode(struct vcpu *vcpu);

6
hypervisor/include/arch/x86/guest/vcpu.h
View File

@ -259,8 +259,8 @@ struct vcpu {
#define VCPU_RETAIN_RIP(vcpu) ((vcpu)->arch_vcpu.inst_len = 0) #define VCPU_RETAIN_RIP(vcpu) ((vcpu)->arch_vcpu.inst_len = 0)
/* External Interfaces */ /* External Interfaces */
struct vcpu* get_ever_run_vcpu(int pcpu_id); struct vcpu* get_ever_run_vcpu(uint16_t pcpu_id);
int create_vcpu(int cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle); int create_vcpu(uint16_t cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle);
int start_vcpu(struct vcpu *vcpu); int start_vcpu(struct vcpu *vcpu);
int shutdown_vcpu(struct vcpu *vcpu); int shutdown_vcpu(struct vcpu *vcpu);
void destroy_vcpu(struct vcpu *vcpu); void destroy_vcpu(struct vcpu *vcpu);
@ -269,7 +269,7 @@ void reset_vcpu(struct vcpu *vcpu);
void pause_vcpu(struct vcpu *vcpu, enum vcpu_state new_state); void pause_vcpu(struct vcpu *vcpu, enum vcpu_state new_state);
void resume_vcpu(struct vcpu *vcpu); void resume_vcpu(struct vcpu *vcpu);
void schedule_vcpu(struct vcpu *vcpu); void schedule_vcpu(struct vcpu *vcpu);
int prepare_vcpu(struct vm *vm, int pcpu_id); int prepare_vcpu(struct vm *vm, uint16_t pcpu_id);
void request_vcpu_pre_work(struct vcpu *vcpu, int pre_work_id); void request_vcpu_pre_work(struct vcpu *vcpu, int pre_work_id);

2
hypervisor/include/arch/x86/guest/vlapic.h
View File

@ -57,7 +57,7 @@ int vlapic_pending_intr(struct vlapic *vlapic, uint32_t *vecptr);
void vlapic_intr_accepted(struct vlapic *vlapic, uint32_t vector); void vlapic_intr_accepted(struct vlapic *vlapic, uint32_t vector);
struct vlapic *vm_lapic_from_vcpuid(struct vm *vm, int vcpu_id); struct vlapic *vm_lapic_from_vcpuid(struct vm *vm, int vcpu_id);
struct vlapic *vm_lapic_from_pcpuid(struct vm *vm, int pcpu_id); struct vlapic *vm_lapic_from_pcpuid(struct vm *vm, uint16_t pcpu_id);
bool vlapic_msr(uint32_t num); bool vlapic_msr(uint32_t num);
int vlapic_rdmsr(struct vcpu *vcpu, uint32_t msr, uint64_t *rval); int vlapic_rdmsr(struct vcpu *vcpu, uint32_t msr, uint64_t *rval);
int vlapic_wrmsr(struct vcpu *vcpu, uint32_t msr, uint64_t wval); int vlapic_wrmsr(struct vcpu *vcpu, uint32_t msr, uint64_t wval);

2
hypervisor/include/arch/x86/irq.h
View File

@ -115,7 +115,7 @@ int quick_handler_nolock(struct irq_desc *desc, void *handler_data);
typedef int (*irq_handler_t)(struct irq_desc*, void*); typedef int (*irq_handler_t)(struct irq_desc*, void*);
void update_irq_handler(uint32_t irq, irq_handler_t func); void update_irq_handler(uint32_t irq, irq_handler_t func);
int init_default_irqs(unsigned int cpu); int init_default_irqs(uint16_t cpu);
void dispatch_interrupt(struct intr_excp_ctx *ctx); void dispatch_interrupt(struct intr_excp_ctx *ctx);

4
hypervisor/include/arch/x86/lapic.h
View File

@ -158,14 +158,14 @@ struct lapic_regs {
void write_lapic_reg32(uint32_t offset, uint32_t value); void write_lapic_reg32(uint32_t offset, uint32_t value);
void save_lapic(struct lapic_regs *regs); void save_lapic(struct lapic_regs *regs);
int early_init_lapic(void); int early_init_lapic(void);
int init_lapic(uint32_t cpu_id); int init_lapic(uint16_t cpu_id);
void send_lapic_eoi(void); void send_lapic_eoi(void);
uint32_t get_cur_lapic_id(void); uint32_t get_cur_lapic_id(void);
int send_startup_ipi(enum intr_cpu_startup_shorthand cpu_startup_shorthand, int send_startup_ipi(enum intr_cpu_startup_shorthand cpu_startup_shorthand,
uint32_t cpu_startup_dest, uint32_t cpu_startup_dest,
uint64_t cpu_startup_start_address); uint64_t cpu_startup_start_address);
/* API to send an IPI to a single guest */ /* API to send an IPI to a single guest */
void send_single_ipi(uint32_t pcpu_id, uint32_t vector); void send_single_ipi(uint16_t pcpu_id, uint32_t vector);
void suspend_lapic(void); void suspend_lapic(void);
void resume_lapic(void); void resume_lapic(void);

2
hypervisor/include/arch/x86/per_cpu.h
View File

@ -41,7 +41,7 @@ struct per_cpu_region {
} __aligned(CPU_PAGE_SIZE); //per_cpu_region size aligned with CPU_PAGE_SIZE } __aligned(CPU_PAGE_SIZE); //per_cpu_region size aligned with CPU_PAGE_SIZE
extern struct per_cpu_region *per_cpu_data_base_ptr; extern struct per_cpu_region *per_cpu_data_base_ptr;
extern int phy_cpu_num; extern uint16_t phy_cpu_num;
extern uint64_t pcpu_active_bitmap; extern uint64_t pcpu_active_bitmap;
/* /*
* get percpu data for pcpu_id. * get percpu data for pcpu_id.

4
hypervisor/include/arch/x86/softirq.h
View File

@ -15,8 +15,8 @@
/* used for atomic value for prevent recursive */ /* used for atomic value for prevent recursive */
#define SOFTIRQ_ATOMIC 63 #define SOFTIRQ_ATOMIC 63
void enable_softirq(int cpu_id); void enable_softirq(uint16_t cpu_id);
void disable_softirq(int cpu_id); void disable_softirq(uint16_t cpu_id);
void init_softirq(void); void init_softirq(void);
void raise_softirq(int softirq_id); void raise_softirq(int softirq_id);
void exec_softirq(void); void exec_softirq(void);

2
hypervisor/include/arch/x86/timer.h
View File

@ -54,7 +54,7 @@ static inline void initialize_timer(struct timer *timer,
int add_timer(struct timer *timer); int add_timer(struct timer *timer);
void del_timer(struct timer *timer); void del_timer(struct timer *timer);
void timer_softirq(int pcpu_id); void timer_softirq(uint16_t pcpu_id);
void timer_init(void); void timer_init(void);
void timer_cleanup(void); void timer_cleanup(void);
void check_tsc(void); void check_tsc(void);

6
hypervisor/include/arch/x86/vmx.h
View File

@ -401,15 +401,15 @@
#define VMX_SUPPORT_UNRESTRICTED_GUEST (1U<<5) #define VMX_SUPPORT_UNRESTRICTED_GUEST (1U<<5)
/* External Interfaces */ /* External Interfaces */
int exec_vmxon_instr(uint32_t pcpu_id); int exec_vmxon_instr(uint16_t pcpu_id);
uint64_t exec_vmread(uint32_t field); uint64_t exec_vmread(uint32_t field);
uint64_t exec_vmread64(uint32_t field_full); uint64_t exec_vmread64(uint32_t field_full);
void exec_vmwrite(uint32_t field, uint64_t value); void exec_vmwrite(uint32_t field, uint64_t value);
void exec_vmwrite64(uint32_t field_full, uint64_t value); void exec_vmwrite64(uint32_t field_full, uint64_t value);
int init_vmcs(struct vcpu *vcpu); int init_vmcs(struct vcpu *vcpu);
int vmx_off(int pcpu_id); int vmx_off(uint16_t pcpu_id);
int vmx_restart(int pcpu_id); int vmx_restart(uint16_t pcpu_id);
int exec_vmclear(void *addr); int exec_vmclear(void *addr);
int exec_vmptrld(void *addr); int exec_vmptrld(void *addr);

2
hypervisor/include/common/ptdev.h
View File

@ -67,7 +67,7 @@ extern spinlock_t ptdev_lock;
extern struct ptdev_remapping_info invalid_entry; extern struct ptdev_remapping_info invalid_entry;
extern spinlock_t softirq_dev_lock; extern spinlock_t softirq_dev_lock;
void ptdev_softirq(int cpu); void ptdev_softirq(__unused uint16_t cpu);
void ptdev_init(void); void ptdev_init(void);
void ptdev_release_all_entries(struct vm *vm); void ptdev_release_all_entries(struct vm *vm);
void get_ptdev_info(char *str, int str_max); void get_ptdev_info(char *str, int str_max);

14
hypervisor/include/common/schedule.h
View File

@ -19,12 +19,12 @@ struct sched_context {
}; };
void init_scheduler(void); void init_scheduler(void);
void get_schedule_lock(int pcpu_id); void get_schedule_lock(uint16_t pcpu_id);
void release_schedule_lock(int pcpu_id); void release_schedule_lock(uint16_t pcpu_id);
void set_pcpu_used(int pcpu_id); void set_pcpu_used(uint16_t pcpu_id);
int allocate_pcpu(void); int allocate_pcpu(void);
void free_pcpu(int pcpu_id); void free_pcpu(uint16_t pcpu_id);
void add_vcpu_to_runqueue(struct vcpu *vcpu); void add_vcpu_to_runqueue(struct vcpu *vcpu);
void remove_vcpu_from_runqueue(struct vcpu *vcpu); void remove_vcpu_from_runqueue(struct vcpu *vcpu);
@ -32,9 +32,9 @@ void remove_vcpu_from_runqueue(struct vcpu *vcpu);
void default_idle(void); void default_idle(void);
void make_reschedule_request(struct vcpu *vcpu); void make_reschedule_request(struct vcpu *vcpu);
int need_reschedule(int pcpu_id); int need_reschedule(uint16_t pcpu_id);
void make_pcpu_offline(int pcpu_id); void make_pcpu_offline(uint16_t pcpu_id);
int need_offline(int pcpu_id); int need_offline(uint16_t pcpu_id);
void schedule(void); void schedule(void);

4
hypervisor/include/debug/sbuf.h
View File

@ -76,7 +76,7 @@ struct shared_buf *sbuf_allocate(uint32_t ele_num, uint32_t ele_size);
void sbuf_free(struct shared_buf *sbuf); void sbuf_free(struct shared_buf *sbuf);
int sbuf_get(struct shared_buf *sbuf, uint8_t *data); int sbuf_get(struct shared_buf *sbuf, uint8_t *data);
int sbuf_put(struct shared_buf *sbuf, uint8_t *data); int sbuf_put(struct shared_buf *sbuf, uint8_t *data);
int sbuf_share_setup(uint32_t pcpu_id, uint32_t sbuf_id, uint64_t *hva); int sbuf_share_setup(uint16_t pcpu_id, uint32_t sbuf_id, uint64_t *hva);
#else /* HV_DEBUG */ #else /* HV_DEBUG */
@ -125,7 +125,7 @@ static inline int sbuf_put(
} }
static inline int sbuf_share_setup( static inline int sbuf_share_setup(
__unused uint32_t pcpu_id, __unused uint16_t pcpu_id,
__unused uint32_t sbuf_id, __unused uint32_t sbuf_id,
__unused uint64_t *hva) __unused uint64_t *hva)
{ {

12
hypervisor/include/debug/trace.h
View File

@ -73,7 +73,7 @@ struct trace_entry {
} __attribute__((aligned(8))); } __attribute__((aligned(8)));
static inline bool static inline bool
trace_check(int cpu_id, __unused int evid) trace_check(uint16_t cpu_id, __unused int evid)
{ {
if (cpu_id >= phy_cpu_num) if (cpu_id >= phy_cpu_num)
return false; return false;
@ -85,7 +85,7 @@ trace_check(int cpu_id, __unused int evid)
} }
static inline void static inline void
_trace_put(int cpu_id, int evid, struct trace_entry *entry) _trace_put(uint16_t cpu_id, int evid, struct trace_entry *entry)
{ {
struct shared_buf *sbuf = (struct shared_buf *) struct shared_buf *sbuf = (struct shared_buf *)
per_cpu(sbuf, cpu_id)[ACRN_TRACE]; per_cpu(sbuf, cpu_id)[ACRN_TRACE];
@ -99,7 +99,7 @@ static inline void
TRACE_2L(int evid, uint64_t e, uint64_t f) TRACE_2L(int evid, uint64_t e, uint64_t f)
{ {
struct trace_entry entry; struct trace_entry entry;
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
if (!trace_check(cpu_id, evid)) if (!trace_check(cpu_id, evid))
return; return;
@ -114,7 +114,7 @@ TRACE_4I(int evid, uint32_t a, uint32_t b, uint32_t c,
uint32_t d) uint32_t d)
{ {
struct trace_entry entry; struct trace_entry entry;
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
if (!trace_check(cpu_id, evid)) if (!trace_check(cpu_id, evid))
return; return;
@ -131,7 +131,7 @@ TRACE_6C(int evid, uint8_t a1, uint8_t a2, uint8_t a3,
uint8_t a4, uint8_t b1, uint8_t b2) uint8_t a4, uint8_t b1, uint8_t b2)
{ {
struct trace_entry entry; struct trace_entry entry;
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
if (!trace_check(cpu_id, evid)) if (!trace_check(cpu_id, evid))
return; return;
@ -152,7 +152,7 @@ static inline void
TRACE_16STR(int evid, const char name[]) TRACE_16STR(int evid, const char name[])
{ {
struct trace_entry entry; struct trace_entry entry;
int cpu_id = get_cpu_id(); uint16_t cpu_id = get_cpu_id();
int len; int len;
int i; int i;

4
hypervisor/include/public/acrn_common.h
View File

@ -147,10 +147,10 @@ struct acrn_create_vm {
*/ */
struct acrn_create_vcpu { struct acrn_create_vcpu {
/** the virtual CPU ID for the VCPU created */ /** the virtual CPU ID for the VCPU created */
uint32_t vcpu_id; uint16_t vcpu_id;
/** the physical CPU ID for the VCPU created */ /** the physical CPU ID for the VCPU created */
uint32_t pcpu_id; uint16_t pcpu_id;
} __aligned(8); } __aligned(8);
/** /**

2
hypervisor/include/public/acrn_hv_defs.h
View File

@ -169,7 +169,7 @@ struct set_memmaps {
*/ */
struct sbuf_setup_param { struct sbuf_setup_param {
/** sbuf physical cpu id */ /** sbuf physical cpu id */
uint32_t pcpu_id; uint16_t pcpu_id;
/** sbuf id */ /** sbuf id */
uint32_t sbuf_id; uint32_t sbuf_id;