| /* |
| * qtest function wrappers |
| * |
| * Copyright Red Hat Inc., 2019 |
| * |
| * Authors: |
| * Alexander Bulekov <alxndr@bu.edu> |
| * |
| * This work is licensed under the terms of the GNU GPL, version 2 or later. |
| * See the COPYING file in the top-level directory. |
| * |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "hw/core/cpu.h" |
| #include "exec/ioport.h" |
| |
| #include "fuzz.h" |
| |
| static bool serialize = true; |
| |
| #define WRAP(RET_TYPE, NAME_AND_ARGS)\ |
| RET_TYPE __wrap_##NAME_AND_ARGS;\ |
| RET_TYPE __real_##NAME_AND_ARGS; |
| |
| WRAP(uint8_t , qtest_inb(QTestState *s, uint16_t addr)) |
| WRAP(uint16_t , qtest_inw(QTestState *s, uint16_t addr)) |
| WRAP(uint32_t , qtest_inl(QTestState *s, uint16_t addr)) |
| WRAP(void , qtest_outb(QTestState *s, uint16_t addr, uint8_t value)) |
| WRAP(void , qtest_outw(QTestState *s, uint16_t addr, uint16_t value)) |
| WRAP(void , qtest_outl(QTestState *s, uint16_t addr, uint32_t value)) |
| WRAP(uint8_t , qtest_readb(QTestState *s, uint64_t addr)) |
| WRAP(uint16_t , qtest_readw(QTestState *s, uint64_t addr)) |
| WRAP(uint32_t , qtest_readl(QTestState *s, uint64_t addr)) |
| WRAP(uint64_t , qtest_readq(QTestState *s, uint64_t addr)) |
| WRAP(void , qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)) |
| WRAP(void , qtest_writew(QTestState *s, uint64_t addr, uint16_t value)) |
| WRAP(void , qtest_writel(QTestState *s, uint64_t addr, uint32_t value)) |
| WRAP(void , qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)) |
| WRAP(void , qtest_memread(QTestState *s, uint64_t addr, |
| void *data, size_t size)) |
| WRAP(void , qtest_bufread(QTestState *s, uint64_t addr, void *data, |
| size_t size)) |
| WRAP(void , qtest_memwrite(QTestState *s, uint64_t addr, const void *data, |
| size_t size)) |
| WRAP(void, qtest_bufwrite(QTestState *s, uint64_t addr, |
| const void *data, size_t size)) |
| WRAP(void, qtest_memset(QTestState *s, uint64_t addr, |
| uint8_t patt, size_t size)) |
| |
| |
| uint8_t __wrap_qtest_inb(QTestState *s, uint16_t addr) |
| { |
| if (!serialize) { |
| return cpu_inb(addr); |
| } else { |
| return __real_qtest_inb(s, addr); |
| } |
| } |
| |
| uint16_t __wrap_qtest_inw(QTestState *s, uint16_t addr) |
| { |
| if (!serialize) { |
| return cpu_inw(addr); |
| } else { |
| return __real_qtest_inw(s, addr); |
| } |
| } |
| |
| uint32_t __wrap_qtest_inl(QTestState *s, uint16_t addr) |
| { |
| if (!serialize) { |
| return cpu_inl(addr); |
| } else { |
| return __real_qtest_inl(s, addr); |
| } |
| } |
| |
| void __wrap_qtest_outb(QTestState *s, uint16_t addr, uint8_t value) |
| { |
| if (!serialize) { |
| cpu_outb(addr, value); |
| } else { |
| __real_qtest_outb(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_outw(QTestState *s, uint16_t addr, uint16_t value) |
| { |
| if (!serialize) { |
| cpu_outw(addr, value); |
| } else { |
| __real_qtest_outw(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_outl(QTestState *s, uint16_t addr, uint32_t value) |
| { |
| if (!serialize) { |
| cpu_outl(addr, value); |
| } else { |
| __real_qtest_outl(s, addr, value); |
| } |
| } |
| |
| uint8_t __wrap_qtest_readb(QTestState *s, uint64_t addr) |
| { |
| uint8_t value; |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 1); |
| return value; |
| } else { |
| return __real_qtest_readb(s, addr); |
| } |
| } |
| |
| uint16_t __wrap_qtest_readw(QTestState *s, uint64_t addr) |
| { |
| uint16_t value; |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 2); |
| return value; |
| } else { |
| return __real_qtest_readw(s, addr); |
| } |
| } |
| |
| uint32_t __wrap_qtest_readl(QTestState *s, uint64_t addr) |
| { |
| uint32_t value; |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 4); |
| return value; |
| } else { |
| return __real_qtest_readl(s, addr); |
| } |
| } |
| |
| uint64_t __wrap_qtest_readq(QTestState *s, uint64_t addr) |
| { |
| uint64_t value; |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 8); |
| return value; |
| } else { |
| return __real_qtest_readq(s, addr); |
| } |
| } |
| |
| void __wrap_qtest_writeb(QTestState *s, uint64_t addr, uint8_t value) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 1); |
| } else { |
| __real_qtest_writeb(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_writew(QTestState *s, uint64_t addr, uint16_t value) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 2); |
| } else { |
| __real_qtest_writew(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_writel(QTestState *s, uint64_t addr, uint32_t value) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 4); |
| } else { |
| __real_qtest_writel(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_writeq(QTestState *s, uint64_t addr, uint64_t value) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| &value, 8); |
| } else { |
| __real_qtest_writeq(s, addr, value); |
| } |
| } |
| |
| void __wrap_qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size) |
| { |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data, |
| size); |
| } else { |
| __real_qtest_memread(s, addr, data, size); |
| } |
| } |
| |
| void __wrap_qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size) |
| { |
| if (!serialize) { |
| address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data, |
| size); |
| } else { |
| __real_qtest_bufread(s, addr, data, size); |
| } |
| } |
| |
| void __wrap_qtest_memwrite(QTestState *s, uint64_t addr, const void *data, |
| size_t size) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| data, size); |
| } else { |
| __real_qtest_memwrite(s, addr, data, size); |
| } |
| } |
| |
| void __wrap_qtest_bufwrite(QTestState *s, uint64_t addr, |
| const void *data, size_t size) |
| { |
| if (!serialize) { |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| data, size); |
| } else { |
| __real_qtest_bufwrite(s, addr, data, size); |
| } |
| } |
| void __wrap_qtest_memset(QTestState *s, uint64_t addr, |
| uint8_t patt, size_t size) |
| { |
| void *data; |
| if (!serialize) { |
| data = malloc(size); |
| memset(data, patt, size); |
| address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, |
| data, size); |
| } else { |
| __real_qtest_memset(s, addr, patt, size); |
| } |
| } |
| |
| void fuzz_qtest_set_serialize(bool option) |
| { |
| serialize = option; |
| } |