blob: 1d75d3c93634767a472e1d6b76e46eeb3f628e67 [file] [log] [blame]
Anthony Liguori49ee3592012-03-28 15:42:05 +02001/*
2 * QTest
3 *
4 * Copyright IBM, Corp. 2012
5 * Copyright Red Hat, Inc. 2012
Andreas Färber872536b2013-02-16 22:44:03 +01006 * Copyright SUSE LINUX Products GmbH 2013
Anthony Liguori49ee3592012-03-28 15:42:05 +02007 *
8 * Authors:
9 * Anthony Liguori <aliguori@us.ibm.com>
10 * Paolo Bonzini <pbonzini@redhat.com>
Andreas Färber872536b2013-02-16 22:44:03 +010011 * Andreas Färber <afaerber@suse.de>
Anthony Liguori49ee3592012-03-28 15:42:05 +020012 *
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.
Anthony Liguori49ee3592012-03-28 15:42:05 +020015 */
Markus Armbruster47e6b292018-02-01 12:18:38 +010016
Peter Maydell681c28a2016-02-08 18:08:51 +000017#include "qemu/osdep.h"
Anthony Liguori49ee3592012-03-28 15:42:05 +020018
Anthony Liguori49ee3592012-03-28 15:42:05 +020019#include <sys/socket.h>
20#include <sys/wait.h>
21#include <sys/un.h>
Anthony Liguori49ee3592012-03-28 15:42:05 +020022
Eric Blake50990b12017-09-11 12:19:50 -050023#include "libqtest.h"
Markus Armbruster62815d82018-08-23 18:40:01 +020024#include "qemu-common.h"
Eric Blake50990b12017-09-11 12:19:50 -050025#include "qemu/cutils.h"
Markus Armbruster53f99152017-02-28 22:26:55 +010026#include "qapi/error.h"
Markus Armbruster86cdf9e2018-08-23 18:40:20 +020027#include "qapi/qmp/json-parser.h"
Markus Armbruster452fcdb2018-02-01 12:18:39 +010028#include "qapi/qmp/qdict.h"
Paolo Bonzini563890c2014-06-13 09:35:18 +020029#include "qapi/qmp/qjson.h"
Markus Armbruster47e6b292018-02-01 12:18:38 +010030#include "qapi/qmp/qlist.h"
Markus Armbrusterfc81fa12018-02-01 12:18:40 +010031#include "qapi/qmp/qstring.h"
Anthony Liguori49ee3592012-03-28 15:42:05 +020032
33#define MAX_IRQ 256
Andrea Arcangelif5d45792016-06-13 12:16:44 +010034#define SOCKET_TIMEOUT 50
Anthony Liguori49ee3592012-03-28 15:42:05 +020035
36QTestState *global_qtest;
37
38struct QTestState
39{
40 int fd;
Kevin Wolfa3ca1632012-04-26 19:07:55 +020041 int qmp_fd;
Richard Henderson21f80282018-12-16 19:58:16 -080042 pid_t qemu_pid; /* our child QEMU process */
43 int wstatus;
44 bool big_endian;
Anthony Liguori49ee3592012-03-28 15:42:05 +020045 bool irq_level[MAX_IRQ];
46 GString *rx;
Anthony Liguori49ee3592012-03-28 15:42:05 +020047};
48
Marc-André Lureau063c23d2015-06-19 18:45:14 +020049static GHookList abrt_hooks;
Stefan Hajnoczid7668252014-03-27 15:09:50 +010050static struct sigaction sigact_old;
51
Laurent Vivier54ce6f22016-10-07 12:14:27 +020052static int qtest_query_target_endianness(QTestState *s);
53
Kevin Wolfa3ca1632012-04-26 19:07:55 +020054static int init_socket(const char *socket_path)
Anthony Liguori49ee3592012-03-28 15:42:05 +020055{
Anthony Liguori49ee3592012-03-28 15:42:05 +020056 struct sockaddr_un addr;
Kevin Wolfa3ca1632012-04-26 19:07:55 +020057 int sock;
58 int ret;
Anthony Liguori49ee3592012-03-28 15:42:05 +020059
60 sock = socket(PF_UNIX, SOCK_STREAM, 0);
Markus Armbruster70b11052018-09-26 14:29:33 +020061 g_assert_cmpint(sock, !=, -1);
Anthony Liguori49ee3592012-03-28 15:42:05 +020062
63 addr.sun_family = AF_UNIX;
64 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
65 qemu_set_cloexec(sock);
66
67 do {
68 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
69 } while (ret == -1 && errno == EINTR);
Markus Armbruster70b11052018-09-26 14:29:33 +020070 g_assert_cmpint(ret, !=, -1);
Andreas Färbera7ded162014-04-17 18:19:14 +020071 ret = listen(sock, 1);
Markus Armbruster70b11052018-09-26 14:29:33 +020072 g_assert_cmpint(ret, !=, -1);
Anthony Liguori49ee3592012-03-28 15:42:05 +020073
Kevin Wolfa3ca1632012-04-26 19:07:55 +020074 return sock;
75}
Anthony Liguori49ee3592012-03-28 15:42:05 +020076
Kevin Wolfa3ca1632012-04-26 19:07:55 +020077static int socket_accept(int sock)
78{
79 struct sockaddr_un addr;
80 socklen_t addrlen;
81 int ret;
Marcel Apfelbaumf8762022014-03-11 15:00:34 +020082 struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
83 .tv_usec = 0 };
84
85 setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
86 sizeof(timeout));
Anthony Liguori49ee3592012-03-28 15:42:05 +020087
88 do {
Andreas Färber535b4562014-04-17 19:21:12 +020089 addrlen = sizeof(addr);
Anthony Liguori49ee3592012-03-28 15:42:05 +020090 ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
91 } while (ret == -1 && errno == EINTR);
Andreas Färbera7d915f2014-04-17 18:38:25 +020092 if (ret == -1) {
93 fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno));
94 }
Anthony Liguori49ee3592012-03-28 15:42:05 +020095 close(sock);
96
Kevin Wolfa3ca1632012-04-26 19:07:55 +020097 return ret;
98}
99
Richard Henderson21f80282018-12-16 19:58:16 -0800100bool qtest_probe_child(QTestState *s)
101{
102 pid_t pid = s->qemu_pid;
103
104 if (pid != -1) {
105 pid = waitpid(pid, &s->wstatus, WNOHANG);
106 if (pid == 0) {
107 return true;
108 }
109 s->qemu_pid = -1;
110 }
111 return false;
112}
113
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100114static void kill_qemu(QTestState *s)
115{
Richard Henderson21f80282018-12-16 19:58:16 -0800116 pid_t pid = s->qemu_pid;
117 int wstatus;
Michael S. Tsirkinfa0d4212018-05-24 17:24:35 +0300118
Richard Henderson21f80282018-12-16 19:58:16 -0800119 /* Skip wait if qtest_probe_child already reaped. */
120 if (pid != -1) {
121 kill(pid, SIGTERM);
122 TFR(pid = waitpid(s->qemu_pid, &s->wstatus, 0));
Eric Blake71a268a2018-08-10 08:28:00 -0500123 assert(pid == s->qemu_pid);
Richard Henderson21f80282018-12-16 19:58:16 -0800124 }
Eric Blake71a268a2018-08-10 08:28:00 -0500125
Richard Henderson21f80282018-12-16 19:58:16 -0800126 /*
127 * We expect qemu to exit with status 0; anything else is
128 * fishy and should be logged with as much detail as possible.
129 */
130 wstatus = s->wstatus;
131 if (wstatus) {
132 if (WIFEXITED(wstatus)) {
133 fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU "
134 "process but encountered exit status %d\n",
135 __FILE__, __LINE__, WEXITSTATUS(wstatus));
136 } else if (WIFSIGNALED(wstatus)) {
137 int sig = WTERMSIG(wstatus);
138 const char *signame = strsignal(sig) ?: "unknown ???";
139 const char *dump = WCOREDUMP(wstatus) ? " (core dumped)" : "";
140
141 fprintf(stderr, "%s:%d: kill_qemu() detected QEMU death "
142 "from signal %d (%s)%s\n",
143 __FILE__, __LINE__, sig, signame, dump);
Michael S. Tsirkinfa0d4212018-05-24 17:24:35 +0300144 }
Richard Henderson21f80282018-12-16 19:58:16 -0800145 abort();
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100146 }
147}
148
Markus Armbruster041088c2015-12-02 21:20:33 +0100149static void kill_qemu_hook_func(void *s)
150{
151 kill_qemu(s);
152}
153
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100154static void sigabrt_handler(int signo)
155{
Marc-André Lureau063c23d2015-06-19 18:45:14 +0200156 g_hook_list_invoke(&abrt_hooks, FALSE);
Stefan Hajnoczid7668252014-03-27 15:09:50 +0100157}
158
159static void setup_sigabrt_handler(void)
160{
161 struct sigaction sigact;
162
163 /* Catch SIGABRT to clean up on g_assert() failure */
164 sigact = (struct sigaction){
165 .sa_handler = sigabrt_handler,
166 .sa_flags = SA_RESETHAND,
167 };
168 sigemptyset(&sigact.sa_mask);
169 sigaction(SIGABRT, &sigact, &sigact_old);
170}
171
172static void cleanup_sigabrt_handler(void)
173{
174 sigaction(SIGABRT, &sigact_old, NULL);
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100175}
176
Markus Armbruster041088c2015-12-02 21:20:33 +0100177void qtest_add_abrt_handler(GHookFunc fn, const void *data)
Marc-André Lureau063c23d2015-06-19 18:45:14 +0200178{
179 GHook *hook;
180
181 /* Only install SIGABRT handler once */
182 if (!abrt_hooks.is_setup) {
183 g_hook_list_init(&abrt_hooks, sizeof(GHook));
Marc-André Lureau063c23d2015-06-19 18:45:14 +0200184 }
Jens Freimann24dd1e12017-08-08 22:38:59 +0200185 setup_sigabrt_handler();
Marc-André Lureau063c23d2015-06-19 18:45:14 +0200186
187 hook = g_hook_alloc(&abrt_hooks);
188 hook->func = fn;
189 hook->data = (void *)data;
190
191 g_hook_prepend(&abrt_hooks, hook);
192}
193
Thomas Huthdb221e62017-08-28 12:25:45 +0200194static const char *qtest_qemu_binary(void)
195{
196 const char *qemu_bin;
197
198 qemu_bin = getenv("QTEST_QEMU_BINARY");
199 if (!qemu_bin) {
200 fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n");
201 exit(1);
202 }
203
204 return qemu_bin;
205}
206
Peter Xu192f26a2018-10-09 14:27:16 +0800207QTestState *qtest_init_without_qmp_handshake(const char *extra_args)
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200208{
209 QTestState *s;
Anthony Liguori8a8fd632013-04-16 09:45:15 -0500210 int sock, qmpsock, i;
Stefan Hajnoczi56db2e52013-11-21 11:37:25 +0100211 gchar *socket_path;
212 gchar *qmp_socket_path;
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200213 gchar *command;
Thomas Huthdb221e62017-08-28 12:25:45 +0200214 const char *qemu_binary = qtest_qemu_binary();
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200215
Marc-André Lureau790bbb92017-10-06 20:49:56 -0300216 s = g_new(QTestState, 1);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200217
Stefan Hajnoczi56db2e52013-11-21 11:37:25 +0100218 socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
219 qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
Markus Armbrusterbb494a52012-06-29 17:34:27 +0200220
Peter Maydelld9123d02017-03-31 13:36:41 +0100221 /* It's possible that if an earlier test run crashed it might
222 * have left a stale unix socket lying around. Delete any
223 * stale old socket to avoid spurious test failures with
224 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1)
225 */
226 unlink(socket_path);
227 unlink(qmp_socket_path);
228
Stefan Hajnoczi56db2e52013-11-21 11:37:25 +0100229 sock = init_socket(socket_path);
230 qmpsock = init_socket(qmp_socket_path);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200231
Markus Armbruster041088c2015-12-02 21:20:33 +0100232 qtest_add_abrt_handler(kill_qemu_hook_func, s);
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100233
Paolo Bonziniced09f92018-11-15 13:29:30 +0100234 command = g_strdup_printf("exec %s "
235 "-qtest unix:%s,nowait "
236 "-qtest-log %s "
237 "-chardev socket,path=%s,nowait,id=char0 "
Peter Xu192f26a2018-10-09 14:27:16 +0800238 "-mon chardev=char0,mode=control "
Paolo Bonziniced09f92018-11-15 13:29:30 +0100239 "-machine accel=qtest "
240 "-display none "
241 "%s", qemu_binary, socket_path,
242 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null",
Peter Xu192f26a2018-10-09 14:27:16 +0800243 qmp_socket_path,
Paolo Bonziniced09f92018-11-15 13:29:30 +0100244 extra_args ?: "");
245
246 g_test_message("starting QEMU: %s", command);
247
Richard Henderson21f80282018-12-16 19:58:16 -0800248 s->wstatus = 0;
Stefan Hajnoczicef60c92014-02-17 14:54:17 +0100249 s->qemu_pid = fork();
250 if (s->qemu_pid == 0) {
Stefan Hajnoczi6b029212014-08-27 12:08:52 +0100251 setenv("QEMU_AUDIO_DRV", "none", true);
Anthony Liguori8a8fd632013-04-16 09:45:15 -0500252 execlp("/bin/sh", "sh", "-c", command, NULL);
253 exit(1);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200254 }
255
Paolo Bonziniced09f92018-11-15 13:29:30 +0100256 g_free(command);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200257 s->fd = socket_accept(sock);
Marcel Apfelbaumf8762022014-03-11 15:00:34 +0200258 if (s->fd >= 0) {
259 s->qmp_fd = socket_accept(qmpsock);
260 }
Stefan Hajnoczi56db2e52013-11-21 11:37:25 +0100261 unlink(socket_path);
262 unlink(qmp_socket_path);
263 g_free(socket_path);
264 g_free(qmp_socket_path);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200265
Marcel Apfelbaumf8762022014-03-11 15:00:34 +0200266 g_assert(s->fd >= 0 && s->qmp_fd >= 0);
267
Anthony Liguori49ee3592012-03-28 15:42:05 +0200268 s->rx = g_string_new("");
Anthony Liguori49ee3592012-03-28 15:42:05 +0200269 for (i = 0; i < MAX_IRQ; i++) {
270 s->irq_level[i] = false;
271 }
272
Paolo Bonzinie0fea6b2012-10-01 14:18:07 +0200273 if (getenv("QTEST_STOP")) {
Stefan Hajnoczi1ad3c6a2013-11-21 11:33:17 +0100274 kill(s->qemu_pid, SIGSTOP);
Paolo Bonzinie0fea6b2012-10-01 14:18:07 +0200275 }
276
Laurent Vivier54ce6f22016-10-07 12:14:27 +0200277 /* ask endianness of the target */
278
279 s->big_endian = qtest_query_target_endianness(s);
280
Anthony Liguori49ee3592012-03-28 15:42:05 +0200281 return s;
282}
283
Markus Armbrusterf66e7ac2017-03-03 13:32:23 +0100284QTestState *qtest_init(const char *extra_args)
285{
Peter Xu192f26a2018-10-09 14:27:16 +0800286 QTestState *s = qtest_init_without_qmp_handshake(extra_args);
Markus Armbrusterbe62e172018-08-06 08:53:24 +0200287 QDict *greeting;
Markus Armbrusterf66e7ac2017-03-03 13:32:23 +0100288
289 /* Read the QMP greeting and then do the handshake */
Markus Armbrusterbe62e172018-08-06 08:53:24 +0200290 greeting = qtest_qmp_receive(s);
291 qobject_unref(greeting);
Markus Armbruster055a1ef2018-08-06 08:53:25 +0200292 qobject_unref(qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }"));
Markus Armbrusterf66e7ac2017-03-03 13:32:23 +0100293
294 return s;
295}
296
Markus Armbruster88b988c2018-08-06 08:53:43 +0200297QTestState *qtest_vinitf(const char *fmt, va_list ap)
Eric Blake78b27ba2017-10-18 16:20:27 +0200298{
299 char *args = g_strdup_vprintf(fmt, ap);
300 QTestState *s;
301
Markus Armbruster88b988c2018-08-06 08:53:43 +0200302 s = qtest_init(args);
Eric Blake78b27ba2017-10-18 16:20:27 +0200303 g_free(args);
Eric Blake78b27ba2017-10-18 16:20:27 +0200304 return s;
305}
306
Markus Armbruster88b988c2018-08-06 08:53:43 +0200307QTestState *qtest_initf(const char *fmt, ...)
Eric Blake78b27ba2017-10-18 16:20:27 +0200308{
309 va_list ap;
310 QTestState *s;
311
312 va_start(ap, fmt);
Markus Armbruster88b988c2018-08-06 08:53:43 +0200313 s = qtest_vinitf(fmt, ap);
Eric Blake78b27ba2017-10-18 16:20:27 +0200314 va_end(ap);
315 return s;
316}
317
Anthony Liguori49ee3592012-03-28 15:42:05 +0200318void qtest_quit(QTestState *s)
319{
Marc-André Lureau063c23d2015-06-19 18:45:14 +0200320 g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s));
321
Stefan Hajnoczid7668252014-03-27 15:09:50 +0100322 /* Uninstall SIGABRT handler on last instance */
Eric Blake4fb609a2017-09-11 12:19:49 -0500323 cleanup_sigabrt_handler();
Stefan Hajnoczid7668252014-03-27 15:09:50 +0100324
Stefan Hajnoczib15d4222014-02-17 16:33:35 +0100325 kill_qemu(s);
Markus Armbrusterfdd26fc2013-06-20 08:55:28 +0200326 close(s->fd);
327 close(s->qmp_fd);
328 g_string_free(s->rx, true);
Markus Armbrusterfdd26fc2013-06-20 08:55:28 +0200329 g_free(s);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200330}
331
Paolo Bonzini563890c2014-06-13 09:35:18 +0200332static void socket_send(int fd, const char *buf, size_t size)
Anthony Liguori49ee3592012-03-28 15:42:05 +0200333{
Paolo Bonzini563890c2014-06-13 09:35:18 +0200334 size_t offset;
Anthony Liguori49ee3592012-03-28 15:42:05 +0200335
336 offset = 0;
337 while (offset < size) {
338 ssize_t len;
339
Paolo Bonzini563890c2014-06-13 09:35:18 +0200340 len = write(fd, buf + offset, size - offset);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200341 if (len == -1 && errno == EINTR) {
342 continue;
343 }
344
Anthony Liguori49ee3592012-03-28 15:42:05 +0200345 g_assert_cmpint(len, >, 0);
346
347 offset += len;
348 }
349}
350
Paolo Bonzini563890c2014-06-13 09:35:18 +0200351static void socket_sendf(int fd, const char *fmt, va_list ap)
352{
353 gchar *str = g_strdup_vprintf(fmt, ap);
354 size_t size = strlen(str);
355
356 socket_send(fd, str, size);
357 g_free(str);
358}
359
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200360static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
361{
362 va_list ap;
363
364 va_start(ap, fmt);
365 socket_sendf(s->fd, fmt, ap);
366 va_end(ap);
367}
368
Anthony Liguori49ee3592012-03-28 15:42:05 +0200369static GString *qtest_recv_line(QTestState *s)
370{
371 GString *line;
372 size_t offset;
373 char *eol;
374
375 while ((eol = strchr(s->rx->str, '\n')) == NULL) {
376 ssize_t len;
377 char buffer[1024];
378
379 len = read(s->fd, buffer, sizeof(buffer));
380 if (len == -1 && errno == EINTR) {
381 continue;
382 }
383
384 if (len == -1 || len == 0) {
385 fprintf(stderr, "Broken pipe\n");
Markus Armbrusterf9e986d2018-08-15 16:19:45 +0200386 abort();
Anthony Liguori49ee3592012-03-28 15:42:05 +0200387 }
388
389 g_string_append_len(s->rx, buffer, len);
390 }
391
392 offset = eol - s->rx->str;
393 line = g_string_new_len(s->rx->str, offset);
394 g_string_erase(s->rx, 0, offset + 1);
395
396 return line;
397}
398
399static gchar **qtest_rsp(QTestState *s, int expected_args)
400{
401 GString *line;
402 gchar **words;
403 int i;
404
405redo:
406 line = qtest_recv_line(s);
407 words = g_strsplit(line->str, " ", 0);
408 g_string_free(line, TRUE);
409
410 if (strcmp(words[0], "IRQ") == 0) {
Eric Blake50990b12017-09-11 12:19:50 -0500411 long irq;
412 int ret;
Anthony Liguori49ee3592012-03-28 15:42:05 +0200413
414 g_assert(words[1] != NULL);
415 g_assert(words[2] != NULL);
416
Eric Blake50990b12017-09-11 12:19:50 -0500417 ret = qemu_strtol(words[2], NULL, 0, &irq);
418 g_assert(!ret);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200419 g_assert_cmpint(irq, >=, 0);
420 g_assert_cmpint(irq, <, MAX_IRQ);
421
422 if (strcmp(words[1], "raise") == 0) {
423 s->irq_level[irq] = true;
424 } else {
425 s->irq_level[irq] = false;
426 }
427
428 g_strfreev(words);
429 goto redo;
430 }
431
432 g_assert(words[0] != NULL);
433 g_assert_cmpstr(words[0], ==, "OK");
434
435 if (expected_args) {
436 for (i = 0; i < expected_args; i++) {
437 g_assert(words[i] != NULL);
438 }
439 } else {
440 g_strfreev(words);
441 }
442
443 return words;
444}
445
Laurent Vivier54ce6f22016-10-07 12:14:27 +0200446static int qtest_query_target_endianness(QTestState *s)
447{
448 gchar **args;
449 int big_endian;
450
451 qtest_sendf(s, "endianness\n");
452 args = qtest_rsp(s, 1);
453 g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0);
454 big_endian = strcmp(args[1], "big") == 0;
455 g_strfreev(args);
456
457 return big_endian;
458}
459
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100460typedef struct {
461 JSONMessageParser parser;
462 QDict *response;
463} QMPResponseParser;
464
Markus Armbruster62815d82018-08-23 18:40:01 +0200465static void qmp_response(void *opaque, QObject *obj, Error *err)
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200466{
Markus Armbruster62815d82018-08-23 18:40:01 +0200467 QMPResponseParser *qmp = opaque;
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100468
Markus Armbruster84a56f32018-08-23 18:40:06 +0200469 assert(!obj != !err);
470
471 if (err) {
472 error_prepend(&err, "QMP JSON response parsing failed: ");
473 error_report_err(err);
Markus Armbrusterf9e986d2018-08-15 16:19:45 +0200474 abort();
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100475 }
476
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100477 g_assert(!qmp->response);
Max Reitz7dc847e2018-02-24 16:40:29 +0100478 qmp->response = qobject_to(QDict, obj);
Markus Armbruster4d96f322017-02-17 21:38:16 +0100479 g_assert(qmp->response);
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100480}
481
Marc-André Lureaudc479952015-10-02 14:58:16 +0200482QDict *qmp_fd_receive(int fd)
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100483{
484 QMPResponseParser qmp;
Paolo Bonzini7c282cb2014-08-04 17:11:03 -0400485 bool log = getenv("QTEST_LOG") != NULL;
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200486
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100487 qmp.response = NULL;
Markus Armbruster62815d82018-08-23 18:40:01 +0200488 json_message_parser_init(&qmp.parser, qmp_response, &qmp, NULL);
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100489 while (!qmp.response) {
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200490 ssize_t len;
491 char c;
492
Marc-André Lureaudc479952015-10-02 14:58:16 +0200493 len = read(fd, &c, 1);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200494 if (len == -1 && errno == EINTR) {
495 continue;
496 }
497
Anthony Liguori039380a2012-06-27 08:20:43 -0500498 if (len == -1 || len == 0) {
499 fprintf(stderr, "Broken pipe\n");
Markus Armbrusterf9e986d2018-08-15 16:19:45 +0200500 abort();
Anthony Liguori039380a2012-06-27 08:20:43 -0500501 }
502
Paolo Bonzini7c282cb2014-08-04 17:11:03 -0400503 if (log) {
504 len = write(2, &c, 1);
505 }
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100506 json_message_parser_feed(&qmp.parser, &c, 1);
Kevin Wolfa3ca1632012-04-26 19:07:55 +0200507 }
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100508 json_message_parser_destroy(&qmp.parser);
509
510 return qmp.response;
511}
512
Marc-André Lureaudc479952015-10-02 14:58:16 +0200513QDict *qtest_qmp_receive(QTestState *s)
514{
515 return qmp_fd_receive(s->qmp_fd);
516}
517
John Snowba4ed392015-04-28 15:27:51 -0400518/**
519 * Allow users to send a message without waiting for the reply,
520 * in the case that they choose to discard all replies up until
521 * a particular EVENT is received.
522 */
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200523void qmp_fd_vsend(int fd, const char *fmt, va_list ap)
Andreas Färber66e0c7b2014-02-21 20:55:30 +0100524{
Paolo Bonzini563890c2014-06-13 09:35:18 +0200525 QObject *qobj;
526
Markus Armbruster69f0cb62018-08-06 08:53:29 +0200527 /* Going through qobject ensures we escape strings properly */
528 qobj = qobject_from_vjsonf_nofail(fmt, ap);
Paolo Bonzini563890c2014-06-13 09:35:18 +0200529
530 /* No need to send anything for an empty QObject. */
531 if (qobj) {
Marc Maríae74f182014-08-12 13:41:48 +0200532 int log = getenv("QTEST_LOG") != NULL;
Paolo Bonzini563890c2014-06-13 09:35:18 +0200533 QString *qstr = qobject_to_json(qobj);
Markus Armbruster13420ef2017-03-03 13:32:22 +0100534 const char *str;
535
536 /*
537 * BUG: QMP doesn't react to input until it sees a newline, an
538 * object, or an array. Work-around: give it a newline.
539 */
540 qstring_append_chr(qstr, '\n');
541 str = qstring_get_str(qstr);
Paolo Bonzini563890c2014-06-13 09:35:18 +0200542
Marc Maríae74f182014-08-12 13:41:48 +0200543 if (log) {
544 fprintf(stderr, "%s", str);
545 }
Paolo Bonzini563890c2014-06-13 09:35:18 +0200546 /* Send QMP request */
Markus Armbruster13420ef2017-03-03 13:32:22 +0100547 socket_send(fd, str, qstring_get_length(qstr));
Paolo Bonzini563890c2014-06-13 09:35:18 +0200548
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200549 qobject_unref(qstr);
550 qobject_unref(qobj);
Paolo Bonzini563890c2014-06-13 09:35:18 +0200551 }
John Snowba4ed392015-04-28 15:27:51 -0400552}
553
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200554void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap)
Marc-André Lureaudc479952015-10-02 14:58:16 +0200555{
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200556 qmp_fd_vsend(s->qmp_fd, fmt, ap);
Marc-André Lureaudc479952015-10-02 14:58:16 +0200557}
558
559QDict *qmp_fdv(int fd, const char *fmt, va_list ap)
560{
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200561 qmp_fd_vsend(fd, fmt, ap);
Marc-André Lureaudc479952015-10-02 14:58:16 +0200562
563 return qmp_fd_receive(fd);
564}
565
Markus Armbruster248eef02018-08-06 08:53:44 +0200566QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap)
John Snowba4ed392015-04-28 15:27:51 -0400567{
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200568 qtest_qmp_vsend(s, fmt, ap);
Andreas Färber66e0c7b2014-02-21 20:55:30 +0100569
570 /* Receive reply */
571 return qtest_qmp_receive(s);
572}
573
Marc-André Lureaudc479952015-10-02 14:58:16 +0200574QDict *qmp_fd(int fd, const char *fmt, ...)
575{
576 va_list ap;
577 QDict *response;
578
579 va_start(ap, fmt);
580 response = qmp_fdv(fd, fmt, ap);
581 va_end(ap);
582 return response;
583}
584
585void qmp_fd_send(int fd, const char *fmt, ...)
586{
587 va_list ap;
588
589 va_start(ap, fmt);
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200590 qmp_fd_vsend(fd, fmt, ap);
Marc-André Lureaudc479952015-10-02 14:58:16 +0200591 va_end(ap);
592}
593
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100594QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
595{
596 va_list ap;
597 QDict *response;
598
599 va_start(ap, fmt);
Markus Armbruster248eef02018-08-06 08:53:44 +0200600 response = qtest_vqmp(s, fmt, ap);
Stefan Hajnoczi0c460da2013-10-30 14:54:33 +0100601 va_end(ap);
602 return response;
603}
604
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200605void qtest_qmp_send(QTestState *s, const char *fmt, ...)
John Snowba4ed392015-04-28 15:27:51 -0400606{
607 va_list ap;
608
609 va_start(ap, fmt);
Markus Armbruster4277f1e2018-08-06 08:53:22 +0200610 qtest_qmp_vsend(s, fmt, ap);
John Snowba4ed392015-04-28 15:27:51 -0400611 va_end(ap);
612}
613
Markus Armbrustere2f64a62018-08-23 18:39:34 +0200614void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap)
Markus Armbrusteraed877c2018-08-23 18:39:33 +0200615{
616 bool log = getenv("QTEST_LOG") != NULL;
Markus Armbrustere2f64a62018-08-23 18:39:34 +0200617 char *str = g_strdup_vprintf(fmt, ap);
Markus Armbrusteraed877c2018-08-23 18:39:33 +0200618
619 if (log) {
620 fprintf(stderr, "%s", str);
621 }
Markus Armbrustere2f64a62018-08-23 18:39:34 +0200622 socket_send(fd, str, strlen(str));
Markus Armbrusteraed877c2018-08-23 18:39:33 +0200623 g_free(str);
624}
625
Markus Armbrustere2f64a62018-08-23 18:39:34 +0200626void qmp_fd_send_raw(int fd, const char *fmt, ...)
627{
628 va_list ap;
629
630 va_start(ap, fmt);
631 qmp_fd_vsend_raw(fd, fmt, ap);
632 va_end(ap);
633}
634
635void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...)
636{
637 va_list ap;
638
639 va_start(ap, fmt);
640 qmp_fd_vsend_raw(s->qmp_fd, fmt, ap);
641 va_end(ap);
642}
643
John Snow7ffe3122016-11-14 11:15:54 -0500644QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event)
John Snow8fe941f2015-04-28 15:27:51 -0400645{
646 QDict *response;
647
648 for (;;) {
649 response = qtest_qmp_receive(s);
650 if ((qdict_haskey(response, "event")) &&
651 (strcmp(qdict_get_str(response, "event"), event) == 0)) {
John Snow7ffe3122016-11-14 11:15:54 -0500652 return response;
John Snow8fe941f2015-04-28 15:27:51 -0400653 }
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200654 qobject_unref(response);
John Snow8fe941f2015-04-28 15:27:51 -0400655 }
656}
657
John Snow7ffe3122016-11-14 11:15:54 -0500658void qtest_qmp_eventwait(QTestState *s, const char *event)
659{
660 QDict *response;
661
662 response = qtest_qmp_eventwait_ref(s, event);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200663 qobject_unref(response);
John Snow7ffe3122016-11-14 11:15:54 -0500664}
665
Markus Armbruster248eef02018-08-06 08:53:44 +0200666char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap)
Markus Armbruster5fb48d92015-10-01 10:59:55 +0200667{
668 char *cmd;
669 QDict *resp;
670 char *ret;
671
672 cmd = g_strdup_vprintf(fmt, ap);
673 resp = qtest_qmp(s, "{'execute': 'human-monitor-command',"
674 " 'arguments': {'command-line': %s}}",
675 cmd);
676 ret = g_strdup(qdict_get_try_str(resp, "return"));
Thomas Huth6bb87be2017-03-30 09:50:05 +0200677 while (ret == NULL && qdict_get_try_str(resp, "event")) {
678 /* Ignore asynchronous QMP events */
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200679 qobject_unref(resp);
Thomas Huth6bb87be2017-03-30 09:50:05 +0200680 resp = qtest_qmp_receive(s);
681 ret = g_strdup(qdict_get_try_str(resp, "return"));
682 }
Markus Armbruster5fb48d92015-10-01 10:59:55 +0200683 g_assert(ret);
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +0200684 qobject_unref(resp);
Markus Armbruster5fb48d92015-10-01 10:59:55 +0200685 g_free(cmd);
686 return ret;
687}
688
689char *qtest_hmp(QTestState *s, const char *fmt, ...)
690{
691 va_list ap;
692 char *ret;
693
694 va_start(ap, fmt);
Markus Armbruster248eef02018-08-06 08:53:44 +0200695 ret = qtest_vhmp(s, fmt, ap);
Markus Armbruster5fb48d92015-10-01 10:59:55 +0200696 va_end(ap);
697 return ret;
698}
John Snow8fe941f2015-04-28 15:27:51 -0400699
Anthony Liguori49ee3592012-03-28 15:42:05 +0200700const char *qtest_get_arch(void)
701{
Thomas Huthdb221e62017-08-28 12:25:45 +0200702 const char *qemu = qtest_qemu_binary();
Anthony Liguori49ee3592012-03-28 15:42:05 +0200703 const char *end = strrchr(qemu, '/');
704
705 return end + strlen("/qemu-system-");
706}
707
708bool qtest_get_irq(QTestState *s, int num)
709{
710 /* dummy operation in order to make sure irq is up to date */
711 qtest_inb(s, 0);
712
713 return s->irq_level[num];
714}
715
716static int64_t qtest_clock_rsp(QTestState *s)
717{
718 gchar **words;
719 int64_t clock;
720 words = qtest_rsp(s, 2);
721 clock = g_ascii_strtoll(words[1], NULL, 0);
722 g_strfreev(words);
723 return clock;
724}
725
726int64_t qtest_clock_step_next(QTestState *s)
727{
728 qtest_sendf(s, "clock_step\n");
729 return qtest_clock_rsp(s);
730}
731
732int64_t qtest_clock_step(QTestState *s, int64_t step)
733{
734 qtest_sendf(s, "clock_step %"PRIi64"\n", step);
735 return qtest_clock_rsp(s);
736}
737
738int64_t qtest_clock_set(QTestState *s, int64_t val)
739{
740 qtest_sendf(s, "clock_set %"PRIi64"\n", val);
741 return qtest_clock_rsp(s);
742}
743
744void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
745{
746 qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
747 qtest_rsp(s, 0);
748}
749
750void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
751{
752 qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
753 qtest_rsp(s, 0);
754}
755
756static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
757{
758 qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
759 qtest_rsp(s, 0);
760}
761
762void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
763{
764 qtest_out(s, "outb", addr, value);
765}
766
767void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
768{
769 qtest_out(s, "outw", addr, value);
770}
771
772void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
773{
774 qtest_out(s, "outl", addr, value);
775}
776
777static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
778{
779 gchar **args;
Eric Blake50990b12017-09-11 12:19:50 -0500780 int ret;
781 unsigned long value;
Anthony Liguori49ee3592012-03-28 15:42:05 +0200782
783 qtest_sendf(s, "%s 0x%x\n", cmd, addr);
784 args = qtest_rsp(s, 2);
Eric Blake50990b12017-09-11 12:19:50 -0500785 ret = qemu_strtoul(args[1], NULL, 0, &value);
786 g_assert(!ret && value <= UINT32_MAX);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200787 g_strfreev(args);
788
789 return value;
790}
791
792uint8_t qtest_inb(QTestState *s, uint16_t addr)
793{
794 return qtest_in(s, "inb", addr);
795}
796
797uint16_t qtest_inw(QTestState *s, uint16_t addr)
798{
799 return qtest_in(s, "inw", addr);
800}
801
802uint32_t qtest_inl(QTestState *s, uint16_t addr)
803{
804 return qtest_in(s, "inl", addr);
805}
806
Andreas Färber872536b2013-02-16 22:44:03 +0100807static void qtest_write(QTestState *s, const char *cmd, uint64_t addr,
808 uint64_t value)
809{
810 qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value);
811 qtest_rsp(s, 0);
812}
813
814void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
815{
816 qtest_write(s, "writeb", addr, value);
817}
818
819void qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
820{
821 qtest_write(s, "writew", addr, value);
822}
823
824void qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
825{
826 qtest_write(s, "writel", addr, value);
827}
828
829void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
830{
831 qtest_write(s, "writeq", addr, value);
832}
833
834static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr)
835{
836 gchar **args;
Eric Blake50990b12017-09-11 12:19:50 -0500837 int ret;
Andreas Färber872536b2013-02-16 22:44:03 +0100838 uint64_t value;
839
840 qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
841 args = qtest_rsp(s, 2);
Eric Blake50990b12017-09-11 12:19:50 -0500842 ret = qemu_strtou64(args[1], NULL, 0, &value);
843 g_assert(!ret);
Andreas Färber872536b2013-02-16 22:44:03 +0100844 g_strfreev(args);
845
846 return value;
847}
848
849uint8_t qtest_readb(QTestState *s, uint64_t addr)
850{
851 return qtest_read(s, "readb", addr);
852}
853
854uint16_t qtest_readw(QTestState *s, uint64_t addr)
855{
856 return qtest_read(s, "readw", addr);
857}
858
859uint32_t qtest_readl(QTestState *s, uint64_t addr)
860{
861 return qtest_read(s, "readl", addr);
862}
863
864uint64_t qtest_readq(QTestState *s, uint64_t addr)
865{
866 return qtest_read(s, "readq", addr);
867}
868
Anthony Liguori49ee3592012-03-28 15:42:05 +0200869static int hex2nib(char ch)
870{
871 if (ch >= '0' && ch <= '9') {
872 return ch - '0';
873 } else if (ch >= 'a' && ch <= 'f') {
874 return 10 + (ch - 'a');
875 } else if (ch >= 'A' && ch <= 'F') {
876 return 10 + (ch - 'a');
877 } else {
878 return -1;
879 }
880}
881
882void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
883{
884 uint8_t *ptr = data;
885 gchar **args;
886 size_t i;
887
Greg Kurz204febd2017-01-11 09:49:32 +0100888 if (!size) {
889 return;
890 }
891
Stefan Weilea7697f2012-04-23 21:40:08 +0200892 qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200893 args = qtest_rsp(s, 2);
894
895 for (i = 0; i < size; i++) {
896 ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
897 ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
898 }
899
900 g_strfreev(args);
901}
902
Laurent Viviereeddd592016-09-13 14:52:45 +0200903uint64_t qtest_rtas_call(QTestState *s, const char *name,
904 uint32_t nargs, uint64_t args,
905 uint32_t nret, uint64_t ret)
906{
907 qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n",
908 name, nargs, args, nret, ret);
909 qtest_rsp(s, 0);
910 return 0;
911}
912
Markus Armbruster041088c2015-12-02 21:20:33 +0100913void qtest_add_func(const char *str, void (*fn)(void))
Anthony Liguori49ee3592012-03-28 15:42:05 +0200914{
915 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
916 g_test_add_func(path, fn);
John Snowa7afc6b2014-08-04 17:11:22 -0400917 g_free(path);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200918}
919
Marc-André Lureau822e36c2016-07-19 15:42:01 +0400920void qtest_add_data_func_full(const char *str, void *data,
921 void (*fn)(const void *),
922 GDestroyNotify data_free_func)
923{
924 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
Marc-André Lureau822e36c2016-07-19 15:42:01 +0400925 g_test_add_data_func_full(path, data, fn, data_free_func);
Marc-André Lureau822e36c2016-07-19 15:42:01 +0400926 g_free(path);
927}
928
Markus Armbruster041088c2015-12-02 21:20:33 +0100929void qtest_add_data_func(const char *str, const void *data,
930 void (*fn)(const void *))
Andreas Färber7949c0e2015-03-24 19:33:34 +0100931{
932 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
933 g_test_add_data_func(path, data, fn);
934 g_free(path);
935}
936
John Snow7a6a7402015-05-22 14:13:44 -0400937void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
938{
939 gchar *bdata;
940
941 bdata = g_base64_encode(data, size);
942 qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size);
943 socket_send(s->fd, bdata, strlen(bdata));
944 socket_send(s->fd, "\n", 1);
945 qtest_rsp(s, 0);
946 g_free(bdata);
947}
948
949void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size)
950{
951 gchar **args;
952 size_t len;
953
954 qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size);
955 args = qtest_rsp(s, 2);
956
957 g_base64_decode_inplace(args[1], &len);
958 if (size != len) {
959 fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n",
960 size, len);
961 len = MIN(len, size);
962 }
963
964 memcpy(data, args[1], len);
965 g_strfreev(args);
966}
967
Anthony Liguori49ee3592012-03-28 15:42:05 +0200968void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
969{
970 const uint8_t *ptr = data;
971 size_t i;
Greg Kurz204febd2017-01-11 09:49:32 +0100972 char *enc;
973
974 if (!size) {
975 return;
976 }
977
978 enc = g_malloc(2 * size + 1);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200979
Anthony Liguori49ee3592012-03-28 15:42:05 +0200980 for (i = 0; i < size; i++) {
John Snow5560b852015-05-22 14:13:44 -0400981 sprintf(&enc[i * 2], "%02x", ptr[i]);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200982 }
John Snow5560b852015-05-22 14:13:44 -0400983
984 qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200985 qtest_rsp(s, 0);
John Snow5560b852015-05-22 14:13:44 -0400986 g_free(enc);
Anthony Liguori49ee3592012-03-28 15:42:05 +0200987}
Peter Maydell0100f422014-03-13 11:24:15 +0000988
John Snow86298842014-08-04 17:11:20 -0400989void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size)
990{
John Snow4d007962015-05-22 14:13:44 -0400991 qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern);
John Snow86298842014-08-04 17:11:20 -0400992 qtest_rsp(s, 0);
993}
994
Peter Maydell0100f422014-03-13 11:24:15 +0000995QDict *qmp(const char *fmt, ...)
996{
997 va_list ap;
998 QDict *response;
999
1000 va_start(ap, fmt);
Markus Armbruster248eef02018-08-06 08:53:44 +02001001 response = qtest_vqmp(global_qtest, fmt, ap);
Peter Maydell0100f422014-03-13 11:24:15 +00001002 va_end(ap);
1003 return response;
1004}
1005
Markus Armbruster4277f1e2018-08-06 08:53:22 +02001006void qmp_send(const char *fmt, ...)
John Snowba4ed392015-04-28 15:27:51 -04001007{
1008 va_list ap;
1009
1010 va_start(ap, fmt);
Markus Armbruster4277f1e2018-08-06 08:53:22 +02001011 qtest_qmp_vsend(global_qtest, fmt, ap);
John Snowba4ed392015-04-28 15:27:51 -04001012 va_end(ap);
1013}
1014
Markus Armbruster5fb48d92015-10-01 10:59:55 +02001015char *hmp(const char *fmt, ...)
1016{
1017 va_list ap;
1018 char *ret;
1019
1020 va_start(ap, fmt);
Markus Armbruster248eef02018-08-06 08:53:44 +02001021 ret = qtest_vhmp(global_qtest, fmt, ap);
Markus Armbruster5fb48d92015-10-01 10:59:55 +02001022 va_end(ap);
1023 return ret;
1024}
Marc Marí46e0cf72014-09-01 12:07:55 +02001025
Laurent Vivier54ce6f22016-10-07 12:14:27 +02001026bool qtest_big_endian(QTestState *s)
Marc Marí46e0cf72014-09-01 12:07:55 +02001027{
Laurent Vivier54ce6f22016-10-07 12:14:27 +02001028 return s->big_endian;
Marc Marí46e0cf72014-09-01 12:07:55 +02001029}
Thomas Huth02ef6e82017-03-30 09:50:06 +02001030
Thomas Huth1f4a0d82018-08-16 13:35:55 +02001031static bool qtest_check_machine_version(const char *mname, const char *basename,
1032 int major, int minor)
1033{
1034 char *newname;
1035 bool is_equal;
1036
1037 newname = g_strdup_printf("%s-%i.%i", basename, major, minor);
1038 is_equal = g_str_equal(mname, newname);
1039 g_free(newname);
1040
1041 return is_equal;
1042}
1043
1044static bool qtest_is_old_versioned_machine(const char *mname)
1045{
1046 const char *dash = strrchr(mname, '-');
1047 const char *dot = strrchr(mname, '.');
1048 const char *chr;
1049 char *bname;
1050 const int major = QEMU_VERSION_MAJOR;
1051 const int minor = QEMU_VERSION_MINOR;
1052 bool res = false;
1053
1054 if (dash && dot && dot > dash) {
1055 for (chr = dash + 1; *chr; chr++) {
1056 if (!qemu_isdigit(*chr) && *chr != '.') {
1057 return false;
1058 }
1059 }
1060 /*
1061 * Now check if it is one of the latest versions. Check major + 1
1062 * and minor + 1 versions as well, since they might already exist
1063 * in the development branch.
1064 */
1065 bname = g_strdup(mname);
1066 bname[dash - mname] = 0;
1067 res = !qtest_check_machine_version(mname, bname, major + 1, 0) &&
1068 !qtest_check_machine_version(mname, bname, major, minor + 1) &&
1069 !qtest_check_machine_version(mname, bname, major, minor);
1070 g_free(bname);
1071 }
1072
1073 return res;
1074}
1075
1076void qtest_cb_for_every_machine(void (*cb)(const char *machine),
1077 bool skip_old_versioned)
Thomas Huth02ef6e82017-03-30 09:50:06 +02001078{
1079 QDict *response, *minfo;
1080 QList *list;
1081 const QListEntry *p;
1082 QObject *qobj;
1083 QString *qstr;
1084 const char *mname;
1085
1086 qtest_start("-machine none");
1087 response = qmp("{ 'execute': 'query-machines' }");
1088 g_assert(response);
1089 list = qdict_get_qlist(response, "return");
1090 g_assert(list);
1091
1092 for (p = qlist_first(list); p; p = qlist_next(p)) {
Max Reitz7dc847e2018-02-24 16:40:29 +01001093 minfo = qobject_to(QDict, qlist_entry_obj(p));
Thomas Huth02ef6e82017-03-30 09:50:06 +02001094 g_assert(minfo);
1095 qobj = qdict_get(minfo, "name");
1096 g_assert(qobj);
Max Reitz7dc847e2018-02-24 16:40:29 +01001097 qstr = qobject_to(QString, qobj);
Thomas Huth02ef6e82017-03-30 09:50:06 +02001098 g_assert(qstr);
1099 mname = qstring_get_str(qstr);
Thomas Huth1f4a0d82018-08-16 13:35:55 +02001100 if (!skip_old_versioned || !qtest_is_old_versioned_machine(mname)) {
1101 cb(mname);
1102 }
Thomas Huth02ef6e82017-03-30 09:50:06 +02001103 }
1104
1105 qtest_end();
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001106 qobject_unref(response);
Thomas Huth02ef6e82017-03-30 09:50:06 +02001107}
Thomas Huthacd80012017-08-15 08:58:54 +02001108
Markus Armbruster3cd46d42018-08-06 08:53:37 +02001109QDict *qtest_qmp_receive_success(QTestState *s,
1110 void (*event_cb)(void *opaque,
1111 const char *event,
1112 QDict *data),
1113 void *opaque)
1114{
1115 QDict *response, *ret, *data;
1116 const char *event;
1117
1118 for (;;) {
1119 response = qtest_qmp_receive(s);
1120 g_assert(!qdict_haskey(response, "error"));
1121 ret = qdict_get_qdict(response, "return");
1122 if (ret) {
1123 break;
1124 }
1125 event = qdict_get_str(response, "event");
1126 data = qdict_get_qdict(response, "data");
1127 if (event_cb) {
1128 event_cb(opaque, event, data);
1129 }
1130 qobject_unref(response);
1131 }
1132
1133 qobject_ref(ret);
1134 qobject_unref(response);
1135 return ret;
1136}
1137
Thomas Huthacd80012017-08-15 08:58:54 +02001138/*
1139 * Generic hot-plugging test via the device_add QMP command.
1140 */
Markus Armbruster82cab702018-08-06 08:53:35 +02001141void qtest_qmp_device_add(const char *driver, const char *id,
1142 const char *fmt, ...)
Thomas Huthacd80012017-08-15 08:58:54 +02001143{
Markus Armbruster82cab702018-08-06 08:53:35 +02001144 QDict *args, *response;
1145 va_list ap;
Thomas Huthacd80012017-08-15 08:58:54 +02001146
Markus Armbruster82cab702018-08-06 08:53:35 +02001147 va_start(ap, fmt);
1148 args = qdict_from_vjsonf_nofail(fmt, ap);
1149 va_end(ap);
Thomas Huthacd80012017-08-15 08:58:54 +02001150
Markus Armbruster82cab702018-08-06 08:53:35 +02001151 g_assert(!qdict_haskey(args, "driver") && !qdict_haskey(args, "id"));
1152 qdict_put_str(args, "driver", driver);
1153 qdict_put_str(args, "id", id);
Thomas Huthacd80012017-08-15 08:58:54 +02001154
Markus Armbruster82cab702018-08-06 08:53:35 +02001155 response = qmp("{'execute': 'device_add', 'arguments': %p}", args);
Thomas Huthacd80012017-08-15 08:58:54 +02001156 g_assert(response);
1157 g_assert(!qdict_haskey(response, "event")); /* We don't expect any events */
1158 g_assert(!qdict_haskey(response, "error"));
Marc-André Lureaucb3e7f02018-04-19 17:01:43 +02001159 qobject_unref(response);
Thomas Huthacd80012017-08-15 08:58:54 +02001160}
1161
Markus Armbruster3cd46d42018-08-06 08:53:37 +02001162static void device_deleted_cb(void *opaque, const char *name, QDict *data)
1163{
1164 bool *got_event = opaque;
1165
1166 g_assert_cmpstr(name, ==, "DEVICE_DELETED");
1167 *got_event = true;
1168}
1169
Thomas Huthacd80012017-08-15 08:58:54 +02001170/*
1171 * Generic hot-unplugging test via the device_del QMP command.
1172 * Device deletion will get one response and one event. For example:
1173 *
1174 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}}
1175 *
1176 * will get this one:
1177 *
1178 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862},
1179 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd",
1180 * "path": "/machine/peripheral/scsi-hd"}}
1181 *
1182 * and this one:
1183 *
1184 * {"return": {}}
1185 *
1186 * But the order of arrival may vary - so we've got to detect both.
1187 */
1188void qtest_qmp_device_del(const char *id)
1189{
Markus Armbruster3cd46d42018-08-06 08:53:37 +02001190 bool got_event = false;
1191 QDict *rsp;
Thomas Huthacd80012017-08-15 08:58:54 +02001192
Markus Armbruster3cd46d42018-08-06 08:53:37 +02001193 qtest_qmp_send(global_qtest,
1194 "{'execute': 'device_del', 'arguments': {'id': %s}}",
1195 id);
1196 rsp = qtest_qmp_receive_success(global_qtest, device_deleted_cb,
1197 &got_event);
1198 qobject_unref(rsp);
1199 if (!got_event) {
1200 rsp = qmp_receive();
1201 g_assert_cmpstr(qdict_get_try_str(rsp, "event"),
1202 ==, "DEVICE_DELETED");
1203 qobject_unref(rsp);
Thomas Huthacd80012017-08-15 08:58:54 +02001204 }
Thomas Huthacd80012017-08-15 08:58:54 +02001205}
Igor Mammedovc35665e2018-05-17 13:30:07 +02001206
1207bool qmp_rsp_is_err(QDict *rsp)
1208{
1209 QDict *error = qdict_get_qdict(rsp, "error");
1210 qobject_unref(rsp);
1211 return !!error;
1212}
Marc-André Lureauebb4d822018-08-30 17:58:07 +02001213
1214void qmp_assert_error_class(QDict *rsp, const char *class)
1215{
1216 QDict *error = qdict_get_qdict(rsp, "error");
1217
1218 g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, class);
1219 g_assert_nonnull(qdict_get_try_str(error, "desc"));
1220 g_assert(!qdict_haskey(rsp, "return"));
1221
1222 qobject_unref(rsp);
1223}