OrgACRN
/
acrn-hypervisor
mirror of https://github.com/projectacrn/acrn-hypervisor.git
1
0
Fork 0
Code Issues Releases Wiki Activity

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>
This commit is contained in:
Junjie Mao 2018-07-09 21:25:14 +08:00 committed by lijinxia
parent 0f777d3fe1
commit 3956ce1596
3 changed files with 99 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
hypervisor/arch/x86/pm.c
View File

@ -20,10 +20,12 @@ 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)
@ -31,7 +33,7 @@ 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);

68
hypervisor/common/all_header.c Normal file
View File

@ -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>

44
hypervisor/include/arch/x86/io.h
View File

@ -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,7 +161,8 @@ 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.
@ -167,9 +170,10 @@ static inline void mmio_write_long(uint32_t value, void *addr)
* @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.
@ -177,9 +181,10 @@ static inline void mmio_write_word(uint32_t value, void *addr)
* @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,7 +228,8 @@ 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).
@ -231,9 +237,10 @@ static inline void __mmio_write_long(uint32_t value, void *addr)
* @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).
@ -241,9 +248,10 @@ static inline void __mmio_write_word(uint32_t value, void *addr)
* @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);
}