/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 | } |