![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libqtest.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / tests|
Return to libqtest.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / tests |
1.1 root 1: /*
2: * QTest
3: *
4: * Copyright IBM, Corp. 2012
5: * Copyright Red Hat, Inc. 2012
6: *
7: * Authors:
8: * Anthony Liguori <[email protected]>
9: * Paolo Bonzini <[email protected]>
10: *
11: * This work is licensed under the terms of the GNU GPL, version 2 or later.
12: * See the COPYING file in the top-level directory.
13: *
14: */
15: #ifndef LIBQTEST_H
16: #define LIBQTEST_H
17:
18: #include <stdint.h>
19: #include <stdbool.h>
20: #include <sys/types.h>
21:
22: typedef struct QTestState QTestState;
23:
24: extern QTestState *global_qtest;
25:
26: /**
27: * qtest_init:
28: * @extra_args: other arguments to pass to QEMU.
29: */
30: QTestState *qtest_init(const char *extra_args);
31:
32: /**
33: * qtest_quit:
34: * @s: QTestState instance to operate on.
35: *
36: * Shut down the QEMU process associated to @s.
37: */
38: void qtest_quit(QTestState *s);
39:
40: /**
41: * qtest_qmp:
42: * @s: QTestState instance to operate on.
43: * @fmt...: QMP message to send to qemu
44: *
45: * Sends a QMP message to QEMU
46: */
47: void qtest_qmp(QTestState *s, const char *fmt, ...);
48:
49: /**
50: * qtest_get_irq:
51: * @s: QTestState instance to operate on.
52: * @num: Interrupt to observe.
53: *
54: * Return the level of the @num interrupt.
55: */
56: bool qtest_get_irq(QTestState *s, int num);
57:
58: /**
59: * qtest_irq_intercept_in:
60: * @s: QTestState instance to operate on.
61: * @string: QOM path of a device.
62: *
63: * Associate qtest irqs with the GPIO-in pins of the device
64: * whose path is specified by @string.
65: */
66: void qtest_irq_intercept_in(QTestState *s, const char *string);
67:
68: /**
69: * qtest_irq_intercept_out:
70: * @s: QTestState instance to operate on.
71: * @string: QOM path of a device.
72: *
73: * Associate qtest irqs with the GPIO-out pins of the device
74: * whose path is specified by @string.
75: */
76: void qtest_irq_intercept_out(QTestState *s, const char *string);
77:
78: /**
79: * qtest_outb:
80: * @s: QTestState instance to operate on.
81: * @addr: I/O port to write to.
82: * @value: Value being written.
83: *
84: * Write an 8-bit value to an I/O port.
85: */
86: void qtest_outb(QTestState *s, uint16_t addr, uint8_t value);
87:
88: /**
89: * qtest_outw:
90: * @s: QTestState instance to operate on.
91: * @addr: I/O port to write to.
92: * @value: Value being written.
93: *
94: * Write a 16-bit value to an I/O port.
95: */
96: void qtest_outw(QTestState *s, uint16_t addr, uint16_t value);
97:
98: /**
99: * qtest_outl:
100: * @s: QTestState instance to operate on.
101: * @addr: I/O port to write to.
102: * @value: Value being written.
103: *
104: * Write a 32-bit value to an I/O port.
105: */
106: void qtest_outl(QTestState *s, uint16_t addr, uint32_t value);
107:
108: /**
109: * qtest_inb:
110: * @s: QTestState instance to operate on.
111: * @addr: I/O port to read from.
112: * @value: Value being written.
113: *
114: * Returns an 8-bit value from an I/O port.
115: */
116: uint8_t qtest_inb(QTestState *s, uint16_t addr);
117:
118: /**
119: * qtest_inw:
120: * @s: QTestState instance to operate on.
121: * @addr: I/O port to read from.
122: * @value: Value being written.
123: *
124: * Returns a 16-bit value from an I/O port.
125: */
126: uint16_t qtest_inw(QTestState *s, uint16_t addr);
127:
128: /**
129: * qtest_inl:
130: * @s: QTestState instance to operate on.
131: * @addr: I/O port to read from.
132: * @value: Value being written.
133: *
134: * Returns a 32-bit value from an I/O port.
135: */
136: uint32_t qtest_inl(QTestState *s, uint16_t addr);
137:
138: /**
139: * qtest_memread:
140: * @s: QTestState instance to operate on.
141: * @addr: Guest address to read from.
142: * @data: Pointer to where memory contents will be stored.
143: * @size: Number of bytes to read.
144: *
145: * Read guest memory into a buffer.
146: */
147: void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size);
148:
149: /**
150: * qtest_memwrite:
151: * @s: QTestState instance to operate on.
152: * @addr: Guest address to write to.
153: * @data: Pointer to the bytes that will be written to guest memory.
154: * @size: Number of bytes to write.
155: *
156: * Write a buffer to guest memory.
157: */
158: void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size);
159:
160: /**
161: * qtest_clock_step_next:
162: * @s: QTestState instance to operate on.
163: *
164: * Advance the vm_clock to the next deadline. Return the current
165: * value of the vm_clock in nanoseconds.
166: */
167: int64_t qtest_clock_step_next(QTestState *s);
168:
169: /**
170: * qtest_clock_step:
171: * @s: QTestState instance to operate on.
172: * @step: Number of nanoseconds to advance the clock by.
173: *
174: * Advance the vm_clock by @step nanoseconds. Return the current
175: * value of the vm_clock in nanoseconds.
176: */
177: int64_t qtest_clock_step(QTestState *s, int64_t step);
178:
179: /**
180: * qtest_clock_set:
181: * @s: QTestState instance to operate on.
182: * @val: Nanoseconds value to advance the clock to.
183: *
184: * Advance the vm_clock to @val nanoseconds since the VM was launched.
185: * Return the current value of the vm_clock in nanoseconds.
186: */
187: int64_t qtest_clock_set(QTestState *s, int64_t val);
188:
189: /**
190: * qtest_get_arch:
191: *
192: * Returns the architecture for the QEMU executable under test.
193: */
194: const char *qtest_get_arch(void);
195:
196: /**
197: * qtest_add_func:
198: * @str: Test case path.
199: * @fn: Test case function
200: *
201: * Add a GTester testcase with the given name and function.
202: * The path is prefixed with the architecture under test, as
203: * returned by qtest_get_arch.
204: */
205: void qtest_add_func(const char *str, void (*fn));
206:
207: /**
208: * qtest_start:
209: * @args: other arguments to pass to QEMU
210: *
211: * Start QEMU and assign the resulting QTestState to a global variable.
212: * The global variable is used by "shortcut" macros documented below.
213: */
214: #define qtest_start(args) ( \
215: global_qtest = qtest_init((args)) \
216: )
217:
218: /**
219: * qmp:
220: * @fmt...: QMP message to send to qemu
221: *
222: * Sends a QMP message to QEMU
223: */
224: #define qmp(fmt, ...) qtest_qmp(global_qtest, fmt, ## __VA_ARGS__)
225:
226: /**
227: * get_irq:
228: * @num: Interrupt to observe.
229: *
230: * Return the level of the @num interrupt.
231: */
232: #define get_irq(num) qtest_get_irq(global_qtest, num)
233:
234: /**
235: * irq_intercept_in:
236: * @string: QOM path of a device.
237: *
238: * Associate qtest irqs with the GPIO-in pins of the device
239: * whose path is specified by @string.
240: */
241: #define irq_intercept_in(string) qtest_irq_intercept_in(global_qtest, string)
242:
243: /**
244: * qtest_irq_intercept_out:
245: * @string: QOM path of a device.
246: *
247: * Associate qtest irqs with the GPIO-out pins of the device
248: * whose path is specified by @string.
249: */
250: #define irq_intercept_out(string) qtest_irq_intercept_out(global_qtest, string)
251:
252: /**
253: * outb:
254: * @addr: I/O port to write to.
255: * @value: Value being written.
256: *
257: * Write an 8-bit value to an I/O port.
258: */
259: #define outb(addr, val) qtest_outb(global_qtest, addr, val)
260:
261: /**
262: * outw:
263: * @addr: I/O port to write to.
264: * @value: Value being written.
265: *
266: * Write a 16-bit value to an I/O port.
267: */
268: #define outw(addr, val) qtest_outw(global_qtest, addr, val)
269:
270: /**
271: * outl:
272: * @addr: I/O port to write to.
273: * @value: Value being written.
274: *
275: * Write a 32-bit value to an I/O port.
276: */
277: #define outl(addr, val) qtest_outl(global_qtest, addr, val)
278:
279: /**
280: * inb:
281: * @addr: I/O port to read from.
282: * @value: Value being written.
283: *
284: * Returns an 8-bit value from an I/O port.
285: */
286: #define inb(addr) qtest_inb(global_qtest, addr)
287:
288: /**
289: * inw:
290: * @addr: I/O port to read from.
291: * @value: Value being written.
292: *
293: * Returns a 16-bit value from an I/O port.
294: */
295: #define inw(addr) qtest_inw(global_qtest, addr)
296:
297: /**
298: * inl:
299: * @addr: I/O port to read from.
300: * @value: Value being written.
301: *
302: * Returns a 32-bit value from an I/O port.
303: */
304: #define inl(addr) qtest_inl(global_qtest, addr)
305:
306: /**
307: * memread:
308: * @addr: Guest address to read from.
309: * @data: Pointer to where memory contents will be stored.
310: * @size: Number of bytes to read.
311: *
312: * Read guest memory into a buffer.
313: */
314: #define memread(addr, data, size) qtest_memread(global_qtest, addr, data, size)
315:
316: /**
317: * memwrite:
318: * @addr: Guest address to write to.
319: * @data: Pointer to the bytes that will be written to guest memory.
320: * @size: Number of bytes to write.
321: *
322: * Write a buffer to guest memory.
323: */
324: #define memwrite(addr, data, size) qtest_memwrite(global_qtest, addr, data, size)
325:
326: /**
327: * clock_step_next:
328: *
329: * Advance the vm_clock to the next deadline. Return the current
330: * value of the vm_clock in nanoseconds.
331: */
332: #define clock_step_next() qtest_clock_step_next(global_qtest)
333:
334: /**
335: * clock_step:
336: * @step: Number of nanoseconds to advance the clock by.
337: *
338: * Advance the vm_clock by @step nanoseconds. Return the current
339: * value of the vm_clock in nanoseconds.
340: */
341: #define clock_step(step) qtest_clock_step(global_qtest, step)
342:
343: /**
344: * clock_set:
345: * @val: Nanoseconds value to advance the clock to.
346: *
347: * Advance the vm_clock to @val nanoseconds since the VM was launched.
348: * Return the current value of the vm_clock in nanoseconds.
349: */
350: #define clock_set(val) qtest_clock_set(global_qtest, val)
351:
352: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.