Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 1 | /* |
| 2 | * QTest |
| 3 | * |
| 4 | * Copyright IBM, Corp. 2012 |
| 5 | * Copyright Red Hat, Inc. 2012 |
Andreas Färber | 872536b | 2013-02-16 22:44:03 +0100 | [diff] [blame] | 6 | * Copyright SUSE LINUX Products GmbH 2013 |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 7 | * |
| 8 | * Authors: |
| 9 | * Anthony Liguori <aliguori@us.ibm.com> |
| 10 | * Paolo Bonzini <pbonzini@redhat.com> |
Andreas Färber | 872536b | 2013-02-16 22:44:03 +0100 | [diff] [blame] | 11 | * Andreas Färber <afaerber@suse.de> |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 12 | * |
| 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 Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 15 | */ |
Markus Armbruster | 47e6b29 | 2018-02-01 12:18:38 +0100 | [diff] [blame] | 16 | |
Peter Maydell | 681c28a | 2016-02-08 18:08:51 +0000 | [diff] [blame] | 17 | #include "qemu/osdep.h" |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 18 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 19 | #include <sys/socket.h> |
| 20 | #include <sys/wait.h> |
| 21 | #include <sys/un.h> |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 22 | |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 23 | #include "libqtest.h" |
Markus Armbruster | 62815d8 | 2018-08-23 18:40:01 +0200 | [diff] [blame] | 24 | #include "qemu-common.h" |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 25 | #include "qemu/cutils.h" |
Markus Armbruster | 53f9915 | 2017-02-28 22:26:55 +0100 | [diff] [blame] | 26 | #include "qapi/error.h" |
Markus Armbruster | 86cdf9e | 2018-08-23 18:40:20 +0200 | [diff] [blame] | 27 | #include "qapi/qmp/json-parser.h" |
Markus Armbruster | 452fcdb | 2018-02-01 12:18:39 +0100 | [diff] [blame] | 28 | #include "qapi/qmp/qdict.h" |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 29 | #include "qapi/qmp/qjson.h" |
Markus Armbruster | 47e6b29 | 2018-02-01 12:18:38 +0100 | [diff] [blame] | 30 | #include "qapi/qmp/qlist.h" |
Markus Armbruster | fc81fa1 | 2018-02-01 12:18:40 +0100 | [diff] [blame] | 31 | #include "qapi/qmp/qstring.h" |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 32 | |
| 33 | #define MAX_IRQ 256 |
Andrea Arcangeli | f5d4579 | 2016-06-13 12:16:44 +0100 | [diff] [blame] | 34 | #define SOCKET_TIMEOUT 50 |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 35 | |
| 36 | QTestState *global_qtest; |
| 37 | |
| 38 | struct QTestState |
| 39 | { |
| 40 | int fd; |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 41 | int qmp_fd; |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 42 | pid_t qemu_pid; /* our child QEMU process */ |
| 43 | int wstatus; |
| 44 | bool big_endian; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 45 | bool irq_level[MAX_IRQ]; |
| 46 | GString *rx; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 47 | }; |
| 48 | |
Marc-André Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 49 | static GHookList abrt_hooks; |
Stefan Hajnoczi | d766825 | 2014-03-27 15:09:50 +0100 | [diff] [blame] | 50 | static struct sigaction sigact_old; |
| 51 | |
Laurent Vivier | 54ce6f2 | 2016-10-07 12:14:27 +0200 | [diff] [blame] | 52 | static int qtest_query_target_endianness(QTestState *s); |
| 53 | |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 54 | static int init_socket(const char *socket_path) |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 55 | { |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 56 | struct sockaddr_un addr; |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 57 | int sock; |
| 58 | int ret; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 59 | |
| 60 | sock = socket(PF_UNIX, SOCK_STREAM, 0); |
Markus Armbruster | 70b1105 | 2018-09-26 14:29:33 +0200 | [diff] [blame] | 61 | g_assert_cmpint(sock, !=, -1); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 62 | |
| 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 Armbruster | 70b1105 | 2018-09-26 14:29:33 +0200 | [diff] [blame] | 70 | g_assert_cmpint(ret, !=, -1); |
Andreas Färber | a7ded16 | 2014-04-17 18:19:14 +0200 | [diff] [blame] | 71 | ret = listen(sock, 1); |
Markus Armbruster | 70b1105 | 2018-09-26 14:29:33 +0200 | [diff] [blame] | 72 | g_assert_cmpint(ret, !=, -1); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 73 | |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 74 | return sock; |
| 75 | } |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 76 | |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 77 | static int socket_accept(int sock) |
| 78 | { |
| 79 | struct sockaddr_un addr; |
| 80 | socklen_t addrlen; |
| 81 | int ret; |
Marcel Apfelbaum | f876202 | 2014-03-11 15:00:34 +0200 | [diff] [blame] | 82 | 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 Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 87 | |
| 88 | do { |
Andreas Färber | 535b456 | 2014-04-17 19:21:12 +0200 | [diff] [blame] | 89 | addrlen = sizeof(addr); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 90 | ret = accept(sock, (struct sockaddr *)&addr, &addrlen); |
| 91 | } while (ret == -1 && errno == EINTR); |
Andreas Färber | a7d915f | 2014-04-17 18:38:25 +0200 | [diff] [blame] | 92 | if (ret == -1) { |
| 93 | fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno)); |
| 94 | } |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 95 | close(sock); |
| 96 | |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 97 | return ret; |
| 98 | } |
| 99 | |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 100 | bool 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 Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 114 | static void kill_qemu(QTestState *s) |
| 115 | { |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 116 | pid_t pid = s->qemu_pid; |
| 117 | int wstatus; |
Michael S. Tsirkin | fa0d421 | 2018-05-24 17:24:35 +0300 | [diff] [blame] | 118 | |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 119 | /* 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 Blake | 71a268a | 2018-08-10 08:28:00 -0500 | [diff] [blame] | 123 | assert(pid == s->qemu_pid); |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 124 | } |
Eric Blake | 71a268a | 2018-08-10 08:28:00 -0500 | [diff] [blame] | 125 | |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 126 | /* |
| 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. Tsirkin | fa0d421 | 2018-05-24 17:24:35 +0300 | [diff] [blame] | 144 | } |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 145 | abort(); |
Stefan Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 146 | } |
| 147 | } |
| 148 | |
Markus Armbruster | 041088c | 2015-12-02 21:20:33 +0100 | [diff] [blame] | 149 | static void kill_qemu_hook_func(void *s) |
| 150 | { |
| 151 | kill_qemu(s); |
| 152 | } |
| 153 | |
Stefan Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 154 | static void sigabrt_handler(int signo) |
| 155 | { |
Marc-André Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 156 | g_hook_list_invoke(&abrt_hooks, FALSE); |
Stefan Hajnoczi | d766825 | 2014-03-27 15:09:50 +0100 | [diff] [blame] | 157 | } |
| 158 | |
| 159 | static 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 | |
| 172 | static void cleanup_sigabrt_handler(void) |
| 173 | { |
| 174 | sigaction(SIGABRT, &sigact_old, NULL); |
Stefan Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 175 | } |
| 176 | |
Markus Armbruster | 041088c | 2015-12-02 21:20:33 +0100 | [diff] [blame] | 177 | void qtest_add_abrt_handler(GHookFunc fn, const void *data) |
Marc-André Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 178 | { |
| 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é Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 184 | } |
Jens Freimann | 24dd1e1 | 2017-08-08 22:38:59 +0200 | [diff] [blame] | 185 | setup_sigabrt_handler(); |
Marc-André Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 186 | |
| 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 Huth | db221e6 | 2017-08-28 12:25:45 +0200 | [diff] [blame] | 194 | static 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 Xu | 192f26a | 2018-10-09 14:27:16 +0800 | [diff] [blame] | 207 | QTestState *qtest_init_without_qmp_handshake(const char *extra_args) |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 208 | { |
| 209 | QTestState *s; |
Anthony Liguori | 8a8fd63 | 2013-04-16 09:45:15 -0500 | [diff] [blame] | 210 | int sock, qmpsock, i; |
Stefan Hajnoczi | 56db2e5 | 2013-11-21 11:37:25 +0100 | [diff] [blame] | 211 | gchar *socket_path; |
| 212 | gchar *qmp_socket_path; |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 213 | gchar *command; |
Thomas Huth | db221e6 | 2017-08-28 12:25:45 +0200 | [diff] [blame] | 214 | const char *qemu_binary = qtest_qemu_binary(); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 215 | |
Marc-André Lureau | 790bbb9 | 2017-10-06 20:49:56 -0300 | [diff] [blame] | 216 | s = g_new(QTestState, 1); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 217 | |
Stefan Hajnoczi | 56db2e5 | 2013-11-21 11:37:25 +0100 | [diff] [blame] | 218 | socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid()); |
| 219 | qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid()); |
Markus Armbruster | bb494a5 | 2012-06-29 17:34:27 +0200 | [diff] [blame] | 220 | |
Peter Maydell | d9123d0 | 2017-03-31 13:36:41 +0100 | [diff] [blame] | 221 | /* 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 Hajnoczi | 56db2e5 | 2013-11-21 11:37:25 +0100 | [diff] [blame] | 229 | sock = init_socket(socket_path); |
| 230 | qmpsock = init_socket(qmp_socket_path); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 231 | |
Markus Armbruster | 041088c | 2015-12-02 21:20:33 +0100 | [diff] [blame] | 232 | qtest_add_abrt_handler(kill_qemu_hook_func, s); |
Stefan Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 233 | |
Paolo Bonzini | ced09f9 | 2018-11-15 13:29:30 +0100 | [diff] [blame] | 234 | command = g_strdup_printf("exec %s " |
| 235 | "-qtest unix:%s,nowait " |
| 236 | "-qtest-log %s " |
| 237 | "-chardev socket,path=%s,nowait,id=char0 " |
Peter Xu | 192f26a | 2018-10-09 14:27:16 +0800 | [diff] [blame] | 238 | "-mon chardev=char0,mode=control " |
Paolo Bonzini | ced09f9 | 2018-11-15 13:29:30 +0100 | [diff] [blame] | 239 | "-machine accel=qtest " |
| 240 | "-display none " |
| 241 | "%s", qemu_binary, socket_path, |
| 242 | getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null", |
Peter Xu | 192f26a | 2018-10-09 14:27:16 +0800 | [diff] [blame] | 243 | qmp_socket_path, |
Paolo Bonzini | ced09f9 | 2018-11-15 13:29:30 +0100 | [diff] [blame] | 244 | extra_args ?: ""); |
| 245 | |
| 246 | g_test_message("starting QEMU: %s", command); |
| 247 | |
Richard Henderson | 21f8028 | 2018-12-16 19:58:16 -0800 | [diff] [blame] | 248 | s->wstatus = 0; |
Stefan Hajnoczi | cef60c9 | 2014-02-17 14:54:17 +0100 | [diff] [blame] | 249 | s->qemu_pid = fork(); |
| 250 | if (s->qemu_pid == 0) { |
Stefan Hajnoczi | 6b02921 | 2014-08-27 12:08:52 +0100 | [diff] [blame] | 251 | setenv("QEMU_AUDIO_DRV", "none", true); |
Anthony Liguori | 8a8fd63 | 2013-04-16 09:45:15 -0500 | [diff] [blame] | 252 | execlp("/bin/sh", "sh", "-c", command, NULL); |
| 253 | exit(1); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 254 | } |
| 255 | |
Paolo Bonzini | ced09f9 | 2018-11-15 13:29:30 +0100 | [diff] [blame] | 256 | g_free(command); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 257 | s->fd = socket_accept(sock); |
Marcel Apfelbaum | f876202 | 2014-03-11 15:00:34 +0200 | [diff] [blame] | 258 | if (s->fd >= 0) { |
| 259 | s->qmp_fd = socket_accept(qmpsock); |
| 260 | } |
Stefan Hajnoczi | 56db2e5 | 2013-11-21 11:37:25 +0100 | [diff] [blame] | 261 | unlink(socket_path); |
| 262 | unlink(qmp_socket_path); |
| 263 | g_free(socket_path); |
| 264 | g_free(qmp_socket_path); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 265 | |
Marcel Apfelbaum | f876202 | 2014-03-11 15:00:34 +0200 | [diff] [blame] | 266 | g_assert(s->fd >= 0 && s->qmp_fd >= 0); |
| 267 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 268 | s->rx = g_string_new(""); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 269 | for (i = 0; i < MAX_IRQ; i++) { |
| 270 | s->irq_level[i] = false; |
| 271 | } |
| 272 | |
Paolo Bonzini | e0fea6b | 2012-10-01 14:18:07 +0200 | [diff] [blame] | 273 | if (getenv("QTEST_STOP")) { |
Stefan Hajnoczi | 1ad3c6a | 2013-11-21 11:33:17 +0100 | [diff] [blame] | 274 | kill(s->qemu_pid, SIGSTOP); |
Paolo Bonzini | e0fea6b | 2012-10-01 14:18:07 +0200 | [diff] [blame] | 275 | } |
| 276 | |
Laurent Vivier | 54ce6f2 | 2016-10-07 12:14:27 +0200 | [diff] [blame] | 277 | /* ask endianness of the target */ |
| 278 | |
| 279 | s->big_endian = qtest_query_target_endianness(s); |
| 280 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 281 | return s; |
| 282 | } |
| 283 | |
Markus Armbruster | f66e7ac | 2017-03-03 13:32:23 +0100 | [diff] [blame] | 284 | QTestState *qtest_init(const char *extra_args) |
| 285 | { |
Peter Xu | 192f26a | 2018-10-09 14:27:16 +0800 | [diff] [blame] | 286 | QTestState *s = qtest_init_without_qmp_handshake(extra_args); |
Markus Armbruster | be62e17 | 2018-08-06 08:53:24 +0200 | [diff] [blame] | 287 | QDict *greeting; |
Markus Armbruster | f66e7ac | 2017-03-03 13:32:23 +0100 | [diff] [blame] | 288 | |
| 289 | /* Read the QMP greeting and then do the handshake */ |
Markus Armbruster | be62e17 | 2018-08-06 08:53:24 +0200 | [diff] [blame] | 290 | greeting = qtest_qmp_receive(s); |
| 291 | qobject_unref(greeting); |
Markus Armbruster | 055a1ef | 2018-08-06 08:53:25 +0200 | [diff] [blame] | 292 | qobject_unref(qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }")); |
Markus Armbruster | f66e7ac | 2017-03-03 13:32:23 +0100 | [diff] [blame] | 293 | |
| 294 | return s; |
| 295 | } |
| 296 | |
Markus Armbruster | 88b988c | 2018-08-06 08:53:43 +0200 | [diff] [blame] | 297 | QTestState *qtest_vinitf(const char *fmt, va_list ap) |
Eric Blake | 78b27ba | 2017-10-18 16:20:27 +0200 | [diff] [blame] | 298 | { |
| 299 | char *args = g_strdup_vprintf(fmt, ap); |
| 300 | QTestState *s; |
| 301 | |
Markus Armbruster | 88b988c | 2018-08-06 08:53:43 +0200 | [diff] [blame] | 302 | s = qtest_init(args); |
Eric Blake | 78b27ba | 2017-10-18 16:20:27 +0200 | [diff] [blame] | 303 | g_free(args); |
Eric Blake | 78b27ba | 2017-10-18 16:20:27 +0200 | [diff] [blame] | 304 | return s; |
| 305 | } |
| 306 | |
Markus Armbruster | 88b988c | 2018-08-06 08:53:43 +0200 | [diff] [blame] | 307 | QTestState *qtest_initf(const char *fmt, ...) |
Eric Blake | 78b27ba | 2017-10-18 16:20:27 +0200 | [diff] [blame] | 308 | { |
| 309 | va_list ap; |
| 310 | QTestState *s; |
| 311 | |
| 312 | va_start(ap, fmt); |
Markus Armbruster | 88b988c | 2018-08-06 08:53:43 +0200 | [diff] [blame] | 313 | s = qtest_vinitf(fmt, ap); |
Eric Blake | 78b27ba | 2017-10-18 16:20:27 +0200 | [diff] [blame] | 314 | va_end(ap); |
| 315 | return s; |
| 316 | } |
| 317 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 318 | void qtest_quit(QTestState *s) |
| 319 | { |
Marc-André Lureau | 063c23d | 2015-06-19 18:45:14 +0200 | [diff] [blame] | 320 | g_hook_destroy_link(&abrt_hooks, g_hook_find_data(&abrt_hooks, TRUE, s)); |
| 321 | |
Stefan Hajnoczi | d766825 | 2014-03-27 15:09:50 +0100 | [diff] [blame] | 322 | /* Uninstall SIGABRT handler on last instance */ |
Eric Blake | 4fb609a | 2017-09-11 12:19:49 -0500 | [diff] [blame] | 323 | cleanup_sigabrt_handler(); |
Stefan Hajnoczi | d766825 | 2014-03-27 15:09:50 +0100 | [diff] [blame] | 324 | |
Stefan Hajnoczi | b15d422 | 2014-02-17 16:33:35 +0100 | [diff] [blame] | 325 | kill_qemu(s); |
Markus Armbruster | fdd26fc | 2013-06-20 08:55:28 +0200 | [diff] [blame] | 326 | close(s->fd); |
| 327 | close(s->qmp_fd); |
| 328 | g_string_free(s->rx, true); |
Markus Armbruster | fdd26fc | 2013-06-20 08:55:28 +0200 | [diff] [blame] | 329 | g_free(s); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 330 | } |
| 331 | |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 332 | static void socket_send(int fd, const char *buf, size_t size) |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 333 | { |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 334 | size_t offset; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 335 | |
| 336 | offset = 0; |
| 337 | while (offset < size) { |
| 338 | ssize_t len; |
| 339 | |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 340 | len = write(fd, buf + offset, size - offset); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 341 | if (len == -1 && errno == EINTR) { |
| 342 | continue; |
| 343 | } |
| 344 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 345 | g_assert_cmpint(len, >, 0); |
| 346 | |
| 347 | offset += len; |
| 348 | } |
| 349 | } |
| 350 | |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 351 | static 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 Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 360 | static 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 Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 369 | static 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 Armbruster | f9e986d | 2018-08-15 16:19:45 +0200 | [diff] [blame] | 386 | abort(); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 387 | } |
| 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 | |
| 399 | static gchar **qtest_rsp(QTestState *s, int expected_args) |
| 400 | { |
| 401 | GString *line; |
| 402 | gchar **words; |
| 403 | int i; |
| 404 | |
| 405 | redo: |
| 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 Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 411 | long irq; |
| 412 | int ret; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 413 | |
| 414 | g_assert(words[1] != NULL); |
| 415 | g_assert(words[2] != NULL); |
| 416 | |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 417 | ret = qemu_strtol(words[2], NULL, 0, &irq); |
| 418 | g_assert(!ret); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 419 | 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 Vivier | 54ce6f2 | 2016-10-07 12:14:27 +0200 | [diff] [blame] | 446 | static 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 Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 460 | typedef struct { |
| 461 | JSONMessageParser parser; |
| 462 | QDict *response; |
| 463 | } QMPResponseParser; |
| 464 | |
Markus Armbruster | 62815d8 | 2018-08-23 18:40:01 +0200 | [diff] [blame] | 465 | static void qmp_response(void *opaque, QObject *obj, Error *err) |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 466 | { |
Markus Armbruster | 62815d8 | 2018-08-23 18:40:01 +0200 | [diff] [blame] | 467 | QMPResponseParser *qmp = opaque; |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 468 | |
Markus Armbruster | 84a56f3 | 2018-08-23 18:40:06 +0200 | [diff] [blame] | 469 | assert(!obj != !err); |
| 470 | |
| 471 | if (err) { |
| 472 | error_prepend(&err, "QMP JSON response parsing failed: "); |
| 473 | error_report_err(err); |
Markus Armbruster | f9e986d | 2018-08-15 16:19:45 +0200 | [diff] [blame] | 474 | abort(); |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 475 | } |
| 476 | |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 477 | g_assert(!qmp->response); |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 478 | qmp->response = qobject_to(QDict, obj); |
Markus Armbruster | 4d96f32 | 2017-02-17 21:38:16 +0100 | [diff] [blame] | 479 | g_assert(qmp->response); |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 480 | } |
| 481 | |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 482 | QDict *qmp_fd_receive(int fd) |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 483 | { |
| 484 | QMPResponseParser qmp; |
Paolo Bonzini | 7c282cb | 2014-08-04 17:11:03 -0400 | [diff] [blame] | 485 | bool log = getenv("QTEST_LOG") != NULL; |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 486 | |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 487 | qmp.response = NULL; |
Markus Armbruster | 62815d8 | 2018-08-23 18:40:01 +0200 | [diff] [blame] | 488 | json_message_parser_init(&qmp.parser, qmp_response, &qmp, NULL); |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 489 | while (!qmp.response) { |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 490 | ssize_t len; |
| 491 | char c; |
| 492 | |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 493 | len = read(fd, &c, 1); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 494 | if (len == -1 && errno == EINTR) { |
| 495 | continue; |
| 496 | } |
| 497 | |
Anthony Liguori | 039380a | 2012-06-27 08:20:43 -0500 | [diff] [blame] | 498 | if (len == -1 || len == 0) { |
| 499 | fprintf(stderr, "Broken pipe\n"); |
Markus Armbruster | f9e986d | 2018-08-15 16:19:45 +0200 | [diff] [blame] | 500 | abort(); |
Anthony Liguori | 039380a | 2012-06-27 08:20:43 -0500 | [diff] [blame] | 501 | } |
| 502 | |
Paolo Bonzini | 7c282cb | 2014-08-04 17:11:03 -0400 | [diff] [blame] | 503 | if (log) { |
| 504 | len = write(2, &c, 1); |
| 505 | } |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 506 | json_message_parser_feed(&qmp.parser, &c, 1); |
Kevin Wolf | a3ca163 | 2012-04-26 19:07:55 +0200 | [diff] [blame] | 507 | } |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 508 | json_message_parser_destroy(&qmp.parser); |
| 509 | |
| 510 | return qmp.response; |
| 511 | } |
| 512 | |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 513 | QDict *qtest_qmp_receive(QTestState *s) |
| 514 | { |
| 515 | return qmp_fd_receive(s->qmp_fd); |
| 516 | } |
| 517 | |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 518 | /** |
| 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 Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 523 | void qmp_fd_vsend(int fd, const char *fmt, va_list ap) |
Andreas Färber | 66e0c7b | 2014-02-21 20:55:30 +0100 | [diff] [blame] | 524 | { |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 525 | QObject *qobj; |
| 526 | |
Markus Armbruster | 69f0cb6 | 2018-08-06 08:53:29 +0200 | [diff] [blame] | 527 | /* Going through qobject ensures we escape strings properly */ |
| 528 | qobj = qobject_from_vjsonf_nofail(fmt, ap); |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 529 | |
| 530 | /* No need to send anything for an empty QObject. */ |
| 531 | if (qobj) { |
Marc Marí | ae74f18 | 2014-08-12 13:41:48 +0200 | [diff] [blame] | 532 | int log = getenv("QTEST_LOG") != NULL; |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 533 | QString *qstr = qobject_to_json(qobj); |
Markus Armbruster | 13420ef | 2017-03-03 13:32:22 +0100 | [diff] [blame] | 534 | 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 Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 542 | |
Marc Marí | ae74f18 | 2014-08-12 13:41:48 +0200 | [diff] [blame] | 543 | if (log) { |
| 544 | fprintf(stderr, "%s", str); |
| 545 | } |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 546 | /* Send QMP request */ |
Markus Armbruster | 13420ef | 2017-03-03 13:32:22 +0100 | [diff] [blame] | 547 | socket_send(fd, str, qstring_get_length(qstr)); |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 548 | |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 549 | qobject_unref(qstr); |
| 550 | qobject_unref(qobj); |
Paolo Bonzini | 563890c | 2014-06-13 09:35:18 +0200 | [diff] [blame] | 551 | } |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 552 | } |
| 553 | |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 554 | void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap) |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 555 | { |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 556 | qmp_fd_vsend(s->qmp_fd, fmt, ap); |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 557 | } |
| 558 | |
| 559 | QDict *qmp_fdv(int fd, const char *fmt, va_list ap) |
| 560 | { |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 561 | qmp_fd_vsend(fd, fmt, ap); |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 562 | |
| 563 | return qmp_fd_receive(fd); |
| 564 | } |
| 565 | |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 566 | QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap) |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 567 | { |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 568 | qtest_qmp_vsend(s, fmt, ap); |
Andreas Färber | 66e0c7b | 2014-02-21 20:55:30 +0100 | [diff] [blame] | 569 | |
| 570 | /* Receive reply */ |
| 571 | return qtest_qmp_receive(s); |
| 572 | } |
| 573 | |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 574 | QDict *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 | |
| 585 | void qmp_fd_send(int fd, const char *fmt, ...) |
| 586 | { |
| 587 | va_list ap; |
| 588 | |
| 589 | va_start(ap, fmt); |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 590 | qmp_fd_vsend(fd, fmt, ap); |
Marc-André Lureau | dc47995 | 2015-10-02 14:58:16 +0200 | [diff] [blame] | 591 | va_end(ap); |
| 592 | } |
| 593 | |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 594 | QDict *qtest_qmp(QTestState *s, const char *fmt, ...) |
| 595 | { |
| 596 | va_list ap; |
| 597 | QDict *response; |
| 598 | |
| 599 | va_start(ap, fmt); |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 600 | response = qtest_vqmp(s, fmt, ap); |
Stefan Hajnoczi | 0c460da | 2013-10-30 14:54:33 +0100 | [diff] [blame] | 601 | va_end(ap); |
| 602 | return response; |
| 603 | } |
| 604 | |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 605 | void qtest_qmp_send(QTestState *s, const char *fmt, ...) |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 606 | { |
| 607 | va_list ap; |
| 608 | |
| 609 | va_start(ap, fmt); |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 610 | qtest_qmp_vsend(s, fmt, ap); |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 611 | va_end(ap); |
| 612 | } |
| 613 | |
Markus Armbruster | e2f64a6 | 2018-08-23 18:39:34 +0200 | [diff] [blame] | 614 | void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap) |
Markus Armbruster | aed877c | 2018-08-23 18:39:33 +0200 | [diff] [blame] | 615 | { |
| 616 | bool log = getenv("QTEST_LOG") != NULL; |
Markus Armbruster | e2f64a6 | 2018-08-23 18:39:34 +0200 | [diff] [blame] | 617 | char *str = g_strdup_vprintf(fmt, ap); |
Markus Armbruster | aed877c | 2018-08-23 18:39:33 +0200 | [diff] [blame] | 618 | |
| 619 | if (log) { |
| 620 | fprintf(stderr, "%s", str); |
| 621 | } |
Markus Armbruster | e2f64a6 | 2018-08-23 18:39:34 +0200 | [diff] [blame] | 622 | socket_send(fd, str, strlen(str)); |
Markus Armbruster | aed877c | 2018-08-23 18:39:33 +0200 | [diff] [blame] | 623 | g_free(str); |
| 624 | } |
| 625 | |
Markus Armbruster | e2f64a6 | 2018-08-23 18:39:34 +0200 | [diff] [blame] | 626 | void 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 | |
| 635 | void 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 Snow | 7ffe312 | 2016-11-14 11:15:54 -0500 | [diff] [blame] | 644 | QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event) |
John Snow | 8fe941f | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 645 | { |
| 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 Snow | 7ffe312 | 2016-11-14 11:15:54 -0500 | [diff] [blame] | 652 | return response; |
John Snow | 8fe941f | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 653 | } |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 654 | qobject_unref(response); |
John Snow | 8fe941f | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 655 | } |
| 656 | } |
| 657 | |
John Snow | 7ffe312 | 2016-11-14 11:15:54 -0500 | [diff] [blame] | 658 | void qtest_qmp_eventwait(QTestState *s, const char *event) |
| 659 | { |
| 660 | QDict *response; |
| 661 | |
| 662 | response = qtest_qmp_eventwait_ref(s, event); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 663 | qobject_unref(response); |
John Snow | 7ffe312 | 2016-11-14 11:15:54 -0500 | [diff] [blame] | 664 | } |
| 665 | |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 666 | char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap) |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 667 | { |
| 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 Huth | 6bb87be | 2017-03-30 09:50:05 +0200 | [diff] [blame] | 677 | while (ret == NULL && qdict_get_try_str(resp, "event")) { |
| 678 | /* Ignore asynchronous QMP events */ |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 679 | qobject_unref(resp); |
Thomas Huth | 6bb87be | 2017-03-30 09:50:05 +0200 | [diff] [blame] | 680 | resp = qtest_qmp_receive(s); |
| 681 | ret = g_strdup(qdict_get_try_str(resp, "return")); |
| 682 | } |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 683 | g_assert(ret); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 684 | qobject_unref(resp); |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 685 | g_free(cmd); |
| 686 | return ret; |
| 687 | } |
| 688 | |
| 689 | char *qtest_hmp(QTestState *s, const char *fmt, ...) |
| 690 | { |
| 691 | va_list ap; |
| 692 | char *ret; |
| 693 | |
| 694 | va_start(ap, fmt); |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 695 | ret = qtest_vhmp(s, fmt, ap); |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 696 | va_end(ap); |
| 697 | return ret; |
| 698 | } |
John Snow | 8fe941f | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 699 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 700 | const char *qtest_get_arch(void) |
| 701 | { |
Thomas Huth | db221e6 | 2017-08-28 12:25:45 +0200 | [diff] [blame] | 702 | const char *qemu = qtest_qemu_binary(); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 703 | const char *end = strrchr(qemu, '/'); |
| 704 | |
| 705 | return end + strlen("/qemu-system-"); |
| 706 | } |
| 707 | |
| 708 | bool 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 | |
| 716 | static 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 | |
| 726 | int64_t qtest_clock_step_next(QTestState *s) |
| 727 | { |
| 728 | qtest_sendf(s, "clock_step\n"); |
| 729 | return qtest_clock_rsp(s); |
| 730 | } |
| 731 | |
| 732 | int64_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 | |
| 738 | int64_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 | |
| 744 | void 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 | |
| 750 | void 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 | |
| 756 | static 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 | |
| 762 | void qtest_outb(QTestState *s, uint16_t addr, uint8_t value) |
| 763 | { |
| 764 | qtest_out(s, "outb", addr, value); |
| 765 | } |
| 766 | |
| 767 | void qtest_outw(QTestState *s, uint16_t addr, uint16_t value) |
| 768 | { |
| 769 | qtest_out(s, "outw", addr, value); |
| 770 | } |
| 771 | |
| 772 | void qtest_outl(QTestState *s, uint16_t addr, uint32_t value) |
| 773 | { |
| 774 | qtest_out(s, "outl", addr, value); |
| 775 | } |
| 776 | |
| 777 | static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr) |
| 778 | { |
| 779 | gchar **args; |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 780 | int ret; |
| 781 | unsigned long value; |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 782 | |
| 783 | qtest_sendf(s, "%s 0x%x\n", cmd, addr); |
| 784 | args = qtest_rsp(s, 2); |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 785 | ret = qemu_strtoul(args[1], NULL, 0, &value); |
| 786 | g_assert(!ret && value <= UINT32_MAX); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 787 | g_strfreev(args); |
| 788 | |
| 789 | return value; |
| 790 | } |
| 791 | |
| 792 | uint8_t qtest_inb(QTestState *s, uint16_t addr) |
| 793 | { |
| 794 | return qtest_in(s, "inb", addr); |
| 795 | } |
| 796 | |
| 797 | uint16_t qtest_inw(QTestState *s, uint16_t addr) |
| 798 | { |
| 799 | return qtest_in(s, "inw", addr); |
| 800 | } |
| 801 | |
| 802 | uint32_t qtest_inl(QTestState *s, uint16_t addr) |
| 803 | { |
| 804 | return qtest_in(s, "inl", addr); |
| 805 | } |
| 806 | |
Andreas Färber | 872536b | 2013-02-16 22:44:03 +0100 | [diff] [blame] | 807 | static 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 | |
| 814 | void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value) |
| 815 | { |
| 816 | qtest_write(s, "writeb", addr, value); |
| 817 | } |
| 818 | |
| 819 | void qtest_writew(QTestState *s, uint64_t addr, uint16_t value) |
| 820 | { |
| 821 | qtest_write(s, "writew", addr, value); |
| 822 | } |
| 823 | |
| 824 | void qtest_writel(QTestState *s, uint64_t addr, uint32_t value) |
| 825 | { |
| 826 | qtest_write(s, "writel", addr, value); |
| 827 | } |
| 828 | |
| 829 | void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value) |
| 830 | { |
| 831 | qtest_write(s, "writeq", addr, value); |
| 832 | } |
| 833 | |
| 834 | static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr) |
| 835 | { |
| 836 | gchar **args; |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 837 | int ret; |
Andreas Färber | 872536b | 2013-02-16 22:44:03 +0100 | [diff] [blame] | 838 | uint64_t value; |
| 839 | |
| 840 | qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr); |
| 841 | args = qtest_rsp(s, 2); |
Eric Blake | 50990b1 | 2017-09-11 12:19:50 -0500 | [diff] [blame] | 842 | ret = qemu_strtou64(args[1], NULL, 0, &value); |
| 843 | g_assert(!ret); |
Andreas Färber | 872536b | 2013-02-16 22:44:03 +0100 | [diff] [blame] | 844 | g_strfreev(args); |
| 845 | |
| 846 | return value; |
| 847 | } |
| 848 | |
| 849 | uint8_t qtest_readb(QTestState *s, uint64_t addr) |
| 850 | { |
| 851 | return qtest_read(s, "readb", addr); |
| 852 | } |
| 853 | |
| 854 | uint16_t qtest_readw(QTestState *s, uint64_t addr) |
| 855 | { |
| 856 | return qtest_read(s, "readw", addr); |
| 857 | } |
| 858 | |
| 859 | uint32_t qtest_readl(QTestState *s, uint64_t addr) |
| 860 | { |
| 861 | return qtest_read(s, "readl", addr); |
| 862 | } |
| 863 | |
| 864 | uint64_t qtest_readq(QTestState *s, uint64_t addr) |
| 865 | { |
| 866 | return qtest_read(s, "readq", addr); |
| 867 | } |
| 868 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 869 | static 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 | |
| 882 | void 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 Kurz | 204febd | 2017-01-11 09:49:32 +0100 | [diff] [blame] | 888 | if (!size) { |
| 889 | return; |
| 890 | } |
| 891 | |
Stefan Weil | ea7697f | 2012-04-23 21:40:08 +0200 | [diff] [blame] | 892 | qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 893 | 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 Vivier | eeddd59 | 2016-09-13 14:52:45 +0200 | [diff] [blame] | 903 | uint64_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 Armbruster | 041088c | 2015-12-02 21:20:33 +0100 | [diff] [blame] | 913 | void qtest_add_func(const char *str, void (*fn)(void)) |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 914 | { |
| 915 | gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); |
| 916 | g_test_add_func(path, fn); |
John Snow | a7afc6b | 2014-08-04 17:11:22 -0400 | [diff] [blame] | 917 | g_free(path); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 918 | } |
| 919 | |
Marc-André Lureau | 822e36c | 2016-07-19 15:42:01 +0400 | [diff] [blame] | 920 | void 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é Lureau | 822e36c | 2016-07-19 15:42:01 +0400 | [diff] [blame] | 925 | g_test_add_data_func_full(path, data, fn, data_free_func); |
Marc-André Lureau | 822e36c | 2016-07-19 15:42:01 +0400 | [diff] [blame] | 926 | g_free(path); |
| 927 | } |
| 928 | |
Markus Armbruster | 041088c | 2015-12-02 21:20:33 +0100 | [diff] [blame] | 929 | void qtest_add_data_func(const char *str, const void *data, |
| 930 | void (*fn)(const void *)) |
Andreas Färber | 7949c0e | 2015-03-24 19:33:34 +0100 | [diff] [blame] | 931 | { |
| 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 Snow | 7a6a740 | 2015-05-22 14:13:44 -0400 | [diff] [blame] | 937 | void 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 | |
| 949 | void 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 Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 968 | void 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 Kurz | 204febd | 2017-01-11 09:49:32 +0100 | [diff] [blame] | 972 | char *enc; |
| 973 | |
| 974 | if (!size) { |
| 975 | return; |
| 976 | } |
| 977 | |
| 978 | enc = g_malloc(2 * size + 1); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 979 | |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 980 | for (i = 0; i < size; i++) { |
John Snow | 5560b85 | 2015-05-22 14:13:44 -0400 | [diff] [blame] | 981 | sprintf(&enc[i * 2], "%02x", ptr[i]); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 982 | } |
John Snow | 5560b85 | 2015-05-22 14:13:44 -0400 | [diff] [blame] | 983 | |
| 984 | qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 985 | qtest_rsp(s, 0); |
John Snow | 5560b85 | 2015-05-22 14:13:44 -0400 | [diff] [blame] | 986 | g_free(enc); |
Anthony Liguori | 49ee359 | 2012-03-28 15:42:05 +0200 | [diff] [blame] | 987 | } |
Peter Maydell | 0100f42 | 2014-03-13 11:24:15 +0000 | [diff] [blame] | 988 | |
John Snow | 8629884 | 2014-08-04 17:11:20 -0400 | [diff] [blame] | 989 | void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size) |
| 990 | { |
John Snow | 4d00796 | 2015-05-22 14:13:44 -0400 | [diff] [blame] | 991 | qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern); |
John Snow | 8629884 | 2014-08-04 17:11:20 -0400 | [diff] [blame] | 992 | qtest_rsp(s, 0); |
| 993 | } |
| 994 | |
Peter Maydell | 0100f42 | 2014-03-13 11:24:15 +0000 | [diff] [blame] | 995 | QDict *qmp(const char *fmt, ...) |
| 996 | { |
| 997 | va_list ap; |
| 998 | QDict *response; |
| 999 | |
| 1000 | va_start(ap, fmt); |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 1001 | response = qtest_vqmp(global_qtest, fmt, ap); |
Peter Maydell | 0100f42 | 2014-03-13 11:24:15 +0000 | [diff] [blame] | 1002 | va_end(ap); |
| 1003 | return response; |
| 1004 | } |
| 1005 | |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 1006 | void qmp_send(const char *fmt, ...) |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 1007 | { |
| 1008 | va_list ap; |
| 1009 | |
| 1010 | va_start(ap, fmt); |
Markus Armbruster | 4277f1e | 2018-08-06 08:53:22 +0200 | [diff] [blame] | 1011 | qtest_qmp_vsend(global_qtest, fmt, ap); |
John Snow | ba4ed39 | 2015-04-28 15:27:51 -0400 | [diff] [blame] | 1012 | va_end(ap); |
| 1013 | } |
| 1014 | |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 1015 | char *hmp(const char *fmt, ...) |
| 1016 | { |
| 1017 | va_list ap; |
| 1018 | char *ret; |
| 1019 | |
| 1020 | va_start(ap, fmt); |
Markus Armbruster | 248eef0 | 2018-08-06 08:53:44 +0200 | [diff] [blame] | 1021 | ret = qtest_vhmp(global_qtest, fmt, ap); |
Markus Armbruster | 5fb48d9 | 2015-10-01 10:59:55 +0200 | [diff] [blame] | 1022 | va_end(ap); |
| 1023 | return ret; |
| 1024 | } |
Marc Marí | 46e0cf7 | 2014-09-01 12:07:55 +0200 | [diff] [blame] | 1025 | |
Laurent Vivier | 54ce6f2 | 2016-10-07 12:14:27 +0200 | [diff] [blame] | 1026 | bool qtest_big_endian(QTestState *s) |
Marc Marí | 46e0cf7 | 2014-09-01 12:07:55 +0200 | [diff] [blame] | 1027 | { |
Laurent Vivier | 54ce6f2 | 2016-10-07 12:14:27 +0200 | [diff] [blame] | 1028 | return s->big_endian; |
Marc Marí | 46e0cf7 | 2014-09-01 12:07:55 +0200 | [diff] [blame] | 1029 | } |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1030 | |
Thomas Huth | 1f4a0d8 | 2018-08-16 13:35:55 +0200 | [diff] [blame] | 1031 | static 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 | |
| 1044 | static 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 | |
| 1076 | void qtest_cb_for_every_machine(void (*cb)(const char *machine), |
| 1077 | bool skip_old_versioned) |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1078 | { |
| 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 Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 1093 | minfo = qobject_to(QDict, qlist_entry_obj(p)); |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1094 | g_assert(minfo); |
| 1095 | qobj = qdict_get(minfo, "name"); |
| 1096 | g_assert(qobj); |
Max Reitz | 7dc847e | 2018-02-24 16:40:29 +0100 | [diff] [blame] | 1097 | qstr = qobject_to(QString, qobj); |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1098 | g_assert(qstr); |
| 1099 | mname = qstring_get_str(qstr); |
Thomas Huth | 1f4a0d8 | 2018-08-16 13:35:55 +0200 | [diff] [blame] | 1100 | if (!skip_old_versioned || !qtest_is_old_versioned_machine(mname)) { |
| 1101 | cb(mname); |
| 1102 | } |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1103 | } |
| 1104 | |
| 1105 | qtest_end(); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 1106 | qobject_unref(response); |
Thomas Huth | 02ef6e8 | 2017-03-30 09:50:06 +0200 | [diff] [blame] | 1107 | } |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1108 | |
Markus Armbruster | 3cd46d4 | 2018-08-06 08:53:37 +0200 | [diff] [blame] | 1109 | QDict *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 Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1138 | /* |
| 1139 | * Generic hot-plugging test via the device_add QMP command. |
| 1140 | */ |
Markus Armbruster | 82cab70 | 2018-08-06 08:53:35 +0200 | [diff] [blame] | 1141 | void qtest_qmp_device_add(const char *driver, const char *id, |
| 1142 | const char *fmt, ...) |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1143 | { |
Markus Armbruster | 82cab70 | 2018-08-06 08:53:35 +0200 | [diff] [blame] | 1144 | QDict *args, *response; |
| 1145 | va_list ap; |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1146 | |
Markus Armbruster | 82cab70 | 2018-08-06 08:53:35 +0200 | [diff] [blame] | 1147 | va_start(ap, fmt); |
| 1148 | args = qdict_from_vjsonf_nofail(fmt, ap); |
| 1149 | va_end(ap); |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1150 | |
Markus Armbruster | 82cab70 | 2018-08-06 08:53:35 +0200 | [diff] [blame] | 1151 | 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 Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1154 | |
Markus Armbruster | 82cab70 | 2018-08-06 08:53:35 +0200 | [diff] [blame] | 1155 | response = qmp("{'execute': 'device_add', 'arguments': %p}", args); |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1156 | 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é Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 1159 | qobject_unref(response); |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1160 | } |
| 1161 | |
Markus Armbruster | 3cd46d4 | 2018-08-06 08:53:37 +0200 | [diff] [blame] | 1162 | static 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 Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1170 | /* |
| 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 | */ |
| 1188 | void qtest_qmp_device_del(const char *id) |
| 1189 | { |
Markus Armbruster | 3cd46d4 | 2018-08-06 08:53:37 +0200 | [diff] [blame] | 1190 | bool got_event = false; |
| 1191 | QDict *rsp; |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1192 | |
Markus Armbruster | 3cd46d4 | 2018-08-06 08:53:37 +0200 | [diff] [blame] | 1193 | 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 Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1204 | } |
Thomas Huth | acd8001 | 2017-08-15 08:58:54 +0200 | [diff] [blame] | 1205 | } |
Igor Mammedov | c35665e | 2018-05-17 13:30:07 +0200 | [diff] [blame] | 1206 | |
| 1207 | bool 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é Lureau | ebb4d82 | 2018-08-30 17:58:07 +0200 | [diff] [blame] | 1213 | |
| 1214 | void 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 | } |