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