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"
20 #include <sys/socket.h>
24 #include "qapi/error.h"
25 #include "qapi/qmp/json-parser.h"
26 #include "qapi/qmp/json-streamer.h"
27 #include "qapi/qmp/qdict.h"
28 #include "qapi/qmp/qjson.h"
29 #include "qapi/qmp/qlist.h"
30 #include "qapi/qmp/qstring.h"
33 #define SOCKET_TIMEOUT 50
35 QTestState
*global_qtest
;
41 bool irq_level
[MAX_IRQ
];
43 pid_t qemu_pid
; /* our child QEMU process */
47 static GHookList abrt_hooks
;
48 static struct sigaction sigact_old
;
50 #define g_assert_no_errno(ret) do { \
51 g_assert_cmpint(ret, !=, -1); \
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_no_errno(sock
);
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_no_errno(ret
);
73 ret
= listen(sock
, 1);
74 g_assert_no_errno(ret
);
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 static void kill_qemu(QTestState
*s
)
104 if (s
->qemu_pid
!= -1) {
105 kill(s
->qemu_pid
, SIGTERM
);
106 waitpid(s
->qemu_pid
, NULL
, 0);
110 static void kill_qemu_hook_func(void *s
)
115 static void sigabrt_handler(int signo
)
117 g_hook_list_invoke(&abrt_hooks
, FALSE
);
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 void qtest_add_abrt_handler(GHookFunc fn
, const void *data
)
142 /* Only install SIGABRT handler once */
143 if (!abrt_hooks
.is_setup
) {
144 g_hook_list_init(&abrt_hooks
, sizeof(GHook
));
146 setup_sigabrt_handler();
148 hook
= g_hook_alloc(&abrt_hooks
);
150 hook
->data
= (void *)data
;
152 g_hook_prepend(&abrt_hooks
, hook
);
155 static const char *qtest_qemu_binary(void)
157 const char *qemu_bin
;
159 qemu_bin
= getenv("QTEST_QEMU_BINARY");
161 fprintf(stderr
, "Environment variable QTEST_QEMU_BINARY required\n");
168 QTestState
*qtest_init_without_qmp_handshake(const char *extra_args
)
171 int sock
, qmpsock
, i
;
173 gchar
*qmp_socket_path
;
175 const char *qemu_binary
= qtest_qemu_binary();
177 s
= g_new(QTestState
, 1);
179 socket_path
= g_strdup_printf("/tmp/qtest-%d.sock", getpid());
180 qmp_socket_path
= g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
182 /* It's possible that if an earlier test run crashed it might
183 * have left a stale unix socket lying around. Delete any
184 * stale old socket to avoid spurious test failures with
185 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
188 unlink(qmp_socket_path
);
190 sock
= init_socket(socket_path
);
191 qmpsock
= init_socket(qmp_socket_path
);
193 qtest_add_abrt_handler(kill_qemu_hook_func
, s
);
195 s
->qemu_pid
= fork();
196 if (s
->qemu_pid
== 0) {
197 setenv("QEMU_AUDIO_DRV", "none", true);
198 command
= g_strdup_printf("exec %s "
199 "-qtest unix:%s,nowait "
201 "-qmp unix:%s,nowait "
202 "-machine accel=qtest "
204 "%s", qemu_binary
, socket_path
,
205 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
208 execlp("/bin/sh", "sh", "-c", command
, NULL
);
212 s
->fd
= socket_accept(sock
);
214 s
->qmp_fd
= socket_accept(qmpsock
);
217 unlink(qmp_socket_path
);
219 g_free(qmp_socket_path
);
221 g_assert(s
->fd
>= 0 && s
->qmp_fd
>= 0);
223 s
->rx
= g_string_new("");
224 for (i
= 0; i
< MAX_IRQ
; i
++) {
225 s
->irq_level
[i
] = false;
228 if (getenv("QTEST_STOP")) {
229 kill(s
->qemu_pid
, SIGSTOP
);
232 /* ask endianness of the target */
234 s
->big_endian
= qtest_query_target_endianness(s
);
239 QTestState
*qtest_init(const char *extra_args
)
241 QTestState
*s
= qtest_init_without_qmp_handshake(extra_args
);
243 /* Read the QMP greeting and then do the handshake */
244 qtest_qmp_discard_response(s
, "");
245 qtest_qmp_discard_response(s
, "{ 'execute': 'qmp_capabilities' }");
250 QTestState
*qtest_vstartf(const char *fmt
, va_list ap
)
252 char *args
= g_strdup_vprintf(fmt
, ap
);
255 s
= qtest_start(args
);
261 QTestState
*qtest_startf(const char *fmt
, ...)
267 s
= qtest_vstartf(fmt
, ap
);
272 void qtest_quit(QTestState
*s
)
274 g_hook_destroy_link(&abrt_hooks
, g_hook_find_data(&abrt_hooks
, TRUE
, s
));
276 /* Uninstall SIGABRT handler on last instance */
277 cleanup_sigabrt_handler();
282 g_string_free(s
->rx
, true);
286 static void socket_send(int fd
, const char *buf
, size_t size
)
291 while (offset
< size
) {
294 len
= write(fd
, buf
+ offset
, size
- offset
);
295 if (len
== -1 && errno
== EINTR
) {
299 g_assert_no_errno(len
);
300 g_assert_cmpint(len
, >, 0);
306 static void socket_sendf(int fd
, const char *fmt
, va_list ap
)
308 gchar
*str
= g_strdup_vprintf(fmt
, ap
);
309 size_t size
= strlen(str
);
311 socket_send(fd
, str
, size
);
315 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState
*s
, const char *fmt
, ...)
320 socket_sendf(s
->fd
, fmt
, ap
);
324 static GString
*qtest_recv_line(QTestState
*s
)
330 while ((eol
= strchr(s
->rx
->str
, '\n')) == NULL
) {
334 len
= read(s
->fd
, buffer
, sizeof(buffer
));
335 if (len
== -1 && errno
== EINTR
) {
339 if (len
== -1 || len
== 0) {
340 fprintf(stderr
, "Broken pipe\n");
344 g_string_append_len(s
->rx
, buffer
, len
);
347 offset
= eol
- s
->rx
->str
;
348 line
= g_string_new_len(s
->rx
->str
, offset
);
349 g_string_erase(s
->rx
, 0, offset
+ 1);
354 static gchar
**qtest_rsp(QTestState
*s
, int expected_args
)
361 line
= qtest_recv_line(s
);
362 words
= g_strsplit(line
->str
, " ", 0);
363 g_string_free(line
, TRUE
);
365 if (strcmp(words
[0], "IRQ") == 0) {
368 g_assert(words
[1] != NULL
);
369 g_assert(words
[2] != NULL
);
371 irq
= strtoul(words
[2], NULL
, 0);
372 g_assert_cmpint(irq
, >=, 0);
373 g_assert_cmpint(irq
, <, MAX_IRQ
);
375 if (strcmp(words
[1], "raise") == 0) {
376 s
->irq_level
[irq
] = true;
378 s
->irq_level
[irq
] = false;
385 g_assert(words
[0] != NULL
);
386 g_assert_cmpstr(words
[0], ==, "OK");
389 for (i
= 0; i
< expected_args
; i
++) {
390 g_assert(words
[i
] != NULL
);
399 static int qtest_query_target_endianness(QTestState
*s
)
404 qtest_sendf(s
, "endianness\n");
405 args
= qtest_rsp(s
, 1);
406 g_assert(strcmp(args
[1], "big") == 0 || strcmp(args
[1], "little") == 0);
407 big_endian
= strcmp(args
[1], "big") == 0;
414 JSONMessageParser parser
;
418 static void qmp_response(JSONMessageParser
*parser
, GQueue
*tokens
)
420 QMPResponseParser
*qmp
= container_of(parser
, QMPResponseParser
, parser
);
423 obj
= json_parser_parse(tokens
, NULL
);
425 fprintf(stderr
, "QMP JSON response parsing failed\n");
429 g_assert(!qmp
->response
);
430 qmp
->response
= qobject_to_qdict(obj
);
431 g_assert(qmp
->response
);
434 QDict
*qmp_fd_receive(int fd
)
436 QMPResponseParser qmp
;
437 bool log
= getenv("QTEST_LOG") != NULL
;
440 json_message_parser_init(&qmp
.parser
, qmp_response
);
441 while (!qmp
.response
) {
445 len
= read(fd
, &c
, 1);
446 if (len
== -1 && errno
== EINTR
) {
450 if (len
== -1 || len
== 0) {
451 fprintf(stderr
, "Broken pipe\n");
456 len
= write(2, &c
, 1);
458 json_message_parser_feed(&qmp
.parser
, &c
, 1);
460 json_message_parser_destroy(&qmp
.parser
);
465 QDict
*qtest_qmp_receive(QTestState
*s
)
467 return qmp_fd_receive(s
->qmp_fd
);
471 * Allow users to send a message without waiting for the reply,
472 * in the case that they choose to discard all replies up until
473 * a particular EVENT is received.
475 void qmp_fd_sendv(int fd
, const char *fmt
, va_list ap
)
480 /* qobject_from_jsonv() silently eats leading 0xff as invalid
481 * JSON, but we want to test sending them over the wire to force
483 if (*fmt
== '\377') {
484 socket_send(fd
, fmt
, 1);
488 /* Going through qobject ensures we escape strings properly.
489 * This seemingly unnecessary copy is required in case va_list
492 va_copy(ap_copy
, ap
);
493 qobj
= qobject_from_jsonv(fmt
, &ap_copy
, &error_abort
);
496 /* No need to send anything for an empty QObject. */
498 int log
= getenv("QTEST_LOG") != NULL
;
499 QString
*qstr
= qobject_to_json(qobj
);
503 * BUG: QMP doesn't react to input until it sees a newline, an
504 * object, or an array. Work-around: give it a newline.
506 qstring_append_chr(qstr
, '\n');
507 str
= qstring_get_str(qstr
);
510 fprintf(stderr
, "%s", str
);
512 /* Send QMP request */
513 socket_send(fd
, str
, qstring_get_length(qstr
));
516 qobject_decref(qobj
);
520 void qtest_async_qmpv(QTestState
*s
, const char *fmt
, va_list ap
)
522 qmp_fd_sendv(s
->qmp_fd
, fmt
, ap
);
525 QDict
*qmp_fdv(int fd
, const char *fmt
, va_list ap
)
527 qmp_fd_sendv(fd
, fmt
, ap
);
529 return qmp_fd_receive(fd
);
532 QDict
*qtest_qmpv(QTestState
*s
, const char *fmt
, va_list ap
)
534 qtest_async_qmpv(s
, fmt
, ap
);
537 return qtest_qmp_receive(s
);
540 QDict
*qmp_fd(int fd
, const char *fmt
, ...)
546 response
= qmp_fdv(fd
, fmt
, ap
);
551 void qmp_fd_send(int fd
, const char *fmt
, ...)
556 qmp_fd_sendv(fd
, fmt
, ap
);
560 QDict
*qtest_qmp(QTestState
*s
, const char *fmt
, ...)
566 response
= qtest_qmpv(s
, fmt
, ap
);
571 void qtest_async_qmp(QTestState
*s
, const char *fmt
, ...)
576 qtest_async_qmpv(s
, fmt
, ap
);
580 void qtest_qmpv_discard_response(QTestState
*s
, const char *fmt
, va_list ap
)
582 QDict
*response
= qtest_qmpv(s
, fmt
, ap
);
586 void qtest_qmp_discard_response(QTestState
*s
, const char *fmt
, ...)
592 response
= qtest_qmpv(s
, fmt
, ap
);
597 QDict
*qtest_qmp_eventwait_ref(QTestState
*s
, const char *event
)
602 response
= qtest_qmp_receive(s
);
603 if ((qdict_haskey(response
, "event")) &&
604 (strcmp(qdict_get_str(response
, "event"), event
) == 0)) {
611 void qtest_qmp_eventwait(QTestState
*s
, const char *event
)
615 response
= qtest_qmp_eventwait_ref(s
, event
);
619 char *qtest_hmpv(QTestState
*s
, const char *fmt
, va_list ap
)
625 cmd
= g_strdup_vprintf(fmt
, ap
);
626 resp
= qtest_qmp(s
, "{'execute': 'human-monitor-command',"
627 " 'arguments': {'command-line': %s}}",
629 ret
= g_strdup(qdict_get_try_str(resp
, "return"));
630 while (ret
== NULL
&& qdict_get_try_str(resp
, "event")) {
631 /* Ignore asynchronous QMP events */
633 resp
= qtest_qmp_receive(s
);
634 ret
= g_strdup(qdict_get_try_str(resp
, "return"));
642 char *qtest_hmp(QTestState
*s
, const char *fmt
, ...)
648 ret
= qtest_hmpv(s
, fmt
, ap
);
653 const char *qtest_get_arch(void)
655 const char *qemu
= qtest_qemu_binary();
656 const char *end
= strrchr(qemu
, '/');
658 return end
+ strlen("/qemu-system-");
661 bool qtest_get_irq(QTestState
*s
, int num
)
663 /* dummy operation in order to make sure irq is up to date */
666 return s
->irq_level
[num
];
669 static int64_t qtest_clock_rsp(QTestState
*s
)
673 words
= qtest_rsp(s
, 2);
674 clock
= g_ascii_strtoll(words
[1], NULL
, 0);
679 int64_t qtest_clock_step_next(QTestState
*s
)
681 qtest_sendf(s
, "clock_step\n");
682 return qtest_clock_rsp(s
);
685 int64_t qtest_clock_step(QTestState
*s
, int64_t step
)
687 qtest_sendf(s
, "clock_step %"PRIi64
"\n", step
);
688 return qtest_clock_rsp(s
);
691 int64_t qtest_clock_set(QTestState
*s
, int64_t val
)
693 qtest_sendf(s
, "clock_set %"PRIi64
"\n", val
);
694 return qtest_clock_rsp(s
);
697 void qtest_irq_intercept_out(QTestState
*s
, const char *qom_path
)
699 qtest_sendf(s
, "irq_intercept_out %s\n", qom_path
);
703 void qtest_irq_intercept_in(QTestState
*s
, const char *qom_path
)
705 qtest_sendf(s
, "irq_intercept_in %s\n", qom_path
);
709 static void qtest_out(QTestState
*s
, const char *cmd
, uint16_t addr
, uint32_t value
)
711 qtest_sendf(s
, "%s 0x%x 0x%x\n", cmd
, addr
, value
);
715 void qtest_outb(QTestState
*s
, uint16_t addr
, uint8_t value
)
717 qtest_out(s
, "outb", addr
, value
);
720 void qtest_outw(QTestState
*s
, uint16_t addr
, uint16_t value
)
722 qtest_out(s
, "outw", addr
, value
);
725 void qtest_outl(QTestState
*s
, uint16_t addr
, uint32_t value
)
727 qtest_out(s
, "outl", addr
, value
);
730 static uint32_t qtest_in(QTestState
*s
, const char *cmd
, uint16_t addr
)
735 qtest_sendf(s
, "%s 0x%x\n", cmd
, addr
);
736 args
= qtest_rsp(s
, 2);
737 value
= strtoul(args
[1], NULL
, 0);
743 uint8_t qtest_inb(QTestState
*s
, uint16_t addr
)
745 return qtest_in(s
, "inb", addr
);
748 uint16_t qtest_inw(QTestState
*s
, uint16_t addr
)
750 return qtest_in(s
, "inw", addr
);
753 uint32_t qtest_inl(QTestState
*s
, uint16_t addr
)
755 return qtest_in(s
, "inl", addr
);
758 static void qtest_write(QTestState
*s
, const char *cmd
, uint64_t addr
,
761 qtest_sendf(s
, "%s 0x%" PRIx64
" 0x%" PRIx64
"\n", cmd
, addr
, value
);
765 void qtest_writeb(QTestState
*s
, uint64_t addr
, uint8_t value
)
767 qtest_write(s
, "writeb", addr
, value
);
770 void qtest_writew(QTestState
*s
, uint64_t addr
, uint16_t value
)
772 qtest_write(s
, "writew", addr
, value
);
775 void qtest_writel(QTestState
*s
, uint64_t addr
, uint32_t value
)
777 qtest_write(s
, "writel", addr
, value
);
780 void qtest_writeq(QTestState
*s
, uint64_t addr
, uint64_t value
)
782 qtest_write(s
, "writeq", addr
, value
);
785 static uint64_t qtest_read(QTestState
*s
, const char *cmd
, uint64_t addr
)
790 qtest_sendf(s
, "%s 0x%" PRIx64
"\n", cmd
, addr
);
791 args
= qtest_rsp(s
, 2);
792 value
= strtoull(args
[1], NULL
, 0);
798 uint8_t qtest_readb(QTestState
*s
, uint64_t addr
)
800 return qtest_read(s
, "readb", addr
);
803 uint16_t qtest_readw(QTestState
*s
, uint64_t addr
)
805 return qtest_read(s
, "readw", addr
);
808 uint32_t qtest_readl(QTestState
*s
, uint64_t addr
)
810 return qtest_read(s
, "readl", addr
);
813 uint64_t qtest_readq(QTestState
*s
, uint64_t addr
)
815 return qtest_read(s
, "readq", addr
);
818 static int hex2nib(char ch
)
820 if (ch
>= '0' && ch
<= '9') {
822 } else if (ch
>= 'a' && ch
<= 'f') {
823 return 10 + (ch
- 'a');
824 } else if (ch
>= 'A' && ch
<= 'F') {
825 return 10 + (ch
- 'a');
831 void qtest_memread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
841 qtest_sendf(s
, "read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
842 args
= qtest_rsp(s
, 2);
844 for (i
= 0; i
< size
; i
++) {
845 ptr
[i
] = hex2nib(args
[1][2 + (i
* 2)]) << 4;
846 ptr
[i
] |= hex2nib(args
[1][2 + (i
* 2) + 1]);
852 uint64_t qtest_rtas_call(QTestState
*s
, const char *name
,
853 uint32_t nargs
, uint64_t args
,
854 uint32_t nret
, uint64_t ret
)
856 qtest_sendf(s
, "rtas %s %u 0x%"PRIx64
" %u 0x%"PRIx64
"\n",
857 name
, nargs
, args
, nret
, ret
);
862 void qtest_add_func(const char *str
, void (*fn
)(void))
864 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
865 g_test_add_func(path
, fn
);
869 void qtest_add_data_func_full(const char *str
, void *data
,
870 void (*fn
)(const void *),
871 GDestroyNotify data_free_func
)
873 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
874 g_test_add_data_func_full(path
, data
, fn
, data_free_func
);
878 void qtest_add_data_func(const char *str
, const void *data
,
879 void (*fn
)(const void *))
881 gchar
*path
= g_strdup_printf("/%s/%s", qtest_get_arch(), str
);
882 g_test_add_data_func(path
, data
, fn
);
886 void qtest_bufwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
890 bdata
= g_base64_encode(data
, size
);
891 qtest_sendf(s
, "b64write 0x%" PRIx64
" 0x%zx ", addr
, size
);
892 socket_send(s
->fd
, bdata
, strlen(bdata
));
893 socket_send(s
->fd
, "\n", 1);
898 void qtest_bufread(QTestState
*s
, uint64_t addr
, void *data
, size_t size
)
903 qtest_sendf(s
, "b64read 0x%" PRIx64
" 0x%zx\n", addr
, size
);
904 args
= qtest_rsp(s
, 2);
906 g_base64_decode_inplace(args
[1], &len
);
908 fprintf(stderr
, "bufread: asked for %zu bytes but decoded %zu\n",
910 len
= MIN(len
, size
);
913 memcpy(data
, args
[1], len
);
917 void qtest_memwrite(QTestState
*s
, uint64_t addr
, const void *data
, size_t size
)
919 const uint8_t *ptr
= data
;
927 enc
= g_malloc(2 * size
+ 1);
929 for (i
= 0; i
< size
; i
++) {
930 sprintf(&enc
[i
* 2], "%02x", ptr
[i
]);
933 qtest_sendf(s
, "write 0x%" PRIx64
" 0x%zx 0x%s\n", addr
, size
, enc
);
938 void qtest_memset(QTestState
*s
, uint64_t addr
, uint8_t pattern
, size_t size
)
940 qtest_sendf(s
, "memset 0x%" PRIx64
" 0x%zx 0x%02x\n", addr
, size
, pattern
);
944 QDict
*qmp(const char *fmt
, ...)
950 response
= qtest_qmpv(global_qtest
, fmt
, ap
);
955 void qmp_async(const char *fmt
, ...)
960 qtest_async_qmpv(global_qtest
, fmt
, ap
);
964 void qmp_discard_response(const char *fmt
, ...)
969 qtest_qmpv_discard_response(global_qtest
, fmt
, ap
);
972 char *hmp(const char *fmt
, ...)
978 ret
= qtest_hmpv(global_qtest
, fmt
, ap
);
983 bool qtest_big_endian(QTestState
*s
)
985 return s
->big_endian
;
988 void qtest_cb_for_every_machine(void (*cb
)(const char *machine
))
990 QDict
*response
, *minfo
;
997 qtest_start("-machine none");
998 response
= qmp("{ 'execute': 'query-machines' }");
1000 list
= qdict_get_qlist(response
, "return");
1003 for (p
= qlist_first(list
); p
; p
= qlist_next(p
)) {
1004 minfo
= qobject_to_qdict(qlist_entry_obj(p
));
1006 qobj
= qdict_get(minfo
, "name");
1008 qstr
= qobject_to_qstring(qobj
);
1010 mname
= qstring_get_str(qstr
);
1019 * Generic hot-plugging test via the device_add QMP command.
1021 void qtest_qmp_device_add(const char *driver
, const char *id
, const char *fmt
,
1025 char *cmd
, *opts
= NULL
;
1030 opts
= g_strdup_vprintf(fmt
, va
);
1034 cmd
= g_strdup_printf("{'execute': 'device_add',"
1035 " 'arguments': { 'driver': '%s', 'id': '%s'%s%s }}",
1036 driver
, id
, opts
? ", " : "", opts
? opts
: "");
1039 response
= qmp(cmd
);
1042 g_assert(!qdict_haskey(response
, "event")); /* We don't expect any events */
1043 g_assert(!qdict_haskey(response
, "error"));
1048 * Generic hot-unplugging test via the device_del QMP command.
1049 * Device deletion will get one response and one event. For example:
1051 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
1053 * will get this one:
1055 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
1056 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
1057 * "path": "/machine/peripheral/scsi-hd"}}
1063 * But the order of arrival may vary - so we've got to detect both.
1065 void qtest_qmp_device_del(const char *id
)
1067 QDict
*response1
, *response2
, *event
= NULL
;
1070 cmd
= g_strdup_printf("{'execute': 'device_del',"
1071 " 'arguments': { 'id': '%s' }}", id
);
1072 response1
= qmp(cmd
);
1074 g_assert(response1
);
1075 g_assert(!qdict_haskey(response1
, "error"));
1077 response2
= qmp("");
1078 g_assert(response2
);
1079 g_assert(!qdict_haskey(response2
, "error"));
1081 if (qdict_haskey(response1
, "event")) {
1083 } else if (qdict_haskey(response2
, "event")) {
1087 g_assert_cmpstr(qdict_get_str(event
, "event"), ==, "DEVICE_DELETED");