]>
Commit | Line | Data |
---|---|---|
0ba67974 TH |
1 | /* |
2 | * QTest - wrappers for test with single QEMU instances | |
3 | * | |
4 | * Copyright IBM, Corp. 2012 | |
5 | * Copyright Red Hat, Inc. 2012 | |
6 | * Copyright SUSE LINUX Products GmbH 2013 | |
7 | * | |
8 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
9 | * See the COPYING file in the top-level directory. | |
10 | */ | |
11 | #ifndef LIBQTEST_SINGLE_H | |
12 | #define LIBQTEST_SINGLE_H | |
13 | ||
907b5105 | 14 | #include "libqtest.h" |
dd210749 | 15 | |
39f0e991 | 16 | #ifndef _WIN32 |
dd210749 | 17 | QTestState *global_qtest __attribute__((common, weak)); |
39f0e991 XC |
18 | #else |
19 | __declspec(selectany) QTestState *global_qtest; | |
20 | #endif | |
dd210749 | 21 | |
0ba67974 TH |
22 | /** |
23 | * qtest_start: | |
24 | * @args: other arguments to pass to QEMU | |
25 | * | |
26 | * Start QEMU and assign the resulting #QTestState to a global variable. | |
27 | * The global variable is used by "shortcut" functions documented below. | |
28 | * | |
29 | * Returns: #QTestState instance. | |
30 | */ | |
31 | static inline QTestState *qtest_start(const char *args) | |
32 | { | |
33 | global_qtest = qtest_init(args); | |
34 | return global_qtest; | |
35 | } | |
36 | ||
37 | /** | |
38 | * qtest_end: | |
39 | * | |
40 | * Shut down the QEMU process started by qtest_start(). | |
41 | */ | |
42 | static inline void qtest_end(void) | |
43 | { | |
44 | if (!global_qtest) { | |
45 | return; | |
46 | } | |
47 | qtest_quit(global_qtest); | |
48 | global_qtest = NULL; | |
49 | } | |
50 | ||
51 | /** | |
52 | * qmp: | |
53 | * @fmt...: QMP message to send to qemu, formatted like | |
ad57e2b1 | 54 | * qobject_from_jsonf_nofail(). See parse_interpolation() for what's |
0ba67974 TH |
55 | * supported after '%'. |
56 | * | |
57 | * Sends a QMP message to QEMU and returns the response. | |
58 | */ | |
9edc6313 | 59 | G_GNUC_PRINTF(1, 2) |
0ba67974 TH |
60 | static inline QDict *qmp(const char *fmt, ...) |
61 | { | |
62 | va_list ap; | |
63 | QDict *response; | |
64 | ||
65 | va_start(ap, fmt); | |
66 | response = qtest_vqmp(global_qtest, fmt, ap); | |
67 | va_end(ap); | |
68 | return response; | |
69 | } | |
70 | ||
71 | /** | |
72 | * qmp_eventwait: | |
73 | * @s: #event event to wait for. | |
74 | * | |
75 | * Continuously polls for QMP responses until it receives the desired event. | |
76 | */ | |
77 | static inline void qmp_eventwait(const char *event) | |
78 | { | |
79 | return qtest_qmp_eventwait(global_qtest, event); | |
80 | } | |
81 | ||
82 | /** | |
83 | * get_irq: | |
84 | * @num: Interrupt to observe. | |
85 | * | |
86 | * Returns: The level of the @num interrupt. | |
87 | */ | |
88 | static inline bool get_irq(int num) | |
89 | { | |
90 | return qtest_get_irq(global_qtest, num); | |
91 | } | |
92 | ||
93 | /** | |
94 | * outb: | |
95 | * @addr: I/O port to write to. | |
96 | * @value: Value being written. | |
97 | * | |
98 | * Write an 8-bit value to an I/O port. | |
99 | */ | |
100 | static inline void outb(uint16_t addr, uint8_t value) | |
101 | { | |
102 | qtest_outb(global_qtest, addr, value); | |
103 | } | |
104 | ||
105 | /** | |
106 | * outw: | |
107 | * @addr: I/O port to write to. | |
108 | * @value: Value being written. | |
109 | * | |
110 | * Write a 16-bit value to an I/O port. | |
111 | */ | |
112 | static inline void outw(uint16_t addr, uint16_t value) | |
113 | { | |
114 | qtest_outw(global_qtest, addr, value); | |
115 | } | |
116 | ||
117 | /** | |
118 | * outl: | |
119 | * @addr: I/O port to write to. | |
120 | * @value: Value being written. | |
121 | * | |
122 | * Write a 32-bit value to an I/O port. | |
123 | */ | |
124 | static inline void outl(uint16_t addr, uint32_t value) | |
125 | { | |
126 | qtest_outl(global_qtest, addr, value); | |
127 | } | |
128 | ||
129 | /** | |
130 | * inb: | |
131 | * @addr: I/O port to read from. | |
132 | * | |
133 | * Reads an 8-bit value from an I/O port. | |
134 | * | |
135 | * Returns: Value read. | |
136 | */ | |
137 | static inline uint8_t inb(uint16_t addr) | |
138 | { | |
139 | return qtest_inb(global_qtest, addr); | |
140 | } | |
141 | ||
142 | /** | |
143 | * inw: | |
144 | * @addr: I/O port to read from. | |
145 | * | |
146 | * Reads a 16-bit value from an I/O port. | |
147 | * | |
148 | * Returns: Value read. | |
149 | */ | |
150 | static inline uint16_t inw(uint16_t addr) | |
151 | { | |
152 | return qtest_inw(global_qtest, addr); | |
153 | } | |
154 | ||
155 | /** | |
156 | * inl: | |
157 | * @addr: I/O port to read from. | |
158 | * | |
159 | * Reads a 32-bit value from an I/O port. | |
160 | * | |
161 | * Returns: Value read. | |
162 | */ | |
163 | static inline uint32_t inl(uint16_t addr) | |
164 | { | |
165 | return qtest_inl(global_qtest, addr); | |
166 | } | |
167 | ||
168 | /** | |
169 | * writeb: | |
170 | * @addr: Guest address to write to. | |
171 | * @value: Value being written. | |
172 | * | |
173 | * Writes an 8-bit value to guest memory. | |
174 | */ | |
175 | static inline void writeb(uint64_t addr, uint8_t value) | |
176 | { | |
177 | qtest_writeb(global_qtest, addr, value); | |
178 | } | |
179 | ||
180 | /** | |
181 | * writew: | |
182 | * @addr: Guest address to write to. | |
183 | * @value: Value being written. | |
184 | * | |
185 | * Writes a 16-bit value to guest memory. | |
186 | */ | |
187 | static inline void writew(uint64_t addr, uint16_t value) | |
188 | { | |
189 | qtest_writew(global_qtest, addr, value); | |
190 | } | |
191 | ||
192 | /** | |
193 | * writel: | |
194 | * @addr: Guest address to write to. | |
195 | * @value: Value being written. | |
196 | * | |
197 | * Writes a 32-bit value to guest memory. | |
198 | */ | |
199 | static inline void writel(uint64_t addr, uint32_t value) | |
200 | { | |
201 | qtest_writel(global_qtest, addr, value); | |
202 | } | |
203 | ||
204 | /** | |
205 | * writeq: | |
206 | * @addr: Guest address to write to. | |
207 | * @value: Value being written. | |
208 | * | |
209 | * Writes a 64-bit value to guest memory. | |
210 | */ | |
211 | static inline void writeq(uint64_t addr, uint64_t value) | |
212 | { | |
213 | qtest_writeq(global_qtest, addr, value); | |
214 | } | |
215 | ||
216 | /** | |
217 | * readb: | |
218 | * @addr: Guest address to read from. | |
219 | * | |
220 | * Reads an 8-bit value from guest memory. | |
221 | * | |
222 | * Returns: Value read. | |
223 | */ | |
224 | static inline uint8_t readb(uint64_t addr) | |
225 | { | |
226 | return qtest_readb(global_qtest, addr); | |
227 | } | |
228 | ||
229 | /** | |
230 | * readw: | |
231 | * @addr: Guest address to read from. | |
232 | * | |
233 | * Reads a 16-bit value from guest memory. | |
234 | * | |
235 | * Returns: Value read. | |
236 | */ | |
237 | static inline uint16_t readw(uint64_t addr) | |
238 | { | |
239 | return qtest_readw(global_qtest, addr); | |
240 | } | |
241 | ||
242 | /** | |
243 | * readl: | |
244 | * @addr: Guest address to read from. | |
245 | * | |
246 | * Reads a 32-bit value from guest memory. | |
247 | * | |
248 | * Returns: Value read. | |
249 | */ | |
250 | static inline uint32_t readl(uint64_t addr) | |
251 | { | |
252 | return qtest_readl(global_qtest, addr); | |
253 | } | |
254 | ||
255 | /** | |
256 | * readq: | |
257 | * @addr: Guest address to read from. | |
258 | * | |
259 | * Reads a 64-bit value from guest memory. | |
260 | * | |
261 | * Returns: Value read. | |
262 | */ | |
263 | static inline uint64_t readq(uint64_t addr) | |
264 | { | |
265 | return qtest_readq(global_qtest, addr); | |
266 | } | |
267 | ||
268 | /** | |
269 | * memread: | |
270 | * @addr: Guest address to read from. | |
271 | * @data: Pointer to where memory contents will be stored. | |
272 | * @size: Number of bytes to read. | |
273 | * | |
274 | * Read guest memory into a buffer. | |
275 | */ | |
276 | static inline void memread(uint64_t addr, void *data, size_t size) | |
277 | { | |
278 | qtest_memread(global_qtest, addr, data, size); | |
279 | } | |
280 | ||
281 | /** | |
282 | * memwrite: | |
283 | * @addr: Guest address to write to. | |
284 | * @data: Pointer to the bytes that will be written to guest memory. | |
285 | * @size: Number of bytes to write. | |
286 | * | |
287 | * Write a buffer to guest memory. | |
288 | */ | |
289 | static inline void memwrite(uint64_t addr, const void *data, size_t size) | |
290 | { | |
291 | qtest_memwrite(global_qtest, addr, data, size); | |
292 | } | |
293 | ||
294 | /** | |
295 | * clock_step_next: | |
296 | * | |
297 | * Advance the QEMU_CLOCK_VIRTUAL to the next deadline. | |
298 | * | |
299 | * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds. | |
300 | */ | |
301 | static inline int64_t clock_step_next(void) | |
302 | { | |
303 | return qtest_clock_step_next(global_qtest); | |
304 | } | |
305 | ||
306 | /** | |
307 | * clock_step: | |
308 | * @step: Number of nanoseconds to advance the clock by. | |
309 | * | |
310 | * Advance the QEMU_CLOCK_VIRTUAL by @step nanoseconds. | |
311 | * | |
312 | * Returns: The current value of the QEMU_CLOCK_VIRTUAL in nanoseconds. | |
313 | */ | |
314 | static inline int64_t clock_step(int64_t step) | |
315 | { | |
316 | return qtest_clock_step(global_qtest, step); | |
317 | } | |
318 | ||
319 | #endif |