1 /* 2 * QTest 3 * 4 * Copyright IBM, Corp. 2012 5 * Copyright Red Hat, Inc. 2012 6 * Copyright SUSE LINUX Products GmbH 2013 7 * 8 * Authors: 9 * Anthony Liguori <aliguori@us.ibm.com> 10 * Paolo Bonzini <pbonzini@redhat.com> 11 * Andreas Färber <afaerber@suse.de> 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. 15 */ 16 17 #include "qemu/osdep.h" 18 19 #include <sys/socket.h> 20 #include <sys/wait.h> 21 #include <sys/un.h> 22 23 #include "libqos/libqtest.h" 24 #include "qemu/ctype.h" 25 #include "qemu/cutils.h" 26 #include "qapi/error.h" 27 #include "qapi/qmp/json-parser.h" 28 #include "qapi/qmp/qdict.h" 29 #include "qapi/qmp/qjson.h" 30 #include "qapi/qmp/qlist.h" 31 #include "qapi/qmp/qstring.h" 32 33 #define MAX_IRQ 256 34 #define SOCKET_TIMEOUT 50 35 #define SOCKET_MAX_FDS 16 36 37 38 typedef void (*QTestSendFn)(QTestState *s, const char *buf); 39 typedef void (*ExternalSendFn)(void *s, const char *buf); 40 typedef GString* (*QTestRecvFn)(QTestState *); 41 42 typedef struct QTestClientTransportOps { 43 QTestSendFn send; /* for sending qtest commands */ 44 45 /* 46 * use external_send to send qtest command strings through functions which 47 * do not accept a QTestState as the first parameter. 48 */ 49 ExternalSendFn external_send; 50 51 QTestRecvFn recv_line; /* for receiving qtest command responses */ 52 } QTestTransportOps; 53 54 struct QTestState 55 { 56 int fd; 57 int qmp_fd; 58 pid_t qemu_pid; /* our child QEMU process */ 59 int wstatus; 60 int expected_status; 61 bool big_endian; 62 bool irq_level[MAX_IRQ]; 63 GString *rx; 64 QTestTransportOps ops; 65 GList *pending_events; 66 }; 67 68 static GHookList abrt_hooks; 69 static struct sigaction sigact_old; 70 71 static int qtest_query_target_endianness(QTestState *s); 72 73 static void qtest_client_socket_send(QTestState*, const char *buf); 74 static void socket_send(int fd, const char *buf, size_t size); 75 76 static GString *qtest_client_socket_recv_line(QTestState *); 77 78 static void qtest_client_set_tx_handler(QTestState *s, QTestSendFn send); 79 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv); 80 81 static int init_socket(const char *socket_path) 82 { 83 int sock = qtest_socket_server(socket_path); 84 qemu_set_cloexec(sock); 85 return sock; 86 } 87 88 static int socket_accept(int sock) 89 { 90 struct sockaddr_un addr; 91 socklen_t addrlen; 92 int ret; 93 struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT, 94 .tv_usec = 0 }; 95 96 if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, 97 (void *)&timeout, sizeof(timeout))) { 98 fprintf(stderr, "%s failed to set SO_RCVTIMEO: %s\n", 99 __func__, strerror(errno)); 100 close(sock); 101 return -1; 102 } 103 104 do { 105 addrlen = sizeof(addr); 106 ret = accept(sock, (struct sockaddr *)&addr, &addrlen); 107 } while (ret == -1 && errno == EINTR); 108 if (ret == -1) { 109 fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno)); 110 } 111 close(sock); 112 113 return ret; 114 } 115 116 bool qtest_probe_child(QTestState *s) 117 { 118 pid_t pid = s->qemu_pid; 119 120 if (pid != -1) { 121 pid = waitpid(pid, &s->wstatus, WNOHANG); 122 if (pid == 0) { 123 return true; 124 } 125 s->qemu_pid = -1; 126 } 127 return false; 128 } 129 130 void qtest_set_expected_status(QTestState *s, int status) 131 { 132 s->expected_status = status; 133 } 134 135 void qtest_kill_qemu(QTestState *s) 136 { 137 pid_t pid = s->qemu_pid; 138 int wstatus; 139 140 /* Skip wait if qtest_probe_child already reaped. */ 141 if (pid != -1) { 142 kill(pid, SIGTERM); 143 TFR(pid = waitpid(s->qemu_pid, &s->wstatus, 0)); 144 assert(pid == s->qemu_pid); 145 s->qemu_pid = -1; 146 } 147 148 /* 149 * Check whether qemu exited with expected exit status; anything else is 150 * fishy and should be logged with as much detail as possible. 151 */ 152 wstatus = s->wstatus; 153 if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) != s->expected_status) { 154 fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU " 155 "process but encountered exit status %d (expected %d)\n", 156 __FILE__, __LINE__, WEXITSTATUS(wstatus), s->expected_status); 157 abort(); 158 } else if (WIFSIGNALED(wstatus)) { 159 int sig = WTERMSIG(wstatus); 160 const char *signame = strsignal(sig) ?: "unknown ???"; 161 const char *dump = WCOREDUMP(wstatus) ? " (core dumped)" : ""; 162 163 fprintf(stderr, "%s:%d: kill_qemu() detected QEMU death " 164 "from signal %d (%s)%s\n", 165 __FILE__, __LINE__, sig, signame, dump); 166 abort(); 167 } 168 } 169 170 static void kill_qemu_hook_func(void *s) 171 { 172 qtest_kill_qemu(s); 173 } 174 175 static void sigabrt_handler(int signo) 176 { 177 g_hook_list_invoke(&abrt_hooks, FALSE); 178 } 179 180 static void setup_sigabrt_handler(void) 181 { 182 struct sigaction sigact; 183 184 /* Catch SIGABRT to clean up on g_assert() failure */ 185 sigact = (struct sigaction){ 186 .sa_handler = sigabrt_handler, 187 .sa_flags = SA_RESETHAND, 188 }; 189 sigemptyset(&sigact.sa_mask); 190 sigaction(SIGABRT, &sigact, &sigact_old); 191 } 192 193 static void cleanup_sigabrt_handler(void) 194 { 195 sigaction(SIGABRT, &sigact_old, NULL); 196 } 197 198 static bool hook_list_is_empty(GHookList *hook_list) 199 { 200 GHook *hook = g_hook_first_valid(hook_list, TRUE); 201 202 if (!hook) { 203 return false; 204 } 205 206 g_hook_unref(hook_list, hook); 207 return true; 208 } 209 210 void qtest_add_abrt_handler(GHookFunc fn, const void *data) 211 { 212 GHook *hook; 213 214 if (!abrt_hooks.is_setup) { 215 g_hook_list_init(&abrt_hooks, sizeof(GHook)); 216 } 217 218 /* Only install SIGABRT handler once */ 219 if (hook_list_is_empty(&abrt_hooks)) { 220 setup_sigabrt_handler(); 221 } 222 223 hook = g_hook_alloc(&abrt_hooks); 224 hook->func = fn; 225 hook->data = (void *)data; 226 227 g_hook_prepend(&abrt_hooks, hook); 228 } 229 230 void qtest_remove_abrt_handler(void *data) 231 { 232 GHook *hook = g_hook_find_data(&abrt_hooks, TRUE, data); 233 g_hook_destroy_link(&abrt_hooks, hook); 234 235 /* Uninstall SIGABRT handler on last instance */ 236 if (hook_list_is_empty(&abrt_hooks)) { 237 cleanup_sigabrt_handler(); 238 } 239 } 240 241 static const char *qtest_qemu_binary(void) 242 { 243 const char *qemu_bin; 244 245 qemu_bin = getenv("QTEST_QEMU_BINARY"); 246 if (!qemu_bin) { 247 fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n"); 248 exit(1); 249 } 250 251 return qemu_bin; 252 } 253 254 QTestState *qtest_init_without_qmp_handshake(const char *extra_args) 255 { 256 QTestState *s; 257 int sock, qmpsock, i; 258 gchar *socket_path; 259 gchar *qmp_socket_path; 260 gchar *command; 261 const char *qemu_binary = qtest_qemu_binary(); 262 263 s = g_new(QTestState, 1); 264 265 socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid()); 266 qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid()); 267 268 /* It's possible that if an earlier test run crashed it might 269 * have left a stale unix socket lying around. Delete any 270 * stale old socket to avoid spurious test failures with 271 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1) 272 */ 273 unlink(socket_path); 274 unlink(qmp_socket_path); 275 276 sock = init_socket(socket_path); 277 qmpsock = init_socket(qmp_socket_path); 278 279 qtest_client_set_rx_handler(s, qtest_client_socket_recv_line); 280 qtest_client_set_tx_handler(s, qtest_client_socket_send); 281 282 qtest_add_abrt_handler(kill_qemu_hook_func, s); 283 284 command = g_strdup_printf("exec %s " 285 "-qtest unix:%s " 286 "-qtest-log %s " 287 "-chardev socket,path=%s,id=char0 " 288 "-mon chardev=char0,mode=control " 289 "-display none " 290 "%s" 291 " -accel qtest", qemu_binary, socket_path, 292 getenv("QTEST_LOG") ? "/dev/fd/2" : "/dev/null", 293 qmp_socket_path, 294 extra_args ?: ""); 295 296 g_test_message("starting QEMU: %s", command); 297 298 s->pending_events = NULL; 299 s->wstatus = 0; 300 s->expected_status = 0; 301 s->qemu_pid = fork(); 302 if (s->qemu_pid == 0) { 303 if (!g_setenv("QEMU_AUDIO_DRV", "none", true)) { 304 exit(1); 305 } 306 execlp("/bin/sh", "sh", "-c", command, NULL); 307 exit(1); 308 } 309 310 g_free(command); 311 s->fd = socket_accept(sock); 312 if (s->fd >= 0) { 313 s->qmp_fd = socket_accept(qmpsock); 314 } 315 unlink(socket_path); 316 unlink(qmp_socket_path); 317 g_free(socket_path); 318 g_free(qmp_socket_path); 319 320 g_assert(s->fd >= 0 && s->qmp_fd >= 0); 321 322 s->rx = g_string_new(""); 323 for (i = 0; i < MAX_IRQ; i++) { 324 s->irq_level[i] = false; 325 } 326 327 if (getenv("QTEST_STOP")) { 328 kill(s->qemu_pid, SIGSTOP); 329 } 330 331 /* ask endianness of the target */ 332 333 s->big_endian = qtest_query_target_endianness(s); 334 335 return s; 336 } 337 338 QTestState *qtest_init(const char *extra_args) 339 { 340 QTestState *s = qtest_init_without_qmp_handshake(extra_args); 341 QDict *greeting; 342 343 /* Read the QMP greeting and then do the handshake */ 344 greeting = qtest_qmp_receive(s); 345 qobject_unref(greeting); 346 qobject_unref(qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }")); 347 348 return s; 349 } 350 351 QTestState *qtest_vinitf(const char *fmt, va_list ap) 352 { 353 char *args = g_strdup_vprintf(fmt, ap); 354 QTestState *s; 355 356 s = qtest_init(args); 357 g_free(args); 358 return s; 359 } 360 361 QTestState *qtest_initf(const char *fmt, ...) 362 { 363 va_list ap; 364 QTestState *s; 365 366 va_start(ap, fmt); 367 s = qtest_vinitf(fmt, ap); 368 va_end(ap); 369 return s; 370 } 371 372 QTestState *qtest_init_with_serial(const char *extra_args, int *sock_fd) 373 { 374 int sock_fd_init; 375 char *sock_path, sock_dir[] = "/tmp/qtest-serial-XXXXXX"; 376 QTestState *qts; 377 378 g_assert_true(mkdtemp(sock_dir) != NULL); 379 sock_path = g_strdup_printf("%s/sock", sock_dir); 380 381 sock_fd_init = init_socket(sock_path); 382 383 qts = qtest_initf("-chardev socket,id=s0,path=%s -serial chardev:s0 %s", 384 sock_path, extra_args); 385 386 *sock_fd = socket_accept(sock_fd_init); 387 388 unlink(sock_path); 389 g_free(sock_path); 390 rmdir(sock_dir); 391 392 g_assert_true(*sock_fd >= 0); 393 394 return qts; 395 } 396 397 void qtest_quit(QTestState *s) 398 { 399 qtest_remove_abrt_handler(s); 400 401 qtest_kill_qemu(s); 402 close(s->fd); 403 close(s->qmp_fd); 404 g_string_free(s->rx, true); 405 406 for (GList *it = s->pending_events; it != NULL; it = it->next) { 407 qobject_unref((QDict *)it->data); 408 } 409 410 g_list_free(s->pending_events); 411 412 g_free(s); 413 } 414 415 static void socket_send(int fd, const char *buf, size_t size) 416 { 417 size_t offset; 418 419 offset = 0; 420 while (offset < size) { 421 ssize_t len; 422 423 len = write(fd, buf + offset, size - offset); 424 if (len == -1 && errno == EINTR) { 425 continue; 426 } 427 428 g_assert_cmpint(len, >, 0); 429 430 offset += len; 431 } 432 } 433 434 static void qtest_client_socket_send(QTestState *s, const char *buf) 435 { 436 socket_send(s->fd, buf, strlen(buf)); 437 } 438 439 static void G_GNUC_PRINTF(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) 440 { 441 va_list ap; 442 443 va_start(ap, fmt); 444 gchar *str = g_strdup_vprintf(fmt, ap); 445 va_end(ap); 446 447 s->ops.send(s, str); 448 g_free(str); 449 } 450 451 /* Sends a message and file descriptors to the socket. 452 * It's needed for qmp-commands like getfd/add-fd */ 453 static void socket_send_fds(int socket_fd, int *fds, size_t fds_num, 454 const char *buf, size_t buf_size) 455 { 456 ssize_t ret; 457 struct msghdr msg = { 0 }; 458 char control[CMSG_SPACE(sizeof(int) * SOCKET_MAX_FDS)] = { 0 }; 459 size_t fdsize = sizeof(int) * fds_num; 460 struct cmsghdr *cmsg; 461 struct iovec iov = { .iov_base = (char *)buf, .iov_len = buf_size }; 462 463 msg.msg_iov = &iov; 464 msg.msg_iovlen = 1; 465 466 if (fds && fds_num > 0) { 467 g_assert_cmpuint(fds_num, <, SOCKET_MAX_FDS); 468 469 msg.msg_control = control; 470 msg.msg_controllen = CMSG_SPACE(fdsize); 471 472 cmsg = CMSG_FIRSTHDR(&msg); 473 cmsg->cmsg_len = CMSG_LEN(fdsize); 474 cmsg->cmsg_level = SOL_SOCKET; 475 cmsg->cmsg_type = SCM_RIGHTS; 476 memcpy(CMSG_DATA(cmsg), fds, fdsize); 477 } 478 479 do { 480 ret = sendmsg(socket_fd, &msg, 0); 481 } while (ret < 0 && errno == EINTR); 482 g_assert_cmpint(ret, >, 0); 483 } 484 485 static GString *qtest_client_socket_recv_line(QTestState *s) 486 { 487 GString *line; 488 size_t offset; 489 char *eol; 490 491 while ((eol = strchr(s->rx->str, '\n')) == NULL) { 492 ssize_t len; 493 char buffer[1024]; 494 495 len = read(s->fd, buffer, sizeof(buffer)); 496 if (len == -1 && errno == EINTR) { 497 continue; 498 } 499 500 if (len == -1 || len == 0) { 501 fprintf(stderr, "Broken pipe\n"); 502 abort(); 503 } 504 505 g_string_append_len(s->rx, buffer, len); 506 } 507 508 offset = eol - s->rx->str; 509 line = g_string_new_len(s->rx->str, offset); 510 g_string_erase(s->rx, 0, offset + 1); 511 512 return line; 513 } 514 515 static gchar **qtest_rsp_args(QTestState *s, int expected_args) 516 { 517 GString *line; 518 gchar **words; 519 int i; 520 521 redo: 522 line = s->ops.recv_line(s); 523 words = g_strsplit(line->str, " ", 0); 524 g_string_free(line, TRUE); 525 526 if (strcmp(words[0], "IRQ") == 0) { 527 long irq; 528 int ret; 529 530 g_assert(words[1] != NULL); 531 g_assert(words[2] != NULL); 532 533 ret = qemu_strtol(words[2], NULL, 0, &irq); 534 g_assert(!ret); 535 g_assert_cmpint(irq, >=, 0); 536 g_assert_cmpint(irq, <, MAX_IRQ); 537 538 if (strcmp(words[1], "raise") == 0) { 539 s->irq_level[irq] = true; 540 } else { 541 s->irq_level[irq] = false; 542 } 543 544 g_strfreev(words); 545 goto redo; 546 } 547 548 g_assert(words[0] != NULL); 549 g_assert_cmpstr(words[0], ==, "OK"); 550 551 for (i = 0; i < expected_args; i++) { 552 g_assert(words[i] != NULL); 553 } 554 555 return words; 556 } 557 558 static void qtest_rsp(QTestState *s) 559 { 560 gchar **words = qtest_rsp_args(s, 0); 561 562 g_strfreev(words); 563 } 564 565 static int qtest_query_target_endianness(QTestState *s) 566 { 567 gchar **args; 568 int big_endian; 569 570 qtest_sendf(s, "endianness\n"); 571 args = qtest_rsp_args(s, 1); 572 g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0); 573 big_endian = strcmp(args[1], "big") == 0; 574 g_strfreev(args); 575 576 return big_endian; 577 } 578 579 typedef struct { 580 JSONMessageParser parser; 581 QDict *response; 582 } QMPResponseParser; 583 584 static void qmp_response(void *opaque, QObject *obj, Error *err) 585 { 586 QMPResponseParser *qmp = opaque; 587 588 assert(!obj != !err); 589 590 if (err) { 591 error_prepend(&err, "QMP JSON response parsing failed: "); 592 error_report_err(err); 593 abort(); 594 } 595 596 g_assert(!qmp->response); 597 qmp->response = qobject_to(QDict, obj); 598 g_assert(qmp->response); 599 } 600 601 QDict *qmp_fd_receive(int fd) 602 { 603 QMPResponseParser qmp; 604 bool log = getenv("QTEST_LOG") != NULL; 605 606 qmp.response = NULL; 607 json_message_parser_init(&qmp.parser, qmp_response, &qmp, NULL); 608 while (!qmp.response) { 609 ssize_t len; 610 char c; 611 612 len = read(fd, &c, 1); 613 if (len == -1 && errno == EINTR) { 614 continue; 615 } 616 617 if (len == -1 || len == 0) { 618 fprintf(stderr, "Broken pipe\n"); 619 abort(); 620 } 621 622 if (log) { 623 len = write(2, &c, 1); 624 } 625 json_message_parser_feed(&qmp.parser, &c, 1); 626 } 627 json_message_parser_destroy(&qmp.parser); 628 629 return qmp.response; 630 } 631 632 QDict *qtest_qmp_receive(QTestState *s) 633 { 634 while (true) { 635 QDict *response = qtest_qmp_receive_dict(s); 636 637 if (!qdict_get_try_str(response, "event")) { 638 return response; 639 } 640 /* Stash the event for a later consumption */ 641 s->pending_events = g_list_append(s->pending_events, response); 642 } 643 } 644 645 QDict *qtest_qmp_receive_dict(QTestState *s) 646 { 647 return qmp_fd_receive(s->qmp_fd); 648 } 649 650 int qtest_socket_server(const char *socket_path) 651 { 652 struct sockaddr_un addr; 653 int sock; 654 int ret; 655 656 sock = socket(PF_UNIX, SOCK_STREAM, 0); 657 g_assert_cmpint(sock, !=, -1); 658 659 addr.sun_family = AF_UNIX; 660 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path); 661 662 do { 663 ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr)); 664 } while (ret == -1 && errno == EINTR); 665 g_assert_cmpint(ret, !=, -1); 666 ret = listen(sock, 1); 667 g_assert_cmpint(ret, !=, -1); 668 669 return sock; 670 } 671 672 /** 673 * Allow users to send a message without waiting for the reply, 674 * in the case that they choose to discard all replies up until 675 * a particular EVENT is received. 676 */ 677 void qmp_fd_vsend_fds(int fd, int *fds, size_t fds_num, 678 const char *fmt, va_list ap) 679 { 680 QObject *qobj; 681 682 /* Going through qobject ensures we escape strings properly */ 683 qobj = qobject_from_vjsonf_nofail(fmt, ap); 684 685 /* No need to send anything for an empty QObject. */ 686 if (qobj) { 687 int log = getenv("QTEST_LOG") != NULL; 688 GString *str = qobject_to_json(qobj); 689 690 /* 691 * BUG: QMP doesn't react to input until it sees a newline, an 692 * object, or an array. Work-around: give it a newline. 693 */ 694 g_string_append_c(str, '\n'); 695 696 if (log) { 697 fprintf(stderr, "%s", str->str); 698 } 699 /* Send QMP request */ 700 if (fds && fds_num > 0) { 701 socket_send_fds(fd, fds, fds_num, str->str, str->len); 702 } else { 703 socket_send(fd, str->str, str->len); 704 } 705 706 g_string_free(str, true); 707 qobject_unref(qobj); 708 } 709 } 710 711 void qmp_fd_vsend(int fd, const char *fmt, va_list ap) 712 { 713 qmp_fd_vsend_fds(fd, NULL, 0, fmt, ap); 714 } 715 716 void qtest_qmp_vsend_fds(QTestState *s, int *fds, size_t fds_num, 717 const char *fmt, va_list ap) 718 { 719 qmp_fd_vsend_fds(s->qmp_fd, fds, fds_num, fmt, ap); 720 } 721 722 void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap) 723 { 724 qmp_fd_vsend_fds(s->qmp_fd, NULL, 0, fmt, ap); 725 } 726 727 QDict *qmp_fdv(int fd, const char *fmt, va_list ap) 728 { 729 qmp_fd_vsend_fds(fd, NULL, 0, fmt, ap); 730 731 return qmp_fd_receive(fd); 732 } 733 734 QDict *qtest_vqmp_fds(QTestState *s, int *fds, size_t fds_num, 735 const char *fmt, va_list ap) 736 { 737 qtest_qmp_vsend_fds(s, fds, fds_num, fmt, ap); 738 739 /* Receive reply */ 740 return qtest_qmp_receive(s); 741 } 742 743 QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap) 744 { 745 qtest_qmp_vsend(s, fmt, ap); 746 747 /* Receive reply */ 748 return qtest_qmp_receive(s); 749 } 750 751 QDict *qmp_fd(int fd, const char *fmt, ...) 752 { 753 va_list ap; 754 QDict *response; 755 756 va_start(ap, fmt); 757 response = qmp_fdv(fd, fmt, ap); 758 va_end(ap); 759 return response; 760 } 761 762 void qmp_fd_send(int fd, const char *fmt, ...) 763 { 764 va_list ap; 765 766 va_start(ap, fmt); 767 qmp_fd_vsend(fd, fmt, ap); 768 va_end(ap); 769 } 770 771 QDict *qtest_qmp_fds(QTestState *s, int *fds, size_t fds_num, 772 const char *fmt, ...) 773 { 774 va_list ap; 775 QDict *response; 776 777 va_start(ap, fmt); 778 response = qtest_vqmp_fds(s, fds, fds_num, fmt, ap); 779 va_end(ap); 780 return response; 781 } 782 783 QDict *qtest_qmp(QTestState *s, const char *fmt, ...) 784 { 785 va_list ap; 786 QDict *response; 787 788 va_start(ap, fmt); 789 response = qtest_vqmp(s, fmt, ap); 790 va_end(ap); 791 return response; 792 } 793 794 void qtest_qmp_send(QTestState *s, const char *fmt, ...) 795 { 796 va_list ap; 797 798 va_start(ap, fmt); 799 qtest_qmp_vsend(s, fmt, ap); 800 va_end(ap); 801 } 802 803 void qmp_fd_vsend_raw(int fd, const char *fmt, va_list ap) 804 { 805 bool log = getenv("QTEST_LOG") != NULL; 806 char *str = g_strdup_vprintf(fmt, ap); 807 808 if (log) { 809 fprintf(stderr, "%s", str); 810 } 811 socket_send(fd, str, strlen(str)); 812 g_free(str); 813 } 814 815 void qmp_fd_send_raw(int fd, const char *fmt, ...) 816 { 817 va_list ap; 818 819 va_start(ap, fmt); 820 qmp_fd_vsend_raw(fd, fmt, ap); 821 va_end(ap); 822 } 823 824 void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...) 825 { 826 va_list ap; 827 828 va_start(ap, fmt); 829 qmp_fd_vsend_raw(s->qmp_fd, fmt, ap); 830 va_end(ap); 831 } 832 833 QDict *qtest_qmp_event_ref(QTestState *s, const char *event) 834 { 835 while (s->pending_events) { 836 837 GList *first = s->pending_events; 838 QDict *response = (QDict *)first->data; 839 840 s->pending_events = g_list_delete_link(s->pending_events, first); 841 842 if (!strcmp(qdict_get_str(response, "event"), event)) { 843 return response; 844 } 845 qobject_unref(response); 846 } 847 return NULL; 848 } 849 850 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event) 851 { 852 QDict *response = qtest_qmp_event_ref(s, event); 853 854 if (response) { 855 return response; 856 } 857 858 for (;;) { 859 response = qtest_qmp_receive_dict(s); 860 if ((qdict_haskey(response, "event")) && 861 (strcmp(qdict_get_str(response, "event"), event) == 0)) { 862 return response; 863 } 864 qobject_unref(response); 865 } 866 } 867 868 void qtest_qmp_eventwait(QTestState *s, const char *event) 869 { 870 QDict *response; 871 872 response = qtest_qmp_eventwait_ref(s, event); 873 qobject_unref(response); 874 } 875 876 char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap) 877 { 878 char *cmd; 879 QDict *resp; 880 char *ret; 881 882 cmd = g_strdup_vprintf(fmt, ap); 883 resp = qtest_qmp(s, "{'execute': 'human-monitor-command'," 884 " 'arguments': {'command-line': %s}}", 885 cmd); 886 ret = g_strdup(qdict_get_try_str(resp, "return")); 887 g_assert(ret); 888 qobject_unref(resp); 889 g_free(cmd); 890 return ret; 891 } 892 893 char *qtest_hmp(QTestState *s, const char *fmt, ...) 894 { 895 va_list ap; 896 char *ret; 897 898 va_start(ap, fmt); 899 ret = qtest_vhmp(s, fmt, ap); 900 va_end(ap); 901 return ret; 902 } 903 904 const char *qtest_get_arch(void) 905 { 906 const char *qemu = qtest_qemu_binary(); 907 const char *end = strrchr(qemu, '-'); 908 909 if (!end) { 910 fprintf(stderr, "Can't determine architecture from binary name.\n"); 911 exit(1); 912 } 913 914 if (!strstr(qemu, "-system-")) { 915 fprintf(stderr, "QTEST_QEMU_BINARY must end with *-system-<arch> " 916 "where 'arch' is the target\narchitecture (x86_64, aarch64, " 917 "etc).\n"); 918 exit(1); 919 } 920 921 return end + 1; 922 } 923 924 bool qtest_has_accel(const char *accel_name) 925 { 926 if (g_str_equal(accel_name, "tcg")) { 927 #if defined(CONFIG_TCG) 928 return true; 929 #else 930 return false; 931 #endif 932 } else if (g_str_equal(accel_name, "kvm")) { 933 int i; 934 const char *arch = qtest_get_arch(); 935 const char *targets[] = { CONFIG_KVM_TARGETS }; 936 937 for (i = 0; i < ARRAY_SIZE(targets); i++) { 938 if (!strncmp(targets[i], arch, strlen(arch))) { 939 if (!access("/dev/kvm", R_OK | W_OK)) { 940 return true; 941 } 942 } 943 } 944 } else { 945 /* not implemented */ 946 g_assert_not_reached(); 947 } 948 return false; 949 } 950 951 bool qtest_get_irq(QTestState *s, int num) 952 { 953 /* dummy operation in order to make sure irq is up to date */ 954 qtest_inb(s, 0); 955 956 return s->irq_level[num]; 957 } 958 959 void qtest_module_load(QTestState *s, const char *prefix, const char *libname) 960 { 961 qtest_sendf(s, "module_load %s %s\n", prefix, libname); 962 qtest_rsp(s); 963 } 964 965 static int64_t qtest_clock_rsp(QTestState *s) 966 { 967 gchar **words; 968 int64_t clock; 969 words = qtest_rsp_args(s, 2); 970 clock = g_ascii_strtoll(words[1], NULL, 0); 971 g_strfreev(words); 972 return clock; 973 } 974 975 int64_t qtest_clock_step_next(QTestState *s) 976 { 977 qtest_sendf(s, "clock_step\n"); 978 return qtest_clock_rsp(s); 979 } 980 981 int64_t qtest_clock_step(QTestState *s, int64_t step) 982 { 983 qtest_sendf(s, "clock_step %"PRIi64"\n", step); 984 return qtest_clock_rsp(s); 985 } 986 987 int64_t qtest_clock_set(QTestState *s, int64_t val) 988 { 989 qtest_sendf(s, "clock_set %"PRIi64"\n", val); 990 return qtest_clock_rsp(s); 991 } 992 993 void qtest_irq_intercept_out(QTestState *s, const char *qom_path) 994 { 995 qtest_sendf(s, "irq_intercept_out %s\n", qom_path); 996 qtest_rsp(s); 997 } 998 999 void qtest_irq_intercept_in(QTestState *s, const char *qom_path) 1000 { 1001 qtest_sendf(s, "irq_intercept_in %s\n", qom_path); 1002 qtest_rsp(s); 1003 } 1004 1005 void qtest_set_irq_in(QTestState *s, const char *qom_path, const char *name, 1006 int num, int level) 1007 { 1008 if (!name) { 1009 name = "unnamed-gpio-in"; 1010 } 1011 qtest_sendf(s, "set_irq_in %s %s %d %d\n", qom_path, name, num, level); 1012 qtest_rsp(s); 1013 } 1014 1015 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value) 1016 { 1017 qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value); 1018 qtest_rsp(s); 1019 } 1020 1021 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value) 1022 { 1023 qtest_out(s, "outb", addr, value); 1024 } 1025 1026 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value) 1027 { 1028 qtest_out(s, "outw", addr, value); 1029 } 1030 1031 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value) 1032 { 1033 qtest_out(s, "outl", addr, value); 1034 } 1035 1036 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr) 1037 { 1038 gchar **args; 1039 int ret; 1040 unsigned long value; 1041 1042 qtest_sendf(s, "%s 0x%x\n", cmd, addr); 1043 args = qtest_rsp_args(s, 2); 1044 ret = qemu_strtoul(args[1], NULL, 0, &value); 1045 g_assert(!ret && value <= UINT32_MAX); 1046 g_strfreev(args); 1047 1048 return value; 1049 } 1050 1051 uint8_t qtest_inb(QTestState *s, uint16_t addr) 1052 { 1053 return qtest_in(s, "inb", addr); 1054 } 1055 1056 uint16_t qtest_inw(QTestState *s, uint16_t addr) 1057 { 1058 return qtest_in(s, "inw", addr); 1059 } 1060 1061 uint32_t qtest_inl(QTestState *s, uint16_t addr) 1062 { 1063 return qtest_in(s, "inl", addr); 1064 } 1065 1066 static void qtest_write(QTestState *s, const char *cmd, uint64_t addr, 1067 uint64_t value) 1068 { 1069 qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value); 1070 qtest_rsp(s); 1071 } 1072 1073 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value) 1074 { 1075 qtest_write(s, "writeb", addr, value); 1076 } 1077 1078 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value) 1079 { 1080 qtest_write(s, "writew", addr, value); 1081 } 1082 1083 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value) 1084 { 1085 qtest_write(s, "writel", addr, value); 1086 } 1087 1088 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value) 1089 { 1090 qtest_write(s, "writeq", addr, value); 1091 } 1092 1093 static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr) 1094 { 1095 gchar **args; 1096 int ret; 1097 uint64_t value; 1098 1099 qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr); 1100 args = qtest_rsp_args(s, 2); 1101 ret = qemu_strtou64(args[1], NULL, 0, &value); 1102 g_assert(!ret); 1103 g_strfreev(args); 1104 1105 return value; 1106 } 1107 1108 uint8_t qtest_readb(QTestState *s, uint64_t addr) 1109 { 1110 return qtest_read(s, "readb", addr); 1111 } 1112 1113 uint16_t qtest_readw(QTestState *s, uint64_t addr) 1114 { 1115 return qtest_read(s, "readw", addr); 1116 } 1117 1118 uint32_t qtest_readl(QTestState *s, uint64_t addr) 1119 { 1120 return qtest_read(s, "readl", addr); 1121 } 1122 1123 uint64_t qtest_readq(QTestState *s, uint64_t addr) 1124 { 1125 return qtest_read(s, "readq", addr); 1126 } 1127 1128 static int hex2nib(char ch) 1129 { 1130 if (ch >= '0' && ch <= '9') { 1131 return ch - '0'; 1132 } else if (ch >= 'a' && ch <= 'f') { 1133 return 10 + (ch - 'a'); 1134 } else if (ch >= 'A' && ch <= 'F') { 1135 return 10 + (ch - 'a'); 1136 } else { 1137 return -1; 1138 } 1139 } 1140 1141 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size) 1142 { 1143 uint8_t *ptr = data; 1144 gchar **args; 1145 size_t i; 1146 1147 if (!size) { 1148 return; 1149 } 1150 1151 qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size); 1152 args = qtest_rsp_args(s, 2); 1153 1154 for (i = 0; i < size; i++) { 1155 ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4; 1156 ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]); 1157 } 1158 1159 g_strfreev(args); 1160 } 1161 1162 uint64_t qtest_rtas_call(QTestState *s, const char *name, 1163 uint32_t nargs, uint64_t args, 1164 uint32_t nret, uint64_t ret) 1165 { 1166 qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n", 1167 name, nargs, args, nret, ret); 1168 qtest_rsp(s); 1169 return 0; 1170 } 1171 1172 void qtest_add_func(const char *str, void (*fn)(void)) 1173 { 1174 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1175 g_test_add_func(path, fn); 1176 g_free(path); 1177 } 1178 1179 void qtest_add_data_func_full(const char *str, void *data, 1180 void (*fn)(const void *), 1181 GDestroyNotify data_free_func) 1182 { 1183 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1184 g_test_add_data_func_full(path, data, fn, data_free_func); 1185 g_free(path); 1186 } 1187 1188 void qtest_add_data_func(const char *str, const void *data, 1189 void (*fn)(const void *)) 1190 { 1191 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1192 g_test_add_data_func(path, data, fn); 1193 g_free(path); 1194 } 1195 1196 void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size) 1197 { 1198 gchar *bdata; 1199 1200 bdata = g_base64_encode(data, size); 1201 qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size); 1202 s->ops.send(s, bdata); 1203 s->ops.send(s, "\n"); 1204 qtest_rsp(s); 1205 g_free(bdata); 1206 } 1207 1208 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size) 1209 { 1210 gchar **args; 1211 size_t len; 1212 1213 qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size); 1214 args = qtest_rsp_args(s, 2); 1215 1216 g_base64_decode_inplace(args[1], &len); 1217 if (size != len) { 1218 fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n", 1219 size, len); 1220 len = MIN(len, size); 1221 } 1222 1223 memcpy(data, args[1], len); 1224 g_strfreev(args); 1225 } 1226 1227 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size) 1228 { 1229 const uint8_t *ptr = data; 1230 size_t i; 1231 char *enc; 1232 1233 if (!size) { 1234 return; 1235 } 1236 1237 enc = g_malloc(2 * size + 1); 1238 1239 for (i = 0; i < size; i++) { 1240 sprintf(&enc[i * 2], "%02x", ptr[i]); 1241 } 1242 1243 qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc); 1244 qtest_rsp(s); 1245 g_free(enc); 1246 } 1247 1248 void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size) 1249 { 1250 qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern); 1251 qtest_rsp(s); 1252 } 1253 1254 void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...) 1255 { 1256 va_list ap; 1257 QDict *response; 1258 1259 va_start(ap, fmt); 1260 response = qtest_vqmp(qts, fmt, ap); 1261 va_end(ap); 1262 1263 g_assert(response); 1264 if (!qdict_haskey(response, "return")) { 1265 GString *s = qobject_to_json_pretty(QOBJECT(response), true); 1266 g_test_message("%s", s->str); 1267 g_string_free(s, true); 1268 } 1269 g_assert(qdict_haskey(response, "return")); 1270 qobject_unref(response); 1271 } 1272 1273 bool qtest_big_endian(QTestState *s) 1274 { 1275 return s->big_endian; 1276 } 1277 1278 static bool qtest_check_machine_version(const char *mname, const char *basename, 1279 int major, int minor) 1280 { 1281 char *newname; 1282 bool is_equal; 1283 1284 newname = g_strdup_printf("%s-%i.%i", basename, major, minor); 1285 is_equal = g_str_equal(mname, newname); 1286 g_free(newname); 1287 1288 return is_equal; 1289 } 1290 1291 static bool qtest_is_old_versioned_machine(const char *mname) 1292 { 1293 const char *dash = strrchr(mname, '-'); 1294 const char *dot = strrchr(mname, '.'); 1295 const char *chr; 1296 char *bname; 1297 const int major = QEMU_VERSION_MAJOR; 1298 const int minor = QEMU_VERSION_MINOR; 1299 bool res = false; 1300 1301 if (dash && dot && dot > dash) { 1302 for (chr = dash + 1; *chr; chr++) { 1303 if (!qemu_isdigit(*chr) && *chr != '.') { 1304 return false; 1305 } 1306 } 1307 /* 1308 * Now check if it is one of the latest versions. Check major + 1 1309 * and minor + 1 versions as well, since they might already exist 1310 * in the development branch. 1311 */ 1312 bname = g_strdup(mname); 1313 bname[dash - mname] = 0; 1314 res = !qtest_check_machine_version(mname, bname, major + 1, 0) && 1315 !qtest_check_machine_version(mname, bname, major, minor + 1) && 1316 !qtest_check_machine_version(mname, bname, major, minor); 1317 g_free(bname); 1318 } 1319 1320 return res; 1321 } 1322 1323 struct MachInfo { 1324 char *name; 1325 char *alias; 1326 }; 1327 1328 /* 1329 * Returns an array with pointers to the available machine names. 1330 * The terminating entry has the name set to NULL. 1331 */ 1332 static struct MachInfo *qtest_get_machines(void) 1333 { 1334 static struct MachInfo *machines; 1335 QDict *response, *minfo; 1336 QList *list; 1337 const QListEntry *p; 1338 QObject *qobj; 1339 QString *qstr; 1340 QTestState *qts; 1341 int idx; 1342 1343 if (machines) { 1344 return machines; 1345 } 1346 1347 qts = qtest_init("-machine none"); 1348 response = qtest_qmp(qts, "{ 'execute': 'query-machines' }"); 1349 g_assert(response); 1350 list = qdict_get_qlist(response, "return"); 1351 g_assert(list); 1352 1353 machines = g_new(struct MachInfo, qlist_size(list) + 1); 1354 1355 for (p = qlist_first(list), idx = 0; p; p = qlist_next(p), idx++) { 1356 minfo = qobject_to(QDict, qlist_entry_obj(p)); 1357 g_assert(minfo); 1358 1359 qobj = qdict_get(minfo, "name"); 1360 g_assert(qobj); 1361 qstr = qobject_to(QString, qobj); 1362 g_assert(qstr); 1363 machines[idx].name = g_strdup(qstring_get_str(qstr)); 1364 1365 qobj = qdict_get(minfo, "alias"); 1366 if (qobj) { /* The alias is optional */ 1367 qstr = qobject_to(QString, qobj); 1368 g_assert(qstr); 1369 machines[idx].alias = g_strdup(qstring_get_str(qstr)); 1370 } else { 1371 machines[idx].alias = NULL; 1372 } 1373 } 1374 1375 qtest_quit(qts); 1376 qobject_unref(response); 1377 1378 memset(&machines[idx], 0, sizeof(struct MachInfo)); /* Terminating entry */ 1379 return machines; 1380 } 1381 1382 void qtest_cb_for_every_machine(void (*cb)(const char *machine), 1383 bool skip_old_versioned) 1384 { 1385 struct MachInfo *machines; 1386 int i; 1387 1388 machines = qtest_get_machines(); 1389 1390 for (i = 0; machines[i].name != NULL; i++) { 1391 /* Ignore machines that cannot be used for qtests */ 1392 if (!strncmp("xenfv", machines[i].name, 5) || 1393 g_str_equal("xenpv", machines[i].name)) { 1394 continue; 1395 } 1396 if (!skip_old_versioned || 1397 !qtest_is_old_versioned_machine(machines[i].name)) { 1398 cb(machines[i].name); 1399 } 1400 } 1401 } 1402 1403 bool qtest_has_machine(const char *machine) 1404 { 1405 struct MachInfo *machines; 1406 int i; 1407 1408 machines = qtest_get_machines(); 1409 1410 for (i = 0; machines[i].name != NULL; i++) { 1411 if (g_str_equal(machine, machines[i].name) || 1412 (machines[i].alias && g_str_equal(machine, machines[i].alias))) { 1413 return true; 1414 } 1415 } 1416 1417 return false; 1418 } 1419 1420 bool qtest_has_device(const char *device) 1421 { 1422 static QList *list; 1423 const QListEntry *p; 1424 QObject *qobj; 1425 QString *qstr; 1426 QDict *devinfo; 1427 int idx; 1428 1429 if (!list) { 1430 QDict *resp; 1431 QDict *args; 1432 QTestState *qts = qtest_init("-machine none"); 1433 1434 args = qdict_new(); 1435 qdict_put_bool(args, "abstract", false); 1436 qdict_put_str(args, "implements", "device"); 1437 1438 resp = qtest_qmp(qts, "{'execute': 'qom-list-types', 'arguments': %p }", 1439 args); 1440 g_assert(qdict_haskey(resp, "return")); 1441 list = qdict_get_qlist(resp, "return"); 1442 qobject_ref(list); 1443 qobject_unref(resp); 1444 1445 qtest_quit(qts); 1446 } 1447 1448 for (p = qlist_first(list), idx = 0; p; p = qlist_next(p), idx++) { 1449 devinfo = qobject_to(QDict, qlist_entry_obj(p)); 1450 g_assert(devinfo); 1451 1452 qobj = qdict_get(devinfo, "name"); 1453 g_assert(qobj); 1454 qstr = qobject_to(QString, qobj); 1455 g_assert(qstr); 1456 if (g_str_equal(qstring_get_str(qstr), device)) { 1457 return true; 1458 } 1459 } 1460 1461 return false; 1462 } 1463 1464 /* 1465 * Generic hot-plugging test via the device_add QMP commands. 1466 */ 1467 void qtest_qmp_device_add_qdict(QTestState *qts, const char *drv, 1468 const QDict *arguments) 1469 { 1470 QDict *resp; 1471 QDict *args = arguments ? qdict_clone_shallow(arguments) : qdict_new(); 1472 1473 g_assert(!qdict_haskey(args, "driver")); 1474 qdict_put_str(args, "driver", drv); 1475 resp = qtest_qmp(qts, "{'execute': 'device_add', 'arguments': %p}", args); 1476 g_assert(resp); 1477 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1478 g_assert(!qdict_haskey(resp, "error")); 1479 qobject_unref(resp); 1480 } 1481 1482 void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id, 1483 const char *fmt, ...) 1484 { 1485 QDict *args; 1486 va_list ap; 1487 1488 va_start(ap, fmt); 1489 args = qdict_from_vjsonf_nofail(fmt, ap); 1490 va_end(ap); 1491 1492 g_assert(!qdict_haskey(args, "id")); 1493 qdict_put_str(args, "id", id); 1494 1495 qtest_qmp_device_add_qdict(qts, driver, args); 1496 qobject_unref(args); 1497 } 1498 1499 void qtest_qmp_add_client(QTestState *qts, const char *protocol, int fd) 1500 { 1501 QDict *resp; 1502 1503 resp = qtest_qmp_fds(qts, &fd, 1, "{'execute': 'getfd'," 1504 "'arguments': {'fdname': 'fdname'}}"); 1505 g_assert(resp); 1506 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1507 g_assert(!qdict_haskey(resp, "error")); 1508 qobject_unref(resp); 1509 1510 resp = qtest_qmp( 1511 qts, "{'execute': 'add_client'," 1512 "'arguments': {'protocol': %s, 'fdname': 'fdname'}}", protocol); 1513 g_assert(resp); 1514 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1515 g_assert(!qdict_haskey(resp, "error")); 1516 qobject_unref(resp); 1517 } 1518 1519 /* 1520 * Generic hot-unplugging test via the device_del QMP command. 1521 * Device deletion will get one response and one event. For example: 1522 * 1523 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}} 1524 * 1525 * will get this one: 1526 * 1527 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862}, 1528 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd", 1529 * "path": "/machine/peripheral/scsi-hd"}} 1530 * 1531 * and this one: 1532 * 1533 * {"return": {}} 1534 */ 1535 void qtest_qmp_device_del(QTestState *qts, const char *id) 1536 { 1537 QDict *rsp; 1538 1539 rsp = qtest_qmp(qts, "{'execute': 'device_del', 'arguments': {'id': %s}}", 1540 id); 1541 1542 g_assert(qdict_haskey(rsp, "return")); 1543 qobject_unref(rsp); 1544 qtest_qmp_eventwait(qts, "DEVICE_DELETED"); 1545 } 1546 1547 bool qmp_rsp_is_err(QDict *rsp) 1548 { 1549 QDict *error = qdict_get_qdict(rsp, "error"); 1550 qobject_unref(rsp); 1551 return !!error; 1552 } 1553 1554 void qmp_expect_error_and_unref(QDict *rsp, const char *class) 1555 { 1556 QDict *error = qdict_get_qdict(rsp, "error"); 1557 1558 g_assert_cmpstr(qdict_get_try_str(error, "class"), ==, class); 1559 g_assert_nonnull(qdict_get_try_str(error, "desc")); 1560 g_assert(!qdict_haskey(rsp, "return")); 1561 1562 qobject_unref(rsp); 1563 } 1564 1565 static void qtest_client_set_tx_handler(QTestState *s, 1566 QTestSendFn send) 1567 { 1568 s->ops.send = send; 1569 } 1570 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv) 1571 { 1572 s->ops.recv_line = recv; 1573 } 1574 /* A type-safe wrapper for s->send() */ 1575 static void send_wrapper(QTestState *s, const char *buf) 1576 { 1577 s->ops.external_send(s, buf); 1578 } 1579 1580 static GString *qtest_client_inproc_recv_line(QTestState *s) 1581 { 1582 GString *line; 1583 size_t offset; 1584 char *eol; 1585 1586 eol = strchr(s->rx->str, '\n'); 1587 offset = eol - s->rx->str; 1588 line = g_string_new_len(s->rx->str, offset); 1589 g_string_erase(s->rx, 0, offset + 1); 1590 return line; 1591 } 1592 1593 QTestState *qtest_inproc_init(QTestState **s, bool log, const char* arch, 1594 void (*send)(void*, const char*)) 1595 { 1596 QTestState *qts; 1597 qts = g_new0(QTestState, 1); 1598 qts->pending_events = NULL; 1599 *s = qts; /* Expose qts early on, since the query endianness relies on it */ 1600 qts->wstatus = 0; 1601 for (int i = 0; i < MAX_IRQ; i++) { 1602 qts->irq_level[i] = false; 1603 } 1604 1605 qtest_client_set_rx_handler(qts, qtest_client_inproc_recv_line); 1606 1607 /* send() may not have a matching protoype, so use a type-safe wrapper */ 1608 qts->ops.external_send = send; 1609 qtest_client_set_tx_handler(qts, send_wrapper); 1610 1611 qts->big_endian = qtest_query_target_endianness(qts); 1612 1613 /* 1614 * Set a dummy path for QTEST_QEMU_BINARY. Doesn't need to exist, but this 1615 * way, qtest_get_arch works for inproc qtest. 1616 */ 1617 gchar *bin_path = g_strconcat("/qemu-system-", arch, NULL); 1618 setenv("QTEST_QEMU_BINARY", bin_path, 0); 1619 g_free(bin_path); 1620 1621 return qts; 1622 } 1623 1624 void qtest_client_inproc_recv(void *opaque, const char *str) 1625 { 1626 QTestState *qts = *(QTestState **)opaque; 1627 1628 if (!qts->rx) { 1629 qts->rx = g_string_new(NULL); 1630 } 1631 g_string_append(qts->rx, str); 1632 return; 1633 } 1634