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-streamer.h"
34 #include "qapi/qmp/json-parser.h"
37 #define SOCKET_TIMEOUT 5
39 QTestState
*global_qtest
;
45 bool irq_level
[MAX_IRQ
];
47 pid_t qemu_pid
; /* our child QEMU process */
48 struct sigaction sigact_old
; /* restored on exit */
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
,
92 addrlen
= sizeof(addr
);
94 ret
= accept(sock
, (struct sockaddr
*)&addr
, &addrlen
);
95 } while (ret
== -1 && errno
== EINTR
);
101 static void kill_qemu(QTestState
*s
)
103 if (s
->qemu_pid
!= -1) {
104 kill(s
->qemu_pid
, SIGTERM
);
105 waitpid(s
->qemu_pid
, NULL
, 0);
109 static void sigabrt_handler(int signo
)
112 for (elem
= qtest_instances
; elem
; elem
= elem
->next
) {
113 kill_qemu(elem
->data
);
117 static void setup_sigabrt_handler(void)
119 struct sigaction sigact
;
121 /* Catch SIGABRT to clean up on g_assert() failure */
122 sigact
= (struct sigaction
){
123 .sa_handler
= sigabrt_handler
,
124 .sa_flags
= SA_RESETHAND
,
126 sigemptyset(&sigact
.sa_mask
);
127 sigaction(SIGABRT
, &sigact
, &sigact_old
);
130 static void cleanup_sigabrt_handler(void)
132 sigaction(SIGABRT
, &sigact_old
, NULL
);
135 QTestState
*qtest_init(const char *extra_args
)
138 int sock
, qmpsock
, i
;
140 gchar
*qmp_socket_path
;
142 const char *qemu_binary
;
144 qemu_binary
= getenv("QTEST_QEMU_BINARY");
145 g_assert(qemu_binary
!= NULL
);
147 s
= g_malloc(sizeof(*s
));
149 socket_path
= g_strdup_printf("/tmp/qtest-%d.sock", getpid());
150 qmp_socket_path
= g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
152 sock
= init_socket(socket_path
);
153 qmpsock
= init_socket(qmp_socket_path
);
155 /* Only install SIGABRT handler once */
156 if (!qtest_instances
) {
157 setup_sigabrt_handler();
160 qtest_instances
= g_list_prepend(qtest_instances
, s
);
162 s
->qemu_pid
= fork();
163 if (s
->qemu_pid
== 0) {
164 command
= g_strdup_printf("exec %s "
165 "-qtest unix:%s,nowait "
166 "-qtest-log /dev/null "
167 "-qmp unix:%s,nowait "
168 "-machine accel=qtest "
170 "%s", qemu_binary
, socket_path
,
173 execlp("/bin/sh", "sh", "-c", command
, NULL
);
177 s
->fd
= socket_accept(sock
);
179 s
->qmp_fd
= socket_accept(qmpsock
);
182 unlink(qmp_socket_path
);
184 g_free(qmp_socket_path
);
186 g_assert(s
->fd
>= 0 && s
->qmp_fd
>= 0);
188 s
->rx
= g_string_new("");
189 for (i
= 0; i
< MAX_IRQ
; i
++) {
190 s
->irq_level
[i
] = false;
193 /* Read the QMP greeting and then do the handshake */
194 qtest_qmp_discard_response(s
, "");
195 qtest_qmp_discard_response(s
, "{ 'execute': 'qmp_capabilities' }");
197 if (getenv("QTEST_STOP")) {
198 kill(s
->qemu_pid
, SIGSTOP
);
204 void qtest_quit(QTestState
*s
)
206 /* Uninstall SIGABRT handler on last instance */
207 if (qtest_instances
&& !qtest_instances
->next
) {
208 cleanup_sigabrt_handler();
211 qtest_instances
= g_list_remove(qtest_instances
, s
);
216 g_string_free(s
->rx
, true);
220 static void socket_sendf(int fd
, const char *fmt
, va_list ap
)
225 str
= g_strdup_vprintf(fmt
, ap
);
229 while (offset
< size
) {
232 len
= write(fd
, str
+ offset
, size
- offset
);
233 if (len
== -1 && errno
== EINTR
) {
237 g_assert_no_errno(len
);
238 g_assert_cmpint(len
, >, 0);
244 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState
*s
, const char *fmt
, ...)
249 socket_sendf(s
->fd
, fmt
, ap
);
253 static GString
*qtest_recv_line(QTestState
*s
)
259 while ((eol
= strchr(s
->rx
->str
, '\n')) == NULL
) {
263 len
= read(s
->fd
, buffer
, sizeof(buffer
));
264 if (len
== -1 && errno
== EINTR
) {
268 if (len
== -1 || len
== 0) {
269 fprintf(stderr
, "Broken pipe\n");
273 g_string_append_len(s
->rx
, buffer
, len
);
276 offset
= eol
- s
->rx
->str
;
277 line
= g_string_new_len(s
->rx
->str
, offset
);
278 g_string_erase(s
->rx
, 0, offset
+ 1);
283 static gchar
**qtest_rsp(QTestState
*s
, int expected_args
)
290 line
= qtest_recv_line(s
);
291 words
= g_strsplit(line
->str
, " ", 0);
292 g_string_free(line
, TRUE
);
294 if (strcmp(words
[0], "IRQ") == 0) {
297 g_assert(words
[1] != NULL
);
298 g_assert(words
[2] != NULL
);
300 irq
= strtoul(words
[2], NULL
, 0);
301 g_assert_cmpint(irq
, >=, 0);
302 g_assert_cmpint(irq
, <, MAX_IRQ
);
304 if (strcmp(words
[1], "raise") == 0) {
305 s
->irq_level
[irq
] = true;
307 s
->irq_level
[irq
] = false;
314 g_assert(words
[0] != NULL
);
315 g_assert_cmpstr(words
[0], ==, "OK");
318 for (i
= 0; i
< expected_args
; i
++) {
319 g_assert(words
[i
] != NULL
);
329 JSONMessageParser parser
;
333 static void qmp_response(JSONMessageParser
*parser
, QList
*tokens
)
335 QMPResponseParser
*qmp
= container_of(parser
, QMPResponseParser
, parser
);
338 obj
= json_parser_parse(tokens
, NULL
);
340 fprintf(stderr
, "QMP JSON response parsing failed\n");
344 g_assert(qobject_type(obj
) == QTYPE_QDICT
);
345 g_assert(!qmp
->response
);
346 qmp
->response
= (QDict
*)obj
;
349 QDict
*qtest_qmp_receive(QTestState
*s
)
351 QMPResponseParser qmp
;
354 json_message_parser_init(&qmp
.parser
, qmp_response
);
355 while (!qmp
.response
) {
359 len
= read(s
->qmp_fd
, &c
, 1);
360 if (len
== -1 && errno
== EINTR
) {
364 if (len
== -1 || len
== 0) {
365 fprintf(stderr
, "Broken pipe\n");
369 json_message_parser_feed(&qmp
.parser
, &c
, 1);
371 json_message_parser_destroy(&qmp
.parser
);
376 QDict
*qtest_qmpv(QTestState
*s
, const char *fmt
, va_list ap
)
378 /* Send QMP request */
379 socket_sendf(s
->qmp_fd
, fmt
, ap
);
382 return qtest_qmp_receive(s
);
385 QDict
*qtest_qmp(QTestState
*s
, const char *fmt
, ...)
391 response
= qtest_qmpv(s
, fmt
, ap
);
396 void qtest_qmpv_discard_response(QTestState
*s
, const char *fmt
, va_list ap
)
398 QDict
*response
= qtest_qmpv(s
, fmt
, ap
);
402 void qtest_qmp_discard_response(QTestState
*s
, const char *fmt
, ...)
408 response
= qtest_qmpv(s
, fmt
, ap
);
413 const char *qtest_get_arch(void)
415 const char *qemu
= getenv("QTEST_QEMU_BINARY");
416 const char *end
= strrchr(qemu
, '/');
418 return end
+ strlen("/qemu-system-");
421 bool qtest_get_irq(QTestState
*s
, int num
)
423 /* dummy operation in order to make sure irq is up to date */
426 return s
->irq_level
[num
];
429 static int64_t qtest_clock_rsp(QTestState
*s
)
433 words
= qtest_rsp(s
, 2);
434 clock
= g_ascii_strtoll(words
[1], NULL
, 0);
439 int64_t qtest_clock_step_next(QTestState
*s
)
441 qtest_sendf(s
, "clock_step\n");
442 return qtest_clock_rsp(s
);
445 int64_t qtest_clock_step(QTestState
*s
, int64_t step
)
447 qtest_sendf(s
, "clock_step %"PRIi64
"\n", step
);
448 return qtest_clock_rsp(s
);
451 int64_t qtest_clock_set(QTestState
*s
, int64_t val
)
453 qtest_sendf(s
, "clock_set %"PRIi64
"\n", val
);
454 return qtest_clock_rsp(s
);
457 void qtest_irq_intercept_out(QTestState
*s
, const char *qom_path
)
459 qtest_sendf(s
, "irq_intercept_out %s\n", qom_path
);
463 void qtest_irq_intercept_in(QTestState
*s
, const char *qom_path
)
465 qtest_sendf(s
, "irq_intercept_in %s\n", qom_path
);
469 static void qtest_out(QTestState
*s
, const char *cmd
, uint16_t addr
, uint32_t value
)
471 qtest_sendf(s
, "%s 0x%x 0x%x\n", cmd
, addr
, value
);
475 void qtest_outb(QTestState
*s
, uint16_t addr
, uint8_t value
)
477 qtest_out(s
, "outb", addr
, value
);
480 void qtest_outw(QTestState
*s
, uint16_t addr
, uint16_t value
)
482 qtest_out(s
, "outw", addr
, value
);
485 void qtest_outl(QTestState
*s
, uint16_t addr
, uint32_t value
)
487 qtest_out(s
, "outl", addr
, value
);
490 static uint32_t qtest_in(QTestState
*s
, const char *cmd
, uint16_t addr
)
495 qtest_sendf(s
, "%s 0x%x\n", cmd
, addr
);
496 args
= qtest_rsp(s
, 2);
497 value
= strtoul(args
[1], NULL
, 0);
503 uint8_t qtest_inb(QTestState
*s
, uint16_t addr
)
505 return qtest_in(s
, "inb", addr
);
508 uint16_t qtest_inw(QTestState
*s
, uint16_t addr
)
510 return qtest_in(s
, "inw", addr
);
513 uint32_t qtest_inl(QTestState
*s
, uint16_t addr
)
515 return qtest_in(s
, "inl", addr
);
518 static void qtest_write(QTestState
*s
, const char *cmd
, uint64_t addr
,
521 qtest_sendf(s
, "%s 0x%" PRIx64
" 0x%" PRIx64
"\n", cmd
, addr
, value
);
525 void qtest_writeb(QTestState
*s
, uint64_t addr
, uint8_t value
)
527 qtest_write(s
, "writeb", addr
, value
);
530 void qtest_writew(QTestState
*s
, uint64_t addr
, uint16_t value
)
532 qtest_write(s
, "writew", addr
, value
);
535 void qtest_writel(QTestState
*s
, uint64_t addr
, uint32_t value
)
537 qtest_write(s
, "writel", addr
, value
);
540 void qtest_writeq(QTestState
*s
, uint64_t addr
, uint64_t value
)
542 qtest_write(s
, "writeq", addr
, value
);
545 static uint64_t qtest_read(QTestState
*s
, const char *cmd
, uint64_t addr
)
550 qtest_sendf(s
, "%s 0x%" PRIx64
"\n", cmd
, addr
);
551 args
= qtest_rsp(s
, 2);
552 value
= strtoull(args
[1], NULL
, 0);
558 uint8_t qtest_readb(QTestState
*s
, uint64_t addr
)
560 return qtest_read(s
, "readb", addr
);
563 uint16_t qtest_readw(QTestState
*s
, uint64_t addr
)
565 return qtest_read(s
, "readw", addr
);
568 uint32_t qtest_readl(QTestState
*s
, uint64_t addr
)
570 return qtest_read(s
, "readl", addr
);
573 uint64_t qtest_readq(QTestState
*s
, uint64_t addr
)
575 return qtest_read(s
, "readq", addr
);
578 static int hex2nib(char ch
)
580 if (ch
>= '0' && ch
<= '9') {
582 } else if (ch
>= 'a' && ch
<= 'f') {
583 return 10 + (ch
- 'a');
584 } else if (ch
>= 'A' && ch
<= 'F') {
585 return 10 + (ch
- 'a');
591 void qtest_memread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
597 qtest_sendf(s
, "read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
598 args
= qtest_rsp(s
, 2);
600 for (i
= 0; i
< size
; i
++) {
601 ptr
[i
] = hex2nib(args
[1][2 + (i
* 2)]) << 4;
602 ptr
[i
] |= hex2nib(args
[1][2 + (i
* 2) + 1]);
608 void qtest_add_func(const char *str
, void (*fn
))
610 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
611 g_test_add_func(path
, fn
);
614 void qtest_memwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
616 const uint8_t *ptr
= data
;
619 qtest_sendf(s
, "write 0x%" PRIx64
" 0x%zx 0x", addr
, size
);
620 for (i
= 0; i
< size
; i
++) {
621 qtest_sendf(s
, "%02x", ptr
[i
]);
623 qtest_sendf(s
, "\n");
627 QDict
*qmp(const char *fmt
, ...)
633 response
= qtest_qmpv(global_qtest
, fmt
, ap
);
638 void qmp_discard_response(const char *fmt
, ...)
643 qtest_qmpv_discard_response(global_qtest
, fmt
, ap
);