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-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"
35 #define SOCKET_TIMEOUT 50
36 #define SOCKET_MAX_FDS 16
38 QTestState
*global_qtest
;
44 pid_t qemu_pid
; /* our child QEMU process */
47 bool irq_level
[MAX_IRQ
];
51 static GHookList abrt_hooks
;
52 static struct sigaction sigact_old
;
54 static int qtest_query_target_endianness(QTestState
*s
);
56 static int init_socket(const char *socket_path
)
58 struct sockaddr_un addr
;
62 sock
= socket(PF_UNIX
, SOCK_STREAM
, 0);
63 g_assert_cmpint(sock
, !=, -1);
65 addr
.sun_family
= AF_UNIX
;
66 snprintf(addr
.sun_path
, sizeof(addr
.sun_path
), "%s", socket_path
);
67 qemu_set_cloexec(sock
);
70 ret
= bind(sock
, (struct sockaddr
*)&addr
, sizeof(addr
));
71 } while (ret
== -1 && errno
== EINTR
);
72 g_assert_cmpint(ret
, !=, -1);
73 ret
= listen(sock
, 1);
74 g_assert_cmpint(ret
, !=, -1);
79 static int socket_accept(int sock
)
81 struct sockaddr_un addr
;
84 struct timeval timeout
= { .tv_sec
= SOCKET_TIMEOUT
,
87 setsockopt(sock
, SOL_SOCKET
, SO_RCVTIMEO
, (void *)&timeout
,
91 addrlen
= sizeof(addr
);
92 ret
= accept(sock
, (struct sockaddr
*)&addr
, &addrlen
);
93 } while (ret
== -1 && errno
== EINTR
);
95 fprintf(stderr
, "%s failed: %s\n", __func__
, strerror(errno
));
102 bool qtest_probe_child(QTestState
*s
)
104 pid_t pid
= s
->qemu_pid
;
107 pid
= waitpid(pid
, &s
->wstatus
, WNOHANG
);
116 static void kill_qemu(QTestState
*s
)
118 pid_t pid
= s
->qemu_pid
;
121 /* Skip wait if qtest_probe_child already reaped. */
124 TFR(pid
= waitpid(s
->qemu_pid
, &s
->wstatus
, 0));
125 assert(pid
== s
->qemu_pid
);
129 * We expect qemu to exit with status 0; anything else is
130 * fishy and should be logged with as much detail as possible.
132 wstatus
= s
->wstatus
;
134 if (WIFEXITED(wstatus
)) {
135 fprintf(stderr
, "%s:%d: kill_qemu() tried to terminate QEMU "
136 "process but encountered exit status %d\n",
137 __FILE__
, __LINE__
, WEXITSTATUS(wstatus
));
138 } else if (WIFSIGNALED(wstatus
)) {
139 int sig
= WTERMSIG(wstatus
);
140 const char *signame
= strsignal(sig
) ?: "unknown ???";
141 const char *dump
= WCOREDUMP(wstatus
) ? " (core dumped)" : "";
143 fprintf(stderr
, "%s:%d: kill_qemu() detected QEMU death "
144 "from signal %d (%s)%s\n",
145 __FILE__
, __LINE__
, sig
, signame
, dump
);
151 static void kill_qemu_hook_func(void *s
)
156 static void sigabrt_handler(int signo
)
158 g_hook_list_invoke(&abrt_hooks
, FALSE
);
161 static void setup_sigabrt_handler(void)
163 struct sigaction sigact
;
165 /* Catch SIGABRT to clean up on g_assert() failure */
166 sigact
= (struct sigaction
){
167 .sa_handler
= sigabrt_handler
,
168 .sa_flags
= SA_RESETHAND
,
170 sigemptyset(&sigact
.sa_mask
);
171 sigaction(SIGABRT
, &sigact
, &sigact_old
);
174 static void cleanup_sigabrt_handler(void)
176 sigaction(SIGABRT
, &sigact_old
, NULL
);
179 void qtest_add_abrt_handler(GHookFunc fn
, const void *data
)
183 /* Only install SIGABRT handler once */
184 if (!abrt_hooks
.is_setup
) {
185 g_hook_list_init(&abrt_hooks
, sizeof(GHook
));
187 setup_sigabrt_handler();
189 hook
= g_hook_alloc(&abrt_hooks
);
191 hook
->data
= (void *)data
;
193 g_hook_prepend(&abrt_hooks
, hook
);
196 static const char *qtest_qemu_binary(void)
198 const char *qemu_bin
;
200 qemu_bin
= getenv("QTEST_QEMU_BINARY");
202 fprintf(stderr
, "Environment variable QTEST_QEMU_BINARY required\n");
209 QTestState
*qtest_init_without_qmp_handshake(const char *extra_args
)
212 int sock
, qmpsock
, i
;
214 gchar
*qmp_socket_path
;
216 const char *qemu_binary
= qtest_qemu_binary();
218 s
= g_new(QTestState
, 1);
220 socket_path
= g_strdup_printf("/tmp/qtest-%d.sock", getpid());
221 qmp_socket_path
= g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
223 /* It's possible that if an earlier test run crashed it might
224 * have left a stale unix socket lying around. Delete any
225 * stale old socket to avoid spurious test failures with
226 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
229 unlink(qmp_socket_path
);
231 sock
= init_socket(socket_path
);
232 qmpsock
= init_socket(qmp_socket_path
);
234 qtest_add_abrt_handler(kill_qemu_hook_func
, s
);
236 command
= g_strdup_printf("exec %s "
239 "-chardev socket,path=%s,id=char0 "
240 "-mon chardev=char0,mode=control "
241 "-machine accel=qtest "
243 "%s", qemu_binary
, socket_path
,
244 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
248 g_test_message("starting QEMU: %s", command
);
251 s
->qemu_pid
= fork();
252 if (s
->qemu_pid
== 0) {
253 setenv("QEMU_AUDIO_DRV", "none", true);
254 execlp("/bin/sh", "sh", "-c", command
, NULL
);
259 s
->fd
= socket_accept(sock
);
261 s
->qmp_fd
= socket_accept(qmpsock
);
264 unlink(qmp_socket_path
);
266 g_free(qmp_socket_path
);
268 g_assert(s
->fd
>= 0 && s
->qmp_fd
>= 0);
270 s
->rx
= g_string_new("");
271 for (i
= 0; i
< MAX_IRQ
; i
++) {
272 s
->irq_level
[i
] = false;
275 if (getenv("QTEST_STOP")) {
276 kill(s
->qemu_pid
, SIGSTOP
);
279 /* ask endianness of the target */
281 s
->big_endian
= qtest_query_target_endianness(s
);
286 QTestState
*qtest_init(const char *extra_args
)
288 QTestState
*s
= qtest_init_without_qmp_handshake(extra_args
);
291 /* Read the QMP greeting and then do the handshake */
292 greeting
= qtest_qmp_receive(s
);
293 qobject_unref(greeting
);
294 qobject_unref(qtest_qmp(s
, "{ 'execute': 'qmp_capabilities' }"));
299 QTestState
*qtest_vinitf(const char *fmt
, va_list ap
)
301 char *args
= g_strdup_vprintf(fmt
, ap
);
304 s
= qtest_init(args
);
309 QTestState
*qtest_initf(const char *fmt
, ...)
315 s
= qtest_vinitf(fmt
, ap
);
320 QTestState
*qtest_init_with_serial(const char *extra_args
, int *sock_fd
)
323 char *sock_path
, sock_dir
[] = "/tmp/qtest-serial-XXXXXX";
326 g_assert_true(mkdtemp(sock_dir
) != NULL
);
327 sock_path
= g_strdup_printf("%s/sock", sock_dir
);
329 sock_fd_init
= init_socket(sock_path
);
331 qts
= qtest_initf("-chardev socket,id=s0,path=%s -serial chardev:s0 %s",
332 sock_path
, extra_args
);
334 *sock_fd
= socket_accept(sock_fd_init
);
340 g_assert_true(*sock_fd
>= 0);
345 void qtest_quit(QTestState
*s
)
347 g_hook_destroy_link(&abrt_hooks
, g_hook_find_data(&abrt_hooks
, TRUE
, s
));
349 /* Uninstall SIGABRT handler on last instance */
350 cleanup_sigabrt_handler();
355 g_string_free(s
->rx
, true);
359 static void socket_send(int fd
, const char *buf
, size_t size
)
364 while (offset
< size
) {
367 len
= write(fd
, buf
+ offset
, size
- offset
);
368 if (len
== -1 && errno
== EINTR
) {
372 g_assert_cmpint(len
, >, 0);
378 static void socket_sendf(int fd
, const char *fmt
, va_list ap
)
380 gchar
*str
= g_strdup_vprintf(fmt
, ap
);
381 size_t size
= strlen(str
);
383 socket_send(fd
, str
, size
);
387 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState
*s
, const char *fmt
, ...)
392 socket_sendf(s
->fd
, fmt
, ap
);
396 /* Sends a message and file descriptors to the socket.
397 * It's needed for qmp-commands like getfd/add-fd */
398 static void socket_send_fds(int socket_fd
, int *fds
, size_t fds_num
,
399 const char *buf
, size_t buf_size
)
402 struct msghdr msg
= { 0 };
403 char control
[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS
)] = { 0 };
404 size_t fdsize
= sizeof(int) * fds_num
;
405 struct cmsghdr
*cmsg
;
406 struct iovec iov
= { .iov_base
= (char *)buf
, .iov_len
= buf_size
};
411 if (fds
&& fds_num
> 0) {
412 g_assert_cmpuint(fds_num
, <, SOCKET_MAX_FDS
);
414 msg
.msg_control
= control
;
415 msg
.msg_controllen
= CMSG_SPACE(fdsize
);
417 cmsg
= CMSG_FIRSTHDR(&msg
);
418 cmsg
->cmsg_len
= CMSG_LEN(fdsize
);
419 cmsg
->cmsg_level
= SOL_SOCKET
;
420 cmsg
->cmsg_type
= SCM_RIGHTS
;
421 memcpy(CMSG_DATA(cmsg
), fds
, fdsize
);
425 ret
= sendmsg(socket_fd
, &msg
, 0);
426 } while (ret
< 0 && errno
== EINTR
);
427 g_assert_cmpint(ret
, >, 0);
430 static GString
*qtest_recv_line(QTestState
*s
)
436 while ((eol
= strchr(s
->rx
->str
, '\n')) == NULL
) {
440 len
= read(s
->fd
, buffer
, sizeof(buffer
));
441 if (len
== -1 && errno
== EINTR
) {
445 if (len
== -1 || len
== 0) {
446 fprintf(stderr
, "Broken pipe\n");
450 g_string_append_len(s
->rx
, buffer
, len
);
453 offset
= eol
- s
->rx
->str
;
454 line
= g_string_new_len(s
->rx
->str
, offset
);
455 g_string_erase(s
->rx
, 0, offset
+ 1);
460 static gchar
**qtest_rsp(QTestState
*s
, int expected_args
)
467 line
= qtest_recv_line(s
);
468 words
= g_strsplit(line
->str
, " ", 0);
469 g_string_free(line
, TRUE
);
471 if (strcmp(words
[0], "IRQ") == 0) {
475 g_assert(words
[1] != NULL
);
476 g_assert(words
[2] != NULL
);
478 ret
= qemu_strtol(words
[2], NULL
, 0, &irq
);
480 g_assert_cmpint(irq
, >=, 0);
481 g_assert_cmpint(irq
, <, MAX_IRQ
);
483 if (strcmp(words
[1], "raise") == 0) {
484 s
->irq_level
[irq
] = true;
486 s
->irq_level
[irq
] = false;
493 g_assert(words
[0] != NULL
);
494 g_assert_cmpstr(words
[0], ==, "OK");
497 for (i
= 0; i
< expected_args
; i
++) {
498 g_assert(words
[i
] != NULL
);
507 static int qtest_query_target_endianness(QTestState
*s
)
512 qtest_sendf(s
, "endianness\n");
513 args
= qtest_rsp(s
, 1);
514 g_assert(strcmp(args
[1], "big") == 0 || strcmp(args
[1], "little") == 0);
515 big_endian
= strcmp(args
[1], "big") == 0;
522 JSONMessageParser parser
;
526 static void qmp_response(void *opaque
, QObject
*obj
, Error
*err
)
528 QMPResponseParser
*qmp
= opaque
;
530 assert(!obj
!= !err
);
533 error_prepend(&err
, "QMP JSON response parsing failed: ");
534 error_report_err(err
);
538 g_assert(!qmp
->response
);
539 qmp
->response
= qobject_to(QDict
, obj
);
540 g_assert(qmp
->response
);
543 QDict
*qmp_fd_receive(int fd
)
545 QMPResponseParser qmp
;
546 bool log
= getenv("QTEST_LOG") != NULL
;
549 json_message_parser_init(&qmp
.parser
, qmp_response
, &qmp
, NULL
);
550 while (!qmp
.response
) {
554 len
= read(fd
, &c
, 1);
555 if (len
== -1 && errno
== EINTR
) {
559 if (len
== -1 || len
== 0) {
560 fprintf(stderr
, "Broken pipe\n");
565 len
= write(2, &c
, 1);
567 json_message_parser_feed(&qmp
.parser
, &c
, 1);
569 json_message_parser_destroy(&qmp
.parser
);
574 QDict
*qtest_qmp_receive(QTestState
*s
)
576 return qmp_fd_receive(s
->qmp_fd
);
580 * Allow users to send a message without waiting for the reply,
581 * in the case that they choose to discard all replies up until
582 * a particular EVENT is received.
584 void qmp_fd_vsend_fds(int fd
, int *fds
, size_t fds_num
,
585 const char *fmt
, va_list ap
)
589 /* Going through qobject ensures we escape strings properly */
590 qobj
= qobject_from_vjsonf_nofail(fmt
, ap
);
592 /* No need to send anything for an empty QObject. */
594 int log
= getenv("QTEST_LOG") != NULL
;
595 QString
*qstr
= qobject_to_json(qobj
);
599 * BUG: QMP doesn't react to input until it sees a newline, an
600 * object, or an array. Work-around: give it a newline.
602 qstring_append_chr(qstr
, '\n');
603 str
= qstring_get_str(qstr
);
606 fprintf(stderr
, "%s", str
);
608 /* Send QMP request */
609 if (fds
&& fds_num
> 0) {
610 socket_send_fds(fd
, fds
, fds_num
, str
, qstring_get_length(qstr
));
612 socket_send(fd
, str
, qstring_get_length(qstr
));
620 void qmp_fd_vsend(int fd
, const char *fmt
, va_list ap
)
622 qmp_fd_vsend_fds(fd
, NULL
, 0, fmt
, ap
);
625 void qtest_qmp_vsend_fds(QTestState
*s
, int *fds
, size_t fds_num
,
626 const char *fmt
, va_list ap
)
628 qmp_fd_vsend_fds(s
->qmp_fd
, fds
, fds_num
, fmt
, ap
);
631 void qtest_qmp_vsend(QTestState
*s
, const char *fmt
, va_list ap
)
633 qmp_fd_vsend_fds(s
->qmp_fd
, NULL
, 0, fmt
, ap
);
636 QDict
*qmp_fdv(int fd
, const char *fmt
, va_list ap
)
638 qmp_fd_vsend_fds(fd
, NULL
, 0, fmt
, ap
);
640 return qmp_fd_receive(fd
);
643 QDict
*qtest_vqmp_fds(QTestState
*s
, int *fds
, size_t fds_num
,
644 const char *fmt
, va_list ap
)
646 qtest_qmp_vsend_fds(s
, fds
, fds_num
, fmt
, ap
);
649 return qtest_qmp_receive(s
);
652 QDict
*qtest_vqmp(QTestState
*s
, const char *fmt
, va_list ap
)
654 qtest_qmp_vsend(s
, fmt
, ap
);
657 return qtest_qmp_receive(s
);
660 QDict
*qmp_fd(int fd
, const char *fmt
, ...)
666 response
= qmp_fdv(fd
, fmt
, ap
);
671 void qmp_fd_send(int fd
, const char *fmt
, ...)
676 qmp_fd_vsend(fd
, fmt
, ap
);
680 QDict
*qtest_qmp_fds(QTestState
*s
, int *fds
, size_t fds_num
,
681 const char *fmt
, ...)
687 response
= qtest_vqmp_fds(s
, fds
, fds_num
, fmt
, ap
);
692 QDict
*qtest_qmp(QTestState
*s
, const char *fmt
, ...)
698 response
= qtest_vqmp(s
, fmt
, ap
);
703 void qtest_qmp_send(QTestState
*s
, const char *fmt
, ...)
708 qtest_qmp_vsend(s
, fmt
, ap
);
712 void qmp_fd_vsend_raw(int fd
, const char *fmt
, va_list ap
)
714 bool log
= getenv("QTEST_LOG") != NULL
;
715 char *str
= g_strdup_vprintf(fmt
, ap
);
718 fprintf(stderr
, "%s", str
);
720 socket_send(fd
, str
, strlen(str
));
724 void qmp_fd_send_raw(int fd
, const char *fmt
, ...)
729 qmp_fd_vsend_raw(fd
, fmt
, ap
);
733 void qtest_qmp_send_raw(QTestState
*s
, const char *fmt
, ...)
738 qmp_fd_vsend_raw(s
->qmp_fd
, fmt
, ap
);
742 QDict
*qtest_qmp_eventwait_ref(QTestState
*s
, const char *event
)
747 response
= qtest_qmp_receive(s
);
748 if ((qdict_haskey(response
, "event")) &&
749 (strcmp(qdict_get_str(response
, "event"), event
) == 0)) {
752 qobject_unref(response
);
756 void qtest_qmp_eventwait(QTestState
*s
, const char *event
)
760 response
= qtest_qmp_eventwait_ref(s
, event
);
761 qobject_unref(response
);
764 char *qtest_vhmp(QTestState
*s
, const char *fmt
, va_list ap
)
770 cmd
= g_strdup_vprintf(fmt
, ap
);
771 resp
= qtest_qmp(s
, "{'execute': 'human-monitor-command',"
772 " 'arguments': {'command-line': %s}}",
774 ret
= g_strdup(qdict_get_try_str(resp
, "return"));
775 while (ret
== NULL
&& qdict_get_try_str(resp
, "event")) {
776 /* Ignore asynchronous QMP events */
778 resp
= qtest_qmp_receive(s
);
779 ret
= g_strdup(qdict_get_try_str(resp
, "return"));
787 char *qtest_hmp(QTestState
*s
, const char *fmt
, ...)
793 ret
= qtest_vhmp(s
, fmt
, ap
);
798 const char *qtest_get_arch(void)
800 const char *qemu
= qtest_qemu_binary();
801 const char *end
= strrchr(qemu
, '/');
803 return end
+ strlen("/qemu-system-");
806 bool qtest_get_irq(QTestState
*s
, int num
)
808 /* dummy operation in order to make sure irq is up to date */
811 return s
->irq_level
[num
];
814 static int64_t qtest_clock_rsp(QTestState
*s
)
818 words
= qtest_rsp(s
, 2);
819 clock
= g_ascii_strtoll(words
[1], NULL
, 0);
824 int64_t qtest_clock_step_next(QTestState
*s
)
826 qtest_sendf(s
, "clock_step\n");
827 return qtest_clock_rsp(s
);
830 int64_t qtest_clock_step(QTestState
*s
, int64_t step
)
832 qtest_sendf(s
, "clock_step %"PRIi64
"\n", step
);
833 return qtest_clock_rsp(s
);
836 int64_t qtest_clock_set(QTestState
*s
, int64_t val
)
838 qtest_sendf(s
, "clock_set %"PRIi64
"\n", val
);
839 return qtest_clock_rsp(s
);
842 void qtest_irq_intercept_out(QTestState
*s
, const char *qom_path
)
844 qtest_sendf(s
, "irq_intercept_out %s\n", qom_path
);
848 void qtest_irq_intercept_in(QTestState
*s
, const char *qom_path
)
850 qtest_sendf(s
, "irq_intercept_in %s\n", qom_path
);
854 void qtest_set_irq_in(QTestState
*s
, const char *qom_path
, const char *name
,
858 name
= "unnamed-gpio-in";
860 qtest_sendf(s
, "set_irq_in %s %s %d %d\n", qom_path
, name
, num
, level
);
864 static void qtest_out(QTestState
*s
, const char *cmd
, uint16_t addr
, uint32_t value
)
866 qtest_sendf(s
, "%s 0x%x 0x%x\n", cmd
, addr
, value
);
870 void qtest_outb(QTestState
*s
, uint16_t addr
, uint8_t value
)
872 qtest_out(s
, "outb", addr
, value
);
875 void qtest_outw(QTestState
*s
, uint16_t addr
, uint16_t value
)
877 qtest_out(s
, "outw", addr
, value
);
880 void qtest_outl(QTestState
*s
, uint16_t addr
, uint32_t value
)
882 qtest_out(s
, "outl", addr
, value
);
885 static uint32_t qtest_in(QTestState
*s
, const char *cmd
, uint16_t addr
)
891 qtest_sendf(s
, "%s 0x%x\n", cmd
, addr
);
892 args
= qtest_rsp(s
, 2);
893 ret
= qemu_strtoul(args
[1], NULL
, 0, &value
);
894 g_assert(!ret
&& value
<= UINT32_MAX
);
900 uint8_t qtest_inb(QTestState
*s
, uint16_t addr
)
902 return qtest_in(s
, "inb", addr
);
905 uint16_t qtest_inw(QTestState
*s
, uint16_t addr
)
907 return qtest_in(s
, "inw", addr
);
910 uint32_t qtest_inl(QTestState
*s
, uint16_t addr
)
912 return qtest_in(s
, "inl", addr
);
915 static void qtest_write(QTestState
*s
, const char *cmd
, uint64_t addr
,
918 qtest_sendf(s
, "%s 0x%" PRIx64
" 0x%" PRIx64
"\n", cmd
, addr
, value
);
922 void qtest_writeb(QTestState
*s
, uint64_t addr
, uint8_t value
)
924 qtest_write(s
, "writeb", addr
, value
);
927 void qtest_writew(QTestState
*s
, uint64_t addr
, uint16_t value
)
929 qtest_write(s
, "writew", addr
, value
);
932 void qtest_writel(QTestState
*s
, uint64_t addr
, uint32_t value
)
934 qtest_write(s
, "writel", addr
, value
);
937 void qtest_writeq(QTestState
*s
, uint64_t addr
, uint64_t value
)
939 qtest_write(s
, "writeq", addr
, value
);
942 static uint64_t qtest_read(QTestState
*s
, const char *cmd
, uint64_t addr
)
948 qtest_sendf(s
, "%s 0x%" PRIx64
"\n", cmd
, addr
);
949 args
= qtest_rsp(s
, 2);
950 ret
= qemu_strtou64(args
[1], NULL
, 0, &value
);
957 uint8_t qtest_readb(QTestState
*s
, uint64_t addr
)
959 return qtest_read(s
, "readb", addr
);
962 uint16_t qtest_readw(QTestState
*s
, uint64_t addr
)
964 return qtest_read(s
, "readw", addr
);
967 uint32_t qtest_readl(QTestState
*s
, uint64_t addr
)
969 return qtest_read(s
, "readl", addr
);
972 uint64_t qtest_readq(QTestState
*s
, uint64_t addr
)
974 return qtest_read(s
, "readq", addr
);
977 static int hex2nib(char ch
)
979 if (ch
>= '0' && ch
<= '9') {
981 } else if (ch
>= 'a' && ch
<= 'f') {
982 return 10 + (ch
- 'a');
983 } else if (ch
>= 'A' && ch
<= 'F') {
984 return 10 + (ch
- 'a');
990 void qtest_memread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
1000 qtest_sendf(s
, "read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
1001 args
= qtest_rsp(s
, 2);
1003 for (i
= 0; i
< size
; i
++) {
1004 ptr
[i
] = hex2nib(args
[1][2 + (i
* 2)]) << 4;
1005 ptr
[i
] |= hex2nib(args
[1][2 + (i
* 2) + 1]);
1011 uint64_t qtest_rtas_call(QTestState
*s
, const char *name
,
1012 uint32_t nargs
, uint64_t args
,
1013 uint32_t nret
, uint64_t ret
)
1015 qtest_sendf(s
, "rtas %s %u 0x%"PRIx64
" %u 0x%"PRIx64
"\n",
1016 name
, nargs
, args
, nret
, ret
);
1021 void qtest_add_func(const char *str
, void (*fn
)(void))
1023 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
1024 g_test_add_func(path
, fn
);
1028 void qtest_add_data_func_full(const char *str
, void *data
,
1029 void (*fn
)(const void *),
1030 GDestroyNotify data_free_func
)
1032 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
1033 g_test_add_data_func_full(path
, data
, fn
, data_free_func
);
1037 void qtest_add_data_func(const char *str
, const void *data
,
1038 void (*fn
)(const void *))
1040 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
1041 g_test_add_data_func(path
, data
, fn
);
1045 void qtest_bufwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
1049 bdata
= g_base64_encode(data
, size
);
1050 qtest_sendf(s
, "b64write 0x%" PRIx64
" 0x%zx ", addr
, size
);
1051 socket_send(s
->fd
, bdata
, strlen(bdata
));
1052 socket_send(s
->fd
, "\n", 1);
1057 void qtest_bufread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
1062 qtest_sendf(s
, "b64read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
1063 args
= qtest_rsp(s
, 2);
1065 g_base64_decode_inplace(args
[1], &len
);
1067 fprintf(stderr
, "bufread: asked for %zu bytes but decoded %zu\n",
1069 len
= MIN(len
, size
);
1072 memcpy(data
, args
[1], len
);
1076 void qtest_memwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
1078 const uint8_t *ptr
= data
;
1086 enc
= g_malloc(2 * size
+ 1);
1088 for (i
= 0; i
< size
; i
++) {
1089 sprintf(&enc
[i
* 2], "%02x", ptr
[i
]);
1092 qtest_sendf(s
, "write 0x%" PRIx64
" 0x%zx 0x%s\n", addr
, size
, enc
);
1097 void qtest_memset(QTestState
*s
, uint64_t addr
, uint8_t pattern
, size_t size
)
1099 qtest_sendf(s
, "memset 0x%" PRIx64
" 0x%zx 0x%02x\n", addr
, size
, pattern
);
1103 QDict
*qmp(const char *fmt
, ...)
1109 response
= qtest_vqmp(global_qtest
, fmt
, ap
);
1114 void qmp_assert_success(const char *fmt
, ...)
1120 response
= qtest_vqmp(global_qtest
, fmt
, ap
);
1124 if (!qdict_haskey(response
, "return")) {
1125 QString
*s
= qobject_to_json_pretty(QOBJECT(response
));
1126 g_test_message("%s", qstring_get_str(s
));
1129 g_assert(qdict_haskey(response
, "return"));
1130 qobject_unref(response
);
1133 char *hmp(const char *fmt
, ...)
1139 ret
= qtest_vhmp(global_qtest
, fmt
, ap
);
1144 bool qtest_big_endian(QTestState
*s
)
1146 return s
->big_endian
;
1149 static bool qtest_check_machine_version(const char *mname
, const char *basename
,
1150 int major
, int minor
)
1155 newname
= g_strdup_printf("%s-%i.%i", basename
, major
, minor
);
1156 is_equal
= g_str_equal(mname
, newname
);
1162 static bool qtest_is_old_versioned_machine(const char *mname
)
1164 const char *dash
= strrchr(mname
, '-');
1165 const char *dot
= strrchr(mname
, '.');
1168 const int major
= QEMU_VERSION_MAJOR
;
1169 const int minor
= QEMU_VERSION_MINOR
;
1172 if (dash
&& dot
&& dot
> dash
) {
1173 for (chr
= dash
+ 1; *chr
; chr
++) {
1174 if (!qemu_isdigit(*chr
) && *chr
!= '.') {
1179 * Now check if it is one of the latest versions. Check major + 1
1180 * and minor + 1 versions as well, since they might already exist
1181 * in the development branch.
1183 bname
= g_strdup(mname
);
1184 bname
[dash
- mname
] = 0;
1185 res
= !qtest_check_machine_version(mname
, bname
, major
+ 1, 0) &&
1186 !qtest_check_machine_version(mname
, bname
, major
, minor
+ 1) &&
1187 !qtest_check_machine_version(mname
, bname
, major
, minor
);
1194 void qtest_cb_for_every_machine(void (*cb
)(const char *machine
),
1195 bool skip_old_versioned
)
1197 QDict
*response
, *minfo
;
1199 const QListEntry
*p
;
1204 qtest_start("-machine none");
1205 response
= qmp("{ 'execute': 'query-machines' }");
1207 list
= qdict_get_qlist(response
, "return");
1210 for (p
= qlist_first(list
); p
; p
= qlist_next(p
)) {
1211 minfo
= qobject_to(QDict
, qlist_entry_obj(p
));
1213 qobj
= qdict_get(minfo
, "name");
1215 qstr
= qobject_to(QString
, qobj
);
1217 mname
= qstring_get_str(qstr
);
1218 if (!skip_old_versioned
|| !qtest_is_old_versioned_machine(mname
)) {
1224 qobject_unref(response
);
1227 QDict
*qtest_qmp_receive_success(QTestState
*s
,
1228 void (*event_cb
)(void *opaque
,
1233 QDict
*response
, *ret
, *data
;
1237 response
= qtest_qmp_receive(s
);
1238 g_assert(!qdict_haskey(response
, "error"));
1239 ret
= qdict_get_qdict(response
, "return");
1243 event
= qdict_get_str(response
, "event");
1244 data
= qdict_get_qdict(response
, "data");
1246 event_cb(opaque
, event
, data
);
1248 qobject_unref(response
);
1252 qobject_unref(response
);
1257 * Generic hot-plugging test via the device_add QMP command.
1259 void qtest_qmp_device_add(const char *driver
, const char *id
,
1260 const char *fmt
, ...)
1262 QDict
*args
, *response
;
1266 args
= qdict_from_vjsonf_nofail(fmt
, ap
);
1269 g_assert(!qdict_haskey(args
, "driver") && !qdict_haskey(args
, "id"));
1270 qdict_put_str(args
, "driver", driver
);
1271 qdict_put_str(args
, "id", id
);
1273 response
= qmp("{'execute': 'device_add', 'arguments': %p}", args
);
1275 g_assert(!qdict_haskey(response
, "event")); /* We don't expect any events */
1276 g_assert(!qdict_haskey(response
, "error"));
1277 qobject_unref(response
);
1280 static void device_deleted_cb(void *opaque
, const char *name
, QDict
*data
)
1282 bool *got_event
= opaque
;
1284 g_assert_cmpstr(name
, ==, "DEVICE_DELETED");
1289 * Generic hot-unplugging test via the device_del QMP command.
1290 * Device deletion will get one response and one event. For example:
1292 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
1294 * will get this one:
1296 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
1297 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
1298 * "path": "/machine/peripheral/scsi-hd"}}
1304 * But the order of arrival may vary - so we've got to detect both.
1306 void qtest_qmp_device_del(const char *id
)
1308 bool got_event
= false;
1311 qtest_qmp_send(global_qtest
,
1312 "{'execute': 'device_del', 'arguments': {'id': %s}}",
1314 rsp
= qtest_qmp_receive_success(global_qtest
, device_deleted_cb
,
1318 rsp
= qtest_qmp_receive(global_qtest
);
1319 g_assert_cmpstr(qdict_get_try_str(rsp
, "event"),
1320 ==, "DEVICE_DELETED");
1325 bool qmp_rsp_is_err(QDict
*rsp
)
1327 QDict
*error
= qdict_get_qdict(rsp
, "error");
1332 void qmp_assert_error_class(QDict
*rsp
, const char *class)
1334 QDict
*error
= qdict_get_qdict(rsp
, "error");
1336 g_assert_cmpstr(qdict_get_try_str(error
, "class"), ==, class);
1337 g_assert_nonnull(qdict_get_try_str(error
, "desc"));
1338 g_assert(!qdict_haskey(rsp
, "return"));