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.
20 #include <sys/types.h>
21 #include <sys/socket.h>
31 #include "qemu/compiler.h"
32 #include "qemu/osdep.h"
33 #include "qapi/qmp/json-parser.h"
34 #include "qapi/qmp/json-streamer.h"
35 #include "qapi/qmp/qjson.h"
38 #define SOCKET_TIMEOUT 5
40 QTestState
*global_qtest
;
46 bool irq_level
[MAX_IRQ
];
48 pid_t qemu_pid
; /* our child QEMU process */
51 static GList
*qtest_instances
;
52 static struct sigaction sigact_old
;
54 #define g_assert_no_errno(ret) do { \
55 g_assert_cmpint(ret, !=, -1); \
58 static int init_socket(const char *socket_path
)
60 struct sockaddr_un addr
;
64 sock
= socket(PF_UNIX
, SOCK_STREAM
, 0);
65 g_assert_no_errno(sock
);
67 addr
.sun_family
= AF_UNIX
;
68 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s", socket_path
);
69 qemu_set_cloexec(sock
);
72 ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
));
73 } while (ret
== -1 && errno
== EINTR
);
74 g_assert_no_errno(ret
);
75 ret
= listen(sock
, 1);
76 g_assert_no_errno(ret
);
81 static int socket_accept(int sock
)
83 struct sockaddr_un addr
;
86 struct timeval timeout
= { .tv_sec
= SOCKET_TIMEOUT
,
89 setsockopt(sock
, SOL_SOCKET
, SO_RCVTIMEO
, (void *)&timeout
,
93 addrlen
= sizeof(addr
);
94 ret
= accept(sock
, (struct sockaddr
*)&addr
, &addrlen
);
95 } while (ret
== -1 && errno
== EINTR
);
97 fprintf(stderr
, "%s failed: %s\n", __func__
, strerror(errno
));
104 static void kill_qemu(QTestState
*s
)
106 if (s
->qemu_pid
!= -1) {
107 kill(s
->qemu_pid
, SIGTERM
);
108 waitpid(s
->qemu_pid
, NULL
, 0);
112 static void sigabrt_handler(int signo
)
115 for (elem
= qtest_instances
; elem
; elem
= elem
->next
) {
116 kill_qemu(elem
->data
);
120 static void setup_sigabrt_handler(void)
122 struct sigaction sigact
;
124 /* Catch SIGABRT to clean up on g_assert() failure */
125 sigact
= (struct sigaction
){
126 .sa_handler
= sigabrt_handler
,
127 .sa_flags
= SA_RESETHAND
,
129 sigemptyset(&sigact
.sa_mask
);
130 sigaction(SIGABRT
, &sigact
, &sigact_old
);
133 static void cleanup_sigabrt_handler(void)
135 sigaction(SIGABRT
, &sigact_old
, NULL
);
138 QTestState
*qtest_init(const char *extra_args
)
141 int sock
, qmpsock
, i
;
143 gchar
*qmp_socket_path
;
145 const char *qemu_binary
;
147 qemu_binary
= getenv("QTEST_QEMU_BINARY");
148 g_assert(qemu_binary
!= NULL
);
150 s
= g_malloc(sizeof(*s
));
152 socket_path
= g_strdup_printf("/tmp/qtest-%d.sock", getpid());
153 qmp_socket_path
= g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
155 sock
= init_socket(socket_path
);
156 qmpsock
= init_socket(qmp_socket_path
);
158 /* Only install SIGABRT handler once */
159 if (!qtest_instances
) {
160 setup_sigabrt_handler();
163 qtest_instances
= g_list_prepend(qtest_instances
, s
);
165 s
->qemu_pid
= fork();
166 if (s
->qemu_pid
== 0) {
167 setenv("QEMU_AUDIO_DRV", "none", true);
168 command
= g_strdup_printf("exec %s "
169 "-qtest unix:%s,nowait "
171 "-qmp unix:%s,nowait "
172 "-machine accel=qtest "
174 "%s", qemu_binary
, socket_path
,
175 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
178 execlp("/bin/sh", "sh", "-c", command
, NULL
);
182 s
->fd
= socket_accept(sock
);
184 s
->qmp_fd
= socket_accept(qmpsock
);
187 unlink(qmp_socket_path
);
189 g_free(qmp_socket_path
);
191 g_assert(s
->fd
>= 0 && s
->qmp_fd
>= 0);
193 s
->rx
= g_string_new("");
194 for (i
= 0; i
< MAX_IRQ
; i
++) {
195 s
->irq_level
[i
] = false;
198 /* Read the QMP greeting and then do the handshake */
199 qtest_qmp_discard_response(s
, "");
200 qtest_qmp_discard_response(s
, "{ 'execute': 'qmp_capabilities' }");
202 if (getenv("QTEST_STOP")) {
203 kill(s
->qemu_pid
, SIGSTOP
);
209 void qtest_quit(QTestState
*s
)
211 /* Uninstall SIGABRT handler on last instance */
212 if (qtest_instances
&& !qtest_instances
->next
) {
213 cleanup_sigabrt_handler();
216 qtest_instances
= g_list_remove(qtest_instances
, s
);
221 g_string_free(s
->rx
, true);
225 static void socket_send(int fd
, const char *buf
, size_t size
)
230 while (offset
< size
) {
233 len
= write(fd
, buf
+ offset
, size
- offset
);
234 if (len
== -1 && errno
== EINTR
) {
238 g_assert_no_errno(len
);
239 g_assert_cmpint(len
, >, 0);
245 static void socket_sendf(int fd
, const char *fmt
, va_list ap
)
247 gchar
*str
= g_strdup_vprintf(fmt
, ap
);
248 size_t size
= strlen(str
);
250 socket_send(fd
, str
, size
);
254 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState
*s
, const char *fmt
, ...)
259 socket_sendf(s
->fd
, fmt
, ap
);
263 static GString
*qtest_recv_line(QTestState
*s
)
269 while ((eol
= strchr(s
->rx
->str
, '\n')) == NULL
) {
273 len
= read(s
->fd
, buffer
, sizeof(buffer
));
274 if (len
== -1 && errno
== EINTR
) {
278 if (len
== -1 || len
== 0) {
279 fprintf(stderr
, "Broken pipe\n");
283 g_string_append_len(s
->rx
, buffer
, len
);
286 offset
= eol
- s
->rx
->str
;
287 line
= g_string_new_len(s
->rx
->str
, offset
);
288 g_string_erase(s
->rx
, 0, offset
+ 1);
293 static gchar
**qtest_rsp(QTestState
*s
, int expected_args
)
300 line
= qtest_recv_line(s
);
301 words
= g_strsplit(line
->str
, " ", 0);
302 g_string_free(line
, TRUE
);
304 if (strcmp(words
[0], "IRQ") == 0) {
307 g_assert(words
[1] != NULL
);
308 g_assert(words
[2] != NULL
);
310 irq
= strtoul(words
[2], NULL
, 0);
311 g_assert_cmpint(irq
, >=, 0);
312 g_assert_cmpint(irq
, <, MAX_IRQ
);
314 if (strcmp(words
[1], "raise") == 0) {
315 s
->irq_level
[irq
] = true;
317 s
->irq_level
[irq
] = false;
324 g_assert(words
[0] != NULL
);
325 g_assert_cmpstr(words
[0], ==, "OK");
328 for (i
= 0; i
< expected_args
; i
++) {
329 g_assert(words
[i
] != NULL
);
339 JSONMessageParser parser
;
343 static void qmp_response(JSONMessageParser
*parser
, QList
*tokens
)
345 QMPResponseParser
*qmp
= container_of(parser
, QMPResponseParser
, parser
);
348 obj
= json_parser_parse(tokens
, NULL
);
350 fprintf(stderr
, "QMP JSON response parsing failed\n");
354 g_assert(qobject_type(obj
) == QTYPE_QDICT
);
355 g_assert(!qmp
->response
);
356 qmp
->response
= (QDict
*)obj
;
359 QDict
*qtest_qmp_receive(QTestState
*s
)
361 QMPResponseParser qmp
;
362 bool log
= getenv("QTEST_LOG") != NULL
;
365 json_message_parser_init(&qmp
.parser
, qmp_response
);
366 while (!qmp
.response
) {
370 len
= read(s
->qmp_fd
, &c
, 1);
371 if (len
== -1 && errno
== EINTR
) {
375 if (len
== -1 || len
== 0) {
376 fprintf(stderr
, "Broken pipe\n");
381 len
= write(2, &c
, 1);
383 json_message_parser_feed(&qmp
.parser
, &c
, 1);
385 json_message_parser_destroy(&qmp
.parser
);
391 * Allow users to send a message without waiting for the reply,
392 * in the case that they choose to discard all replies up until
393 * a particular EVENT is received.
395 void qtest_async_qmpv(QTestState
*s
, const char *fmt
, va_list ap
)
400 /* Going through qobject ensures we escape strings properly.
401 * This seemingly unnecessary copy is required in case va_list
404 va_copy(ap_copy
, ap
);
405 qobj
= qobject_from_jsonv(fmt
, &ap_copy
);
408 /* No need to send anything for an empty QObject. */
410 int log
= getenv("QTEST_LOG") != NULL
;
411 QString
*qstr
= qobject_to_json(qobj
);
412 const char *str
= qstring_get_str(qstr
);
413 size_t size
= qstring_get_length(qstr
);
416 fprintf(stderr
, "%s", str
);
418 /* Send QMP request */
419 socket_send(s
->qmp_fd
, str
, size
);
422 qobject_decref(qobj
);
426 QDict
*qtest_qmpv(QTestState
*s
, const char *fmt
, va_list ap
)
428 qtest_async_qmpv(s
, fmt
, ap
);
431 return qtest_qmp_receive(s
);
434 QDict
*qtest_qmp(QTestState
*s
, const char *fmt
, ...)
440 response
= qtest_qmpv(s
, fmt
, ap
);
445 void qtest_async_qmp(QTestState
*s
, const char *fmt
, ...)
450 qtest_async_qmpv(s
, fmt
, ap
);
454 void qtest_qmpv_discard_response(QTestState
*s
, const char *fmt
, va_list ap
)
456 QDict
*response
= qtest_qmpv(s
, fmt
, ap
);
460 void qtest_qmp_discard_response(QTestState
*s
, const char *fmt
, ...)
466 response
= qtest_qmpv(s
, fmt
, ap
);
471 void qtest_qmp_eventwait(QTestState
*s
, const char *event
)
476 response
= qtest_qmp_receive(s
);
477 if ((qdict_haskey(response
, "event")) &&
478 (strcmp(qdict_get_str(response
, "event"), event
) == 0)) {
486 char *qtest_hmpv(QTestState
*s
, const char *fmt
, va_list ap
)
492 cmd
= g_strdup_vprintf(fmt
, ap
);
493 resp
= qtest_qmp(s
, "{'execute': 'human-monitor-command',"
494 " 'arguments': {'command-line': %s}}",
496 ret
= g_strdup(qdict_get_try_str(resp
, "return"));
503 char *qtest_hmp(QTestState
*s
, const char *fmt
, ...)
509 ret
= qtest_hmpv(s
, fmt
, ap
);
514 const char *qtest_get_arch(void)
516 const char *qemu
= getenv("QTEST_QEMU_BINARY");
517 g_assert(qemu
!= NULL
);
518 const char *end
= strrchr(qemu
, '/');
520 return end
+ strlen("/qemu-system-");
523 bool qtest_get_irq(QTestState
*s
, int num
)
525 /* dummy operation in order to make sure irq is up to date */
528 return s
->irq_level
[num
];
531 static int64_t qtest_clock_rsp(QTestState
*s
)
535 words
= qtest_rsp(s
, 2);
536 clock
= g_ascii_strtoll(words
[1], NULL
, 0);
541 int64_t qtest_clock_step_next(QTestState
*s
)
543 qtest_sendf(s
, "clock_step\n");
544 return qtest_clock_rsp(s
);
547 int64_t qtest_clock_step(QTestState
*s
, int64_t step
)
549 qtest_sendf(s
, "clock_step %"PRIi64
"\n", step
);
550 return qtest_clock_rsp(s
);
553 int64_t qtest_clock_set(QTestState
*s
, int64_t val
)
555 qtest_sendf(s
, "clock_set %"PRIi64
"\n", val
);
556 return qtest_clock_rsp(s
);
559 void qtest_irq_intercept_out(QTestState
*s
, const char *qom_path
)
561 qtest_sendf(s
, "irq_intercept_out %s\n", qom_path
);
565 void qtest_irq_intercept_in(QTestState
*s
, const char *qom_path
)
567 qtest_sendf(s
, "irq_intercept_in %s\n", qom_path
);
571 static void qtest_out(QTestState
*s
, const char *cmd
, uint16_t addr
, uint32_t value
)
573 qtest_sendf(s
, "%s 0x%x 0x%x\n", cmd
, addr
, value
);
577 void qtest_outb(QTestState
*s
, uint16_t addr
, uint8_t value
)
579 qtest_out(s
, "outb", addr
, value
);
582 void qtest_outw(QTestState
*s
, uint16_t addr
, uint16_t value
)
584 qtest_out(s
, "outw", addr
, value
);
587 void qtest_outl(QTestState
*s
, uint16_t addr
, uint32_t value
)
589 qtest_out(s
, "outl", addr
, value
);
592 static uint32_t qtest_in(QTestState
*s
, const char *cmd
, uint16_t addr
)
597 qtest_sendf(s
, "%s 0x%x\n", cmd
, addr
);
598 args
= qtest_rsp(s
, 2);
599 value
= strtoul(args
[1], NULL
, 0);
605 uint8_t qtest_inb(QTestState
*s
, uint16_t addr
)
607 return qtest_in(s
, "inb", addr
);
610 uint16_t qtest_inw(QTestState
*s
, uint16_t addr
)
612 return qtest_in(s
, "inw", addr
);
615 uint32_t qtest_inl(QTestState
*s
, uint16_t addr
)
617 return qtest_in(s
, "inl", addr
);
620 static void qtest_write(QTestState
*s
, const char *cmd
, uint64_t addr
,
623 qtest_sendf(s
, "%s 0x%" PRIx64
" 0x%" PRIx64
"\n", cmd
, addr
, value
);
627 void qtest_writeb(QTestState
*s
, uint64_t addr
, uint8_t value
)
629 qtest_write(s
, "writeb", addr
, value
);
632 void qtest_writew(QTestState
*s
, uint64_t addr
, uint16_t value
)
634 qtest_write(s
, "writew", addr
, value
);
637 void qtest_writel(QTestState
*s
, uint64_t addr
, uint32_t value
)
639 qtest_write(s
, "writel", addr
, value
);
642 void qtest_writeq(QTestState
*s
, uint64_t addr
, uint64_t value
)
644 qtest_write(s
, "writeq", addr
, value
);
647 static uint64_t qtest_read(QTestState
*s
, const char *cmd
, uint64_t addr
)
652 qtest_sendf(s
, "%s 0x%" PRIx64
"\n", cmd
, addr
);
653 args
= qtest_rsp(s
, 2);
654 value
= strtoull(args
[1], NULL
, 0);
660 uint8_t qtest_readb(QTestState
*s
, uint64_t addr
)
662 return qtest_read(s
, "readb", addr
);
665 uint16_t qtest_readw(QTestState
*s
, uint64_t addr
)
667 return qtest_read(s
, "readw", addr
);
670 uint32_t qtest_readl(QTestState
*s
, uint64_t addr
)
672 return qtest_read(s
, "readl", addr
);
675 uint64_t qtest_readq(QTestState
*s
, uint64_t addr
)
677 return qtest_read(s
, "readq", addr
);
680 static int hex2nib(char ch
)
682 if (ch
>= '0' && ch
<= '9') {
684 } else if (ch
>= 'a' && ch
<= 'f') {
685 return 10 + (ch
- 'a');
686 } else if (ch
>= 'A' && ch
<= 'F') {
687 return 10 + (ch
- 'a');
693 void qtest_memread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
699 qtest_sendf(s
, "read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
700 args
= qtest_rsp(s
, 2);
702 for (i
= 0; i
< size
; i
++) {
703 ptr
[i
] = hex2nib(args
[1][2 + (i
* 2)]) << 4;
704 ptr
[i
] |= hex2nib(args
[1][2 + (i
* 2) + 1]);
710 void qtest_add_func(const char *str
, void (*fn
))
712 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
713 g_test_add_func(path
, fn
);
717 void qtest_add_data_func(const char *str
, const void *data
, void (*fn
))
719 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
720 g_test_add_data_func(path
, data
, fn
);
724 void qtest_bufwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
728 bdata
= g_base64_encode(data
, size
);
729 qtest_sendf(s
, "b64write 0x%" PRIx64
" 0x%zx ", addr
, size
);
730 socket_send(s
->fd
, bdata
, strlen(bdata
));
731 socket_send(s
->fd
, "\n", 1);
736 void qtest_bufread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
741 qtest_sendf(s
, "b64read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
742 args
= qtest_rsp(s
, 2);
744 g_base64_decode_inplace(args
[1], &len
);
746 fprintf(stderr
, "bufread: asked for %zu bytes but decoded %zu\n",
748 len
= MIN(len
, size
);
751 memcpy(data
, args
[1], len
);
755 void qtest_memwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
757 const uint8_t *ptr
= data
;
759 char *enc
= g_malloc(2 * size
+ 1);
761 for (i
= 0; i
< size
; i
++) {
762 sprintf(&enc
[i
* 2], "%02x", ptr
[i
]);
765 qtest_sendf(s
, "write 0x%" PRIx64
" 0x%zx 0x%s\n", addr
, size
, enc
);
770 void qtest_memset(QTestState
*s
, uint64_t addr
, uint8_t pattern
, size_t size
)
772 qtest_sendf(s
, "memset 0x%" PRIx64
" 0x%zx 0x%02x\n", addr
, size
, pattern
);
776 QDict
*qmp(const char *fmt
, ...)
782 response
= qtest_qmpv(global_qtest
, fmt
, ap
);
787 void qmp_async(const char *fmt
, ...)
792 qtest_async_qmpv(global_qtest
, fmt
, ap
);
796 void qmp_discard_response(const char *fmt
, ...)
801 qtest_qmpv_discard_response(global_qtest
, fmt
, ap
);
804 char *hmp(const char *fmt
, ...)
810 ret
= qtest_hmpv(global_qtest
, fmt
, ap
);
815 bool qtest_big_endian(void)
817 const char *arch
= qtest_get_arch();
820 static const struct {
824 { "aarch64", false },
831 { "microblaze", true },
832 { "microblazeel", false },
835 { "mips64el", false },
847 { "unicore32", false },
850 { "xtensaeb", true },
854 for (i
= 0; endianness
[i
].arch
; i
++) {
855 if (strcmp(endianness
[i
].arch
, arch
) == 0) {
856 return endianness
[i
].big_endian
;