4 * Copyright IBM, Corp. 2012
5 * Copyright Red Hat, Inc. 2012
6 * Copyright SUSE LINUX Products GmbH 2013
9 * Anthony Liguori <aliguori@us.ibm.com>
10 * Paolo Bonzini <pbonzini@redhat.com>
11 * Andreas Färber <afaerber@suse.de>
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.
17 #include "qemu/osdep.h"
19 #include <sys/socket.h>
24 #include "qemu/cutils.h"
25 #include "qapi/error.h"
26 #include "qapi/qmp/json-parser.h"
27 #include "qapi/qmp/json-streamer.h"
28 #include "qapi/qmp/qdict.h"
29 #include "qapi/qmp/qjson.h"
30 #include "qapi/qmp/qlist.h"
31 #include "qapi/qmp/qstring.h"
34 #define SOCKET_TIMEOUT 50
36 QTestState *global_qtest;
42 bool irq_level[MAX_IRQ];
44 pid_t qemu_pid; /* our child QEMU process */
48 static GHookList abrt_hooks;
49 static struct sigaction sigact_old;
51 #define g_assert_no_errno(ret) do { \
52 g_assert_cmpint(ret, !=, -1); \
55 static int qtest_query_target_endianness(QTestState *s);
57 static int init_socket(const char *socket_path)
59 struct sockaddr_un addr;
63 sock = socket(PF_UNIX, SOCK_STREAM, 0);
64 g_assert_no_errno(sock);
66 addr.sun_family = AF_UNIX;
67 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
68 qemu_set_cloexec(sock);
71 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
72 } while (ret == -1 && errno == EINTR);
73 g_assert_no_errno(ret);
74 ret = listen(sock, 1);
75 g_assert_no_errno(ret);
80 static int socket_accept(int sock)
82 struct sockaddr_un addr;
85 struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
88 setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
92 addrlen = sizeof(addr);
93 ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
94 } while (ret == -1 && errno == EINTR);
96 fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno));
103 static void kill_qemu(QTestState *s)
107 if (s->qemu_pid != -1) {
108 kill(s->qemu_pid, SIGTERM);
109 waitpid(s->qemu_pid, &wstatus, 0);
111 if (WIFSIGNALED(wstatus)) {
112 assert(!WCOREDUMP(wstatus));
117 static void kill_qemu_hook_func(void *s)
122 static void sigabrt_handler(int signo)
124 g_hook_list_invoke(&abrt_hooks, FALSE);
127 static void setup_sigabrt_handler(void)
129 struct sigaction sigact;
131 /* Catch SIGABRT to clean up on g_assert() failure */
132 sigact = (struct sigaction){
133 .sa_handler = sigabrt_handler,
134 .sa_flags = SA_RESETHAND,
136 sigemptyset(&sigact.sa_mask);
137 sigaction(SIGABRT, &sigact, &sigact_old);
140 static void cleanup_sigabrt_handler(void)
142 sigaction(SIGABRT, &sigact_old, NULL);
145 void qtest_add_abrt_handler(GHookFunc fn, const void *data)
149 /* Only install SIGABRT handler once */
150 if (!abrt_hooks.is_setup) {
151 g_hook_list_init(&abrt_hooks, sizeof(GHook));
153 setup_sigabrt_handler();
155 hook = g_hook_alloc(&abrt_hooks);
157 hook->data = (void *)data;
159 g_hook_prepend(&abrt_hooks, hook);
162 static const char *qtest_qemu_binary(void)
164 const char *qemu_bin;
166 qemu_bin = getenv("QTEST_QEMU_BINARY");
168 fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n");
175 QTestState *qtest_init_without_qmp_handshake(bool use_oob,
176 const char *extra_args)
179 int sock, qmpsock, i;
181 gchar *qmp_socket_path;
183 const char *qemu_binary = qtest_qemu_binary();
185 s = g_new(QTestState, 1);
187 socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
188 qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
190 /* It's possible that if an earlier test run crashed it might
191 * have left a stale unix socket lying around. Delete any
192 * stale old socket to avoid spurious test failures with
193 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
196 unlink(qmp_socket_path);
198 sock = init_socket(socket_path);
199 qmpsock = init_socket(qmp_socket_path);
201 qtest_add_abrt_handler(kill_qemu_hook_func, s);
203 s->qemu_pid = fork();
204 if (s->qemu_pid == 0) {
205 setenv("QEMU_AUDIO_DRV", "none", true);
206 command = g_strdup_printf("exec %s "
207 "-qtest unix:%s,nowait "
209 "-chardev socket,path=%s,nowait,id=char0 "
210 "-mon chardev=char0,mode=control%s "
211 "-machine accel=qtest "
213 "%s", qemu_binary, socket_path,
214 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
215 qmp_socket_path, use_oob ? ",x-oob=on" : "",
217 execlp("/bin/sh", "sh", "-c", command, NULL);
221 s->fd = socket_accept(sock);
223 s->qmp_fd = socket_accept(qmpsock);
226 unlink(qmp_socket_path);
228 g_free(qmp_socket_path);
230 g_assert(s->fd >= 0 && s->qmp_fd >= 0);
232 s->rx = g_string_new("");
233 for (i = 0; i < MAX_IRQ; i++) {
234 s->irq_level[i] = false;
237 if (getenv("QTEST_STOP")) {
238 kill(s->qemu_pid, SIGSTOP);
241 /* ask endianness of the target */
243 s->big_endian = qtest_query_target_endianness(s);
248 QTestState *qtest_init(const char *extra_args)
250 QTestState *s = qtest_init_without_qmp_handshake(false, extra_args);
252 /* Read the QMP greeting and then do the handshake */
253 qtest_qmp_discard_response(s, "");
254 qtest_qmp_discard_response(s, "{ 'execute': 'qmp_capabilities' }");
259 QTestState *qtest_vstartf(const char *fmt, va_list ap)
261 char *args = g_strdup_vprintf(fmt, ap);
264 s = qtest_start(args);
270 QTestState *qtest_startf(const char *fmt, ...)
276 s = qtest_vstartf(fmt, ap);
281 void qtest_quit(QTestState *s)
283 g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
285 /* Uninstall SIGABRT handler on last instance */
286 cleanup_sigabrt_handler();
291 g_string_free(s->rx, true);
295 static void socket_send(int fd, const char *buf, size_t size)
300 while (offset < size) {
303 len = write(fd, buf + offset, size - offset);
304 if (len == -1 && errno == EINTR) {
308 g_assert_no_errno(len);
309 g_assert_cmpint(len, >, 0);
315 static void socket_sendf(int fd, const char *fmt, va_list ap)
317 gchar *str = g_strdup_vprintf(fmt, ap);
318 size_t size = strlen(str);
320 socket_send(fd, str, size);
324 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
329 socket_sendf(s->fd, fmt, ap);
333 static GString *qtest_recv_line(QTestState *s)
339 while ((eol = strchr(s->rx->str, '\n')) == NULL) {
343 len = read(s->fd, buffer, sizeof(buffer));
344 if (len == -1 && errno == EINTR) {
348 if (len == -1 || len == 0) {
349 fprintf(stderr, "Broken pipe\n");
353 g_string_append_len(s->rx, buffer, len);
356 offset = eol - s->rx->str;
357 line = g_string_new_len(s->rx->str, offset);
358 g_string_erase(s->rx, 0, offset + 1);
363 static gchar **qtest_rsp(QTestState *s, int expected_args)
370 line = qtest_recv_line(s);
371 words = g_strsplit(line->str, " ", 0);
372 g_string_free(line, TRUE);
374 if (strcmp(words[0], "IRQ") == 0) {
378 g_assert(words[1] != NULL);
379 g_assert(words[2] != NULL);
381 ret = qemu_strtol(words[2], NULL, 0, &irq);
383 g_assert_cmpint(irq, >=, 0);
384 g_assert_cmpint(irq, <, MAX_IRQ);
386 if (strcmp(words[1], "raise") == 0) {
387 s->irq_level[irq] = true;
389 s->irq_level[irq] = false;
396 g_assert(words[0] != NULL);
397 g_assert_cmpstr(words[0], ==, "OK");
400 for (i = 0; i < expected_args; i++) {
401 g_assert(words[i] != NULL);
410 static int qtest_query_target_endianness(QTestState *s)
415 qtest_sendf(s, "endianness\n");
416 args = qtest_rsp(s, 1);
417 g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0);
418 big_endian = strcmp(args[1], "big") == 0;
425 JSONMessageParser parser;
429 static void qmp_response(JSONMessageParser *parser, GQueue *tokens)
431 QMPResponseParser *qmp = container_of(parser, QMPResponseParser, parser);
434 obj = json_parser_parse(tokens, NULL);
436 fprintf(stderr, "QMP JSON response parsing failed\n");
440 g_assert(!qmp->response);
441 qmp->response = qobject_to(QDict, obj);
442 g_assert(qmp->response);
445 QDict *qmp_fd_receive(int fd)
447 QMPResponseParser qmp;
448 bool log = getenv("QTEST_LOG") != NULL;
451 json_message_parser_init(&qmp.parser, qmp_response);
452 while (!qmp.response) {
456 len = read(fd, &c, 1);
457 if (len == -1 && errno == EINTR) {
461 if (len == -1 || len == 0) {
462 fprintf(stderr, "Broken pipe\n");
467 len = write(2, &c, 1);
469 json_message_parser_feed(&qmp.parser, &c, 1);
471 json_message_parser_destroy(&qmp.parser);
476 QDict *qtest_qmp_receive(QTestState *s)
478 return qmp_fd_receive(s->qmp_fd);
482 * Allow users to send a message without waiting for the reply,
483 * in the case that they choose to discard all replies up until
484 * a particular EVENT is received.
486 void qmp_fd_sendv(int fd, const char *fmt, va_list ap)
491 /* qobject_from_jsonv() silently eats leading 0xff as invalid
492 * JSON, but we want to test sending them over the wire to force
494 if (*fmt == '\377') {
495 socket_send(fd, fmt, 1);
499 /* Going through qobject ensures we escape strings properly.
500 * This seemingly unnecessary copy is required in case va_list
503 va_copy(ap_copy, ap);
504 qobj = qobject_from_jsonv(fmt, &ap_copy, &error_abort);
507 /* No need to send anything for an empty QObject. */
509 int log = getenv("QTEST_LOG") != NULL;
510 QString *qstr = qobject_to_json(qobj);
514 * BUG: QMP doesn't react to input until it sees a newline, an
515 * object, or an array. Work-around: give it a newline.
517 qstring_append_chr(qstr, '\n');
518 str = qstring_get_str(qstr);
521 fprintf(stderr, "%s", str);
523 /* Send QMP request */
524 socket_send(fd, str, qstring_get_length(qstr));
531 void qtest_async_qmpv(QTestState *s, const char *fmt, va_list ap)
533 qmp_fd_sendv(s->qmp_fd, fmt, ap);
536 QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
538 qmp_fd_sendv(fd, fmt, ap);
540 return qmp_fd_receive(fd);
543 QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
545 qtest_async_qmpv(s, fmt, ap);
548 return qtest_qmp_receive(s);
551 QDict *qmp_fd(int fd, const char *fmt, ...)
557 response = qmp_fdv(fd, fmt, ap);
562 void qmp_fd_send(int fd, const char *fmt, ...)
567 qmp_fd_sendv(fd, fmt, ap);
571 QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
577 response = qtest_qmpv(s, fmt, ap);
582 void qtest_async_qmp(QTestState *s, const char *fmt, ...)
587 qtest_async_qmpv(s, fmt, ap);
591 void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap)
593 QDict *response = qtest_qmpv(s, fmt, ap);
594 qobject_unref(response);
597 void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
603 response = qtest_qmpv(s, fmt, ap);
605 qobject_unref(response);
608 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
613 response = qtest_qmp_receive(s);
614 if ((qdict_haskey(response, "event")) &&
615 (strcmp(qdict_get_str(response, "event"), event) == 0)) {
618 qobject_unref(response);
622 void qtest_qmp_eventwait(QTestState *s, const char *event)
626 response = qtest_qmp_eventwait_ref(s, event);
627 qobject_unref(response);
630 char *qtest_hmpv(QTestState *s, const char *fmt, va_list ap)
636 cmd = g_strdup_vprintf(fmt, ap);
637 resp = qtest_qmp(s, "{'execute': 'human-monitor-command',"
638 " 'arguments': {'command-line': %s}}",
640 ret = g_strdup(qdict_get_try_str(resp, "return"));
641 while (ret == NULL && qdict_get_try_str(resp, "event")) {
642 /* Ignore asynchronous QMP events */
644 resp = qtest_qmp_receive(s);
645 ret = g_strdup(qdict_get_try_str(resp, "return"));
653 char *qtest_hmp(QTestState *s, const char *fmt, ...)
659 ret = qtest_hmpv(s, fmt, ap);
664 const char *qtest_get_arch(void)
666 const char *qemu = qtest_qemu_binary();
667 const char *end = strrchr(qemu, '/');
669 return end + strlen("/qemu-system-");
672 bool qtest_get_irq(QTestState *s, int num)
674 /* dummy operation in order to make sure irq is up to date */
677 return s->irq_level[num];
680 static int64_t qtest_clock_rsp(QTestState *s)
684 words = qtest_rsp(s, 2);
685 clock = g_ascii_strtoll(words[1], NULL, 0);
690 int64_t qtest_clock_step_next(QTestState *s)
692 qtest_sendf(s, "clock_step\n");
693 return qtest_clock_rsp(s);
696 int64_t qtest_clock_step(QTestState *s, int64_t step)
698 qtest_sendf(s, "clock_step %"PRIi64"\n", step);
699 return qtest_clock_rsp(s);
702 int64_t qtest_clock_set(QTestState *s, int64_t val)
704 qtest_sendf(s, "clock_set %"PRIi64"\n", val);
705 return qtest_clock_rsp(s);
708 void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
710 qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
714 void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
716 qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
720 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
722 qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
726 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
728 qtest_out(s, "outb", addr, value);
731 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
733 qtest_out(s, "outw", addr, value);
736 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
738 qtest_out(s, "outl", addr, value);
741 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
747 qtest_sendf(s, "%s 0x%x\n", cmd, addr);
748 args = qtest_rsp(s, 2);
749 ret = qemu_strtoul(args[1], NULL, 0, &value);
750 g_assert(!ret && value <= UINT32_MAX);
756 uint8_t qtest_inb(QTestState *s, uint16_t addr)
758 return qtest_in(s, "inb", addr);
761 uint16_t qtest_inw(QTestState *s, uint16_t addr)
763 return qtest_in(s, "inw", addr);
766 uint32_t qtest_inl(QTestState *s, uint16_t addr)
768 return qtest_in(s, "inl", addr);
771 static void qtest_write(QTestState *s, const char *cmd, uint64_t addr,
774 qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value);
778 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
780 qtest_write(s, "writeb", addr, value);
783 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
785 qtest_write(s, "writew", addr, value);
788 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
790 qtest_write(s, "writel", addr, value);
793 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
795 qtest_write(s, "writeq", addr, value);
798 static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr)
804 qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
805 args = qtest_rsp(s, 2);
806 ret = qemu_strtou64(args[1], NULL, 0, &value);
813 uint8_t qtest_readb(QTestState *s, uint64_t addr)
815 return qtest_read(s, "readb", addr);
818 uint16_t qtest_readw(QTestState *s, uint64_t addr)
820 return qtest_read(s, "readw", addr);
823 uint32_t qtest_readl(QTestState *s, uint64_t addr)
825 return qtest_read(s, "readl", addr);
828 uint64_t qtest_readq(QTestState *s, uint64_t addr)
830 return qtest_read(s, "readq", addr);
833 static int hex2nib(char ch)
835 if (ch >= '0' && ch <= '9') {
837 } else if (ch >= 'a' && ch <= 'f') {
838 return 10 + (ch - 'a');
839 } else if (ch >= 'A' && ch <= 'F') {
840 return 10 + (ch - 'a');
846 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
856 qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
857 args = qtest_rsp(s, 2);
859 for (i = 0; i < size; i++) {
860 ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
861 ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
867 uint64_t qtest_rtas_call(QTestState *s, const char *name,
868 uint32_t nargs, uint64_t args,
869 uint32_t nret, uint64_t ret)
871 qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n",
872 name, nargs, args, nret, ret);
877 void qtest_add_func(const char *str, void (*fn)(void))
879 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
880 g_test_add_func(path, fn);
884 void qtest_add_data_func_full(const char *str, void *data,
885 void (*fn)(const void *),
886 GDestroyNotify data_free_func)
888 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
889 g_test_add_data_func_full(path, data, fn, data_free_func);
893 void qtest_add_data_func(const char *str, const void *data,
894 void (*fn)(const void *))
896 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
897 g_test_add_data_func(path, data, fn);
901 void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
905 bdata = g_base64_encode(data, size);
906 qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size);
907 socket_send(s->fd, bdata, strlen(bdata));
908 socket_send(s->fd, "\n", 1);
913 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
918 qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size);
919 args = qtest_rsp(s, 2);
921 g_base64_decode_inplace(args[1], &len);
923 fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n",
925 len = MIN(len, size);
928 memcpy(data, args[1], len);
932 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
934 const uint8_t *ptr = data;
942 enc = g_malloc(2 * size + 1);
944 for (i = 0; i < size; i++) {
945 sprintf(&enc[i * 2], "%02x", ptr[i]);
948 qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc);
953 void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)
955 qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern);
959 QDict *qmp(const char *fmt, ...)
965 response = qtest_qmpv(global_qtest, fmt, ap);
970 void qmp_async(const char *fmt, ...)
975 qtest_async_qmpv(global_qtest, fmt, ap);
979 void qmp_discard_response(const char *fmt, ...)
984 qtest_qmpv_discard_response(global_qtest, fmt, ap);
987 char *hmp(const char *fmt, ...)
993 ret = qtest_hmpv(global_qtest, fmt, ap);
998 bool qtest_big_endian(QTestState *s)
1000 return s->big_endian;
1003 void qtest_cb_for_every_machine(void (*cb)(const char *machine))
1005 QDict *response, *minfo;
1007 const QListEntry *p;
1012 qtest_start("-machine none");
1013 response = qmp("{ 'execute': 'query-machines' }");
1015 list = qdict_get_qlist(response, "return");
1018 for (p = qlist_first(list); p; p = qlist_next(p)) {
1019 minfo = qobject_to(QDict, qlist_entry_obj(p));
1021 qobj = qdict_get(minfo, "name");
1023 qstr = qobject_to(QString, qobj);
1025 mname = qstring_get_str(qstr);
1030 qobject_unref(response);
1034 * Generic hot-plugging test via the device_add QMP command.
1036 void qtest_qmp_device_add(const char *driver, const char *id, const char *fmt,
1040 char *cmd, *opts = NULL;
1045 opts = g_strdup_vprintf(fmt, va);
1049 cmd = g_strdup_printf("{'execute': 'device_add',"
1050 " 'arguments': { 'driver': '%s', 'id': '%s'%s%s }}",
1051 driver, id, opts ? ", " : "", opts ? opts : "");
1054 response = qmp(cmd);
1057 g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
1058 g_assert(!qdict_haskey(response, "error"));
1059 qobject_unref(response);
1063 * Generic hot-unplugging test via the device_del QMP command.
1064 * Device deletion will get one response and one event. For example:
1066 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
1068 * will get this one:
1070 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
1071 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
1072 * "path": "/machine/peripheral/scsi-hd"}}
1078 * But the order of arrival may vary - so we've got to detect both.
1080 void qtest_qmp_device_del(const char *id)
1082 QDict *response1, *response2, *event = NULL;
1085 cmd = g_strdup_printf("{'execute': 'device_del',"
1086 " 'arguments': { 'id': '%s' }}", id);
1087 response1 = qmp(cmd);
1089 g_assert(response1);
1090 g_assert(!qdict_haskey(response1, "error"));
1092 response2 = qmp("");
1093 g_assert(response2);
1094 g_assert(!qdict_haskey(response2, "error"));
1096 if (qdict_haskey(response1, "event")) {
1098 } else if (qdict_haskey(response2, "event")) {
1102 g_assert_cmpstr(qdict_get_str(event, "event"), ==, "DEVICE_DELETED");
1104 qobject_unref(response1);
1105 qobject_unref(response2);