qtest: do not return freed argument vector from qtest_rsp
[qemu.git] / tests / qtest / libqtest.c
1 /*
2 * QTest
3 *
4 * Copyright IBM, Corp. 2012
5 * Copyright Red Hat, Inc. 2012
6 * Copyright SUSE LINUX Products GmbH 2013
7 *
8 * Authors:
9 * Anthony Liguori <aliguori@us.ibm.com>
10 * Paolo Bonzini <pbonzini@redhat.com>
11 * Andreas Färber <afaerber@suse.de>
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 "qemu/osdep.h"
18
19 #include <sys/socket.h>
20 #include <sys/wait.h>
21 #include <sys/un.h>
22
23 #include "libqos/libqtest.h"
24 #include "qemu-common.h"
25 #include "qemu/ctype.h"
26 #include "qemu/cutils.h"
27 #include "qapi/error.h"
28 #include "qapi/qmp/json-parser.h"
29 #include "qapi/qmp/qdict.h"
30 #include "qapi/qmp/qjson.h"
31 #include "qapi/qmp/qlist.h"
32 #include "qapi/qmp/qstring.h"
33
34 #define MAX_IRQ 256
35 #define SOCKET_TIMEOUT 50
36 #define SOCKET_MAX_FDS 16
37
38
39 typedef void (*QTestSendFn)(QTestState *s, const char *buf);
40 typedef void (*ExternalSendFn)(void *s, const char *buf);
41 typedef GString* (*QTestRecvFn)(QTestState *);
42
43 typedef struct QTestClientTransportOps {
44 QTestSendFn send; /* for sending qtest commands */
45
46 /*
47 * use external_send to send qtest command strings through functions which
48 * do not accept a QTestState as the first parameter.
49 */
50 ExternalSendFn external_send;
51
52 QTestRecvFn recv_line; /* for receiving qtest command responses */
53 } QTestTransportOps;
54
55 struct QTestState
56 {
57 int fd;
58 int qmp_fd;
59 pid_t qemu_pid; /* our child QEMU process */
60 int wstatus;
61 int expected_status;
62 bool big_endian;
63 bool irq_level[MAX_IRQ];
64 GString *rx;
65 QTestTransportOps ops;
66 GList *pending_events;
67 };
68
69 static GHookList abrt_hooks;
70 static struct sigaction sigact_old;
71
72 static int qtest_query_target_endianness(QTestState *s);
73
74 static void qtest_client_socket_send(QTestState*, const char *buf);
75 static void socket_send(int fd, const char *buf, size_t size);
76
77 static GString *qtest_client_socket_recv_line(QTestState *);
78
79 static void qtest_client_set_tx_handler(QTestState *s, QTestSendFn send);
80 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv);
81
82 static int init_socket(const char *socket_path)
83 {
84 struct sockaddr_un addr;
85 int sock;
86 int ret;
87
88 sock = socket(PF_UNIX, SOCK_STREAM, 0);
89 g_assert_cmpint(sock, !=, -1);
90
91 addr.sun_family = AF_UNIX;
92 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
93 qemu_set_cloexec(sock);
94
95 do {
96 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
97 } while (ret == -1 && errno == EINTR);
98 g_assert_cmpint(ret, !=, -1);
99 ret = listen(sock, 1);
100 g_assert_cmpint(ret, !=, -1);
101
102 return sock;
103 }
104
105 static int socket_accept(int sock)
106 {
107 struct sockaddr_un addr;
108 socklen_t addrlen;
109 int ret;
110 struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
111 .tv_usec = 0 };
112
113 if (qemu_setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO,
114 (void *)&timeout, sizeof(timeout))) {
115 fprintf(stderr, "%s failed to set SO_RCVTIMEO: %s\n",
116 __func__, strerror(errno));
117 close(sock);
118 return -1;
119 }
120
121 do {
122 addrlen = sizeof(addr);
123 ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
124 } while (ret == -1 && errno == EINTR);
125 if (ret == -1) {
126 fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno));
127 }
128 close(sock);
129
130 return ret;
131 }
132
133 bool qtest_probe_child(QTestState *s)
134 {
135 pid_t pid = s->qemu_pid;
136
137 if (pid != -1) {
138 pid = waitpid(pid, &s->wstatus, WNOHANG);
139 if (pid == 0) {
140 return true;
141 }
142 s->qemu_pid = -1;
143 }
144 return false;
145 }
146
147 void qtest_set_expected_status(QTestState *s, int status)
148 {
149 s->expected_status = status;
150 }
151
152 static void kill_qemu(QTestState *s)
153 {
154 pid_t pid = s->qemu_pid;
155 int wstatus;
156
157 /* Skip wait if qtest_probe_child already reaped. */
158 if (pid != -1) {
159 kill(pid, SIGTERM);
160 TFR(pid = waitpid(s->qemu_pid, &s->wstatus, 0));
161 assert(pid == s->qemu_pid);
162 }
163
164 /*
165 * Check whether qemu exited with expected exit status; anything else is
166 * fishy and should be logged with as much detail as possible.
167 */
168 wstatus = s->wstatus;
169 if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) != s->expected_status) {
170 fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU "
171 "process but encountered exit status %d (expected %d)\n",
172 __FILE__, __LINE__, WEXITSTATUS(wstatus), s->expected_status);
173 abort();
174 } else if (WIFSIGNALED(wstatus)) {
175 int sig = WTERMSIG(wstatus);
176 const char *signame = strsignal(sig) ?: "unknown ???";
177 const char *dump = WCOREDUMP(wstatus) ? " (core dumped)" : "";
178
179 fprintf(stderr, "%s:%d: kill_qemu() detected QEMU death "
180 "from signal %d (%s)%s\n",
181 __FILE__, __LINE__, sig, signame, dump);
182 abort();
183 }
184 }
185
186 static void kill_qemu_hook_func(void *s)
187 {
188 kill_qemu(s);
189 }
190
191 static void sigabrt_handler(int signo)
192 {
193 g_hook_list_invoke(&abrt_hooks, FALSE);
194 }
195
196 static void setup_sigabrt_handler(void)
197 {
198 struct sigaction sigact;
199
200 /* Catch SIGABRT to clean up on g_assert() failure */
201 sigact = (struct sigaction){
202 .sa_handler = sigabrt_handler,
203 .sa_flags = SA_RESETHAND,
204 };
205 sigemptyset(&sigact.sa_mask);
206 sigaction(SIGABRT, &sigact, &sigact_old);
207 }
208
209 static void cleanup_sigabrt_handler(void)
210 {
211 sigaction(SIGABRT, &sigact_old, NULL);
212 }
213
214 void qtest_add_abrt_handler(GHookFunc fn, const void *data)
215 {
216 GHook *hook;
217
218 /* Only install SIGABRT handler once */
219 if (!abrt_hooks.is_setup) {
220 g_hook_list_init(&abrt_hooks, sizeof(GHook));
221 }
222 setup_sigabrt_handler();
223
224 hook = g_hook_alloc(&abrt_hooks);
225 hook->func = fn;
226 hook->data = (void *)data;
227
228 g_hook_prepend(&abrt_hooks, hook);
229 }
230
231 static const char *qtest_qemu_binary(void)
232 {
233 const char *qemu_bin;
234
235 qemu_bin = getenv("QTEST_QEMU_BINARY");
236 if (!qemu_bin) {
237 fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n");
238 exit(1);
239 }
240
241 return qemu_bin;
242 }
243
244 QTestState *qtest_init_without_qmp_handshake(const char *extra_args)
245 {
246 QTestState *s;
247 int sock, qmpsock, i;
248 gchar *socket_path;
249 gchar *qmp_socket_path;
250 gchar *command;
251 const char *qemu_binary = qtest_qemu_binary();
252
253 s = g_new(QTestState, 1);
254
255 socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
256 qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
257
258 /* It's possible that if an earlier test run crashed it might
259 * have left a stale unix socket lying around. Delete any
260 * stale old socket to avoid spurious test failures with
261 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
262 */
263 unlink(socket_path);
264 unlink(qmp_socket_path);
265
266 sock = init_socket(socket_path);
267 qmpsock = init_socket(qmp_socket_path);
268
269 qtest_client_set_rx_handler(s, qtest_client_socket_recv_line);
270 qtest_client_set_tx_handler(s, qtest_client_socket_send);
271
272 qtest_add_abrt_handler(kill_qemu_hook_func, s);
273
274 command = g_strdup_printf("exec %s "
275 "-qtest unix:%s "
276 "-qtest-log %s "
277 "-chardev socket,path=%s,id=char0 "
278 "-mon chardev=char0,mode=control "
279 "-display none "
280 "%s"
281 " -accel qtest", qemu_binary, socket_path,
282 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
283 qmp_socket_path,
284 extra_args ?: "");
285
286 g_test_message("starting QEMU: %s", command);
287
288 s->pending_events = NULL;
289 s->wstatus = 0;
290 s->expected_status = 0;
291 s->qemu_pid = fork();
292 if (s->qemu_pid == 0) {
293 g_setenv("QEMU_AUDIO_DRV", "none", true);
294 execlp("/bin/sh", "sh", "-c", command, NULL);
295 exit(1);
296 }
297
298 g_free(command);
299 s->fd = socket_accept(sock);
300 if (s->fd >= 0) {
301 s->qmp_fd = socket_accept(qmpsock);
302 }
303 unlink(socket_path);
304 unlink(qmp_socket_path);
305 g_free(socket_path);
306 g_free(qmp_socket_path);
307
308 g_assert(s->fd >= 0 && s->qmp_fd >= 0);
309
310 s->rx = g_string_new("");
311 for (i = 0; i < MAX_IRQ; i++) {
312 s->irq_level[i] = false;
313 }
314
315 if (getenv("QTEST_STOP")) {
316 kill(s->qemu_pid, SIGSTOP);
317 }
318
319 /* ask endianness of the target */
320
321 s->big_endian = qtest_query_target_endianness(s);
322
323 return s;
324 }
325
326 QTestState *qtest_init(const char *extra_args)
327 {
328 QTestState *s = qtest_init_without_qmp_handshake(extra_args);
329 QDict *greeting;
330
331 /* Read the QMP greeting and then do the handshake */
332 greeting = qtest_qmp_receive(s);
333 qobject_unref(greeting);
334 qobject_unref(qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }"));
335
336 return s;
337 }
338
339 QTestState *qtest_vinitf(const char *fmt, va_list ap)
340 {
341 char *args = g_strdup_vprintf(fmt, ap);
342 QTestState *s;
343
344 s = qtest_init(args);
345 g_free(args);
346 return s;
347 }
348
349 QTestState *qtest_initf(const char *fmt, ...)
350 {
351 va_list ap;
352 QTestState *s;
353
354 va_start(ap, fmt);
355 s = qtest_vinitf(fmt, ap);
356 va_end(ap);
357 return s;
358 }
359
360 QTestState *qtest_init_with_serial(const char *extra_args, int *sock_fd)
361 {
362 int sock_fd_init;
363 char *sock_path, sock_dir[] = "/tmp/qtest-serial-XXXXXX";
364 QTestState *qts;
365
366 g_assert_true(mkdtemp(sock_dir) != NULL);
367 sock_path = g_strdup_printf("%s/sock", sock_dir);
368
369 sock_fd_init = init_socket(sock_path);
370
371 qts = qtest_initf("-chardev socket,id=s0,path=%s -serial chardev:s0 %s",
372 sock_path, extra_args);
373
374 *sock_fd = socket_accept(sock_fd_init);
375
376 unlink(sock_path);
377 g_free(sock_path);
378 rmdir(sock_dir);
379
380 g_assert_true(*sock_fd >= 0);
381
382 return qts;
383 }
384
385 void qtest_quit(QTestState *s)
386 {
387 g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
388
389 /* Uninstall SIGABRT handler on last instance */
390 cleanup_sigabrt_handler();
391
392 kill_qemu(s);
393 close(s->fd);
394 close(s->qmp_fd);
395 g_string_free(s->rx, true);
396
397 for (GList *it = s->pending_events; it != NULL; it = it->next) {
398 qobject_unref((QDict *)it->data);
399 }
400
401 g_list_free(s->pending_events);
402
403 g_free(s);
404 }
405
406 static void socket_send(int fd, const char *buf, size_t size)
407 {
408 size_t offset;
409
410 offset = 0;
411 while (offset < size) {
412 ssize_t len;
413
414 len = write(fd, buf + offset, size - offset);
415 if (len == -1 && errno == EINTR) {
416 continue;
417 }
418
419 g_assert_cmpint(len, >, 0);
420
421 offset += len;
422 }
423 }
424
425 static void qtest_client_socket_send(QTestState *s, const char *buf)
426 {
427 socket_send(s->fd, buf, strlen(buf));
428 }
429
430 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
431 {
432 va_list ap;
433
434 va_start(ap, fmt);
435 gchar *str = g_strdup_vprintf(fmt, ap);
436 va_end(ap);
437
438 s->ops.send(s, str);
439 g_free(str);
440 }
441
442 /* Sends a message and file descriptors to the socket.
443 * It's needed for qmp-commands like getfd/add-fd */
444 static void socket_send_fds(int socket_fd, int *fds, size_t fds_num,
445 const char *buf, size_t buf_size)
446 {
447 ssize_t ret;
448 struct msghdr msg = { 0 };
449 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)] = { 0 };
450 size_t fdsize = sizeof(int) * fds_num;
451 struct cmsghdr *cmsg;
452 struct iovec iov = { .iov_base = (char *)buf, .iov_len = buf_size };
453
454 msg.msg_iov = &iov;
455 msg.msg_iovlen = 1;
456
457 if (fds && fds_num > 0) {
458 g_assert_cmpuint(fds_num, <, SOCKET_MAX_FDS);
459
460 msg.msg_control = control;
461 msg.msg_controllen = CMSG_SPACE(fdsize);
462
463 cmsg = CMSG_FIRSTHDR(&msg);
464 cmsg->cmsg_len = CMSG_LEN(fdsize);
465 cmsg->cmsg_level = SOL_SOCKET;
466 cmsg->cmsg_type = SCM_RIGHTS;
467 memcpy(CMSG_DATA(cmsg), fds, fdsize);
468 }
469
470 do {
471 ret = sendmsg(socket_fd, &msg, 0);
472 } while (ret < 0 && errno == EINTR);
473 g_assert_cmpint(ret, >, 0);
474 }
475
476 static GString *qtest_client_socket_recv_line(QTestState *s)
477 {
478 GString *line;
479 size_t offset;
480 char *eol;
481
482 while ((eol = strchr(s->rx->str, '\n')) == NULL) {
483 ssize_t len;
484 char buffer[1024];
485
486 len = read(s->fd, buffer, sizeof(buffer));
487 if (len == -1 && errno == EINTR) {
488 continue;
489 }
490
491 if (len == -1 || len == 0) {
492 fprintf(stderr, "Broken pipe\n");
493 abort();
494 }
495
496 g_string_append_len(s->rx, buffer, len);
497 }
498
499 offset = eol - s->rx->str;
500 line = g_string_new_len(s->rx->str, offset);
501 g_string_erase(s->rx, 0, offset + 1);
502
503 return line;
504 }
505
506 static gchar **qtest_rsp(QTestState *s, int expected_args)
507 {
508 GString *line;
509 gchar **words;
510 int i;
511
512 redo:
513 line = s->ops.recv_line(s);
514 words = g_strsplit(line->str, " ", 0);
515 g_string_free(line, TRUE);
516
517 if (strcmp(words[0], "IRQ") == 0) {
518 long irq;
519 int ret;
520
521 g_assert(words[1] != NULL);
522 g_assert(words[2] != NULL);
523
524 ret = qemu_strtol(words[2], NULL, 0, &irq);
525 g_assert(!ret);
526 g_assert_cmpint(irq, >=, 0);
527 g_assert_cmpint(irq, <, MAX_IRQ);
528
529 if (strcmp(words[1], "raise") == 0) {
530 s->irq_level[irq] = true;
531 } else {
532 s->irq_level[irq] = false;
533 }
534
535 g_strfreev(words);
536 goto redo;
537 }
538
539 g_assert(words[0] != NULL);
540 g_assert_cmpstr(words[0], ==, "OK");
541
542 if (expected_args) {
543 for (i = 0; i < expected_args; i++) {
544 g_assert(words[i] != NULL);
545 }
546 } else {
547 g_strfreev(words);
548 words = NULL;
549 }
550
551 return words;
552 }
553
554 static int qtest_query_target_endianness(QTestState *s)
555 {
556 gchar **args;
557 int big_endian;
558
559 qtest_sendf(s, "endianness\n");
560 args = qtest_rsp(s, 1);
561 g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0);
562 big_endian = strcmp(args[1], "big") == 0;
563 g_strfreev(args);
564
565 return big_endian;
566 }
567
568 typedef struct {
569 JSONMessageParser parser;
570 QDict *response;
571 } QMPResponseParser;
572
573 static void qmp_response(void *opaque, QObject *obj, Error *err)
574 {
575 QMPResponseParser *qmp = opaque;
576
577 assert(!obj != !err);
578
579 if (err) {
580 error_prepend(&err, "QMP JSON response parsing failed: ");
581 error_report_err(err);
582 abort();
583 }
584
585 g_assert(!qmp->response);
586 qmp->response = qobject_to(QDict, obj);
587 g_assert(qmp->response);
588 }
589
590 QDict *qmp_fd_receive(int fd)
591 {
592 QMPResponseParser qmp;
593 bool log = getenv("QTEST_LOG") != NULL;
594
595 qmp.response = NULL;
596 json_message_parser_init(&qmp.parser, qmp_response, &qmp, NULL);
597 while (!qmp.response) {
598 ssize_t len;
599 char c;
600
601 len = read(fd, &c, 1);
602 if (len == -1 && errno == EINTR) {
603 continue;
604 }
605
606 if (len == -1 || len == 0) {
607 fprintf(stderr, "Broken pipe\n");
608 abort();
609 }
610
611 if (log) {
612 len = write(2, &c, 1);
613 }
614 json_message_parser_feed(&qmp.parser, &c, 1);
615 }
616 json_message_parser_destroy(&qmp.parser);
617
618 return qmp.response;
619 }
620
621 QDict *qtest_qmp_receive(QTestState *s)
622 {
623 while (true) {
624 QDict *response = qtest_qmp_receive_dict(s);
625
626 if (!qdict_get_try_str(response, "event")) {
627 return response;
628 }
629 /* Stash the event for a later consumption */
630 s->pending_events = g_list_append(s->pending_events, response);
631 }
632 }
633
634 QDict *qtest_qmp_receive_dict(QTestState *s)
635 {
636 return qmp_fd_receive(s->qmp_fd);
637 }
638
639 /**
640 * Allow users to send a message without waiting for the reply,
641 * in the case that they choose to discard all replies up until
642 * a particular EVENT is received.
643 */
644 void qmp_fd_vsend_fds(int fd, int *fds, size_t fds_num,
645 const char *fmt, va_list ap)
646 {
647 QObject *qobj;
648
649 /* Going through qobject ensures we escape strings properly */
650 qobj = qobject_from_vjsonf_nofail(fmt, ap);
651
652 /* No need to send anything for an empty QObject. */
653 if (qobj) {
654 int log = getenv("QTEST_LOG") != NULL;
655 QString *qstr = qobject_to_json(qobj);
656 const char *str;
657
658 /*
659 * BUG: QMP doesn't react to input until it sees a newline, an
660 * object, or an array. Work-around: give it a newline.
661 */
662 qstring_append_chr(qstr, '\n');
663 str = qstring_get_str(qstr);
664
665 if (log) {
666 fprintf(stderr, "%s", str);
667 }
668 /* Send QMP request */
669 if (fds && fds_num > 0) {
670 socket_send_fds(fd, fds, fds_num, str, qstring_get_length(qstr));
671 } else {
672 socket_send(fd, str, qstring_get_length(qstr));
673 }
674
675 qobject_unref(qstr);
676 qobject_unref(qobj);
677 }
678 }
679
680 void qmp_fd_vsend(int fd, const char *fmt, va_list ap)
681 {
682 qmp_fd_vsend_fds(fd, NULL, 0, fmt, ap);
683 }
684
685 void qtest_qmp_vsend_fds(QTestState *s, int *fds, size_t fds_num,
686 const char *fmt, va_list ap)
687 {
688 qmp_fd_vsend_fds(s->qmp_fd, fds, fds_num, fmt, ap);
689 }
690
691 void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap)
692 {
693 qmp_fd_vsend_fds(s->qmp_fd, NULL, 0, fmt, ap);
694 }
695
696 QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
697 {
698 qmp_fd_vsend_fds(fd, NULL, 0, fmt, ap);
699
700 return qmp_fd_receive(fd);
701 }
702
703 QDict *qtest_vqmp_fds(QTestState *s, int *fds, size_t fds_num,
704 const char *fmt, va_list ap)
705 {
706 qtest_qmp_vsend_fds(s, fds, fds_num, fmt, ap);
707
708 /* Receive reply */
709 return qtest_qmp_receive(s);
710 }
711
712 QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap)
713 {
714 qtest_qmp_vsend(s, fmt, ap);
715
716 /* Receive reply */
717 return qtest_qmp_receive(s);
718 }
719
720 QDict *qmp_fd(int fd, const char *fmt, ...)
721 {
722 va_list ap;
723 QDict *response;
724
725 va_start(ap, fmt);
726 response = qmp_fdv(fd, fmt, ap);
727 va_end(ap);
728 return response;
729 }
730
731 void qmp_fd_send(int fd, const char *fmt, ...)
732 {
733 va_list ap;
734
735 va_start(ap, fmt);
736 qmp_fd_vsend(fd, fmt, ap);
737 va_end(ap);
738 }
739
740 QDict *qtest_qmp_fds(QTestState *s, int *fds, size_t fds_num,
741 const char *fmt, ...)
742 {
743 va_list ap;
744 QDict *response;
745
746 va_start(ap, fmt);
747 response = qtest_vqmp_fds(s, fds, fds_num, fmt, ap);
748 va_end(ap);
749 return response;
750 }
751
752 QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
753 {
754 va_list ap;
755 QDict *response;
756
757 va_start(ap, fmt);
758 response = qtest_vqmp(s, fmt, ap);
759 va_end(ap);
760 return response;
761 }
762
763 void qtest_qmp_send(QTestState *s, const char *fmt, ...)
764 {
765 va_list ap;
766
767 va_start(ap, fmt);
768 qtest_qmp_vsend(s, fmt, ap);
769 va_end(ap);
770 }
771
772 void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap)
773 {
774 bool log = getenv("QTEST_LOG") != NULL;
775 char *str = g_strdup_vprintf(fmt, ap);
776
777 if (log) {
778 fprintf(stderr, "%s", str);
779 }
780 socket_send(fd, str, strlen(str));
781 g_free(str);
782 }
783
784 void qmp_fd_send_raw(int fd, const char *fmt, ...)
785 {
786 va_list ap;
787
788 va_start(ap, fmt);
789 qmp_fd_vsend_raw(fd, fmt, ap);
790 va_end(ap);
791 }
792
793 void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...)
794 {
795 va_list ap;
796
797 va_start(ap, fmt);
798 qmp_fd_vsend_raw(s->qmp_fd, fmt, ap);
799 va_end(ap);
800 }
801
802 QDict *qtest_qmp_event_ref(QTestState *s, const char *event)
803 {
804 while (s->pending_events) {
805
806 GList *first = s->pending_events;
807 QDict *response = (QDict *)first->data;
808
809 s->pending_events = g_list_delete_link(s->pending_events, first);
810
811 if (!strcmp(qdict_get_str(response, "event"), event)) {
812 return response;
813 }
814 qobject_unref(response);
815 }
816 return NULL;
817 }
818
819 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
820 {
821 QDict *response = qtest_qmp_event_ref(s, event);
822
823 if (response) {
824 return response;
825 }
826
827 for (;;) {
828 response = qtest_qmp_receive_dict(s);
829 if ((qdict_haskey(response, "event")) &&
830 (strcmp(qdict_get_str(response, "event"), event) == 0)) {
831 return response;
832 }
833 qobject_unref(response);
834 }
835 }
836
837 void qtest_qmp_eventwait(QTestState *s, const char *event)
838 {
839 QDict *response;
840
841 response = qtest_qmp_eventwait_ref(s, event);
842 qobject_unref(response);
843 }
844
845 char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap)
846 {
847 char *cmd;
848 QDict *resp;
849 char *ret;
850
851 cmd = g_strdup_vprintf(fmt, ap);
852 resp = qtest_qmp(s, "{'execute': 'human-monitor-command',"
853 " 'arguments': {'command-line': %s}}",
854 cmd);
855 ret = g_strdup(qdict_get_try_str(resp, "return"));
856 g_assert(ret);
857 qobject_unref(resp);
858 g_free(cmd);
859 return ret;
860 }
861
862 char *qtest_hmp(QTestState *s, const char *fmt, ...)
863 {
864 va_list ap;
865 char *ret;
866
867 va_start(ap, fmt);
868 ret = qtest_vhmp(s, fmt, ap);
869 va_end(ap);
870 return ret;
871 }
872
873 const char *qtest_get_arch(void)
874 {
875 const char *qemu = qtest_qemu_binary();
876 const char *end = strrchr(qemu, '-');
877
878 if (!end) {
879 fprintf(stderr, "Can't determine architecture from binary name.\n");
880 abort();
881 }
882
883 return end + 1;
884 }
885
886 bool qtest_get_irq(QTestState *s, int num)
887 {
888 /* dummy operation in order to make sure irq is up to date */
889 qtest_inb(s, 0);
890
891 return s->irq_level[num];
892 }
893
894 void qtest_module_load(QTestState *s, const char *prefix, const char *libname)
895 {
896 qtest_sendf(s, "module_load %s %s\n", prefix, libname);
897 qtest_rsp(s, 0);
898 }
899
900 static int64_t qtest_clock_rsp(QTestState *s)
901 {
902 gchar **words;
903 int64_t clock;
904 words = qtest_rsp(s, 2);
905 clock = g_ascii_strtoll(words[1], NULL, 0);
906 g_strfreev(words);
907 return clock;
908 }
909
910 int64_t qtest_clock_step_next(QTestState *s)
911 {
912 qtest_sendf(s, "clock_step\n");
913 return qtest_clock_rsp(s);
914 }
915
916 int64_t qtest_clock_step(QTestState *s, int64_t step)
917 {
918 qtest_sendf(s, "clock_step %"PRIi64"\n", step);
919 return qtest_clock_rsp(s);
920 }
921
922 int64_t qtest_clock_set(QTestState *s, int64_t val)
923 {
924 qtest_sendf(s, "clock_set %"PRIi64"\n", val);
925 return qtest_clock_rsp(s);
926 }
927
928 void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
929 {
930 qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
931 qtest_rsp(s, 0);
932 }
933
934 void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
935 {
936 qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
937 qtest_rsp(s, 0);
938 }
939
940 void qtest_set_irq_in(QTestState *s, const char *qom_path, const char *name,
941 int num, int level)
942 {
943 if (!name) {
944 name = "unnamed-gpio-in";
945 }
946 qtest_sendf(s, "set_irq_in %s %s %d %d\n", qom_path, name, num, level);
947 qtest_rsp(s, 0);
948 }
949
950 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
951 {
952 qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
953 qtest_rsp(s, 0);
954 }
955
956 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
957 {
958 qtest_out(s, "outb", addr, value);
959 }
960
961 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
962 {
963 qtest_out(s, "outw", addr, value);
964 }
965
966 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
967 {
968 qtest_out(s, "outl", addr, value);
969 }
970
971 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
972 {
973 gchar **args;
974 int ret;
975 unsigned long value;
976
977 qtest_sendf(s, "%s 0x%x\n", cmd, addr);
978 args = qtest_rsp(s, 2);
979 ret = qemu_strtoul(args[1], NULL, 0, &value);
980 g_assert(!ret && value <= UINT32_MAX);
981 g_strfreev(args);
982
983 return value;
984 }
985
986 uint8_t qtest_inb(QTestState *s, uint16_t addr)
987 {
988 return qtest_in(s, "inb", addr);
989 }
990
991 uint16_t qtest_inw(QTestState *s, uint16_t addr)
992 {
993 return qtest_in(s, "inw", addr);
994 }
995
996 uint32_t qtest_inl(QTestState *s, uint16_t addr)
997 {
998 return qtest_in(s, "inl", addr);
999 }
1000
1001 static void qtest_write(QTestState *s, const char *cmd, uint64_t addr,
1002 uint64_t value)
1003 {
1004 qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value);
1005 qtest_rsp(s, 0);
1006 }
1007
1008 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
1009 {
1010 qtest_write(s, "writeb", addr, value);
1011 }
1012
1013 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
1014 {
1015 qtest_write(s, "writew", addr, value);
1016 }
1017
1018 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
1019 {
1020 qtest_write(s, "writel", addr, value);
1021 }
1022
1023 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
1024 {
1025 qtest_write(s, "writeq", addr, value);
1026 }
1027
1028 static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr)
1029 {
1030 gchar **args;
1031 int ret;
1032 uint64_t value;
1033
1034 qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
1035 args = qtest_rsp(s, 2);
1036 ret = qemu_strtou64(args[1], NULL, 0, &value);
1037 g_assert(!ret);
1038 g_strfreev(args);
1039
1040 return value;
1041 }
1042
1043 uint8_t qtest_readb(QTestState *s, uint64_t addr)
1044 {
1045 return qtest_read(s, "readb", addr);
1046 }
1047
1048 uint16_t qtest_readw(QTestState *s, uint64_t addr)
1049 {
1050 return qtest_read(s, "readw", addr);
1051 }
1052
1053 uint32_t qtest_readl(QTestState *s, uint64_t addr)
1054 {
1055 return qtest_read(s, "readl", addr);
1056 }
1057
1058 uint64_t qtest_readq(QTestState *s, uint64_t addr)
1059 {
1060 return qtest_read(s, "readq", addr);
1061 }
1062
1063 static int hex2nib(char ch)
1064 {
1065 if (ch >= '0' && ch <= '9') {
1066 return ch - '0';
1067 } else if (ch >= 'a' && ch <= 'f') {
1068 return 10 + (ch - 'a');
1069 } else if (ch >= 'A' && ch <= 'F') {
1070 return 10 + (ch - 'a');
1071 } else {
1072 return -1;
1073 }
1074 }
1075
1076 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
1077 {
1078 uint8_t *ptr = data;
1079 gchar **args;
1080 size_t i;
1081
1082 if (!size) {
1083 return;
1084 }
1085
1086 qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
1087 args = qtest_rsp(s, 2);
1088
1089 for (i = 0; i < size; i++) {
1090 ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
1091 ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
1092 }
1093
1094 g_strfreev(args);
1095 }
1096
1097 uint64_t qtest_rtas_call(QTestState *s, const char *name,
1098 uint32_t nargs, uint64_t args,
1099 uint32_t nret, uint64_t ret)
1100 {
1101 qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n",
1102 name, nargs, args, nret, ret);
1103 qtest_rsp(s, 0);
1104 return 0;
1105 }
1106
1107 void qtest_add_func(const char *str, void (*fn)(void))
1108 {
1109 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
1110 g_test_add_func(path, fn);
1111 g_free(path);
1112 }
1113
1114 void qtest_add_data_func_full(const char *str, void *data,
1115 void (*fn)(const void *),
1116 GDestroyNotify data_free_func)
1117 {
1118 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
1119 g_test_add_data_func_full(path, data, fn, data_free_func);
1120 g_free(path);
1121 }
1122
1123 void qtest_add_data_func(const char *str, const void *data,
1124 void (*fn)(const void *))
1125 {
1126 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
1127 g_test_add_data_func(path, data, fn);
1128 g_free(path);
1129 }
1130
1131 void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
1132 {
1133 gchar *bdata;
1134
1135 bdata = g_base64_encode(data, size);
1136 qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size);
1137 s->ops.send(s, bdata);
1138 s->ops.send(s, "\n");
1139 qtest_rsp(s, 0);
1140 g_free(bdata);
1141 }
1142
1143 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
1144 {
1145 gchar **args;
1146 size_t len;
1147
1148 qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size);
1149 args = qtest_rsp(s, 2);
1150
1151 g_base64_decode_inplace(args[1], &len);
1152 if (size != len) {
1153 fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n",
1154 size, len);
1155 len = MIN(len, size);
1156 }
1157
1158 memcpy(data, args[1], len);
1159 g_strfreev(args);
1160 }
1161
1162 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
1163 {
1164 const uint8_t *ptr = data;
1165 size_t i;
1166 char *enc;
1167
1168 if (!size) {
1169 return;
1170 }
1171
1172 enc = g_malloc(2 * size + 1);
1173
1174 for (i = 0; i < size; i++) {
1175 sprintf(&enc[i * 2], "%02x", ptr[i]);
1176 }
1177
1178 qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc);
1179 qtest_rsp(s, 0);
1180 g_free(enc);
1181 }
1182
1183 void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)
1184 {
1185 qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern);
1186 qtest_rsp(s, 0);
1187 }
1188
1189 void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...)
1190 {
1191 va_list ap;
1192 QDict *response;
1193
1194 va_start(ap, fmt);
1195 response = qtest_vqmp(qts, fmt, ap);
1196 va_end(ap);
1197
1198 g_assert(response);
1199 if (!qdict_haskey(response, "return")) {
1200 QString *s = qobject_to_json_pretty(QOBJECT(response));
1201 g_test_message("%s", qstring_get_str(s));
1202 qobject_unref(s);
1203 }
1204 g_assert(qdict_haskey(response, "return"));
1205 qobject_unref(response);
1206 }
1207
1208 bool qtest_big_endian(QTestState *s)
1209 {
1210 return s->big_endian;
1211 }
1212
1213 static bool qtest_check_machine_version(const char *mname, const char *basename,
1214 int major, int minor)
1215 {
1216 char *newname;
1217 bool is_equal;
1218
1219 newname = g_strdup_printf("%s-%i.%i", basename, major, minor);
1220 is_equal = g_str_equal(mname, newname);
1221 g_free(newname);
1222
1223 return is_equal;
1224 }
1225
1226 static bool qtest_is_old_versioned_machine(const char *mname)
1227 {
1228 const char *dash = strrchr(mname, '-');
1229 const char *dot = strrchr(mname, '.');
1230 const char *chr;
1231 char *bname;
1232 const int major = QEMU_VERSION_MAJOR;
1233 const int minor = QEMU_VERSION_MINOR;
1234 bool res = false;
1235
1236 if (dash && dot && dot > dash) {
1237 for (chr = dash + 1; *chr; chr++) {
1238 if (!qemu_isdigit(*chr) && *chr != '.') {
1239 return false;
1240 }
1241 }
1242 /*
1243 * Now check if it is one of the latest versions. Check major + 1
1244 * and minor + 1 versions as well, since they might already exist
1245 * in the development branch.
1246 */
1247 bname = g_strdup(mname);
1248 bname[dash - mname] = 0;
1249 res = !qtest_check_machine_version(mname, bname, major + 1, 0) &&
1250 !qtest_check_machine_version(mname, bname, major, minor + 1) &&
1251 !qtest_check_machine_version(mname, bname, major, minor);
1252 g_free(bname);
1253 }
1254
1255 return res;
1256 }
1257
1258 void qtest_cb_for_every_machine(void (*cb)(const char *machine),
1259 bool skip_old_versioned)
1260 {
1261 QDict *response, *minfo;
1262 QList *list;
1263 const QListEntry *p;
1264 QObject *qobj;
1265 QString *qstr;
1266 const char *mname;
1267 QTestState *qts;
1268
1269 qts = qtest_init("-machine none");
1270 response = qtest_qmp(qts, "{ 'execute': 'query-machines' }");
1271 g_assert(response);
1272 list = qdict_get_qlist(response, "return");
1273 g_assert(list);
1274
1275 for (p = qlist_first(list); p; p = qlist_next(p)) {
1276 minfo = qobject_to(QDict, qlist_entry_obj(p));
1277 g_assert(minfo);
1278 qobj = qdict_get(minfo, "name");
1279 g_assert(qobj);
1280 qstr = qobject_to(QString, qobj);
1281 g_assert(qstr);
1282 mname = qstring_get_str(qstr);
1283 /* Ignore machines that cannot be used for qtests */
1284 if (!memcmp("xenfv", mname, 5) || g_str_equal("xenpv", mname)) {
1285 continue;
1286 }
1287 if (!skip_old_versioned || !qtest_is_old_versioned_machine(mname)) {
1288 cb(mname);
1289 }
1290 }
1291
1292 qtest_quit(qts);
1293 qobject_unref(response);
1294 }
1295
1296 /*
1297 * Generic hot-plugging test via the device_add QMP commands.
1298 */
1299 void qtest_qmp_device_add_qdict(QTestState *qts, const char *drv,
1300 const QDict *arguments)
1301 {
1302 QDict *resp;
1303 QDict *args = arguments ? qdict_clone_shallow(arguments) : qdict_new();
1304
1305 g_assert(!qdict_haskey(args, "driver"));
1306 qdict_put_str(args, "driver", drv);
1307 resp = qtest_qmp(qts, "{'execute': 'device_add', 'arguments': %p}", args);
1308 g_assert(resp);
1309 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */
1310 g_assert(!qdict_haskey(resp, "error"));
1311 qobject_unref(resp);
1312 }
1313
1314 void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id,
1315 const char *fmt, ...)
1316 {
1317 QDict *args;
1318 va_list ap;
1319
1320 va_start(ap, fmt);
1321 args = qdict_from_vjsonf_nofail(fmt, ap);
1322 va_end(ap);
1323
1324 g_assert(!qdict_haskey(args, "id"));
1325 qdict_put_str(args, "id", id);
1326
1327 qtest_qmp_device_add_qdict(qts, driver, args);
1328 qobject_unref(args);
1329 }
1330
1331
1332 /*
1333 * Generic hot-unplugging test via the device_del QMP command.
1334 * Device deletion will get one response and one event. For example:
1335 *
1336 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
1337 *
1338 * will get this one:
1339 *
1340 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
1341 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
1342 * "path": "/machine/peripheral/scsi-hd"}}
1343 *
1344 * and this one:
1345 *
1346 * {"return": {}}
1347 */
1348 void qtest_qmp_device_del(QTestState *qts, const char *id)
1349 {
1350 QDict *rsp;
1351
1352 rsp = qtest_qmp(qts, "{'execute': 'device_del', 'arguments': {'id': %s}}",
1353 id);
1354
1355 g_assert(qdict_haskey(rsp, "return"));
1356 qobject_unref(rsp);
1357 qtest_qmp_eventwait(qts, "DEVICE_DELETED");
1358 }
1359
1360 bool qmp_rsp_is_err(QDict *rsp)
1361 {
1362 QDict *error = qdict_get_qdict(rsp, "error");
1363 qobject_unref(rsp);
1364 return !!error;
1365 }
1366
1367 void qmp_expect_error_and_unref(QDict *rsp, const char *class)
1368 {
1369 QDict *error = qdict_get_qdict(rsp, "error");
1370
1371 g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, class);
1372 g_assert_nonnull(qdict_get_try_str(error, "desc"));
1373 g_assert(!qdict_haskey(rsp, "return"));
1374
1375 qobject_unref(rsp);
1376 }
1377
1378 static void qtest_client_set_tx_handler(QTestState *s,
1379 QTestSendFn send)
1380 {
1381 s->ops.send = send;
1382 }
1383 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv)
1384 {
1385 s->ops.recv_line = recv;
1386 }
1387 /* A type-safe wrapper for s->send() */
1388 static void send_wrapper(QTestState *s, const char *buf)
1389 {
1390 s->ops.external_send(s, buf);
1391 }
1392
1393 static GString *qtest_client_inproc_recv_line(QTestState *s)
1394 {
1395 GString *line;
1396 size_t offset;
1397 char *eol;
1398
1399 eol = strchr(s->rx->str, '\n');
1400 offset = eol - s->rx->str;
1401 line = g_string_new_len(s->rx->str, offset);
1402 g_string_erase(s->rx, 0, offset + 1);
1403 return line;
1404 }
1405
1406 QTestState *qtest_inproc_init(QTestState **s, bool log, const char* arch,
1407 void (*send)(void*, const char*))
1408 {
1409 QTestState *qts;
1410 qts = g_new0(QTestState, 1);
1411 qts->pending_events = NULL;
1412 *s = qts; /* Expose qts early on, since the query endianness relies on it */
1413 qts->wstatus = 0;
1414 for (int i = 0; i < MAX_IRQ; i++) {
1415 qts->irq_level[i] = false;
1416 }
1417
1418 qtest_client_set_rx_handler(qts, qtest_client_inproc_recv_line);
1419
1420 /* send() may not have a matching protoype, so use a type-safe wrapper */
1421 qts->ops.external_send = send;
1422 qtest_client_set_tx_handler(qts, send_wrapper);
1423
1424 qts->big_endian = qtest_query_target_endianness(qts);
1425
1426 /*
1427 * Set a dummy path for QTEST_QEMU_BINARY. Doesn't need to exist, but this
1428 * way, qtest_get_arch works for inproc qtest.
1429 */
1430 gchar *bin_path = g_strconcat("/qemu-system-", arch, NULL);
1431 setenv("QTEST_QEMU_BINARY", bin_path, 0);
1432 g_free(bin_path);
1433
1434 return qts;
1435 }
1436
1437 void qtest_client_inproc_recv(void *opaque, const char *str)
1438 {
1439 QTestState *qts = *(QTestState **)opaque;
1440
1441 if (!qts->rx) {
1442 qts->rx = g_string_new(NULL);
1443 }
1444 g_string_append(qts->rx, str);
1445 return;
1446 }