qemu

FORK: QEMU emulator
git clone https://git.neptards.moe/neptards/qemu.git
Log | Files | Refs | Submodules | LICENSE

qtest_wrappers.c (7114B)

      1 /*
      2  * qtest function wrappers
      3  *
      4  * Copyright Red Hat Inc., 2019
      5  *
      6  * Authors:
      7  *  Alexander Bulekov   <alxndr@bu.edu>
      8  *
      9  * This work is licensed under the terms of the GNU GPL, version 2 or later.
     10  * See the COPYING file in the top-level directory.
     11  *
     12  */
     13 
     14 #include "qemu/osdep.h"
     15 #include "hw/core/cpu.h"
     16 #include "exec/ioport.h"
     17 
     18 #include "fuzz.h"
     19 
     20 static bool serialize = true;
     21 
     22 #define WRAP(RET_TYPE, NAME_AND_ARGS)\
     23     RET_TYPE __wrap_##NAME_AND_ARGS;\
     24     RET_TYPE __real_##NAME_AND_ARGS;
     25 
     26 WRAP(uint8_t  , qtest_inb(QTestState *s, uint16_t addr))
     27 WRAP(uint16_t , qtest_inw(QTestState *s, uint16_t addr))
     28 WRAP(uint32_t , qtest_inl(QTestState *s, uint16_t addr))
     29 WRAP(void     , qtest_outb(QTestState *s, uint16_t addr, uint8_t value))
     30 WRAP(void     , qtest_outw(QTestState *s, uint16_t addr, uint16_t value))
     31 WRAP(void     , qtest_outl(QTestState *s, uint16_t addr, uint32_t value))
     32 WRAP(uint8_t  , qtest_readb(QTestState *s, uint64_t addr))
     33 WRAP(uint16_t , qtest_readw(QTestState *s, uint64_t addr))
     34 WRAP(uint32_t , qtest_readl(QTestState *s, uint64_t addr))
     35 WRAP(uint64_t , qtest_readq(QTestState *s, uint64_t addr))
     36 WRAP(void     , qtest_writeb(QTestState *s, uint64_t addr, uint8_t value))
     37 WRAP(void     , qtest_writew(QTestState *s, uint64_t addr, uint16_t value))
     38 WRAP(void     , qtest_writel(QTestState *s, uint64_t addr, uint32_t value))
     39 WRAP(void     , qtest_writeq(QTestState *s, uint64_t addr, uint64_t value))
     40 WRAP(void     , qtest_memread(QTestState *s, uint64_t addr,
     41                               void *data, size_t size))
     42 WRAP(void     , qtest_bufread(QTestState *s, uint64_t addr, void *data,
     43                               size_t size))
     44 WRAP(void     , qtest_memwrite(QTestState *s, uint64_t addr, const void *data,
     45                                size_t size))
     46 WRAP(void,      qtest_bufwrite(QTestState *s, uint64_t addr,
     47                                const void *data, size_t size))
     48 WRAP(void,      qtest_memset(QTestState *s, uint64_t addr,
     49                              uint8_t patt, size_t size))
     50 
     51 
     52 uint8_t __wrap_qtest_inb(QTestState *s, uint16_t addr)
     53 {
     54     if (!serialize) {
     55         return cpu_inb(addr);
     56     } else {
     57         return __real_qtest_inb(s, addr);
     58     }
     59 }
     60 
     61 uint16_t __wrap_qtest_inw(QTestState *s, uint16_t addr)
     62 {
     63     if (!serialize) {
     64         return cpu_inw(addr);
     65     } else {
     66         return __real_qtest_inw(s, addr);
     67     }
     68 }
     69 
     70 uint32_t __wrap_qtest_inl(QTestState *s, uint16_t addr)
     71 {
     72     if (!serialize) {
     73         return cpu_inl(addr);
     74     } else {
     75         return __real_qtest_inl(s, addr);
     76     }
     77 }
     78 
     79 void __wrap_qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
     80 {
     81     if (!serialize) {
     82         cpu_outb(addr, value);
     83     } else {
     84         __real_qtest_outb(s, addr, value);
     85     }
     86 }
     87 
     88 void __wrap_qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
     89 {
     90     if (!serialize) {
     91         cpu_outw(addr, value);
     92     } else {
     93         __real_qtest_outw(s, addr, value);
     94     }
     95 }
     96 
     97 void __wrap_qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
     98 {
     99     if (!serialize) {
    100         cpu_outl(addr, value);
    101     } else {
    102         __real_qtest_outl(s, addr, value);
    103     }
    104 }
    105 
    106 uint8_t __wrap_qtest_readb(QTestState *s, uint64_t addr)
    107 {
    108     uint8_t value;
    109     if (!serialize) {
    110         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    111                             &value, 1);
    112         return value;
    113     } else {
    114         return __real_qtest_readb(s, addr);
    115     }
    116 }
    117 
    118 uint16_t __wrap_qtest_readw(QTestState *s, uint64_t addr)
    119 {
    120     uint16_t value;
    121     if (!serialize) {
    122         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    123                             &value, 2);
    124         return value;
    125     } else {
    126         return __real_qtest_readw(s, addr);
    127     }
    128 }
    129 
    130 uint32_t __wrap_qtest_readl(QTestState *s, uint64_t addr)
    131 {
    132     uint32_t value;
    133     if (!serialize) {
    134         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    135                             &value, 4);
    136         return value;
    137     } else {
    138         return __real_qtest_readl(s, addr);
    139     }
    140 }
    141 
    142 uint64_t __wrap_qtest_readq(QTestState *s, uint64_t addr)
    143 {
    144     uint64_t value;
    145     if (!serialize) {
    146         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    147                             &value, 8);
    148         return value;
    149     } else {
    150         return __real_qtest_readq(s, addr);
    151     }
    152 }
    153 
    154 void __wrap_qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
    155 {
    156     if (!serialize) {
    157         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    158                             &value, 1);
    159     } else {
    160         __real_qtest_writeb(s, addr, value);
    161     }
    162 }
    163 
    164 void __wrap_qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
    165 {
    166     if (!serialize) {
    167         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    168                             &value, 2);
    169     } else {
    170         __real_qtest_writew(s, addr, value);
    171     }
    172 }
    173 
    174 void __wrap_qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
    175 {
    176     if (!serialize) {
    177         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    178                             &value, 4);
    179     } else {
    180         __real_qtest_writel(s, addr, value);
    181     }
    182 }
    183 
    184 void __wrap_qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
    185 {
    186     if (!serialize) {
    187         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    188                             &value, 8);
    189     } else {
    190         __real_qtest_writeq(s, addr, value);
    191     }
    192 }
    193 
    194 void __wrap_qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
    195 {
    196     if (!serialize) {
    197         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data,
    198                            size);
    199     } else {
    200         __real_qtest_memread(s, addr, data, size);
    201     }
    202 }
    203 
    204 void __wrap_qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
    205 {
    206     if (!serialize) {
    207         address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data,
    208                            size);
    209     } else {
    210         __real_qtest_bufread(s, addr, data, size);
    211     }
    212 }
    213 
    214 void __wrap_qtest_memwrite(QTestState *s, uint64_t addr, const void *data,
    215                            size_t size)
    216 {
    217     if (!serialize) {
    218         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    219                             data, size);
    220     } else {
    221         __real_qtest_memwrite(s, addr, data, size);
    222     }
    223 }
    224 
    225 void __wrap_qtest_bufwrite(QTestState *s, uint64_t addr,
    226                     const void *data, size_t size)
    227 {
    228     if (!serialize) {
    229         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    230                             data, size);
    231     } else {
    232         __real_qtest_bufwrite(s, addr, data, size);
    233     }
    234 }
    235 void __wrap_qtest_memset(QTestState *s, uint64_t addr,
    236                          uint8_t patt, size_t size)
    237 {
    238     void *data;
    239     if (!serialize) {
    240         data = malloc(size);
    241         memset(data, patt, size);
    242         address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
    243                             data, size);
    244     } else {
    245         __real_qtest_memset(s, addr, patt, size);
    246     }
    247 }
    248 
    249 void fuzz_qtest_set_serialize(bool option)
    250 {
    251     serialize = option;
    252 }