cachepc-qemu

Fork of AMDESE/qemu with changes for cachepc side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-qemu
Log | Files | Refs | Submodules | LICENSE | sfeed.txt

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
     20static 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
     26WRAP(uint8_t  , qtest_inb(QTestState *s, uint16_t addr))
     27WRAP(uint16_t , qtest_inw(QTestState *s, uint16_t addr))
     28WRAP(uint32_t , qtest_inl(QTestState *s, uint16_t addr))
     29WRAP(void     , qtest_outb(QTestState *s, uint16_t addr, uint8_t value))
     30WRAP(void     , qtest_outw(QTestState *s, uint16_t addr, uint16_t value))
     31WRAP(void     , qtest_outl(QTestState *s, uint16_t addr, uint32_t value))
     32WRAP(uint8_t  , qtest_readb(QTestState *s, uint64_t addr))
     33WRAP(uint16_t , qtest_readw(QTestState *s, uint64_t addr))
     34WRAP(uint32_t , qtest_readl(QTestState *s, uint64_t addr))
     35WRAP(uint64_t , qtest_readq(QTestState *s, uint64_t addr))
     36WRAP(void     , qtest_writeb(QTestState *s, uint64_t addr, uint8_t value))
     37WRAP(void     , qtest_writew(QTestState *s, uint64_t addr, uint16_t value))
     38WRAP(void     , qtest_writel(QTestState *s, uint64_t addr, uint32_t value))
     39WRAP(void     , qtest_writeq(QTestState *s, uint64_t addr, uint64_t value))
     40WRAP(void     , qtest_memread(QTestState *s, uint64_t addr,
     41                              void *data, size_t size))
     42WRAP(void     , qtest_bufread(QTestState *s, uint64_t addr, void *data,
     43                              size_t size))
     44WRAP(void     , qtest_memwrite(QTestState *s, uint64_t addr, const void *data,
     45                               size_t size))
     46WRAP(void,      qtest_bufwrite(QTestState *s, uint64_t addr,
     47                               const void *data, size_t size))
     48WRAP(void,      qtest_memset(QTestState *s, uint64_t addr,
     49                             uint8_t patt, size_t size))
     50
     51
     52uint8_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
     61uint16_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
     70uint32_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
     79void __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
     88void __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
     97void __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
    106uint8_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
    118uint16_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
    130uint32_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
    142uint64_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
    154void __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
    164void __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
    174void __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
    184void __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
    194void __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
    204void __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
    214void __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
    225void __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}
    235void __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
    249void fuzz_qtest_set_serialize(bool option)
    250{
    251    serialize = option;
    252}