HV: handle integral issues as MISRA-C report

mainly focus on: like U/UL as unsigned suffix;
char and int mix usage; also change some function's params
for data type consistent.

Signed-off-by: Minggui Cao <minggui.cao@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>

Author: mgcao

hypervisor/arch/x86/trusty.c

@@ -359,7 +359,7 @@ static bool setup_trusty_info(struct vcpu *vcpu,
 	(void)memcpy_s(&mem->first_page.data.key_info, sizeof(g_key_info),
 			&g_key_info, sizeof(g_key_info));
 
-	(void)memset(mem->first_page.data.key_info.dseed_list, 0,
+	(void)memset(mem->first_page.data.key_info.dseed_list, 0U,
 			sizeof(mem->first_page.data.key_info.dseed_list));
 	/* Derive dvseed from dseed for Trusty */
 	key_info = &mem->first_page.data.key_info;
@@ -370,7 +370,7 @@ static bool setup_trusty_info(struct vcpu *vcpu,
 				BUP_MKHI_BOOTLOADER_SEED_LEN,
 				NULL, 0U,
 				vcpu->vm->GUID, sizeof(vcpu->vm->GUID)) == 0) {
-			(void)memset(key_info, 0, sizeof(struct key_info));
+			(void)memset(key_info, 0U, sizeof(struct key_info));
 			pr_err("%s: derive dvseed failed!", __func__);
 			return false;
 		}
@@ -439,7 +439,7 @@ bool initialize_trusty(struct vcpu *vcpu, uint64_t param)
 	struct vm *vm = vcpu->vm;
 	struct trusty_boot_param boot_param;
 
-	memset(&boot_param, 0, sizeof(boot_param));
+	memset(&boot_param, 0U, sizeof(boot_param));
 	if (copy_from_gpa(vcpu->vm, &boot_param, param, sizeof(boot_param))) {
 		pr_err("%s: Unable to copy trusty_boot_param\n", __func__);
 		return false;
@@ -497,7 +497,7 @@ void trusty_set_dseed(void *dseed, uint8_t dseed_num)
 		(dseed_num > BOOTLOADER_SEED_MAX_ENTRIES)) {
 
 		g_key_info.num_seeds = 1U;
-		(void)memset(g_key_info.dseed_list[0].seed, 0xA5,
+		(void)memset(g_key_info.dseed_list[0].seed, 0xA5U,
 			sizeof(g_key_info.dseed_list[0].seed));
 		return;
 	}

hypervisor/arch/x86/trusty2.c

@@ -53,7 +53,7 @@ uint64_t gpa2hpa_for_trusty(struct vm *vm, uint64_t gpa)
  *
  */
 void create_secure_world_ept(struct vm *vm, uint64_t gpa_orig,
-		int64_t size, uint64_t gpa_rebased)
+		uint64_t size, uint64_t gpa_rebased)
 {
 	uint64_t nworld_pml4e = 0UL;
 	uint64_t sworld_pml4e = 0UL;

hypervisor/boot/sbl/hob_parse.c

@@ -10,7 +10,7 @@
 void parse_seed_list(struct seed_list_hob *seed_hob)
 {
 	uint8_t i;
-	uint8_t dseed_index = 0;
+	uint8_t dseed_index = 0U;
 	struct seed_entry *entry;
 	struct seed_info dseed_list[BOOTLOADER_SEED_MAX_ENTRIES];
 
@@ -19,15 +19,15 @@ void parse_seed_list(struct seed_list_hob *seed_hob)
 		goto fail;
 	}
 
-	if (seed_hob->total_seed_count == 0) {
+	if (seed_hob->total_seed_count == 0U) {
 		pr_warn("Total seed count is 0. Use fake seed!");
 		goto fail;
 	}
 
 	entry = (struct seed_entry *)((uint8_t *)seed_hob +
 					sizeof(struct seed_list_hob));
 
-	for (i = 0; i < seed_hob->total_seed_count; i++) {
+	for (i = 0U; i < seed_hob->total_seed_count; i++) {
 		/* retrieve dseed */
 		if ((SEED_ENTRY_TYPE_SVNSEED == entry->type) &&
 			(SEED_ENTRY_USAGE_DSEED == entry->usage)) {
@@ -52,18 +52,18 @@ void parse_seed_list(struct seed_list_hob *seed_hob)
 			dseed_index++;
 
 			/* erase original seed in seed entry */
-			(void)memset(entry->seed, 0, sizeof(struct seed_info));
+			(void)memset(entry->seed, 0U, sizeof(struct seed_info));
 		}
 
 		entry = (struct seed_entry *)((uint8_t *)entry +
 						entry->seed_entry_size);
 	}
 
 	trusty_set_dseed(dseed_list, dseed_index);
-	(void)memset(dseed_list, 0, sizeof(dseed_list));
+	(void)memset(dseed_list, 0U, sizeof(dseed_list));
 	return;
 
 fail:
-	trusty_set_dseed(NULL, 0);
-	(void)memset(dseed_list, 0, sizeof(dseed_list));
+	trusty_set_dseed(NULL, 0U);
+	(void)memset(dseed_list, 0U, sizeof(dseed_list));
 }

hypervisor/boot/sbl/multiboot.c

@@ -11,7 +11,7 @@
 
 #define BOOT_ARGS_LOAD_ADDR				0x24EFC000
 
-#define ACRN_DBG_BOOT	6
+#define ACRN_DBG_BOOT	6U
 
 /* There are two sources for vm0 kernel cmdline:
  * - cmdline from sbl. mbi->cmdline
@@ -22,12 +22,12 @@ static char kernel_cmdline[MEM_2K];
 
 /* now modules support: FIRMWARE & RAMDISK & SeedList */
 static void parse_other_modules(struct vm *vm,
-	struct multiboot_module *mods, int mods_count)
+	struct multiboot_module *mods, uint32_t mods_count)
 {
-	int i = 0;
+	uint32_t i;
 
-	for (i = 0; i < mods_count; i++) {
-		int type_len = 0;
+	for (i = 0U; i < mods_count; i++) {
+		uint32_t type_len;
 		const char *start = HPA2HVA((uint64_t)mods[i].mm_string);
 		const char *end;
 		void *mod_addr = HPA2HVA((uint64_t)mods[i].mm_mod_start);
@@ -43,13 +43,13 @@ static void parse_other_modules(struct vm *vm,
 		}
 
 		end = start;
-		while (*end != ' ' && (*end) != 0) {
+		while (*end != ' ' && (*end) != '\0') {
 			end++;
 		}
 
 		type_len = end - start;
 		if (strncmp("FIRMWARE", start, type_len) == 0) {
-			char  dyn_bootargs[100] = {0};
+			char  dyn_bootargs[100] = {'\0'};
 			void *load_addr = GPA2HVA(vm,
 				(uint64_t)vm->sw.linux_info.bootargs_load_addr);
 			uint32_t args_size = vm->sw.linux_info.bootargs_size;
@@ -63,23 +63,23 @@ static void parse_other_modules(struct vm *vm,
 			/*copy boot args to load addr, set src=load addr*/
 			if (copy_once != 0) {
 				copy_once = 0;
-				(void)strcpy_s(load_addr, MEM_2K,
-					vm->sw.linux_info.bootargs_src_addr);
+				(void)strcpy_s(load_addr, MEM_2K, (const
+				char *)vm->sw.linux_info.bootargs_src_addr);
 				vm->sw.linux_info.bootargs_src_addr = load_addr;
 			}
 
 			(void)strcpy_s(load_addr + args_size,
-				100, dyn_bootargs);
+				100U, dyn_bootargs);
 			vm->sw.linux_info.bootargs_size =
 				strnlen_s(load_addr, MEM_2K);
 
 		} else if (strncmp("RAMDISK", start, type_len) == 0) {
 			vm->sw.linux_info.ramdisk_src_addr = mod_addr;
 			vm->sw.linux_info.ramdisk_load_addr =
-				mods[i].mm_mod_start;
+				(void *)(uint64_t)mods[i].mm_mod_start;
 			vm->sw.linux_info.ramdisk_size = mod_size;
 		} else if (strncmp("SeedList", start, type_len) == 0) {
-			parse_seed_list(mod_addr);
+			parse_seed_list((struct seed_list_hob *)mod_addr);
 		} else {
 			pr_warn("not support mod, cmd: %s", start);
 		}
@@ -151,22 +151,21 @@ int init_vm0_boot_info(struct vm *vm)
 	vm->sw.kernel_info.kernel_load_addr = (void *)HVA2GPA(vm, 
 		get_kernel_load_addr(vm->sw.kernel_info.kernel_src_addr));
 
-
 	/*
 	 * If there is cmdline from mbi->mi_cmdline, merge it with
 	 * mods[0].mm_string
 	 */
 	if ((mbi->mi_flags & MULTIBOOT_INFO_HAS_CMDLINE) != 0U) {
 		char *cmd_src, *cmd_dst;
-		int off = 0;
+		uint32_t off;
 
 		cmd_dst = kernel_cmdline;
 		cmd_src = HPA2HVA((uint64_t)mbi->mi_cmdline);
 		(void)strncpy_s(cmd_dst, MEM_2K, cmd_src,
 			strnlen_s(cmd_src, MEM_2K));
 		off = strnlen_s(cmd_dst, MEM_2K);
 		cmd_dst[off] = ' ';	/* insert space */
-		off += 1;
+		off += 1U;
 
 		cmd_dst += off;
 		cmd_src = HPA2HVA((uint64_t)mods[0].mm_string);
@@ -186,7 +185,7 @@ int init_vm0_boot_info(struct vm *vm)
 
 	vm->sw.linux_info.bootargs_load_addr = (void *)BOOT_ARGS_LOAD_ADDR;
 
-	if (mbi->mi_mods_count > 1) {
+	if (mbi->mi_mods_count > 1U) {
 		/*parse other modules, like firmware /ramdisk */
 		parse_other_modules(vm, mods + 1, mbi->mi_mods_count - 1);
 	}

hypervisor/include/arch/x86/hob_parse.h

@@ -7,11 +7,11 @@
 #ifndef HOB_PARSE_H_
 #define HOB_PARSE_H_
 
-#define SEED_ENTRY_TYPE_SVNSEED         0x1
-#define SEED_ENTRY_TYPE_RPMBSEED        0x2
+#define SEED_ENTRY_TYPE_SVNSEED         0x1U
+#define SEED_ENTRY_TYPE_RPMBSEED        0x2U
 
-#define SEED_ENTRY_USAGE_USEED          0x1
-#define SEED_ENTRY_USAGE_DSEED          0x2
+#define SEED_ENTRY_USAGE_USEED          0x1U
+#define SEED_ENTRY_USAGE_DSEED          0x2U
 
 struct seed_list_hob {
 	uint8_t revision;

hypervisor/include/arch/x86/trusty.h

@@ -14,7 +14,7 @@
 
 #define RPMB_MAX_PARTITION_NUMBER       6
 #define MMC_PROD_NAME_WITH_PSN_LEN      15
-#define BUP_MKHI_BOOTLOADER_SEED_LEN    64
+#define BUP_MKHI_BOOTLOADER_SEED_LEN    64U
 
 /* Trusty EPT rebase gpa: 511G */
 #define TRUSTY_EPT_REBASE_GPA (511UL * 1024UL * 1024UL * 1024UL)
@@ -96,7 +96,7 @@ struct key_info {
 
 #ifdef WORKAROUND_FOR_TRUSTY_4G_MEM
 void create_secure_world_ept(struct vm *vm, uint64_t gpa_orig,
-		int64_t size, uint64_t gpa_rebased);
+		uint64_t size, uint64_t gpa_rebased);
 struct secure_world_memory {
 	/* The secure world base address of GPA for secure world*/
 	uint64_t base_gpa;

hypervisor/include/lib/sprintf.h

@@ -24,7 +24,7 @@ struct print_param {
 	/* Contains variables which are recalculated for each argument. */
 	struct {
 		/* A bitfield with the parsed format flags. */
-		int flags;
+		uint32_t flags;
 		/* The parsed format width. */
 		int width;
 		/* The parsed format precision. */

hypervisor/lib/div.c

@@ -43,11 +43,11 @@ int udiv32(uint32_t dividend, uint32_t divisor, struct udiv_result *res)
 	/* test for "division by 0" condition */
 	if (divisor == 0U) {
 		res->q.dwords.low = 0xffffffffU;
-		return !0;
+		return 1;
 	}
 	/* trivial case: divisor==dividend */
 	if (divisor == dividend) {
-		res->q.dwords.low = 1;
+		res->q.dwords.low = 1U;
 		return 0;
 	}
 	/* trivial case: divisor>dividend */

hypervisor/lib/mdelay.c

@@ -9,9 +9,9 @@
 void mdelay(uint32_t loop_count)
 {
 	/* Loop until done */
-	while (loop_count != 0) {
+	while (loop_count != 0U) {
 		/* Delay for 1 ms */
-		udelay(1000);
+		udelay(1000U);
 		loop_count--;
 	}
 }

hypervisor/lib/memory.c

@@ -95,7 +95,7 @@ static void *allocate_mem(struct mem_pool *pool, unsigned int num_bytes)
 			/* Check requested_buffs number of buffers availability
 			 * in memory-pool right after selected buffer
 			 */
-			for (i = 1; i < requested_buffs; i++) {
+			for (i = 1U; i < requested_buffs; i++) {
 				/* Check if tmp_bit_idx is out-of-range */
 				tmp_bit_idx++;
 				if (tmp_bit_idx == BITMAP_WORD_SIZE) {
@@ -244,8 +244,8 @@ void *malloc(unsigned int num_bytes)
 		 */
 		memory = allocate_mem(&Memory_Pool, num_bytes);
 	} else {
-		int page_num =
-			(num_bytes + CPU_PAGE_SIZE - 1) >> CPU_PAGE_SHIFT;
+		uint32_t page_num =
+			(num_bytes + CPU_PAGE_SIZE - 1U) >> CPU_PAGE_SHIFT;
 		/* Request memory allocation through alloc_page */
 		memory = alloc_pages(page_num);
 	}
@@ -276,7 +276,7 @@ void *alloc_pages(unsigned int page_num)
 
 void *alloc_page(void)
 {
-	return alloc_pages(1);
+	return alloc_pages(1U);
 }
 
 void *calloc(unsigned int num_elements, unsigned int element_size)
@@ -286,7 +286,7 @@ void *calloc(unsigned int num_elements, unsigned int element_size)
 	/* Determine if memory was allocated */
 	if (memory != NULL) {
 		/* Zero all the memory */
-		(void)memset(memory, 0, num_elements * element_size);
+		(void)memset(memory, 0U, num_elements * element_size);
 	}
 
 	/* Return pointer to memory */