HV: io: spell out explicit narrowing of integers

The MMIO/PIO write APIs in io.h always take a uint32_t value but may uses it as
8, 16 or 32-bit integers. This patch converts the prototypes to align with their
functionality.

The pointer conversion and assignment are splitted to separate statements to
prevent static checkers from being confused about the underlying types.

v1 -> v2:

    * Change the prototype of mmio-related functions, instead of keeping the
      explicit conversions internal. The addresses are kept void* since in most
      cases hva (in void*) is passed.

Signed-off-by: Junjie Mao <junjie.mao@intel.com>
Acked-by: Eddie Dong <eddie.dong@intel.com>

Author: junjiemao1

hypervisor/arch/x86/pm.c

@@ -20,18 +20,20 @@ void restore_msrs(void)
 
 static void acpi_gas_write(struct acpi_generic_address *gas, uint32_t val)
 {
+	uint16_t val16 = (uint16_t)val;
+
 	if (gas->space_id == SPACE_SYSTEM_MEMORY)
-		mmio_write_word(val, (void *)HPA2HVA(gas->address));
+		mmio_write_word(val16, HPA2HVA(gas->address));
 	else
-		io_write_word(val, gas->address);
+		io_write_word(val16, gas->address);
 }
 
 static uint32_t acpi_gas_read(struct acpi_generic_address *gas)
 {
 	uint32_t ret = 0;
 
 	if (gas->space_id == SPACE_SYSTEM_MEMORY)
-		ret = mmio_read_word((void *)HPA2HVA(gas->address));
+		ret = mmio_read_word(HPA2HVA(gas->address));
 	else
 		ret = io_read_word(gas->address);
 

hypervisor/common/all_header.c

@@ -0,0 +1,68 @@
+#include <hypervisor.h>
+#include <lib/stdarg.h>
+#include <lib/util.h>
+#include <lib/list.h>
+#include <lib/macros.h>
+#include <lib/rtl.h>
+#include <lib/spinlock.h>
+#include <lib/atomic.h>
+#include <lib/types.h>
+#include <lib/errno.h>
+#include <lib/bits.h>
+#include <lib/crypto/hkdf.h>
+#include <lib/sprintf.h>
+#include <lib/mem_mgt.h>
+#include <hv_debug.h>
+#include <common/acrn_efi.h>
+#include <common/schedule.h>
+#include <common/irq.h>
+#include <common/ptdev.h>
+#include <common/hypercall.h>
+#include <debug/console.h>
+#include <debug/printf.h>
+#include <debug/serial.h>
+#include <debug/dump.h>
+#include <debug/vuart.h>
+#include <debug/trace.h>
+#include <debug/assert.h>
+#include <debug/sbuf.h>
+#include <debug/shell.h>
+#include <debug/logmsg.h>
+#include <hv_lib.h>
+#include <public/acrn_common.h>
+#include <public/acrn_hv_defs.h>
+#include <arch/x86/softirq.h>
+#include <arch/x86/vmexit.h>
+#include <arch/x86/msr.h>
+#include <arch/x86/ioapic.h>
+#include <arch/x86/cpuid.h>
+#include <arch/x86/multiboot.h>
+#include <arch/x86/per_cpu.h>
+#include <arch/x86/vtd.h>
+#include <arch/x86/vmx.h>
+#include <arch/x86/hv_arch.h>
+#include <arch/x86/lapic.h>
+#include <arch/x86/apicreg.h>
+#include <arch/x86/zeropage.h>
+#include <arch/x86/host_pm.h>
+#include <arch/x86/timer.h>
+#include <arch/x86/cpu.h>
+#include <arch/x86/mtrr.h>
+#include <arch/x86/assign.h>
+#include <arch/x86/hob_parse.h>
+#include <arch/x86/gdt.h>
+#include <arch/x86/mmu.h>
+#include <arch/x86/idt.h>
+#include <arch/x86/io.h>
+#include <arch/x86/cpufeatures.h>
+#include <arch/x86/trusty.h>
+#include <arch/x86/irq.h>
+#include <arch/x86/guest/guest_pm.h>
+#include <arch/x86/guest/vlapic.h>
+#include <arch/x86/guest/vm.h>
+#include <arch/x86/guest/vioapic.h>
+#include <arch/x86/guest/ucode.h>
+#include <arch/x86/guest/vpic.h>
+#include <arch/x86/guest/vcpu.h>
+#include <arch/x86/guest/guest.h>
+#include <arch/x86/reboot.h>

hypervisor/include/arch/x86/io.h

@@ -7,6 +7,8 @@
 #ifndef IO_H
 #define IO_H
 
+#include <types.h>
+
 /* Definition of a IO port range */
 struct vm_io_range {
 	uint16_t base;		/* IO port base */
@@ -61,19 +63,19 @@ static inline uint32_t io_read_long(uint16_t port)
 
 static inline void io_write(uint32_t v, uint16_t addr, size_t sz)
 {
-	if (sz == 1)
-		io_write_byte(v, addr);
-	else if (sz == 2)
-		io_write_word(v, addr);
+	if (sz == 1U)
+		io_write_byte((uint8_t)v, addr);
+	else if (sz == 2U)
+		io_write_word((uint16_t)v, addr);
 	else
 		io_write_long(v, addr);
 }
 
 static inline uint32_t io_read(uint16_t addr, size_t sz)
 {
-	if (sz == 1)
+	if (sz == 1U)
 		return io_read_byte(addr);
-	if (sz == 2)
+	if (sz == 2U)
 		return io_read_word(addr);
 	return io_read_long(addr);
 }
@@ -159,27 +161,30 @@ int dm_emulate_pio_post(struct vcpu *vcpu);
  */
 static inline void mmio_write_long(uint32_t value, void *addr)
 {
-	*((volatile int32_t *)addr) = value;
+	volatile uint32_t *addr32 = (volatile uint32_t *)addr;
+	*addr32 = value;
 }
 
 /** Writes a 16 bit value to a memory mapped IO device.
  *
  *  @param value The 16 bit value to write.
  *  @param addr The memory address to write to.
  */
-static inline void mmio_write_word(uint32_t value, void *addr)
+static inline void mmio_write_word(uint16_t value, void *addr)
 {
-	*((volatile uint16_t *)addr) = value;
+	volatile uint16_t *addr16 = (volatile uint16_t *)addr;
+	*addr16 = value;
 }
 
 /** Writes an 8 bit value to a memory mapped IO device.
  *
  *  @param value The 8 bit value to write.
  *  @param addr The memory address to write to.
  */
-static inline void mmio_write_byte(uint32_t value, void *addr)
+static inline void mmio_write_byte(uint8_t value, void *addr)
 {
-	*((volatile uint8_t *)addr) = value;
+	volatile uint8_t *addr8 = (volatile uint8_t *)addr;
+	*addr8 = value;
 }
 
 /** Reads a 32 bit value from a memory mapped IO device.
@@ -223,27 +228,30 @@ static inline uint8_t mmio_read_byte(void *addr)
  */
 static inline void __mmio_write_long(uint32_t value, void *addr)
 {
-	*((volatile uint32_t *)addr) = value;
+	volatile uint32_t *addr32 = (volatile uint32_t *)addr;
+	*addr32 = value;
 }
 
 /** Writes a 16 bit value to a memory mapped IO device (ROM code version).
  *
  *  @param value The 16 bit value to write.
  *  @param addr The memory address to write to.
  */
-static inline void __mmio_write_word(uint32_t value, void *addr)
+static inline void __mmio_write_word(uint16_t value, void *addr)
 {
-	*((volatile uint16_t *)addr) = value;
+	volatile uint16_t *addr16 = (volatile uint16_t *)addr;
+	*addr16 = value;
 }
 
 /** Writes an 8 bit value to a memory mapped IO device (ROM code version).
  *
  *  @param value The 8 bit value to write.
  *  @param addr The memory address to write to.
  */
-static inline void __mmio_write_byte(uint32_t value, void *addr)
+static inline void __mmio_write_byte(uint8_t value, void *addr)
 {
-	*((volatile uint8_t *)addr) = value;
+	volatile uint8_t *addr8 = (volatile uint8_t *)addr;
+	*addr8 = value;
 }
 
 /** Reads a 32 bit value from a memory mapped IO device (ROM code version).
@@ -299,7 +307,7 @@ static inline void setl(void *addr, uint32_t mask, uint32_t value)
  * @param mask    The mask to apply to the value read.
  * @param value   The 16 bit value to write.
  */
-static inline void setw(void *addr, uint32_t mask, uint32_t value)
+static inline void setw(void *addr, uint16_t mask, uint16_t value)
 {
 	mmio_write_word((mmio_read_word(addr) & ~mask) | value, addr);
 }
@@ -311,7 +319,7 @@ static inline void setw(void *addr, uint32_t mask, uint32_t value)
  * @param mask    The mask to apply to the value read.
  * @param value   The 8 bit value to write.
  */
-static inline void setb(void *addr, uint32_t mask, uint32_t value)
+static inline void setb(void *addr, uint8_t mask, uint8_t value)
 {
 	mmio_write_byte((mmio_read_byte(addr) & ~mask) | value, addr);
 }