Coverage Report

Created: 2026-10-31 08:12

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/qemu/tests/qtest/fuzz/qtest_wrappers.c
Line
Count
Source
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 "system/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
447k
{
54
447k
    if (!serialize) {
55
447k
        return cpu_inb(addr);
56
447k
    } else {
57
0
        return __real_qtest_inb(s, addr);
58
0
    }
59
447k
}
60
61
uint16_t __wrap_qtest_inw(QTestState *s, uint16_t addr)
62
1.68M
{
63
1.68M
    if (!serialize) {
64
1.68M
        return cpu_inw(addr);
65
1.68M
    } else {
66
0
        return __real_qtest_inw(s, addr);
67
0
    }
68
1.68M
}
69
70
uint32_t __wrap_qtest_inl(QTestState *s, uint16_t addr)
71
547k
{
72
547k
    if (!serialize) {
73
547k
        return cpu_inl(addr);
74
547k
    } else {
75
0
        return __real_qtest_inl(s, addr);
76
0
    }
77
547k
}
78
79
void __wrap_qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
80
1.69M
{
81
1.69M
    if (!serialize) {
82
1.69M
        cpu_outb(addr, value);
83
1.69M
    } else {
84
0
        __real_qtest_outb(s, addr, value);
85
0
    }
86
1.69M
}
87
88
void __wrap_qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
89
2.39M
{
90
2.39M
    if (!serialize) {
91
2.39M
        cpu_outw(addr, value);
92
2.39M
    } else {
93
0
        __real_qtest_outw(s, addr, value);
94
0
    }
95
2.39M
}
96
97
void __wrap_qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
98
5.38M
{
99
5.38M
    if (!serialize) {
100
5.38M
        cpu_outl(addr, value);
101
5.38M
    } else {
102
0
        __real_qtest_outl(s, addr, value);
103
0
    }
104
5.38M
}
105
106
uint8_t __wrap_qtest_readb(QTestState *s, uint64_t addr)
107
23.2k
{
108
23.2k
    uint8_t value;
109
23.2k
    if (!serialize) {
110
23.2k
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
111
23.2k
                            &value, 1);
112
23.2k
        return value;
113
23.2k
    } else {
114
0
        return __real_qtest_readb(s, addr);
115
0
    }
116
23.2k
}
117
118
uint16_t __wrap_qtest_readw(QTestState *s, uint64_t addr)
119
20.5k
{
120
20.5k
    uint16_t value;
121
20.5k
    if (!serialize) {
122
20.5k
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
123
20.5k
                            &value, 2);
124
20.5k
        return value;
125
20.5k
    } else {
126
0
        return __real_qtest_readw(s, addr);
127
0
    }
128
20.5k
}
129
130
uint32_t __wrap_qtest_readl(QTestState *s, uint64_t addr)
131
124k
{
132
124k
    uint32_t value;
133
124k
    if (!serialize) {
134
124k
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
135
124k
                            &value, 4);
136
124k
        return value;
137
124k
    } else {
138
0
        return __real_qtest_readl(s, addr);
139
0
    }
140
124k
}
141
142
uint64_t __wrap_qtest_readq(QTestState *s, uint64_t addr)
143
272k
{
144
272k
    uint64_t value;
145
272k
    if (!serialize) {
146
272k
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
147
272k
                            &value, 8);
148
272k
        return value;
149
272k
    } else {
150
0
        return __real_qtest_readq(s, addr);
151
0
    }
152
272k
}
153
154
void __wrap_qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
155
89.4k
{
156
89.4k
    if (!serialize) {
157
89.4k
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
158
89.4k
                            &value, 1);
159
89.4k
    } else {
160
0
        __real_qtest_writeb(s, addr, value);
161
0
    }
162
89.4k
}
163
164
void __wrap_qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
165
52.7k
{
166
52.7k
    if (!serialize) {
167
52.7k
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
168
52.7k
                            &value, 2);
169
52.7k
    } else {
170
0
        __real_qtest_writew(s, addr, value);
171
0
    }
172
52.7k
}
173
174
void __wrap_qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
175
443k
{
176
443k
    if (!serialize) {
177
443k
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
178
443k
                            &value, 4);
179
443k
    } else {
180
0
        __real_qtest_writel(s, addr, value);
181
0
    }
182
443k
}
183
184
void __wrap_qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
185
2.49M
{
186
2.49M
    if (!serialize) {
187
2.49M
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
188
2.49M
                            &value, 8);
189
2.49M
    } else {
190
0
        __real_qtest_writeq(s, addr, value);
191
0
    }
192
2.49M
}
193
194
void __wrap_qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
195
0
{
196
0
    if (!serialize) {
197
0
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data,
198
0
                           size);
199
0
    } else {
200
0
        __real_qtest_memread(s, addr, data, size);
201
0
    }
202
0
}
203
204
void __wrap_qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
205
0
{
206
0
    if (!serialize) {
207
0
        address_space_read(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED, data,
208
0
                           size);
209
0
    } else {
210
0
        __real_qtest_bufread(s, addr, data, size);
211
0
    }
212
0
}
213
214
void __wrap_qtest_memwrite(QTestState *s, uint64_t addr, const void *data,
215
                           size_t size)
216
79.4M
{
217
79.4M
    if (!serialize) {
218
79.4M
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
219
79.4M
                            data, size);
220
79.4M
    } else {
221
0
        __real_qtest_memwrite(s, addr, data, size);
222
0
    }
223
79.4M
}
224
225
void __wrap_qtest_bufwrite(QTestState *s, uint64_t addr,
226
                    const void *data, size_t size)
227
0
{
228
0
    if (!serialize) {
229
0
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
230
0
                            data, size);
231
0
    } else {
232
0
        __real_qtest_bufwrite(s, addr, data, size);
233
0
    }
234
0
}
235
void __wrap_qtest_memset(QTestState *s, uint64_t addr,
236
                         uint8_t patt, size_t size)
237
0
{
238
0
    void *data;
239
0
    if (!serialize) {
240
0
        data = malloc(size);
241
0
        memset(data, patt, size);
242
0
        address_space_write(first_cpu->as, addr, MEMTXATTRS_UNSPECIFIED,
243
0
                            data, size);
244
0
    } else {
245
0
        __real_qtest_memset(s, addr, patt, size);
246
0
    }
247
0
}
248
249
void fuzz_qtest_set_serialize(bool option)
250
61
{
251
61
    serialize = option;
252
61
}