HV:treewide:fix "Attempt to change parameter passed by value"

In the function scope,the parameter should not be
changed as Misra required.
V1->V2 recover some violations because of ldra's false positive.
V2->V3 sync local variable' type to parameter's type with the prefix of const.

Signed-off-by: Huihuang Shi <huihuang.shi@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>

hypervisor/arch/x86/cpuid.c

@@ -7,11 +7,12 @@
 #include <hypervisor.h>
 
 static inline struct vcpuid_entry *find_vcpuid_entry(struct vcpu *vcpu,
-					uint32_t leaf, uint32_t subleaf)
+					uint32_t leaf_arg, uint32_t subleaf)
 {
 	uint32_t i = 0U, nr, half;
 	struct vcpuid_entry *entry = NULL;
 	struct vm *vm = vcpu->vm;
+	uint32_t leaf = leaf_arg;
 
 	nr = vm->vcpuid_entry_nr;
 	half = nr / 2U;

hypervisor/arch/x86/ept.c

@@ -485,12 +485,15 @@ int ept_misconfig_vmexit_handler(__unused struct vcpu *vcpu)
 	return status;
 }
 
-int ept_mr_add(struct vm *vm, uint64_t hpa,
-	uint64_t gpa, uint64_t size, uint32_t prot)
+int ept_mr_add(struct vm *vm, uint64_t hpa_arg,
+	uint64_t gpa_arg, uint64_t size, uint32_t prot_arg)
 {
 	struct map_params map_params;
 	uint16_t i;
 	struct vcpu *vcpu;
+	uint64_t hpa = hpa_arg;
+	uint64_t gpa = gpa_arg;
+	uint32_t prot = prot_arg;
 
 	/* Setup memory map parameters */
 	map_params.page_table_type = PTT_EPT;
@@ -536,12 +539,14 @@ int ept_mr_modify(struct vm *vm, uint64_t *pml4_page,
 	return ret;
 }
 
-int ept_mr_del(struct vm *vm, uint64_t hpa,
-		uint64_t gpa, uint64_t size)
+int ept_mr_del(struct vm *vm, uint64_t hpa_arg,
+		uint64_t gpa_arg, uint64_t size)
 {
 	struct map_params map_params;
 	uint16_t i;
 	struct vcpu *vcpu;
+	uint64_t hpa = hpa_arg;
+	uint64_t gpa = gpa_arg;
 
 	/* Setup memory map parameters */
 	map_params.page_table_type = PTT_EPT;

hypervisor/arch/x86/guest/guest.c

@@ -352,10 +352,12 @@ static inline uint32_t _copy_gpa(struct vm *vm, void *h_ptr, uint64_t gpa,
 	return len;
 }
 
-static inline int copy_gpa(struct vm *vm, void *h_ptr, uint64_t gpa,
-	uint32_t size, bool cp_from_vm)
+static inline int copy_gpa(struct vm *vm, void *h_ptr, uint64_t gpa_arg,
+	uint32_t size_arg, bool cp_from_vm)
 {
 	uint32_t len;
+	uint64_t gpa = gpa_arg;
+	uint32_t size = size_arg;
 
 	if (vm == NULL) {
 		pr_err("guest phy addr copy need vm param");
@@ -376,12 +378,14 @@ static inline int copy_gpa(struct vm *vm, void *h_ptr, uint64_t gpa,
 	return 0;
 }
 
-static inline int copy_gva(struct vcpu *vcpu, void *h_ptr, uint64_t gva,
-	uint32_t size, uint32_t *err_code, bool cp_from_vm)
+static inline int copy_gva(struct vcpu *vcpu, void *h_ptr, uint64_t gva_arg,
+	uint32_t size_arg, uint32_t *err_code, bool cp_from_vm)
 {
 	uint64_t gpa = 0UL;
 	int32_t ret;
 	uint32_t len;
+	uint64_t gva = gva_arg;
+	uint32_t size = size_arg;
 
 	if (vcpu == NULL) {
 		pr_err("guest virt addr copy need vcpu param");
@@ -639,9 +643,10 @@ int prepare_vm0_memmap_and_e820(struct vm *vm)
 	return 0;
 }
 
-uint64_t e820_alloc_low_memory(uint32_t size)
+uint64_t e820_alloc_low_memory(uint32_t size_arg)
 {
 	uint32_t i;
+	uint32_t size = size_arg;
 	struct e820_entry *entry, *new_entry;
 
 	/* We want memory in page boundary and integral multiple of pages */

hypervisor/arch/x86/guest/instr_emul.c

@@ -309,10 +309,11 @@ vie_write_bytereg(struct vcpu *vcpu, struct vie *vie, uint8_t byte)
 
 int
 vie_update_register(struct vcpu *vcpu, enum cpu_reg_name reg,
-		uint64_t val, uint8_t size)
+		uint64_t val_arg, uint8_t size)
 {
 	int error;
 	uint64_t origval;
+	uint64_t val = val_arg;
 
 	switch (size) {
 	case 1U:
@@ -1572,10 +1573,12 @@ vie_size2mask(uint8_t size)
 
 int
 vie_calculate_gla(enum vm_cpu_mode cpu_mode, enum cpu_reg_name seg,
-	struct seg_desc *desc, uint64_t offset, uint8_t length,
+	struct seg_desc *desc, uint64_t offset_arg, uint8_t length_arg,
 	uint8_t addrsize, uint32_t prot, uint64_t *gla)
 {
 	uint64_t firstoff, low_limit, high_limit, segbase;
+	uint64_t offset = offset_arg;
+	uint8_t length = length_arg;
 	uint8_t glasize;
 	uint32_t type;
 

hypervisor/arch/x86/guest/instr_emul.h

@@ -57,7 +57,7 @@ int vmm_emulate_instruction(struct vcpu *vcpu, uint64_t gpa, struct vie *vie,
 		mem_region_write_t mrw, void *mrarg);
 
 int vie_update_register(struct vcpu *vcpu, enum cpu_reg_name reg,
-		uint64_t val, uint8_t size);
+		uint64_t val_arg, uint8_t size);
 
 /*
  * Returns 1 if an alignment check exception should be injected and 0 otherwise.
@@ -71,8 +71,8 @@ int vie_canonical_check(enum vm_cpu_mode cpu_mode, uint64_t gla);
 uint64_t vie_size2mask(uint8_t size);
 
 int vie_calculate_gla(enum vm_cpu_mode cpu_mode, enum cpu_reg_name seg,
-	struct seg_desc *desc, uint64_t off, uint8_t length, uint8_t addrsize,
-	uint32_t prot, uint64_t *gla);
+	struct seg_desc *desc, uint64_t offset_arg, uint8_t length_arg,
+	uint8_t addrsize, uint32_t prot, uint64_t *gla);
 
 int vie_init(struct vie *vie, struct vcpu *vcpu);
 

hypervisor/arch/x86/guest/vlapic.c

@@ -409,9 +409,10 @@ static uint64_t vlapic_get_tsc_deadline_msr(struct vlapic *vlapic)
 }
 
 static void vlapic_set_tsc_deadline_msr(struct vlapic *vlapic,
-			uint64_t val)
+			uint64_t val_arg)
 {
 	struct timer *timer;
+	uint64_t val = val_arg;
 
 	if (!vlapic_lvtt_tsc_deadline(vlapic)) {
 		return;
@@ -1299,11 +1300,12 @@ vlapic_svr_write_handler(struct vlapic *vlapic)
 }
 
 static int
-vlapic_read(struct vlapic *vlapic, int mmio_access, uint32_t offset,
+vlapic_read(struct vlapic *vlapic, int mmio_access, uint32_t offset_arg,
 		uint64_t *data)
 {
 	struct lapic_regs *lapic = vlapic->apic_page;
 	uint32_t i;
+	uint32_t offset = offset_arg;
 
 	if (mmio_access == 0) {
 		/*
@@ -1830,11 +1832,12 @@ vlapic_set_intr(struct vcpu *vcpu, uint32_t vector, bool level)
 }
 
 int
-vlapic_set_local_intr(struct vm *vm, uint16_t vcpu_id, uint32_t vector)
+vlapic_set_local_intr(struct vm *vm, uint16_t vcpu_id_arg, uint32_t vector)
 {
 	struct vlapic *vlapic;
 	uint64_t dmask = 0UL;
 	int error;
+	uint16_t vcpu_id = vcpu_id_arg;
 
 	if ((vcpu_id != BROADCAST_CPU_ID) && (vcpu_id >= phys_cpu_num)) {
 		return -EINVAL;

hypervisor/arch/x86/guest/vmsr.c

@@ -25,11 +25,12 @@ static const uint32_t emulated_msrs[] = {
  */
 };
 
-static void enable_msr_interception(uint8_t *bitmap, uint32_t msr)
+static void enable_msr_interception(uint8_t *bitmap, uint32_t msr_arg)
 {
 	uint8_t *read_map;
 	uint8_t *write_map;
 	uint8_t value;
+	uint32_t msr = msr_arg;
 	/* low MSR */
 	if (msr < 0x1FFFU) {
 		read_map = bitmap;
@@ -51,11 +52,12 @@ static void enable_msr_interception(uint8_t *bitmap, uint32_t msr)
 }
 
 /* not used now just leave it for some cases it may be used as API*/
-static void disable_msr_interception(uint8_t *bitmap, uint32_t msr)
+static void disable_msr_interception(uint8_t *bitmap, uint32_t msr_arg)
 {
 	uint8_t *read_map;
 	uint8_t *write_map;
 	uint8_t value;
+	uint32_t msr = msr_arg;
 	/* low MSR */
 	if (msr < 0x1FFFU) {
 		read_map = bitmap;

hypervisor/arch/x86/guest/vpic.c

@@ -335,9 +335,10 @@ static int vpic_icw4(struct vpic *vpic, struct pic *pic, uint8_t val)
 	return 0;
 }
 
-bool vpic_is_pin_mask(struct vpic *vpic, uint8_t virt_pin)
+bool vpic_is_pin_mask(struct vpic *vpic, uint8_t virt_pin_arg)
 {
 	struct pic *pic;
+	uint8_t virt_pin = virt_pin_arg;
 
 	if (virt_pin < 8U) {
 		pic = &vpic->pic[0];

hypervisor/arch/x86/irq.c

@@ -200,12 +200,13 @@ irq_desc_append_dev(struct irq_desc *desc, void *node, bool share)
 }
 
 static struct dev_handler_node*
-common_register_handler(uint32_t irq,
+common_register_handler(uint32_t irq_arg,
 		struct irq_request_info *info)
 {
 	struct dev_handler_node *node = NULL;
 	struct irq_desc *desc;
 	bool added = false;
+	uint32_t irq = irq_arg;
 
 	/* ======================================================
 	 * This is low level ISR handler registering function

hypervisor/arch/x86/mmu.c

@@ -209,8 +209,9 @@ bool check_mmu_1gb_support(enum _page_table_type page_table_type)
 
 static inline uint32_t
 check_page_table_present(enum _page_table_type page_table_type,
-		uint64_t table_entry)
+		uint64_t table_entry_arg)
 {
+	uint64_t table_entry = table_entry_arg;
 	if (page_table_type == PTT_EPT) {
 		table_entry &= (IA32E_EPT_R_BIT | IA32E_EPT_W_BIT |
 				IA32E_EPT_X_BIT);
@@ -234,11 +235,12 @@ check_page_table_present(enum _page_table_type page_table_type,
 }
 
 static uint32_t map_mem_region(void *vaddr, void *paddr,
-		void *table_base, uint64_t attr, uint32_t table_level,
+		void *table_base, uint64_t attr_arg, uint32_t table_level,
 		enum _page_table_type table_type,
 		enum mem_map_request_type request_type)
 {
 	uint64_t table_entry;
+	uint64_t attr = attr_arg;
 	uint32_t table_offset;
 	uint32_t mapped_size;
 
@@ -630,10 +632,12 @@ void free_paging_struct(void *ptr)
 	}
 }
 
-bool check_continuous_hpa(struct vm *vm, uint64_t gpa, uint64_t size)
+bool check_continuous_hpa(struct vm *vm, uint64_t gpa_arg, uint64_t size_arg)
 {
 	uint64_t curr_hpa = 0UL;
 	uint64_t next_hpa = 0UL;
+	uint64_t gpa = gpa_arg;
+	uint64_t size = size_arg;
 
 	/* if size <= PAGE_SIZE_4K, it is continuous,no need check
 	 * if size > PAGE_SIZE_4K, need to fetch next page