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