]>
Commit | Line | Data |
---|---|---|
49ee3590 AL |
1 | /* |
2 | * QTest | |
3 | * | |
4 | * Copyright IBM, Corp. 2012 | |
5 | * Copyright Red Hat, Inc. 2012 | |
872536bf | 6 | * Copyright SUSE LINUX Products GmbH 2013 |
49ee3590 AL |
7 | * |
8 | * Authors: | |
9 | * Anthony Liguori <aliguori@us.ibm.com> | |
10 | * Paolo Bonzini <pbonzini@redhat.com> | |
872536bf | 11 | * Andreas Färber <afaerber@suse.de> |
49ee3590 AL |
12 | * |
13 | * This work is licensed under the terms of the GNU GPL, version 2 or later. | |
14 | * See the COPYING file in the top-level directory. | |
15 | * | |
16 | */ | |
681c28a3 | 17 | #include "qemu/osdep.h" |
49ee3590 AL |
18 | #include "libqtest.h" |
19 | ||
49ee3590 AL |
20 | #include <sys/socket.h> |
21 | #include <sys/wait.h> | |
22 | #include <sys/un.h> | |
49ee3590 | 23 | |
0c460dac | 24 | #include "qapi/qmp/json-parser.h" |
563890c7 PB |
25 | #include "qapi/qmp/json-streamer.h" |
26 | #include "qapi/qmp/qjson.h" | |
49ee3590 AL |
27 | |
28 | #define MAX_IRQ 256 | |
f5d45791 | 29 | #define SOCKET_TIMEOUT 50 |
49ee3590 AL |
30 | |
31 | QTestState *global_qtest; | |
32 | ||
33 | struct QTestState | |
34 | { | |
35 | int fd; | |
a3ca163c | 36 | int qmp_fd; |
49ee3590 AL |
37 | bool irq_level[MAX_IRQ]; |
38 | GString *rx; | |
cef60c92 | 39 | pid_t qemu_pid; /* our child QEMU process */ |
54ce6f22 | 40 | bool big_endian; |
49ee3590 AL |
41 | }; |
42 | ||
063c23d9 | 43 | static GHookList abrt_hooks; |
d7668251 SH |
44 | static GList *qtest_instances; |
45 | static struct sigaction sigact_old; | |
46 | ||
49ee3590 AL |
47 | #define g_assert_no_errno(ret) do { \ |
48 | g_assert_cmpint(ret, !=, -1); \ | |
49 | } while (0) | |
50 | ||
54ce6f22 LV |
51 | static int qtest_query_target_endianness(QTestState *s); |
52 | ||
a3ca163c KW |
53 | static int init_socket(const char *socket_path) |
54 | { | |
55 | struct sockaddr_un addr; | |
56 | int sock; | |
57 | int ret; | |
58 | ||
59 | sock = socket(PF_UNIX, SOCK_STREAM, 0); | |
60 | g_assert_no_errno(sock); | |
61 | ||
62 | addr.sun_family = AF_UNIX; | |
63 | snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path); | |
64 | qemu_set_cloexec(sock); | |
65 | ||
66 | do { | |
67 | ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr)); | |
68 | } while (ret == -1 && errno == EINTR); | |
69 | g_assert_no_errno(ret); | |
a7ded163 AF |
70 | ret = listen(sock, 1); |
71 | g_assert_no_errno(ret); | |
a3ca163c KW |
72 | |
73 | return sock; | |
74 | } | |
75 | ||
76 | static int socket_accept(int sock) | |
77 | { | |
78 | struct sockaddr_un addr; | |
79 | socklen_t addrlen; | |
80 | int ret; | |
f8762027 MA |
81 | struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT, |
82 | .tv_usec = 0 }; | |
83 | ||
84 | setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout, | |
85 | sizeof(timeout)); | |
a3ca163c KW |
86 | |
87 | do { | |
535b4563 | 88 | addrlen = sizeof(addr); |
a3ca163c KW |
89 | ret = accept(sock, (struct sockaddr *)&addr, &addrlen); |
90 | } while (ret == -1 && errno == EINTR); | |
a7d915f3 AF |
91 | if (ret == -1) { |
92 | fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno)); | |
93 | } | |
a3ca163c KW |
94 | close(sock); |
95 | ||
96 | return ret; | |
97 | } | |
98 | ||
b15d422a SH |
99 | static void kill_qemu(QTestState *s) |
100 | { | |
101 | if (s->qemu_pid != -1) { | |
102 | kill(s->qemu_pid, SIGTERM); | |
103 | waitpid(s->qemu_pid, NULL, 0); | |
104 | } | |
105 | } | |
106 | ||
041088c7 MA |
107 | static void kill_qemu_hook_func(void *s) |
108 | { | |
109 | kill_qemu(s); | |
110 | } | |
111 | ||
b15d422a SH |
112 | static void sigabrt_handler(int signo) |
113 | { | |
063c23d9 | 114 | g_hook_list_invoke(&abrt_hooks, FALSE); |
d7668251 SH |
115 | } |
116 | ||
117 | static void setup_sigabrt_handler(void) | |
118 | { | |
119 | struct sigaction sigact; | |
120 | ||
121 | /* Catch SIGABRT to clean up on g_assert() failure */ | |
122 | sigact = (struct sigaction){ | |
123 | .sa_handler = sigabrt_handler, | |
124 | .sa_flags = SA_RESETHAND, | |
125 | }; | |
126 | sigemptyset(&sigact.sa_mask); | |
127 | sigaction(SIGABRT, &sigact, &sigact_old); | |
128 | } | |
129 | ||
130 | static void cleanup_sigabrt_handler(void) | |
131 | { | |
132 | sigaction(SIGABRT, &sigact_old, NULL); | |
b15d422a SH |
133 | } |
134 | ||
041088c7 | 135 | void qtest_add_abrt_handler(GHookFunc fn, const void *data) |
063c23d9 MAL |
136 | { |
137 | GHook *hook; | |
138 | ||
139 | /* Only install SIGABRT handler once */ | |
140 | if (!abrt_hooks.is_setup) { | |
141 | g_hook_list_init(&abrt_hooks, sizeof(GHook)); | |
142 | setup_sigabrt_handler(); | |
143 | } | |
144 | ||
145 | hook = g_hook_alloc(&abrt_hooks); | |
146 | hook->func = fn; | |
147 | hook->data = (void *)data; | |
148 | ||
149 | g_hook_prepend(&abrt_hooks, hook); | |
150 | } | |
151 | ||
49ee3590 AL |
152 | QTestState *qtest_init(const char *extra_args) |
153 | { | |
154 | QTestState *s; | |
8a8fd637 | 155 | int sock, qmpsock, i; |
56db2e58 SH |
156 | gchar *socket_path; |
157 | gchar *qmp_socket_path; | |
49ee3590 AL |
158 | gchar *command; |
159 | const char *qemu_binary; | |
49ee3590 AL |
160 | |
161 | qemu_binary = getenv("QTEST_QEMU_BINARY"); | |
162 | g_assert(qemu_binary != NULL); | |
163 | ||
96b8ca47 | 164 | s = g_malloc(sizeof(*s)); |
49ee3590 | 165 | |
56db2e58 SH |
166 | socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid()); |
167 | qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid()); | |
bb494a50 | 168 | |
56db2e58 SH |
169 | sock = init_socket(socket_path); |
170 | qmpsock = init_socket(qmp_socket_path); | |
49ee3590 | 171 | |
041088c7 | 172 | qtest_add_abrt_handler(kill_qemu_hook_func, s); |
b15d422a | 173 | |
cef60c92 SH |
174 | s->qemu_pid = fork(); |
175 | if (s->qemu_pid == 0) { | |
6b029216 | 176 | setenv("QEMU_AUDIO_DRV", "none", true); |
cef60c92 | 177 | command = g_strdup_printf("exec %s " |
49ee3590 | 178 | "-qtest unix:%s,nowait " |
7c282cb4 | 179 | "-qtest-log %s " |
a3ca163c | 180 | "-qmp unix:%s,nowait " |
49ee3590 | 181 | "-machine accel=qtest " |
2ad645d2 | 182 | "-display none " |
56db2e58 | 183 | "%s", qemu_binary, socket_path, |
7c282cb4 | 184 | getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null", |
cef60c92 | 185 | qmp_socket_path, |
49ee3590 | 186 | extra_args ?: ""); |
8a8fd637 AL |
187 | execlp("/bin/sh", "sh", "-c", command, NULL); |
188 | exit(1); | |
49ee3590 AL |
189 | } |
190 | ||
a3ca163c | 191 | s->fd = socket_accept(sock); |
f8762027 MA |
192 | if (s->fd >= 0) { |
193 | s->qmp_fd = socket_accept(qmpsock); | |
194 | } | |
56db2e58 SH |
195 | unlink(socket_path); |
196 | unlink(qmp_socket_path); | |
197 | g_free(socket_path); | |
198 | g_free(qmp_socket_path); | |
49ee3590 | 199 | |
f8762027 MA |
200 | g_assert(s->fd >= 0 && s->qmp_fd >= 0); |
201 | ||
49ee3590 | 202 | s->rx = g_string_new(""); |
49ee3590 AL |
203 | for (i = 0; i < MAX_IRQ; i++) { |
204 | s->irq_level[i] = false; | |
205 | } | |
206 | ||
a3ca163c | 207 | /* Read the QMP greeting and then do the handshake */ |
0d1aa05e SH |
208 | qtest_qmp_discard_response(s, ""); |
209 | qtest_qmp_discard_response(s, "{ 'execute': 'qmp_capabilities' }"); | |
49ee3590 | 210 | |
e0fea6b1 | 211 | if (getenv("QTEST_STOP")) { |
1ad3c6ab | 212 | kill(s->qemu_pid, SIGSTOP); |
e0fea6b1 PB |
213 | } |
214 | ||
54ce6f22 LV |
215 | /* ask endianness of the target */ |
216 | ||
217 | s->big_endian = qtest_query_target_endianness(s); | |
218 | ||
49ee3590 AL |
219 | return s; |
220 | } | |
221 | ||
222 | void qtest_quit(QTestState *s) | |
223 | { | |
063c23d9 MAL |
224 | qtest_instances = g_list_remove(qtest_instances, s); |
225 | g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s)); | |
226 | ||
d7668251 | 227 | /* Uninstall SIGABRT handler on last instance */ |
063c23d9 | 228 | if (!qtest_instances) { |
d7668251 SH |
229 | cleanup_sigabrt_handler(); |
230 | } | |
231 | ||
b15d422a | 232 | kill_qemu(s); |
fdd26fca MA |
233 | close(s->fd); |
234 | close(s->qmp_fd); | |
235 | g_string_free(s->rx, true); | |
fdd26fca | 236 | g_free(s); |
49ee3590 AL |
237 | } |
238 | ||
563890c7 | 239 | static void socket_send(int fd, const char *buf, size_t size) |
49ee3590 | 240 | { |
563890c7 | 241 | size_t offset; |
49ee3590 AL |
242 | |
243 | offset = 0; | |
244 | while (offset < size) { | |
245 | ssize_t len; | |
246 | ||
563890c7 | 247 | len = write(fd, buf + offset, size - offset); |
49ee3590 AL |
248 | if (len == -1 && errno == EINTR) { |
249 | continue; | |
250 | } | |
251 | ||
252 | g_assert_no_errno(len); | |
253 | g_assert_cmpint(len, >, 0); | |
254 | ||
255 | offset += len; | |
256 | } | |
257 | } | |
258 | ||
563890c7 PB |
259 | static void socket_sendf(int fd, const char *fmt, va_list ap) |
260 | { | |
261 | gchar *str = g_strdup_vprintf(fmt, ap); | |
262 | size_t size = strlen(str); | |
263 | ||
264 | socket_send(fd, str, size); | |
265 | g_free(str); | |
266 | } | |
267 | ||
a3ca163c KW |
268 | static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) |
269 | { | |
270 | va_list ap; | |
271 | ||
272 | va_start(ap, fmt); | |
273 | socket_sendf(s->fd, fmt, ap); | |
274 | va_end(ap); | |
275 | } | |
276 | ||
49ee3590 AL |
277 | static GString *qtest_recv_line(QTestState *s) |
278 | { | |
279 | GString *line; | |
280 | size_t offset; | |
281 | char *eol; | |
282 | ||
283 | while ((eol = strchr(s->rx->str, '\n')) == NULL) { | |
284 | ssize_t len; | |
285 | char buffer[1024]; | |
286 | ||
287 | len = read(s->fd, buffer, sizeof(buffer)); | |
288 | if (len == -1 && errno == EINTR) { | |
289 | continue; | |
290 | } | |
291 | ||
292 | if (len == -1 || len == 0) { | |
293 | fprintf(stderr, "Broken pipe\n"); | |
294 | exit(1); | |
295 | } | |
296 | ||
297 | g_string_append_len(s->rx, buffer, len); | |
298 | } | |
299 | ||
300 | offset = eol - s->rx->str; | |
301 | line = g_string_new_len(s->rx->str, offset); | |
302 | g_string_erase(s->rx, 0, offset + 1); | |
303 | ||
304 | return line; | |
305 | } | |
306 | ||
307 | static gchar **qtest_rsp(QTestState *s, int expected_args) | |
308 | { | |
309 | GString *line; | |
310 | gchar **words; | |
311 | int i; | |
312 | ||
313 | redo: | |
314 | line = qtest_recv_line(s); | |
315 | words = g_strsplit(line->str, " ", 0); | |
316 | g_string_free(line, TRUE); | |
317 | ||
318 | if (strcmp(words[0], "IRQ") == 0) { | |
319 | int irq; | |
320 | ||
321 | g_assert(words[1] != NULL); | |
322 | g_assert(words[2] != NULL); | |
323 | ||
324 | irq = strtoul(words[2], NULL, 0); | |
325 | g_assert_cmpint(irq, >=, 0); | |
326 | g_assert_cmpint(irq, <, MAX_IRQ); | |
327 | ||
328 | if (strcmp(words[1], "raise") == 0) { | |
329 | s->irq_level[irq] = true; | |
330 | } else { | |
331 | s->irq_level[irq] = false; | |
332 | } | |
333 | ||
334 | g_strfreev(words); | |
335 | goto redo; | |
336 | } | |
337 | ||
338 | g_assert(words[0] != NULL); | |
339 | g_assert_cmpstr(words[0], ==, "OK"); | |
340 | ||
341 | if (expected_args) { | |
342 | for (i = 0; i < expected_args; i++) { | |
343 | g_assert(words[i] != NULL); | |
344 | } | |
345 | } else { | |
346 | g_strfreev(words); | |
347 | } | |
348 | ||
349 | return words; | |
350 | } | |
351 | ||
54ce6f22 LV |
352 | static int qtest_query_target_endianness(QTestState *s) |
353 | { | |
354 | gchar **args; | |
355 | int big_endian; | |
356 | ||
357 | qtest_sendf(s, "endianness\n"); | |
358 | args = qtest_rsp(s, 1); | |
359 | g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0); | |
360 | big_endian = strcmp(args[1], "big") == 0; | |
361 | g_strfreev(args); | |
362 | ||
363 | return big_endian; | |
364 | } | |
365 | ||
0c460dac SH |
366 | typedef struct { |
367 | JSONMessageParser parser; | |
368 | QDict *response; | |
369 | } QMPResponseParser; | |
370 | ||
95385fe9 | 371 | static void qmp_response(JSONMessageParser *parser, GQueue *tokens) |
a3ca163c | 372 | { |
0c460dac SH |
373 | QMPResponseParser *qmp = container_of(parser, QMPResponseParser, parser); |
374 | QObject *obj; | |
375 | ||
376 | obj = json_parser_parse(tokens, NULL); | |
377 | if (!obj) { | |
378 | fprintf(stderr, "QMP JSON response parsing failed\n"); | |
379 | exit(1); | |
380 | } | |
381 | ||
382 | g_assert(qobject_type(obj) == QTYPE_QDICT); | |
383 | g_assert(!qmp->response); | |
384 | qmp->response = (QDict *)obj; | |
385 | } | |
386 | ||
dc47995e | 387 | QDict *qmp_fd_receive(int fd) |
0c460dac SH |
388 | { |
389 | QMPResponseParser qmp; | |
7c282cb4 | 390 | bool log = getenv("QTEST_LOG") != NULL; |
a3ca163c | 391 | |
0c460dac SH |
392 | qmp.response = NULL; |
393 | json_message_parser_init(&qmp.parser, qmp_response); | |
394 | while (!qmp.response) { | |
a3ca163c KW |
395 | ssize_t len; |
396 | char c; | |
397 | ||
dc47995e | 398 | len = read(fd, &c, 1); |
a3ca163c KW |
399 | if (len == -1 && errno == EINTR) { |
400 | continue; | |
401 | } | |
402 | ||
039380a8 AL |
403 | if (len == -1 || len == 0) { |
404 | fprintf(stderr, "Broken pipe\n"); | |
405 | exit(1); | |
406 | } | |
407 | ||
7c282cb4 PB |
408 | if (log) { |
409 | len = write(2, &c, 1); | |
410 | } | |
0c460dac | 411 | json_message_parser_feed(&qmp.parser, &c, 1); |
a3ca163c | 412 | } |
0c460dac SH |
413 | json_message_parser_destroy(&qmp.parser); |
414 | ||
415 | return qmp.response; | |
416 | } | |
417 | ||
dc47995e MAL |
418 | QDict *qtest_qmp_receive(QTestState *s) |
419 | { | |
420 | return qmp_fd_receive(s->qmp_fd); | |
421 | } | |
422 | ||
ba4ed393 JS |
423 | /** |
424 | * Allow users to send a message without waiting for the reply, | |
425 | * in the case that they choose to discard all replies up until | |
426 | * a particular EVENT is received. | |
427 | */ | |
dc47995e | 428 | void qmp_fd_sendv(int fd, const char *fmt, va_list ap) |
66e0c7b1 | 429 | { |
563890c7 PB |
430 | va_list ap_copy; |
431 | QObject *qobj; | |
432 | ||
433 | /* Going through qobject ensures we escape strings properly. | |
434 | * This seemingly unnecessary copy is required in case va_list | |
435 | * is an array type. | |
436 | */ | |
437 | va_copy(ap_copy, ap); | |
438 | qobj = qobject_from_jsonv(fmt, &ap_copy); | |
439 | va_end(ap_copy); | |
440 | ||
441 | /* No need to send anything for an empty QObject. */ | |
442 | if (qobj) { | |
ae74f187 | 443 | int log = getenv("QTEST_LOG") != NULL; |
563890c7 PB |
444 | QString *qstr = qobject_to_json(qobj); |
445 | const char *str = qstring_get_str(qstr); | |
446 | size_t size = qstring_get_length(qstr); | |
447 | ||
ae74f187 MM |
448 | if (log) { |
449 | fprintf(stderr, "%s", str); | |
450 | } | |
563890c7 | 451 | /* Send QMP request */ |
dc47995e | 452 | socket_send(fd, str, size); |
563890c7 PB |
453 | |
454 | QDECREF(qstr); | |
455 | qobject_decref(qobj); | |
456 | } | |
ba4ed393 JS |
457 | } |
458 | ||
dc47995e MAL |
459 | void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap) |
460 | { | |
461 | qmp_fd_sendv(s->qmp_fd, fmt, ap); | |
462 | } | |
463 | ||
464 | QDict *qmp_fdv(int fd, const char *fmt, va_list ap) | |
465 | { | |
466 | qmp_fd_sendv(fd, fmt, ap); | |
467 | ||
468 | return qmp_fd_receive(fd); | |
469 | } | |
470 | ||
ba4ed393 JS |
471 | QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap) |
472 | { | |
473 | qtest_async_qmpv(s, fmt, ap); | |
66e0c7b1 AF |
474 | |
475 | /* Receive reply */ | |
476 | return qtest_qmp_receive(s); | |
477 | } | |
478 | ||
dc47995e MAL |
479 | QDict *qmp_fd(int fd, const char *fmt, ...) |
480 | { | |
481 | va_list ap; | |
482 | QDict *response; | |
483 | ||
484 | va_start(ap, fmt); | |
485 | response = qmp_fdv(fd, fmt, ap); | |
486 | va_end(ap); | |
487 | return response; | |
488 | } | |
489 | ||
490 | void qmp_fd_send(int fd, const char *fmt, ...) | |
491 | { | |
492 | va_list ap; | |
493 | ||
494 | va_start(ap, fmt); | |
495 | qmp_fd_sendv(fd, fmt, ap); | |
496 | va_end(ap); | |
497 | } | |
498 | ||
0c460dac SH |
499 | QDict *qtest_qmp(QTestState *s, const char *fmt, ...) |
500 | { | |
501 | va_list ap; | |
502 | QDict *response; | |
503 | ||
504 | va_start(ap, fmt); | |
505 | response = qtest_qmpv(s, fmt, ap); | |
506 | va_end(ap); | |
507 | return response; | |
508 | } | |
509 | ||
ba4ed393 JS |
510 | void qtest_async_qmp(QTestState *s, const char *fmt, ...) |
511 | { | |
512 | va_list ap; | |
513 | ||
514 | va_start(ap, fmt); | |
515 | qtest_async_qmpv(s, fmt, ap); | |
516 | va_end(ap); | |
517 | } | |
518 | ||
0c460dac SH |
519 | void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap) |
520 | { | |
521 | QDict *response = qtest_qmpv(s, fmt, ap); | |
522 | QDECREF(response); | |
a3ca163c KW |
523 | } |
524 | ||
0d1aa05e | 525 | void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...) |
b73cf9e9 AF |
526 | { |
527 | va_list ap; | |
0c460dac | 528 | QDict *response; |
b73cf9e9 AF |
529 | |
530 | va_start(ap, fmt); | |
0c460dac | 531 | response = qtest_qmpv(s, fmt, ap); |
b73cf9e9 | 532 | va_end(ap); |
0c460dac | 533 | QDECREF(response); |
b73cf9e9 AF |
534 | } |
535 | ||
8fe941f7 JS |
536 | void qtest_qmp_eventwait(QTestState *s, const char *event) |
537 | { | |
538 | QDict *response; | |
539 | ||
540 | for (;;) { | |
541 | response = qtest_qmp_receive(s); | |
542 | if ((qdict_haskey(response, "event")) && | |
543 | (strcmp(qdict_get_str(response, "event"), event) == 0)) { | |
544 | QDECREF(response); | |
545 | break; | |
546 | } | |
547 | QDECREF(response); | |
548 | } | |
549 | } | |
550 | ||
5fb48d96 MA |
551 | char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap) |
552 | { | |
553 | char *cmd; | |
554 | QDict *resp; | |
555 | char *ret; | |
556 | ||
557 | cmd = g_strdup_vprintf(fmt, ap); | |
558 | resp = qtest_qmp(s, "{'execute': 'human-monitor-command'," | |
559 | " 'arguments': {'command-line': %s}}", | |
560 | cmd); | |
561 | ret = g_strdup(qdict_get_try_str(resp, "return")); | |
562 | g_assert(ret); | |
563 | QDECREF(resp); | |
564 | g_free(cmd); | |
565 | return ret; | |
566 | } | |
567 | ||
568 | char *qtest_hmp(QTestState *s, const char *fmt, ...) | |
569 | { | |
570 | va_list ap; | |
571 | char *ret; | |
572 | ||
573 | va_start(ap, fmt); | |
574 | ret = qtest_hmpv(s, fmt, ap); | |
575 | va_end(ap); | |
576 | return ret; | |
577 | } | |
8fe941f7 | 578 | |
49ee3590 AL |
579 | const char *qtest_get_arch(void) |
580 | { | |
581 | const char *qemu = getenv("QTEST_QEMU_BINARY"); | |
c8368674 | 582 | g_assert(qemu != NULL); |
49ee3590 AL |
583 | const char *end = strrchr(qemu, '/'); |
584 | ||
585 | return end + strlen("/qemu-system-"); | |
586 | } | |
587 | ||
588 | bool qtest_get_irq(QTestState *s, int num) | |
589 | { | |
590 | /* dummy operation in order to make sure irq is up to date */ | |
591 | qtest_inb(s, 0); | |
592 | ||
593 | return s->irq_level[num]; | |
594 | } | |
595 | ||
596 | static int64_t qtest_clock_rsp(QTestState *s) | |
597 | { | |
598 | gchar **words; | |
599 | int64_t clock; | |
600 | words = qtest_rsp(s, 2); | |
601 | clock = g_ascii_strtoll(words[1], NULL, 0); | |
602 | g_strfreev(words); | |
603 | return clock; | |
604 | } | |
605 | ||
606 | int64_t qtest_clock_step_next(QTestState *s) | |
607 | { | |
608 | qtest_sendf(s, "clock_step\n"); | |
609 | return qtest_clock_rsp(s); | |
610 | } | |
611 | ||
612 | int64_t qtest_clock_step(QTestState *s, int64_t step) | |
613 | { | |
614 | qtest_sendf(s, "clock_step %"PRIi64"\n", step); | |
615 | return qtest_clock_rsp(s); | |
616 | } | |
617 | ||
618 | int64_t qtest_clock_set(QTestState *s, int64_t val) | |
619 | { | |
620 | qtest_sendf(s, "clock_set %"PRIi64"\n", val); | |
621 | return qtest_clock_rsp(s); | |
622 | } | |
623 | ||
624 | void qtest_irq_intercept_out(QTestState *s, const char *qom_path) | |
625 | { | |
626 | qtest_sendf(s, "irq_intercept_out %s\n", qom_path); | |
627 | qtest_rsp(s, 0); | |
628 | } | |
629 | ||
630 | void qtest_irq_intercept_in(QTestState *s, const char *qom_path) | |
631 | { | |
632 | qtest_sendf(s, "irq_intercept_in %s\n", qom_path); | |
633 | qtest_rsp(s, 0); | |
634 | } | |
635 | ||
636 | static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value) | |
637 | { | |
638 | qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value); | |
639 | qtest_rsp(s, 0); | |
640 | } | |
641 | ||
642 | void qtest_outb(QTestState *s, uint16_t addr, uint8_t value) | |
643 | { | |
644 | qtest_out(s, "outb", addr, value); | |
645 | } | |
646 | ||
647 | void qtest_outw(QTestState *s, uint16_t addr, uint16_t value) | |
648 | { | |
649 | qtest_out(s, "outw", addr, value); | |
650 | } | |
651 | ||
652 | void qtest_outl(QTestState *s, uint16_t addr, uint32_t value) | |
653 | { | |
654 | qtest_out(s, "outl", addr, value); | |
655 | } | |
656 | ||
657 | static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr) | |
658 | { | |
659 | gchar **args; | |
660 | uint32_t value; | |
661 | ||
662 | qtest_sendf(s, "%s 0x%x\n", cmd, addr); | |
663 | args = qtest_rsp(s, 2); | |
664 | value = strtoul(args[1], NULL, 0); | |
665 | g_strfreev(args); | |
666 | ||
667 | return value; | |
668 | } | |
669 | ||
670 | uint8_t qtest_inb(QTestState *s, uint16_t addr) | |
671 | { | |
672 | return qtest_in(s, "inb", addr); | |
673 | } | |
674 | ||
675 | uint16_t qtest_inw(QTestState *s, uint16_t addr) | |
676 | { | |
677 | return qtest_in(s, "inw", addr); | |
678 | } | |
679 | ||
680 | uint32_t qtest_inl(QTestState *s, uint16_t addr) | |
681 | { | |
682 | return qtest_in(s, "inl", addr); | |
683 | } | |
684 | ||
872536bf AF |
685 | static void qtest_write(QTestState *s, const char *cmd, uint64_t addr, |
686 | uint64_t value) | |
687 | { | |
688 | qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value); | |
689 | qtest_rsp(s, 0); | |
690 | } | |
691 | ||
692 | void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value) | |
693 | { | |
694 | qtest_write(s, "writeb", addr, value); | |
695 | } | |
696 | ||
697 | void qtest_writew(QTestState *s, uint64_t addr, uint16_t value) | |
698 | { | |
699 | qtest_write(s, "writew", addr, value); | |
700 | } | |
701 | ||
702 | void qtest_writel(QTestState *s, uint64_t addr, uint32_t value) | |
703 | { | |
704 | qtest_write(s, "writel", addr, value); | |
705 | } | |
706 | ||
707 | void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value) | |
708 | { | |
709 | qtest_write(s, "writeq", addr, value); | |
710 | } | |
711 | ||
712 | static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr) | |
713 | { | |
714 | gchar **args; | |
715 | uint64_t value; | |
716 | ||
717 | qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr); | |
718 | args = qtest_rsp(s, 2); | |
719 | value = strtoull(args[1], NULL, 0); | |
720 | g_strfreev(args); | |
721 | ||
722 | return value; | |
723 | } | |
724 | ||
725 | uint8_t qtest_readb(QTestState *s, uint64_t addr) | |
726 | { | |
727 | return qtest_read(s, "readb", addr); | |
728 | } | |
729 | ||
730 | uint16_t qtest_readw(QTestState *s, uint64_t addr) | |
731 | { | |
732 | return qtest_read(s, "readw", addr); | |
733 | } | |
734 | ||
735 | uint32_t qtest_readl(QTestState *s, uint64_t addr) | |
736 | { | |
737 | return qtest_read(s, "readl", addr); | |
738 | } | |
739 | ||
740 | uint64_t qtest_readq(QTestState *s, uint64_t addr) | |
741 | { | |
742 | return qtest_read(s, "readq", addr); | |
743 | } | |
744 | ||
49ee3590 AL |
745 | static int hex2nib(char ch) |
746 | { | |
747 | if (ch >= '0' && ch <= '9') { | |
748 | return ch - '0'; | |
749 | } else if (ch >= 'a' && ch <= 'f') { | |
750 | return 10 + (ch - 'a'); | |
751 | } else if (ch >= 'A' && ch <= 'F') { | |
752 | return 10 + (ch - 'a'); | |
753 | } else { | |
754 | return -1; | |
755 | } | |
756 | } | |
757 | ||
758 | void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size) | |
759 | { | |
760 | uint8_t *ptr = data; | |
761 | gchar **args; | |
762 | size_t i; | |
763 | ||
ea7697fc | 764 | qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size); |
49ee3590 AL |
765 | args = qtest_rsp(s, 2); |
766 | ||
767 | for (i = 0; i < size; i++) { | |
768 | ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4; | |
769 | ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]); | |
770 | } | |
771 | ||
772 | g_strfreev(args); | |
773 | } | |
774 | ||
eeddd59f LV |
775 | uint64_t qtest_rtas_call(QTestState *s, const char *name, |
776 | uint32_t nargs, uint64_t args, | |
777 | uint32_t nret, uint64_t ret) | |
778 | { | |
779 | qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n", | |
780 | name, nargs, args, nret, ret); | |
781 | qtest_rsp(s, 0); | |
782 | return 0; | |
783 | } | |
784 | ||
041088c7 | 785 | void qtest_add_func(const char *str, void (*fn)(void)) |
49ee3590 AL |
786 | { |
787 | gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); | |
788 | g_test_add_func(path, fn); | |
a7afc6b8 | 789 | g_free(path); |
49ee3590 AL |
790 | } |
791 | ||
822e36ca MAL |
792 | void qtest_add_data_func_full(const char *str, void *data, |
793 | void (*fn)(const void *), | |
794 | GDestroyNotify data_free_func) | |
795 | { | |
796 | gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); | |
797 | #if GLIB_CHECK_VERSION(2, 34, 0) | |
798 | g_test_add_data_func_full(path, data, fn, data_free_func); | |
799 | #elif GLIB_CHECK_VERSION(2, 26, 0) | |
800 | /* back-compat casts, remove this once we can require new-enough glib */ | |
801 | g_test_add_vtable(path, 0, data, NULL, | |
802 | (GTestFixtureFunc)fn, (GTestFixtureFunc) data_free_func); | |
803 | #else | |
804 | /* back-compat casts, remove this once we can require new-enough glib */ | |
805 | g_test_add_vtable(path, 0, data, NULL, | |
806 | (void (*)(void)) fn, (void (*)(void)) data_free_func); | |
807 | #endif | |
808 | g_free(path); | |
809 | } | |
810 | ||
041088c7 MA |
811 | void qtest_add_data_func(const char *str, const void *data, |
812 | void (*fn)(const void *)) | |
7949c0e3 AF |
813 | { |
814 | gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); | |
815 | g_test_add_data_func(path, data, fn); | |
816 | g_free(path); | |
817 | } | |
818 | ||
7a6a740d JS |
819 | void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size) |
820 | { | |
821 | gchar *bdata; | |
822 | ||
823 | bdata = g_base64_encode(data, size); | |
824 | qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size); | |
825 | socket_send(s->fd, bdata, strlen(bdata)); | |
826 | socket_send(s->fd, "\n", 1); | |
827 | qtest_rsp(s, 0); | |
828 | g_free(bdata); | |
829 | } | |
830 | ||
831 | void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size) | |
832 | { | |
833 | gchar **args; | |
834 | size_t len; | |
835 | ||
836 | qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size); | |
837 | args = qtest_rsp(s, 2); | |
838 | ||
839 | g_base64_decode_inplace(args[1], &len); | |
840 | if (size != len) { | |
841 | fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n", | |
842 | size, len); | |
843 | len = MIN(len, size); | |
844 | } | |
845 | ||
846 | memcpy(data, args[1], len); | |
847 | g_strfreev(args); | |
848 | } | |
849 | ||
49ee3590 AL |
850 | void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size) |
851 | { | |
852 | const uint8_t *ptr = data; | |
853 | size_t i; | |
5560b85a | 854 | char *enc = g_malloc(2 * size + 1); |
49ee3590 | 855 | |
49ee3590 | 856 | for (i = 0; i < size; i++) { |
5560b85a | 857 | sprintf(&enc[i * 2], "%02x", ptr[i]); |
49ee3590 | 858 | } |
5560b85a JS |
859 | |
860 | qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc); | |
49ee3590 | 861 | qtest_rsp(s, 0); |
5560b85a | 862 | g_free(enc); |
49ee3590 | 863 | } |
0100f425 | 864 | |
86298845 JS |
865 | void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size) |
866 | { | |
4d007963 | 867 | qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern); |
86298845 JS |
868 | qtest_rsp(s, 0); |
869 | } | |
870 | ||
0100f425 PM |
871 | QDict *qmp(const char *fmt, ...) |
872 | { | |
873 | va_list ap; | |
874 | QDict *response; | |
875 | ||
876 | va_start(ap, fmt); | |
877 | response = qtest_qmpv(global_qtest, fmt, ap); | |
878 | va_end(ap); | |
879 | return response; | |
880 | } | |
881 | ||
ba4ed393 JS |
882 | void qmp_async(const char *fmt, ...) |
883 | { | |
884 | va_list ap; | |
885 | ||
886 | va_start(ap, fmt); | |
887 | qtest_async_qmpv(global_qtest, fmt, ap); | |
888 | va_end(ap); | |
889 | } | |
890 | ||
0100f425 PM |
891 | void qmp_discard_response(const char *fmt, ...) |
892 | { | |
893 | va_list ap; | |
894 | ||
895 | va_start(ap, fmt); | |
896 | qtest_qmpv_discard_response(global_qtest, fmt, ap); | |
897 | va_end(ap); | |
898 | } | |
5fb48d96 MA |
899 | char *hmp(const char *fmt, ...) |
900 | { | |
901 | va_list ap; | |
902 | char *ret; | |
903 | ||
904 | va_start(ap, fmt); | |
905 | ret = qtest_hmpv(global_qtest, fmt, ap); | |
906 | va_end(ap); | |
907 | return ret; | |
908 | } | |
46e0cf76 | 909 | |
54ce6f22 | 910 | bool qtest_big_endian(QTestState *s) |
46e0cf76 | 911 | { |
54ce6f22 | 912 | return s->big_endian; |
46e0cf76 | 913 | } |