tests/qtest/fuzz/qtest_wrappers.c

   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 }