HV: treewide: enforce unsignedness of pcpu_id

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>

hypervisor/include/arch/x86/cpu.h

@@ -253,7 +253,7 @@ extern struct cpuinfo_x86 boot_cpu_data;
 /* Function prototypes */
 void cpu_dead(uint32_t logical_id);
 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_intr_delivery_supported(void);
 bool is_vapic_virt_reg_supported(void);
@@ -398,12 +398,12 @@ void start_cpus();
 }
 
 /* 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;
 
 	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)

hypervisor/include/arch/x86/cpuid.h

@@ -96,6 +96,16 @@
 #define CPUID_EXTEND_FUNCTION_4      0x80000004
 #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,
 				uint32_t *ecx, uint32_t *edx)
 {

hypervisor/include/arch/x86/guest/guest.h

@@ -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 *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);
 

hypervisor/include/arch/x86/guest/vcpu.h

@@ -259,8 +259,8 @@ struct vcpu {
 #define VCPU_RETAIN_RIP(vcpu)               ((vcpu)->arch_vcpu.inst_len = 0)
 
 /* External Interfaces */
-struct vcpu* get_ever_run_vcpu(int pcpu_id);
-int create_vcpu(int cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle);
+struct vcpu* get_ever_run_vcpu(uint16_t pcpu_id);
+int create_vcpu(uint16_t cpu_id, struct vm *vm, struct vcpu **rtn_vcpu_handle);
 int start_vcpu(struct vcpu *vcpu);
 int shutdown_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 resume_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);
 

hypervisor/include/arch/x86/guest/vlapic.h

@@ -57,7 +57,7 @@ int vlapic_pending_intr(struct vlapic *vlapic, uint32_t *vecptr);
 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_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);
 int vlapic_rdmsr(struct vcpu *vcpu, uint32_t msr, uint64_t *rval);
 int vlapic_wrmsr(struct vcpu *vcpu, uint32_t msr, uint64_t wval);

hypervisor/include/arch/x86/irq.h

@@ -115,7 +115,7 @@ int quick_handler_nolock(struct irq_desc *desc, void *handler_data);
 typedef int (*irq_handler_t)(struct irq_desc*, void*);
 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);
 

hypervisor/include/arch/x86/lapic.h

@@ -158,14 +158,14 @@ struct lapic_regs {
 void write_lapic_reg32(uint32_t offset, uint32_t value);
 void save_lapic(struct lapic_regs *regs);
 int early_init_lapic(void);
-int init_lapic(uint32_t cpu_id);
+int init_lapic(uint16_t cpu_id);
 void send_lapic_eoi(void);
 uint32_t get_cur_lapic_id(void);
 int send_startup_ipi(enum intr_cpu_startup_shorthand cpu_startup_shorthand,
 		uint32_t cpu_startup_dest,
 		uint64_t cpu_startup_start_address);
 /* 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 resume_lapic(void);

hypervisor/include/arch/x86/per_cpu.h

@@ -41,7 +41,7 @@ struct per_cpu_region {
 } __aligned(CPU_PAGE_SIZE); //per_cpu_region size aligned with CPU_PAGE_SIZE
 
 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;
 /*
  * get percpu data for pcpu_id.

hypervisor/include/arch/x86/softirq.h

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

hypervisor/include/arch/x86/timer.h

@@ -54,7 +54,7 @@ static inline void initialize_timer(struct timer *timer,
 int add_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_cleanup(void);
 void check_tsc(void);

hypervisor/include/arch/x86/vmx.h

@@ -401,15 +401,15 @@
 #define VMX_SUPPORT_UNRESTRICTED_GUEST (1U<<5)
 
 /* 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_vmread64(uint32_t field_full);
 void exec_vmwrite(uint32_t field, uint64_t value);
 void exec_vmwrite64(uint32_t field_full, uint64_t value);
 int init_vmcs(struct vcpu *vcpu);
 
-int vmx_off(int pcpu_id);
-int vmx_restart(int pcpu_id);
+int vmx_off(uint16_t pcpu_id);
+int vmx_restart(uint16_t pcpu_id);
 
 int exec_vmclear(void *addr);
 int exec_vmptrld(void *addr);

hypervisor/include/common/ptdev.h

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

hypervisor/include/common/schedule.h

@@ -19,12 +19,12 @@ struct sched_context {
 };
 
 void init_scheduler(void);
-void get_schedule_lock(int pcpu_id);
-void release_schedule_lock(int pcpu_id);
+void get_schedule_lock(uint16_t 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);
-void free_pcpu(int pcpu_id);
+void free_pcpu(uint16_t pcpu_id);
 
 void add_vcpu_to_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 make_reschedule_request(struct vcpu *vcpu);
-int need_reschedule(int pcpu_id);
-void make_pcpu_offline(int pcpu_id);
-int need_offline(int pcpu_id);
+int need_reschedule(uint16_t pcpu_id);
+void make_pcpu_offline(uint16_t pcpu_id);
+int need_offline(uint16_t pcpu_id);
 
 void schedule(void);
 

hypervisor/include/debug/sbuf.h

@@ -76,7 +76,7 @@ struct shared_buf *sbuf_allocate(uint32_t ele_num, uint32_t ele_size);
 void sbuf_free(struct shared_buf *sbuf);
 int sbuf_get(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 */
 
@@ -125,7 +125,7 @@ static inline int sbuf_put(
 }
 
 static inline int sbuf_share_setup(
-		__unused uint32_t pcpu_id,
+		__unused uint16_t pcpu_id,
 		__unused uint32_t sbuf_id,
 		__unused uint64_t *hva)
 {

hypervisor/include/debug/trace.h

@@ -73,7 +73,7 @@ struct trace_entry {
 } __attribute__((aligned(8)));
 
 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)
 		return false;
@@ -85,7 +85,7 @@ trace_check(int cpu_id, __unused int evid)
 }
 
 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 *)
 				per_cpu(sbuf, cpu_id)[ACRN_TRACE];
@@ -99,7 +99,7 @@ static inline void
 TRACE_2L(int evid, uint64_t e, uint64_t f)
 {
 	struct trace_entry entry;
-	int cpu_id = get_cpu_id();
+	uint16_t cpu_id = get_cpu_id();
 
 	if (!trace_check(cpu_id, evid))
 		return;
@@ -114,7 +114,7 @@ TRACE_4I(int evid, uint32_t a, uint32_t b, uint32_t c,
 		uint32_t d)
 {
 	struct trace_entry entry;
-	int cpu_id = get_cpu_id();
+	uint16_t cpu_id = get_cpu_id();
 
 	if (!trace_check(cpu_id, evid))
 		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)
 {
 	struct trace_entry entry;
-	int cpu_id = get_cpu_id();
+	uint16_t cpu_id = get_cpu_id();
 
 	if (!trace_check(cpu_id, evid))
 		return;
@@ -152,7 +152,7 @@ static inline void
 TRACE_16STR(int evid, const char name[])
 {
 	struct trace_entry entry;
-	int cpu_id = get_cpu_id();
+	uint16_t cpu_id = get_cpu_id();
 	int len;
 	int i;
 

hypervisor/include/public/acrn_common.h

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

hypervisor/include/public/acrn_hv_defs.h

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