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 #ifndef _WIN32 20 #include <sys/socket.h> 21 #include <sys/wait.h> 22 #include <sys/un.h> 23 #endif /* _WIN32 */ 24 #ifdef __linux__ 25 #include <sys/prctl.h> 26 #endif /* __linux__ */ 27 #ifdef __FreeBSD__ 28 #include <sys/procctl.h> 29 #endif /* __FreeBSD__ */ 30 31 #include "libqtest.h" 32 #include "libqmp.h" 33 #include "qemu/accel.h" 34 #include "qemu/ctype.h" 35 #include "qemu/cutils.h" 36 #include "qemu/sockets.h" 37 #include "qobject/qdict.h" 38 #include "qobject/qjson.h" 39 #include "qobject/qlist.h" 40 #include "qobject/qstring.h" 41 #include "qobject/qbool.h" 42 43 #define MAX_IRQ 256 44 45 #ifndef _WIN32 46 # define SOCKET_TIMEOUT 50 47 # define CMD_EXEC "exec " 48 # define DEV_STDERR "/dev/fd/2" 49 # define DEV_NULL "/dev/null" 50 #else 51 # define SOCKET_TIMEOUT 50000 52 # define CMD_EXEC "" 53 # define DEV_STDERR "2" 54 # define DEV_NULL "nul" 55 #endif 56 57 #define WAITPID_TIMEOUT 30 58 59 typedef void (*QTestSendFn)(QTestState *s, const char *buf); 60 typedef void (*ExternalSendFn)(void *s, const char *buf); 61 typedef GString* (*QTestRecvFn)(QTestState *); 62 63 typedef struct QTestClientTransportOps { 64 QTestSendFn send; /* for sending qtest commands */ 65 66 /* 67 * use external_send to send qtest command strings through functions which 68 * do not accept a QTestState as the first parameter. 69 */ 70 ExternalSendFn external_send; 71 72 QTestRecvFn recv_line; /* for receiving qtest command responses */ 73 } QTestTransportOps; 74 75 struct QTestState 76 { 77 int fd; 78 int qmp_fd; 79 int sock; 80 int qmpsock; 81 pid_t qemu_pid; /* our child QEMU process */ 82 int wstatus; 83 #ifdef _WIN32 84 DWORD exit_code; 85 #endif 86 int expected_status; 87 bool big_endian; 88 bool irq_level[MAX_IRQ]; 89 GString *rx; 90 QTestTransportOps ops; 91 GList *pending_events; 92 QTestQMPEventCallback eventCB; 93 void *eventData; 94 }; 95 96 static GHookList abrt_hooks; 97 static void (*sighandler_old)(int); 98 static bool silence_spawn_log; 99 100 static int qtest_query_target_endianness(QTestState *s); 101 102 static void qtest_client_socket_send(QTestState*, const char *buf); 103 static void socket_send(int fd, const char *buf, size_t size); 104 105 static GString *qtest_client_socket_recv_line(QTestState *); 106 107 static void qtest_client_set_tx_handler(QTestState *s, QTestSendFn send); 108 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv); 109 110 static int init_socket(const char *socket_path) 111 { 112 int sock = qtest_socket_server(socket_path); 113 qemu_set_cloexec(sock); 114 return sock; 115 } 116 117 static int socket_accept(int sock) 118 { 119 struct sockaddr_un addr; 120 socklen_t addrlen; 121 int ret; 122 /* 123 * timeout unit of blocking receive calls is different among platforms. 124 * It's in seconds on non-Windows platforms but milliseconds on Windows. 125 */ 126 #ifndef _WIN32 127 struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT, 128 .tv_usec = 0 }; 129 #else 130 DWORD timeout = SOCKET_TIMEOUT; 131 #endif 132 133 if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, 134 (void *)&timeout, sizeof(timeout))) { 135 fprintf(stderr, "%s failed to set SO_RCVTIMEO: %s\n", 136 __func__, strerror(errno)); 137 close(sock); 138 return -1; 139 } 140 141 do { 142 addrlen = sizeof(addr); 143 ret = accept(sock, (struct sockaddr *)&addr, &addrlen); 144 } while (ret == -1 && errno == EINTR); 145 if (ret == -1) { 146 fprintf(stderr, "%s failed: %s\n", __func__, strerror(errno)); 147 } 148 close(sock); 149 150 return ret; 151 } 152 153 pid_t qtest_pid(QTestState *s) 154 { 155 return s->qemu_pid; 156 } 157 158 bool qtest_probe_child(QTestState *s) 159 { 160 pid_t pid = s->qemu_pid; 161 162 if (pid != -1) { 163 #ifndef _WIN32 164 pid = waitpid(pid, &s->wstatus, WNOHANG); 165 if (pid == 0) { 166 return true; 167 } 168 #else 169 GetExitCodeProcess((HANDLE)pid, &s->exit_code); 170 if (s->exit_code == STILL_ACTIVE) { 171 return true; 172 } 173 CloseHandle((HANDLE)pid); 174 #endif 175 s->qemu_pid = -1; 176 qtest_remove_abrt_handler(s); 177 } 178 return false; 179 } 180 181 void qtest_set_expected_status(QTestState *s, int status) 182 { 183 s->expected_status = status; 184 } 185 186 static void qtest_check_status(QTestState *s) 187 { 188 assert(s->qemu_pid == -1); 189 190 /* 191 * Check whether qemu exited with expected exit status; anything else is 192 * fishy and should be logged with as much detail as possible. 193 */ 194 #ifndef _WIN32 195 int wstatus = s->wstatus; 196 if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) != s->expected_status) { 197 fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU " 198 "process but encountered exit status %d (expected %d)\n", 199 __FILE__, __LINE__, WEXITSTATUS(wstatus), s->expected_status); 200 abort(); 201 } else if (WIFSIGNALED(wstatus)) { 202 int sig = WTERMSIG(wstatus); 203 const char *signame = strsignal(sig) ?: "unknown ???"; 204 const char *dump = WCOREDUMP(wstatus) ? " (core dumped)" : ""; 205 206 fprintf(stderr, "%s:%d: kill_qemu() detected QEMU death " 207 "from signal %d (%s)%s\n", 208 __FILE__, __LINE__, sig, signame, dump); 209 abort(); 210 } 211 #else 212 if (s->exit_code != s->expected_status) { 213 fprintf(stderr, "%s:%d: kill_qemu() tried to terminate QEMU " 214 "process but encountered exit status %ld (expected %d)\n", 215 __FILE__, __LINE__, s->exit_code, s->expected_status); 216 abort(); 217 } 218 #endif 219 } 220 221 void qtest_system_reset_nowait(QTestState *s) 222 { 223 /* Request the system reset, but do not wait for it to complete */ 224 qtest_qmp_assert_success(s, "{'execute': 'system_reset' }"); 225 } 226 227 void qtest_system_reset(QTestState *s) 228 { 229 qtest_system_reset_nowait(s); 230 /* 231 * Wait for the RESET event, which is sent once the system reset 232 * has actually completed. 233 */ 234 qtest_qmp_eventwait(s, "RESET"); 235 } 236 237 void qtest_wait_qemu(QTestState *s) 238 { 239 if (s->qemu_pid != -1) { 240 #ifndef _WIN32 241 pid_t pid; 242 uint64_t end; 243 244 /* poll for a while until sending SIGKILL */ 245 end = g_get_monotonic_time() + WAITPID_TIMEOUT * G_TIME_SPAN_SECOND; 246 247 do { 248 pid = waitpid(s->qemu_pid, &s->wstatus, WNOHANG); 249 if (pid != 0) { 250 break; 251 } 252 g_usleep(100 * 1000); 253 } while (g_get_monotonic_time() < end); 254 255 if (pid == 0) { 256 kill(s->qemu_pid, SIGKILL); 257 pid = RETRY_ON_EINTR(waitpid(s->qemu_pid, &s->wstatus, 0)); 258 } 259 260 assert(pid == s->qemu_pid); 261 #else 262 DWORD ret; 263 264 ret = WaitForSingleObject((HANDLE)s->qemu_pid, INFINITE); 265 assert(ret == WAIT_OBJECT_0); 266 GetExitCodeProcess((HANDLE)s->qemu_pid, &s->exit_code); 267 CloseHandle((HANDLE)s->qemu_pid); 268 #endif 269 270 s->qemu_pid = -1; 271 qtest_remove_abrt_handler(s); 272 } 273 qtest_check_status(s); 274 } 275 276 void qtest_kill_qemu(QTestState *s) 277 { 278 /* Skip wait if qtest_probe_child() already reaped */ 279 if (s->qemu_pid != -1) { 280 #ifndef _WIN32 281 kill(s->qemu_pid, SIGTERM); 282 #else 283 TerminateProcess((HANDLE)s->qemu_pid, s->expected_status); 284 #endif 285 qtest_wait_qemu(s); 286 return; 287 } 288 289 qtest_check_status(s); 290 } 291 292 static void kill_qemu_hook_func(void *s) 293 { 294 qtest_kill_qemu(s); 295 } 296 297 static void sigabrt_handler(int signo) 298 { 299 g_hook_list_invoke(&abrt_hooks, FALSE); 300 } 301 302 static void setup_sigabrt_handler(void) 303 { 304 sighandler_old = signal(SIGABRT, sigabrt_handler); 305 } 306 307 static void cleanup_sigabrt_handler(void) 308 { 309 signal(SIGABRT, sighandler_old); 310 } 311 312 static bool hook_list_is_empty(GHookList *hook_list) 313 { 314 GHook *hook = g_hook_first_valid(hook_list, TRUE); 315 316 if (!hook) { 317 return true; 318 } 319 320 g_hook_unref(hook_list, hook); 321 return false; 322 } 323 324 void qtest_add_abrt_handler(GHookFunc fn, const void *data) 325 { 326 GHook *hook; 327 328 if (!abrt_hooks.is_setup) { 329 g_hook_list_init(&abrt_hooks, sizeof(GHook)); 330 } 331 332 /* Only install SIGABRT handler once */ 333 if (hook_list_is_empty(&abrt_hooks)) { 334 setup_sigabrt_handler(); 335 } 336 337 hook = g_hook_alloc(&abrt_hooks); 338 hook->func = fn; 339 hook->data = (void *)data; 340 341 g_hook_prepend(&abrt_hooks, hook); 342 } 343 344 void qtest_remove_abrt_handler(void *data) 345 { 346 GHook *hook = g_hook_find_data(&abrt_hooks, TRUE, data); 347 348 if (!hook) { 349 return; 350 } 351 352 g_hook_destroy_link(&abrt_hooks, hook); 353 354 /* Uninstall SIGABRT handler on last instance */ 355 if (hook_list_is_empty(&abrt_hooks)) { 356 cleanup_sigabrt_handler(); 357 } 358 } 359 360 static const char *qtest_qemu_binary(const char *var) 361 { 362 const char *qemu_bin; 363 364 if (var) { 365 qemu_bin = getenv(var); 366 if (qemu_bin) { 367 return qemu_bin; 368 } 369 } 370 371 qemu_bin = getenv("QTEST_QEMU_BINARY"); 372 if (!qemu_bin) { 373 fprintf(stderr, "Environment variable QTEST_QEMU_BINARY required\n"); 374 exit(1); 375 } 376 377 return qemu_bin; 378 } 379 380 #ifdef _WIN32 381 static pid_t qtest_create_process(char *cmd) 382 { 383 STARTUPINFO si; 384 PROCESS_INFORMATION pi; 385 BOOL ret; 386 387 ZeroMemory(&si, sizeof(si)); 388 si.cb = sizeof(si); 389 ZeroMemory(&pi, sizeof(pi)); 390 391 ret = CreateProcess(NULL, /* module name */ 392 cmd, /* command line */ 393 NULL, /* process handle not inheritable */ 394 NULL, /* thread handle not inheritable */ 395 FALSE, /* set handle inheritance to FALSE */ 396 0, /* No creation flags */ 397 NULL, /* use parent's environment block */ 398 NULL, /* use parent's starting directory */ 399 &si, /* pointer to STARTUPINFO structure */ 400 &pi /* pointer to PROCESS_INFORMATION structure */ 401 ); 402 if (ret == 0) { 403 fprintf(stderr, "%s:%d: unable to create a new process (%s)\n", 404 __FILE__, __LINE__, strerror(GetLastError())); 405 abort(); 406 } 407 408 return (pid_t)pi.hProcess; 409 } 410 #endif /* _WIN32 */ 411 412 static QTestState *G_GNUC_PRINTF(2, 3) qtest_spawn_qemu(const char *qemu_bin, 413 const char *fmt, ...) 414 { 415 va_list ap; 416 QTestState *s = g_new0(QTestState, 1); 417 const char *trace = g_getenv("QTEST_TRACE"); 418 g_autofree char *tracearg = trace ? 419 g_strdup_printf("-trace %s ", trace) : g_strdup(""); 420 g_autoptr(GString) command = g_string_new(""); 421 422 va_start(ap, fmt); 423 g_string_append_printf(command, CMD_EXEC "%s %s", qemu_bin, tracearg); 424 g_string_append_vprintf(command, fmt, ap); 425 va_end(ap); 426 427 qtest_add_abrt_handler(kill_qemu_hook_func, s); 428 429 if (!silence_spawn_log) { 430 g_test_message("starting QEMU: %s", command->str); 431 } 432 433 #ifndef _WIN32 434 s->qemu_pid = fork(); 435 if (s->qemu_pid == 0) { 436 #ifdef __linux__ 437 /* 438 * Although we register a ABRT handler to kill off QEMU 439 * when g_assert() triggers, we want an extra safety 440 * net. The QEMU process might be non-functional and 441 * thus not have responded to SIGTERM. The test script 442 * might also have crashed with SEGV, in which case the 443 * cleanup handlers won't ever run. 444 * 445 * This PR_SET_PDEATHSIG setup will ensure any remaining 446 * QEMU will get terminated with SIGKILL in these cases. 447 */ 448 prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0); 449 #endif /* __linux__ */ 450 #ifdef __FreeBSD__ 451 int sig = SIGKILL; 452 procctl(P_PID, getpid(), PROC_PDEATHSIG_CTL, &sig); 453 #endif /* __FreeBSD__ */ 454 execlp("/bin/sh", "sh", "-c", command->str, NULL); 455 exit(1); 456 } 457 #else 458 s->qemu_pid = qtest_create_process(command->str); 459 #endif /* _WIN32 */ 460 461 return s; 462 } 463 464 static char *qtest_socket_path(const char *suffix) 465 { 466 return g_strdup_printf("%s/qtest-%d.%s", g_get_tmp_dir(), getpid(), suffix); 467 } 468 469 static QTestState *qtest_init_internal(const char *qemu_bin, 470 const char *extra_args, 471 bool do_connect) 472 { 473 QTestState *s; 474 int sock, qmpsock, i; 475 g_autofree gchar *socket_path = qtest_socket_path("sock"); 476 g_autofree gchar *qmp_socket_path = qtest_socket_path("qmp"); 477 478 /* 479 * It's possible that if an earlier test run crashed it might 480 * have left a stale unix socket lying around. Delete any 481 * stale old socket to avoid spurious test failures with 482 * tests/libqtest.c:70:init_socket: assertion failed (ret != -1): (-1 != -1) 483 */ 484 unlink(socket_path); 485 unlink(qmp_socket_path); 486 487 socket_init(); 488 sock = init_socket(socket_path); 489 qmpsock = init_socket(qmp_socket_path); 490 491 s = qtest_spawn_qemu(qemu_bin, 492 "-qtest unix:%s " 493 "-qtest-log %s " 494 "-chardev socket,path=%s,id=char0 " 495 "-mon chardev=char0,mode=control " 496 "-display none " 497 "-audio none " 498 "%s" 499 " -accel qtest", 500 socket_path, 501 getenv("QTEST_LOG") ? DEV_STDERR : DEV_NULL, 502 qmp_socket_path, 503 extra_args ?: ""); 504 505 qtest_client_set_rx_handler(s, qtest_client_socket_recv_line); 506 qtest_client_set_tx_handler(s, qtest_client_socket_send); 507 508 s->rx = g_string_new(""); 509 for (i = 0; i < MAX_IRQ; i++) { 510 s->irq_level[i] = false; 511 } 512 513 s->fd = -1; 514 s->qmp_fd = -1; 515 s->sock = sock; 516 s->qmpsock = qmpsock; 517 if (do_connect) { 518 qtest_connect(s); 519 } 520 521 /* 522 * Stopping QEMU for debugging is not supported on Windows. 523 * 524 * Using DebugActiveProcess() API can suspend the QEMU process, 525 * but gdb cannot attach to the process. Using the undocumented 526 * NtSuspendProcess() can suspend the QEMU process and gdb can 527 * attach to the process, but gdb cannot resume it. 528 */ 529 #ifndef _WIN32 530 if (getenv("QTEST_STOP")) { 531 kill(s->qemu_pid, SIGSTOP); 532 } 533 #endif 534 535 return s; 536 } 537 538 void qtest_connect(QTestState *s) 539 { 540 g_autofree gchar *socket_path = qtest_socket_path("sock"); 541 g_autofree gchar *qmp_socket_path = qtest_socket_path("qmp"); 542 543 g_assert(s->sock >= 0 && s->qmpsock >= 0); 544 s->fd = socket_accept(s->sock); 545 if (s->fd >= 0) { 546 s->qmp_fd = socket_accept(s->qmpsock); 547 } 548 unlink(socket_path); 549 unlink(qmp_socket_path); 550 g_assert(s->fd >= 0 && s->qmp_fd >= 0); 551 s->sock = s->qmpsock = -1; 552 /* ask endianness of the target */ 553 s->big_endian = qtest_query_target_endianness(s); 554 } 555 556 QTestState *qtest_init_without_qmp_handshake(const char *extra_args) 557 { 558 return qtest_init_internal(qtest_qemu_binary(NULL), extra_args, true); 559 } 560 561 void qtest_qmp_handshake(QTestState *s, QList *capabilities) 562 { 563 /* Read the QMP greeting and then do the handshake */ 564 QDict *greeting = qtest_qmp_receive(s); 565 qobject_unref(greeting); 566 567 if (capabilities) { 568 qtest_qmp_assert_success(s, 569 "{ 'execute': 'qmp_capabilities', " 570 "'arguments': { 'enable': %p } }", 571 qobject_ref(capabilities)); 572 } else { 573 qtest_qmp_assert_success(s, "{ 'execute': 'qmp_capabilities' }"); 574 } 575 } 576 577 QTestState *qtest_init_with_env_and_capabilities(const char *var, 578 const char *extra_args, 579 QList *capabilities, 580 bool do_connect) 581 { 582 QTestState *s = qtest_init_internal(qtest_qemu_binary(var), extra_args, 583 do_connect); 584 585 if (do_connect) { 586 qtest_qmp_handshake(s, capabilities); 587 } else { 588 /* 589 * If the connection is delayed, the capabilities must be set 590 * at that moment. 591 */ 592 assert(!capabilities); 593 } 594 return s; 595 } 596 597 QTestState *qtest_init_with_env(const char *var, const char *extra_args, 598 bool do_connect) 599 { 600 return qtest_init_with_env_and_capabilities(var, extra_args, NULL, true); 601 } 602 603 QTestState *qtest_init(const char *extra_args) 604 { 605 return qtest_init_with_env(NULL, extra_args, true); 606 } 607 608 QTestState *qtest_vinitf(const char *fmt, va_list ap) 609 { 610 char *args = g_strdup_vprintf(fmt, ap); 611 QTestState *s; 612 613 s = qtest_init(args); 614 g_free(args); 615 return s; 616 } 617 618 QTestState *qtest_initf(const char *fmt, ...) 619 { 620 va_list ap; 621 QTestState *s; 622 623 va_start(ap, fmt); 624 s = qtest_vinitf(fmt, ap); 625 va_end(ap); 626 return s; 627 } 628 629 QTestState *qtest_init_with_serial(const char *extra_args, int *sock_fd) 630 { 631 int sock_fd_init; 632 g_autofree char *sock_dir = NULL; 633 char *sock_path; 634 QTestState *qts; 635 636 sock_dir = g_dir_make_tmp("qtest-serial-XXXXXX", NULL); 637 g_assert_true(sock_dir != NULL); 638 sock_path = g_strdup_printf("%s/sock", sock_dir); 639 640 socket_init(); 641 sock_fd_init = init_socket(sock_path); 642 643 qts = qtest_initf("-chardev socket,id=s0,path=%s -serial chardev:s0 %s", 644 sock_path, extra_args); 645 646 *sock_fd = socket_accept(sock_fd_init); 647 648 unlink(sock_path); 649 g_free(sock_path); 650 rmdir(sock_dir); 651 652 g_assert_true(*sock_fd >= 0); 653 654 return qts; 655 } 656 657 void qtest_quit(QTestState *s) 658 { 659 qtest_remove_abrt_handler(s); 660 661 qtest_kill_qemu(s); 662 close(s->fd); 663 close(s->qmp_fd); 664 g_string_free(s->rx, true); 665 666 for (GList *it = s->pending_events; it != NULL; it = it->next) { 667 qobject_unref((QDict *)it->data); 668 } 669 670 g_list_free(s->pending_events); 671 672 g_free(s); 673 } 674 675 static void socket_send(int fd, const char *buf, size_t size) 676 { 677 ssize_t res = qemu_send_full(fd, buf, size); 678 679 assert(res == size); 680 } 681 682 static void qtest_client_socket_send(QTestState *s, const char *buf) 683 { 684 socket_send(s->fd, buf, strlen(buf)); 685 } 686 687 static void G_GNUC_PRINTF(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...) 688 { 689 va_list ap; 690 691 va_start(ap, fmt); 692 gchar *str = g_strdup_vprintf(fmt, ap); 693 va_end(ap); 694 695 s->ops.send(s, str); 696 g_free(str); 697 } 698 699 static GString *qtest_client_socket_recv_line(QTestState *s) 700 { 701 GString *line; 702 size_t offset; 703 char *eol; 704 705 while ((eol = strchr(s->rx->str, '\n')) == NULL) { 706 ssize_t len; 707 char buffer[1024]; 708 709 len = recv(s->fd, buffer, sizeof(buffer), 0); 710 if (len == -1 && errno == EINTR) { 711 continue; 712 } 713 714 if (len == -1 || len == 0) { 715 fprintf(stderr, "Broken pipe\n"); 716 abort(); 717 } 718 719 g_string_append_len(s->rx, buffer, len); 720 } 721 722 offset = eol - s->rx->str; 723 line = g_string_new_len(s->rx->str, offset); 724 g_string_erase(s->rx, 0, offset + 1); 725 726 return line; 727 } 728 729 static gchar **qtest_rsp_args(QTestState *s, int expected_args) 730 { 731 GString *line; 732 gchar **words; 733 int i; 734 735 redo: 736 line = s->ops.recv_line(s); 737 words = g_strsplit(line->str, " ", 0); 738 g_string_free(line, TRUE); 739 740 if (strcmp(words[0], "IRQ") == 0) { 741 long irq; 742 int ret; 743 744 g_assert(words[1] != NULL); 745 g_assert(words[2] != NULL); 746 747 ret = qemu_strtol(words[2], NULL, 0, &irq); 748 g_assert(!ret); 749 g_assert_cmpint(irq, >=, 0); 750 g_assert_cmpint(irq, <, MAX_IRQ); 751 752 if (strcmp(words[1], "raise") == 0) { 753 s->irq_level[irq] = true; 754 } else { 755 s->irq_level[irq] = false; 756 } 757 758 g_strfreev(words); 759 goto redo; 760 } 761 762 g_assert(words[0] != NULL); 763 g_assert_cmpstr(words[0], ==, "OK"); 764 765 for (i = 0; i < expected_args; i++) { 766 g_assert(words[i] != NULL); 767 } 768 769 return words; 770 } 771 772 static void qtest_rsp(QTestState *s) 773 { 774 gchar **words = qtest_rsp_args(s, 0); 775 776 g_strfreev(words); 777 } 778 779 static int qtest_query_target_endianness(QTestState *s) 780 { 781 gchar **args; 782 int big_endian; 783 784 qtest_sendf(s, "endianness\n"); 785 args = qtest_rsp_args(s, 1); 786 g_assert(strcmp(args[1], "big") == 0 || strcmp(args[1], "little") == 0); 787 big_endian = strcmp(args[1], "big") == 0; 788 g_strfreev(args); 789 790 return big_endian; 791 } 792 793 QDict *qtest_qmp_receive(QTestState *s) 794 { 795 while (true) { 796 QDict *response = qtest_qmp_receive_dict(s); 797 798 if (!qdict_get_try_str(response, "event")) { 799 return response; 800 } 801 802 if (!s->eventCB || 803 !s->eventCB(s, qdict_get_str(response, "event"), 804 response, s->eventData)) { 805 /* Stash the event for a later consumption */ 806 s->pending_events = g_list_append(s->pending_events, response); 807 } else { 808 qobject_unref(response); 809 } 810 } 811 } 812 813 QDict *qtest_qmp_receive_dict(QTestState *s) 814 { 815 g_assert(s->qmp_fd >= 0); 816 return qmp_fd_receive(s->qmp_fd); 817 } 818 819 int qtest_socket_server(const char *socket_path) 820 { 821 struct sockaddr_un addr; 822 int sock; 823 int ret; 824 825 sock = socket(PF_UNIX, SOCK_STREAM, 0); 826 g_assert_cmpint(sock, !=, -1); 827 828 addr.sun_family = AF_UNIX; 829 snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path); 830 831 ret = RETRY_ON_EINTR(bind(sock, (struct sockaddr *)&addr, sizeof(addr))); 832 g_assert_cmpint(ret, !=, -1); 833 ret = listen(sock, 1); 834 g_assert_cmpint(ret, !=, -1); 835 836 return sock; 837 } 838 839 #ifndef _WIN32 840 void qtest_qmp_vsend_fds(QTestState *s, int *fds, size_t fds_num, 841 const char *fmt, va_list ap) 842 { 843 g_assert(s->qmp_fd >= 0); 844 qmp_fd_vsend_fds(s->qmp_fd, fds, fds_num, fmt, ap); 845 } 846 #endif 847 848 void qtest_qmp_vsend(QTestState *s, const char *fmt, va_list ap) 849 { 850 g_assert(s->qmp_fd >= 0); 851 qmp_fd_vsend(s->qmp_fd, fmt, ap); 852 } 853 854 #ifndef _WIN32 855 QDict *qtest_vqmp_fds(QTestState *s, int *fds, size_t fds_num, 856 const char *fmt, va_list ap) 857 { 858 qtest_qmp_vsend_fds(s, fds, fds_num, fmt, ap); 859 860 /* Receive reply */ 861 return qtest_qmp_receive(s); 862 } 863 #endif 864 865 QDict *qtest_vqmp(QTestState *s, const char *fmt, va_list ap) 866 { 867 qtest_qmp_vsend(s, fmt, ap); 868 869 /* Receive reply */ 870 return qtest_qmp_receive(s); 871 } 872 873 #ifndef _WIN32 874 QDict *qtest_qmp_fds(QTestState *s, int *fds, size_t fds_num, 875 const char *fmt, ...) 876 { 877 va_list ap; 878 QDict *response; 879 880 va_start(ap, fmt); 881 response = qtest_vqmp_fds(s, fds, fds_num, fmt, ap); 882 va_end(ap); 883 return response; 884 } 885 #endif 886 887 QDict *qtest_qmp(QTestState *s, const char *fmt, ...) 888 { 889 va_list ap; 890 QDict *response; 891 892 va_start(ap, fmt); 893 response = qtest_vqmp(s, fmt, ap); 894 va_end(ap); 895 return response; 896 } 897 898 void qtest_qmp_send(QTestState *s, const char *fmt, ...) 899 { 900 va_list ap; 901 902 va_start(ap, fmt); 903 qtest_qmp_vsend(s, fmt, ap); 904 va_end(ap); 905 } 906 907 void qtest_qmp_send_raw(QTestState *s, const char *fmt, ...) 908 { 909 va_list ap; 910 911 g_assert(s->qmp_fd >= 0); 912 va_start(ap, fmt); 913 qmp_fd_vsend_raw(s->qmp_fd, fmt, ap); 914 va_end(ap); 915 } 916 917 void qtest_qmp_set_event_callback(QTestState *s, 918 QTestQMPEventCallback cb, void *opaque) 919 { 920 s->eventCB = cb; 921 s->eventData = opaque; 922 } 923 924 QDict *qtest_qmp_event_ref(QTestState *s, const char *event) 925 { 926 while (s->pending_events) { 927 928 GList *first = s->pending_events; 929 QDict *response = (QDict *)first->data; 930 931 s->pending_events = g_list_delete_link(s->pending_events, first); 932 933 if (!strcmp(qdict_get_str(response, "event"), event)) { 934 return response; 935 } 936 qobject_unref(response); 937 } 938 return NULL; 939 } 940 941 QDict *qtest_qmp_eventwait_ref(QTestState *s, const char *event) 942 { 943 QDict *response = qtest_qmp_event_ref(s, event); 944 945 if (response) { 946 return response; 947 } 948 949 for (;;) { 950 response = qtest_qmp_receive_dict(s); 951 if ((qdict_haskey(response, "event")) && 952 (strcmp(qdict_get_str(response, "event"), event) == 0)) { 953 return response; 954 } 955 qobject_unref(response); 956 } 957 } 958 959 void qtest_qmp_eventwait(QTestState *s, const char *event) 960 { 961 QDict *response; 962 963 response = qtest_qmp_eventwait_ref(s, event); 964 qobject_unref(response); 965 } 966 967 char *qtest_vhmp(QTestState *s, const char *fmt, va_list ap) 968 { 969 char *cmd; 970 QDict *resp; 971 char *ret; 972 973 cmd = g_strdup_vprintf(fmt, ap); 974 resp = qtest_qmp(s, "{'execute': 'human-monitor-command'," 975 " 'arguments': {'command-line': %s}}", 976 cmd); 977 ret = g_strdup(qdict_get_try_str(resp, "return")); 978 g_assert(ret); 979 qobject_unref(resp); 980 g_free(cmd); 981 return ret; 982 } 983 984 char *qtest_hmp(QTestState *s, const char *fmt, ...) 985 { 986 va_list ap; 987 char *ret; 988 989 va_start(ap, fmt); 990 ret = qtest_vhmp(s, fmt, ap); 991 va_end(ap); 992 return ret; 993 } 994 995 const char *qtest_get_arch(void) 996 { 997 const char *qemu = qtest_qemu_binary(NULL); 998 const char *end = strrchr(qemu, '-'); 999 1000 if (!end) { 1001 fprintf(stderr, "Can't determine architecture from binary name.\n"); 1002 exit(1); 1003 } 1004 1005 if (!strstr(qemu, "-system-")) { 1006 fprintf(stderr, "QTEST_QEMU_BINARY must end with *-system-<arch> " 1007 "where 'arch' is the target\narchitecture (x86_64, aarch64, " 1008 "etc).\n"); 1009 exit(1); 1010 } 1011 1012 return end + 1; 1013 } 1014 1015 static bool qtest_qom_has_concrete_type(const char *parent_typename, 1016 const char *child_typename, 1017 QList **cached_list) 1018 { 1019 QList *list = cached_list ? *cached_list : NULL; 1020 const QListEntry *p; 1021 QObject *qobj; 1022 QString *qstr; 1023 QDict *devinfo; 1024 int idx; 1025 1026 if (!list) { 1027 QDict *resp; 1028 QDict *args; 1029 QTestState *qts = qtest_init("-machine none"); 1030 1031 args = qdict_new(); 1032 qdict_put_bool(args, "abstract", false); 1033 qdict_put_str(args, "implements", parent_typename); 1034 1035 resp = qtest_qmp(qts, "{'execute': 'qom-list-types', 'arguments': %p }", 1036 args); 1037 g_assert(qdict_haskey(resp, "return")); 1038 list = qdict_get_qlist(resp, "return"); 1039 qobject_ref(list); 1040 qobject_unref(resp); 1041 1042 qtest_quit(qts); 1043 1044 if (cached_list) { 1045 *cached_list = list; 1046 } 1047 } 1048 1049 for (p = qlist_first(list), idx = 0; p; p = qlist_next(p), idx++) { 1050 devinfo = qobject_to(QDict, qlist_entry_obj(p)); 1051 g_assert(devinfo); 1052 1053 qobj = qdict_get(devinfo, "name"); 1054 g_assert(qobj); 1055 qstr = qobject_to(QString, qobj); 1056 g_assert(qstr); 1057 if (g_str_equal(qstring_get_str(qstr), child_typename)) { 1058 return true; 1059 } 1060 } 1061 1062 return false; 1063 } 1064 1065 bool qtest_has_accel(const char *accel_name) 1066 { 1067 static QList *list; 1068 g_autofree char *accel_type = NULL; 1069 1070 if (g_str_equal(accel_name, "kvm")) { 1071 int i; 1072 const char *arch = qtest_get_arch(); 1073 const char *targets[] = { CONFIG_KVM_TARGETS }; 1074 1075 for (i = 0; i < ARRAY_SIZE(targets); i++) { 1076 if (!strncmp(targets[i], arch, strlen(arch))) { 1077 if (!access("/dev/kvm", R_OK | W_OK)) { 1078 return true; 1079 } 1080 } 1081 } 1082 return false; 1083 } 1084 1085 accel_type = g_strconcat(accel_name, ACCEL_CLASS_SUFFIX, NULL); 1086 1087 return qtest_qom_has_concrete_type("accel", accel_type, &list); 1088 } 1089 1090 bool qtest_get_irq(QTestState *s, int num) 1091 { 1092 /* dummy operation in order to make sure irq is up to date */ 1093 qtest_inb(s, 0); 1094 1095 return s->irq_level[num]; 1096 } 1097 1098 void qtest_module_load(QTestState *s, const char *prefix, const char *libname) 1099 { 1100 qtest_sendf(s, "module_load %s %s\n", prefix, libname); 1101 qtest_rsp(s); 1102 } 1103 1104 static int64_t qtest_clock_rsp(QTestState *s) 1105 { 1106 gchar **words; 1107 int64_t clock; 1108 words = qtest_rsp_args(s, 2); 1109 clock = g_ascii_strtoll(words[1], NULL, 0); 1110 g_strfreev(words); 1111 return clock; 1112 } 1113 1114 int64_t qtest_clock_step_next(QTestState *s) 1115 { 1116 qtest_sendf(s, "clock_step\n"); 1117 return qtest_clock_rsp(s); 1118 } 1119 1120 int64_t qtest_clock_step(QTestState *s, int64_t step) 1121 { 1122 qtest_sendf(s, "clock_step %"PRIi64"\n", step); 1123 return qtest_clock_rsp(s); 1124 } 1125 1126 int64_t qtest_clock_set(QTestState *s, int64_t val) 1127 { 1128 qtest_sendf(s, "clock_set %"PRIi64"\n", val); 1129 return qtest_clock_rsp(s); 1130 } 1131 1132 void qtest_irq_intercept_out(QTestState *s, const char *qom_path) 1133 { 1134 qtest_sendf(s, "irq_intercept_out %s\n", qom_path); 1135 qtest_rsp(s); 1136 } 1137 1138 void qtest_irq_intercept_out_named(QTestState *s, const char *qom_path, const char *name) 1139 { 1140 qtest_sendf(s, "irq_intercept_out %s %s\n", qom_path, name); 1141 qtest_rsp(s); 1142 } 1143 1144 void qtest_irq_intercept_in(QTestState *s, const char *qom_path) 1145 { 1146 qtest_sendf(s, "irq_intercept_in %s\n", qom_path); 1147 qtest_rsp(s); 1148 } 1149 1150 void qtest_set_irq_in(QTestState *s, const char *qom_path, const char *name, 1151 int num, int level) 1152 { 1153 if (!name) { 1154 name = "unnamed-gpio-in"; 1155 } 1156 qtest_sendf(s, "set_irq_in %s %s %d %d\n", qom_path, name, num, level); 1157 qtest_rsp(s); 1158 } 1159 1160 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value) 1161 { 1162 qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value); 1163 qtest_rsp(s); 1164 } 1165 1166 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value) 1167 { 1168 qtest_out(s, "outb", addr, value); 1169 } 1170 1171 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value) 1172 { 1173 qtest_out(s, "outw", addr, value); 1174 } 1175 1176 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value) 1177 { 1178 qtest_out(s, "outl", addr, value); 1179 } 1180 1181 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr) 1182 { 1183 gchar **args; 1184 int ret; 1185 unsigned long value; 1186 1187 qtest_sendf(s, "%s 0x%x\n", cmd, addr); 1188 args = qtest_rsp_args(s, 2); 1189 ret = qemu_strtoul(args[1], NULL, 0, &value); 1190 g_assert(!ret && value <= UINT32_MAX); 1191 g_strfreev(args); 1192 1193 return value; 1194 } 1195 1196 uint8_t qtest_inb(QTestState *s, uint16_t addr) 1197 { 1198 return qtest_in(s, "inb", addr); 1199 } 1200 1201 uint16_t qtest_inw(QTestState *s, uint16_t addr) 1202 { 1203 return qtest_in(s, "inw", addr); 1204 } 1205 1206 uint32_t qtest_inl(QTestState *s, uint16_t addr) 1207 { 1208 return qtest_in(s, "inl", addr); 1209 } 1210 1211 static void qtest_write(QTestState *s, const char *cmd, uint64_t addr, 1212 uint64_t value) 1213 { 1214 qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value); 1215 qtest_rsp(s); 1216 } 1217 1218 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value) 1219 { 1220 qtest_write(s, "writeb", addr, value); 1221 } 1222 1223 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value) 1224 { 1225 qtest_write(s, "writew", addr, value); 1226 } 1227 1228 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value) 1229 { 1230 qtest_write(s, "writel", addr, value); 1231 } 1232 1233 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value) 1234 { 1235 qtest_write(s, "writeq", addr, value); 1236 } 1237 1238 static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr) 1239 { 1240 gchar **args; 1241 int ret; 1242 uint64_t value; 1243 1244 qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr); 1245 args = qtest_rsp_args(s, 2); 1246 ret = qemu_strtou64(args[1], NULL, 0, &value); 1247 g_assert(!ret); 1248 g_strfreev(args); 1249 1250 return value; 1251 } 1252 1253 uint8_t qtest_readb(QTestState *s, uint64_t addr) 1254 { 1255 return qtest_read(s, "readb", addr); 1256 } 1257 1258 uint16_t qtest_readw(QTestState *s, uint64_t addr) 1259 { 1260 return qtest_read(s, "readw", addr); 1261 } 1262 1263 uint32_t qtest_readl(QTestState *s, uint64_t addr) 1264 { 1265 return qtest_read(s, "readl", addr); 1266 } 1267 1268 uint64_t qtest_readq(QTestState *s, uint64_t addr) 1269 { 1270 return qtest_read(s, "readq", addr); 1271 } 1272 1273 static int hex2nib(char ch) 1274 { 1275 if (ch >= '0' && ch <= '9') { 1276 return ch - '0'; 1277 } else if (ch >= 'a' && ch <= 'f') { 1278 return 10 + (ch - 'a'); 1279 } else if (ch >= 'A' && ch <= 'F') { 1280 return 10 + (ch - 'a'); 1281 } else { 1282 return -1; 1283 } 1284 } 1285 1286 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size) 1287 { 1288 uint8_t *ptr = data; 1289 gchar **args; 1290 size_t i; 1291 1292 if (!size) { 1293 return; 1294 } 1295 1296 qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size); 1297 args = qtest_rsp_args(s, 2); 1298 1299 for (i = 0; i < size; i++) { 1300 ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4; 1301 ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]); 1302 } 1303 1304 g_strfreev(args); 1305 } 1306 1307 uint64_t qtest_rtas_call(QTestState *s, const char *name, 1308 uint32_t nargs, uint64_t args, 1309 uint32_t nret, uint64_t ret) 1310 { 1311 qtest_sendf(s, "rtas %s %u 0x%"PRIx64" %u 0x%"PRIx64"\n", 1312 name, nargs, args, nret, ret); 1313 qtest_rsp(s); 1314 return 0; 1315 } 1316 1317 static void qtest_rsp_csr(QTestState *s, uint64_t *val) 1318 { 1319 gchar **args; 1320 uint64_t ret; 1321 int rc; 1322 1323 args = qtest_rsp_args(s, 3); 1324 1325 rc = qemu_strtou64(args[1], NULL, 16, &ret); 1326 g_assert(rc == 0); 1327 rc = qemu_strtou64(args[2], NULL, 16, val); 1328 g_assert(rc == 0); 1329 1330 g_strfreev(args); 1331 } 1332 1333 uint64_t qtest_csr_call(QTestState *s, const char *name, 1334 uint64_t cpu, int csr, 1335 uint64_t *val) 1336 { 1337 qtest_sendf(s, "csr %s 0x%"PRIx64" %d 0x%"PRIx64"\n", 1338 name, cpu, csr, *val); 1339 1340 qtest_rsp_csr(s, val); 1341 return 0; 1342 } 1343 1344 void qtest_add_func(const char *str, void (*fn)(void)) 1345 { 1346 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1347 g_test_add_func(path, fn); 1348 g_free(path); 1349 } 1350 1351 void qtest_add_data_func_full(const char *str, void *data, 1352 void (*fn)(const void *), 1353 GDestroyNotify data_free_func) 1354 { 1355 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1356 g_test_add_data_func_full(path, data, fn, data_free_func); 1357 g_free(path); 1358 } 1359 1360 void qtest_add_data_func(const char *str, const void *data, 1361 void (*fn)(const void *)) 1362 { 1363 gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str); 1364 g_test_add_data_func(path, data, fn); 1365 g_free(path); 1366 } 1367 1368 void qtest_bufwrite(QTestState *s, uint64_t addr, const void *data, size_t size) 1369 { 1370 gchar *bdata; 1371 1372 bdata = g_base64_encode(data, size); 1373 qtest_sendf(s, "b64write 0x%" PRIx64 " 0x%zx ", addr, size); 1374 s->ops.send(s, bdata); 1375 s->ops.send(s, "\n"); 1376 qtest_rsp(s); 1377 g_free(bdata); 1378 } 1379 1380 void qtest_bufread(QTestState *s, uint64_t addr, void *data, size_t size) 1381 { 1382 gchar **args; 1383 size_t len; 1384 1385 qtest_sendf(s, "b64read 0x%" PRIx64 " 0x%zx\n", addr, size); 1386 args = qtest_rsp_args(s, 2); 1387 1388 g_base64_decode_inplace(args[1], &len); 1389 if (size != len) { 1390 fprintf(stderr, "bufread: asked for %zu bytes but decoded %zu\n", 1391 size, len); 1392 len = MIN(len, size); 1393 } 1394 1395 memcpy(data, args[1], len); 1396 g_strfreev(args); 1397 } 1398 1399 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size) 1400 { 1401 const uint8_t *ptr = data; 1402 size_t i; 1403 char *enc; 1404 1405 if (!size) { 1406 return; 1407 } 1408 1409 enc = g_malloc(2 * size + 1); 1410 1411 for (i = 0; i < size; i++) { 1412 sprintf(&enc[i * 2], "%02x", ptr[i]); 1413 } 1414 1415 qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x%s\n", addr, size, enc); 1416 qtest_rsp(s); 1417 g_free(enc); 1418 } 1419 1420 void qtest_memset(QTestState *s, uint64_t addr, uint8_t pattern, size_t size) 1421 { 1422 qtest_sendf(s, "memset 0x%" PRIx64 " 0x%zx 0x%02x\n", addr, size, pattern); 1423 qtest_rsp(s); 1424 } 1425 1426 QDict *qtest_vqmp_assert_failure_ref(QTestState *qts, 1427 const char *fmt, va_list args) 1428 { 1429 QDict *response; 1430 QDict *ret; 1431 1432 response = qtest_vqmp(qts, fmt, args); 1433 1434 g_assert(response); 1435 if (!qdict_haskey(response, "error")) { 1436 g_autoptr(GString) s = qobject_to_json_pretty(QOBJECT(response), true); 1437 g_test_message("%s", s->str); 1438 } 1439 g_assert(qdict_haskey(response, "error")); 1440 g_assert(!qdict_haskey(response, "return")); 1441 ret = qdict_get_qdict(response, "error"); 1442 qobject_ref(ret); 1443 qobject_unref(response); 1444 1445 return ret; 1446 } 1447 1448 QDict *qtest_vqmp_assert_success_ref(QTestState *qts, 1449 const char *fmt, va_list args) 1450 { 1451 QDict *response; 1452 QDict *ret; 1453 1454 response = qtest_vqmp(qts, fmt, args); 1455 1456 g_assert(response); 1457 if (!qdict_haskey(response, "return")) { 1458 g_autoptr(GString) s = qobject_to_json_pretty(QOBJECT(response), true); 1459 g_test_message("%s", s->str); 1460 } 1461 g_assert(qdict_haskey(response, "return")); 1462 ret = qdict_get_qdict(response, "return"); 1463 qobject_ref(ret); 1464 qobject_unref(response); 1465 1466 return ret; 1467 } 1468 1469 void qtest_vqmp_assert_success(QTestState *qts, 1470 const char *fmt, va_list args) 1471 { 1472 QDict *response; 1473 1474 response = qtest_vqmp_assert_success_ref(qts, fmt, args); 1475 1476 qobject_unref(response); 1477 } 1478 1479 #ifndef _WIN32 1480 QDict *qtest_vqmp_fds_assert_success_ref(QTestState *qts, int *fds, size_t nfds, 1481 const char *fmt, va_list args) 1482 { 1483 QDict *response; 1484 QDict *ret; 1485 1486 response = qtest_vqmp_fds(qts, fds, nfds, fmt, args); 1487 1488 g_assert(response); 1489 if (!qdict_haskey(response, "return")) { 1490 g_autoptr(GString) s = qobject_to_json_pretty(QOBJECT(response), true); 1491 g_test_message("%s", s->str); 1492 } 1493 g_assert(qdict_haskey(response, "return")); 1494 ret = qdict_get_qdict(response, "return"); 1495 qobject_ref(ret); 1496 qobject_unref(response); 1497 1498 return ret; 1499 } 1500 1501 void qtest_vqmp_fds_assert_success(QTestState *qts, int *fds, size_t nfds, 1502 const char *fmt, va_list args) 1503 { 1504 QDict *response; 1505 response = qtest_vqmp_fds_assert_success_ref(qts, fds, nfds, fmt, args); 1506 qobject_unref(response); 1507 } 1508 #endif /* !_WIN32 */ 1509 1510 QDict *qtest_qmp_assert_failure_ref(QTestState *qts, const char *fmt, ...) 1511 { 1512 QDict *response; 1513 va_list ap; 1514 1515 va_start(ap, fmt); 1516 response = qtest_vqmp_assert_failure_ref(qts, fmt, ap); 1517 va_end(ap); 1518 return response; 1519 } 1520 1521 QDict *qtest_qmp_assert_success_ref(QTestState *qts, const char *fmt, ...) 1522 { 1523 QDict *response; 1524 va_list ap; 1525 va_start(ap, fmt); 1526 response = qtest_vqmp_assert_success_ref(qts, fmt, ap); 1527 va_end(ap); 1528 return response; 1529 } 1530 1531 void qtest_qmp_assert_success(QTestState *qts, const char *fmt, ...) 1532 { 1533 va_list ap; 1534 va_start(ap, fmt); 1535 qtest_vqmp_assert_success(qts, fmt, ap); 1536 va_end(ap); 1537 } 1538 1539 #ifndef _WIN32 1540 QDict *qtest_qmp_fds_assert_success_ref(QTestState *qts, int *fds, size_t nfds, 1541 const char *fmt, ...) 1542 { 1543 QDict *response; 1544 va_list ap; 1545 va_start(ap, fmt); 1546 response = qtest_vqmp_fds_assert_success_ref(qts, fds, nfds, fmt, ap); 1547 va_end(ap); 1548 return response; 1549 } 1550 1551 void qtest_qmp_fds_assert_success(QTestState *qts, int *fds, size_t nfds, 1552 const char *fmt, ...) 1553 { 1554 va_list ap; 1555 va_start(ap, fmt); 1556 qtest_vqmp_fds_assert_success(qts, fds, nfds, fmt, ap); 1557 va_end(ap); 1558 } 1559 #endif /* !_WIN32 */ 1560 1561 bool qtest_big_endian(QTestState *s) 1562 { 1563 return s->big_endian; 1564 } 1565 1566 static bool qtest_check_machine_version(const char *mname, const char *basename, 1567 int major, int minor) 1568 { 1569 char *newname; 1570 bool is_equal; 1571 1572 newname = g_strdup_printf("%s-%i.%i", basename, major, minor); 1573 is_equal = g_str_equal(mname, newname); 1574 g_free(newname); 1575 1576 return is_equal; 1577 } 1578 1579 static bool qtest_is_old_versioned_machine(const char *mname) 1580 { 1581 const char *dash = strrchr(mname, '-'); 1582 const char *dot = strrchr(mname, '.'); 1583 const char *chr; 1584 char *bname; 1585 const int major = QEMU_VERSION_MAJOR; 1586 const int minor = QEMU_VERSION_MINOR; 1587 bool res = false; 1588 1589 if (dash && dot && dot > dash) { 1590 for (chr = dash + 1; *chr; chr++) { 1591 if (!qemu_isdigit(*chr) && *chr != '.') { 1592 return false; 1593 } 1594 } 1595 /* 1596 * Now check if it is one of the latest versions. Check major + 1 1597 * and minor + 1 versions as well, since they might already exist 1598 * in the development branch. 1599 */ 1600 bname = g_strdup(mname); 1601 bname[dash - mname] = 0; 1602 res = !qtest_check_machine_version(mname, bname, major + 1, 0) && 1603 !qtest_check_machine_version(mname, bname, major, minor + 1) && 1604 !qtest_check_machine_version(mname, bname, major, minor); 1605 g_free(bname); 1606 } 1607 1608 return res; 1609 } 1610 1611 struct MachInfo { 1612 char *name; 1613 char *alias; 1614 }; 1615 1616 struct CpuModel { 1617 char *name; 1618 char *alias_of; 1619 bool deprecated; 1620 }; 1621 1622 static void qtest_free_machine_list(struct MachInfo *machines) 1623 { 1624 if (machines) { 1625 for (int i = 0; machines[i].name != NULL; i++) { 1626 g_free(machines[i].name); 1627 g_free(machines[i].alias); 1628 } 1629 1630 g_free(machines); 1631 } 1632 } 1633 1634 /* 1635 * Returns an array with pointers to the available machine names. 1636 * The terminating entry has the name set to NULL. 1637 */ 1638 static struct MachInfo *qtest_get_machines(const char *var) 1639 { 1640 static struct MachInfo *machines; 1641 static char *qemu_var; 1642 QDict *response, *minfo; 1643 QList *list; 1644 const QListEntry *p; 1645 QObject *qobj; 1646 QString *qstr; 1647 QTestState *qts; 1648 int idx; 1649 1650 if (g_strcmp0(qemu_var, var)) { 1651 g_free(qemu_var); 1652 qemu_var = g_strdup(var); 1653 1654 /* new qemu, clear the cache */ 1655 qtest_free_machine_list(machines); 1656 machines = NULL; 1657 } 1658 1659 if (machines) { 1660 return machines; 1661 } 1662 1663 silence_spawn_log = !g_test_verbose(); 1664 1665 qts = qtest_init_with_env(qemu_var, "-machine none", true); 1666 response = qtest_qmp(qts, "{ 'execute': 'query-machines' }"); 1667 g_assert(response); 1668 list = qdict_get_qlist(response, "return"); 1669 g_assert(list); 1670 1671 machines = g_new(struct MachInfo, qlist_size(list) + 1); 1672 1673 for (p = qlist_first(list), idx = 0; p; p = qlist_next(p), idx++) { 1674 minfo = qobject_to(QDict, qlist_entry_obj(p)); 1675 g_assert(minfo); 1676 1677 qobj = qdict_get(minfo, "name"); 1678 g_assert(qobj); 1679 qstr = qobject_to(QString, qobj); 1680 g_assert(qstr); 1681 machines[idx].name = g_strdup(qstring_get_str(qstr)); 1682 1683 qobj = qdict_get(minfo, "alias"); 1684 if (qobj) { /* The alias is optional */ 1685 qstr = qobject_to(QString, qobj); 1686 g_assert(qstr); 1687 machines[idx].alias = g_strdup(qstring_get_str(qstr)); 1688 } else { 1689 machines[idx].alias = NULL; 1690 } 1691 } 1692 1693 qtest_quit(qts); 1694 qobject_unref(response); 1695 1696 silence_spawn_log = false; 1697 1698 memset(&machines[idx], 0, sizeof(struct MachInfo)); /* Terminating entry */ 1699 return machines; 1700 } 1701 1702 static struct CpuModel *qtest_get_cpu_models(void) 1703 { 1704 static struct CpuModel *cpus; 1705 QDict *response, *minfo; 1706 QList *list; 1707 const QListEntry *p; 1708 QObject *qobj; 1709 QString *qstr; 1710 QBool *qbool; 1711 QTestState *qts; 1712 int idx; 1713 1714 if (cpus) { 1715 return cpus; 1716 } 1717 1718 silence_spawn_log = !g_test_verbose(); 1719 1720 qts = qtest_init_with_env(NULL, "-machine none", true); 1721 response = qtest_qmp(qts, "{ 'execute': 'query-cpu-definitions' }"); 1722 g_assert(response); 1723 list = qdict_get_qlist(response, "return"); 1724 g_assert(list); 1725 1726 cpus = g_new0(struct CpuModel, qlist_size(list) + 1); 1727 1728 for (p = qlist_first(list), idx = 0; p; p = qlist_next(p), idx++) { 1729 minfo = qobject_to(QDict, qlist_entry_obj(p)); 1730 g_assert(minfo); 1731 1732 qobj = qdict_get(minfo, "name"); 1733 g_assert(qobj); 1734 qstr = qobject_to(QString, qobj); 1735 g_assert(qstr); 1736 cpus[idx].name = g_strdup(qstring_get_str(qstr)); 1737 1738 qobj = qdict_get(minfo, "alias_of"); 1739 if (qobj) { /* old machines do not report aliases */ 1740 qstr = qobject_to(QString, qobj); 1741 g_assert(qstr); 1742 cpus[idx].alias_of = g_strdup(qstring_get_str(qstr)); 1743 } else { 1744 cpus[idx].alias_of = NULL; 1745 } 1746 1747 qobj = qdict_get(minfo, "deprecated"); 1748 qbool = qobject_to(QBool, qobj); 1749 g_assert(qbool); 1750 cpus[idx].deprecated = qbool_get_bool(qbool); 1751 } 1752 1753 qtest_quit(qts); 1754 qobject_unref(response); 1755 1756 silence_spawn_log = false; 1757 1758 return cpus; 1759 } 1760 1761 bool qtest_has_cpu_model(const char *cpu) 1762 { 1763 struct CpuModel *cpus; 1764 int i; 1765 1766 cpus = qtest_get_cpu_models(); 1767 1768 for (i = 0; cpus[i].name != NULL; i++) { 1769 if (g_str_equal(cpu, cpus[i].name) || 1770 (cpus[i].alias_of && g_str_equal(cpu, cpus[i].alias_of))) { 1771 return true; 1772 } 1773 } 1774 1775 return false; 1776 } 1777 1778 void qtest_cb_for_every_machine(void (*cb)(const char *machine), 1779 bool skip_old_versioned) 1780 { 1781 struct MachInfo *machines; 1782 int i; 1783 1784 machines = qtest_get_machines(NULL); 1785 1786 for (i = 0; machines[i].name != NULL; i++) { 1787 /* Ignore machines that cannot be used for qtests */ 1788 if (!strncmp("xenfv", machines[i].name, 5) || 1789 g_str_equal("xenpv", machines[i].name) || 1790 g_str_equal("xenpvh", machines[i].name) || 1791 g_str_equal("nitro-enclave", machines[i].name)) { 1792 continue; 1793 } 1794 if (!skip_old_versioned || 1795 !qtest_is_old_versioned_machine(machines[i].name)) { 1796 cb(machines[i].name); 1797 } 1798 } 1799 } 1800 1801 char *qtest_resolve_machine_alias(const char *var, const char *alias) 1802 { 1803 struct MachInfo *machines; 1804 int i; 1805 1806 machines = qtest_get_machines(var); 1807 1808 for (i = 0; machines[i].name != NULL; i++) { 1809 if (machines[i].alias && g_str_equal(alias, machines[i].alias)) { 1810 return g_strdup(machines[i].name); 1811 } 1812 } 1813 1814 return NULL; 1815 } 1816 1817 bool qtest_has_machine_with_env(const char *var, const char *machine) 1818 { 1819 struct MachInfo *machines; 1820 int i; 1821 1822 machines = qtest_get_machines(var); 1823 1824 for (i = 0; machines[i].name != NULL; i++) { 1825 if (g_str_equal(machine, machines[i].name) || 1826 (machines[i].alias && g_str_equal(machine, machines[i].alias))) { 1827 return true; 1828 } 1829 } 1830 1831 return false; 1832 } 1833 1834 bool qtest_has_machine(const char *machine) 1835 { 1836 return qtest_has_machine_with_env(NULL, machine); 1837 } 1838 1839 bool qtest_has_device(const char *device) 1840 { 1841 static QList *list; 1842 1843 return qtest_qom_has_concrete_type("device", device, &list); 1844 } 1845 1846 /* 1847 * Generic hot-plugging test via the device_add QMP commands. 1848 */ 1849 void qtest_qmp_device_add_qdict(QTestState *qts, const char *drv, 1850 const QDict *arguments) 1851 { 1852 QDict *resp; 1853 QDict *args = arguments ? qdict_clone_shallow(arguments) : qdict_new(); 1854 1855 g_assert(!qdict_haskey(args, "driver")); 1856 qdict_put_str(args, "driver", drv); 1857 resp = qtest_qmp(qts, "{'execute': 'device_add', 'arguments': %p}", args); 1858 g_assert(resp); 1859 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1860 if (qdict_haskey(resp, "error")) { 1861 fprintf(stderr, "error: %s\n", 1862 qdict_get_str(qdict_get_qdict(resp, "error"), "desc")); 1863 } 1864 g_assert(!qdict_haskey(resp, "error")); 1865 qobject_unref(resp); 1866 } 1867 1868 void qtest_qmp_device_add(QTestState *qts, const char *driver, const char *id, 1869 const char *fmt, ...) 1870 { 1871 QDict *args; 1872 va_list ap; 1873 1874 va_start(ap, fmt); 1875 args = qdict_from_vjsonf_nofail(fmt, ap); 1876 va_end(ap); 1877 1878 g_assert(!qdict_haskey(args, "id")); 1879 qdict_put_str(args, "id", id); 1880 1881 qtest_qmp_device_add_qdict(qts, driver, args); 1882 qobject_unref(args); 1883 } 1884 1885 void qtest_qmp_add_client(QTestState *qts, const char *protocol, int fd) 1886 { 1887 QDict *resp; 1888 1889 #ifdef WIN32 1890 WSAPROTOCOL_INFOW info; 1891 g_autofree char *info64 = NULL; 1892 SOCKET s; 1893 1894 assert(fd_is_socket(fd)); 1895 s = _get_osfhandle(fd); 1896 if (WSADuplicateSocketW(s, GetProcessId((HANDLE)qts->qemu_pid), &info) == SOCKET_ERROR) { 1897 g_autofree char *emsg = g_win32_error_message(WSAGetLastError()); 1898 g_error("WSADuplicateSocketW failed: %s", emsg); 1899 } 1900 info64 = g_base64_encode((guchar *)&info, sizeof(info)); 1901 resp = qtest_qmp(qts, "{'execute': 'get-win32-socket'," 1902 "'arguments': {'fdname': 'fdname', 'info': %s}}", info64); 1903 #else 1904 resp = qtest_qmp_fds(qts, &fd, 1, "{'execute': 'getfd'," 1905 "'arguments': {'fdname': 'fdname'}}"); 1906 #endif 1907 g_assert(resp); 1908 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1909 g_assert(!qdict_haskey(resp, "error")); 1910 qobject_unref(resp); 1911 1912 resp = qtest_qmp( 1913 qts, "{'execute': 'add_client'," 1914 "'arguments': {'protocol': %s, 'fdname': 'fdname'}}", protocol); 1915 g_assert(resp); 1916 g_assert(!qdict_haskey(resp, "event")); /* We don't expect any events */ 1917 g_assert(!qdict_haskey(resp, "error")); 1918 qobject_unref(resp); 1919 } 1920 1921 /* 1922 * Generic hot-unplugging test via the device_del QMP command. 1923 * Device deletion will get one response and one event. For example: 1924 * 1925 * {'execute': 'device_del','arguments': { 'id': 'scsi-hd'}} 1926 * 1927 * will get this one: 1928 * 1929 * {"timestamp": {"seconds": 1505289667, "microseconds": 569862}, 1930 * "event": "DEVICE_DELETED", "data": {"device": "scsi-hd", 1931 * "path": "/machine/peripheral/scsi-hd"}} 1932 * 1933 * and this one: 1934 * 1935 * {"return": {}} 1936 */ 1937 void qtest_qmp_device_del_send(QTestState *qts, const char *id) 1938 { 1939 QDict *rsp = qtest_qmp(qts, "{'execute': 'device_del', " 1940 "'arguments': {'id': %s}}", id); 1941 g_assert(rsp); 1942 g_assert(qdict_haskey(rsp, "return")); 1943 g_assert(!qdict_haskey(rsp, "error")); 1944 qobject_unref(rsp); 1945 } 1946 1947 void qtest_qmp_device_del(QTestState *qts, const char *id) 1948 { 1949 qtest_qmp_device_del_send(qts, id); 1950 qtest_qmp_eventwait(qts, "DEVICE_DELETED"); 1951 } 1952 1953 static void qtest_client_set_tx_handler(QTestState *s, 1954 QTestSendFn send) 1955 { 1956 s->ops.send = send; 1957 } 1958 static void qtest_client_set_rx_handler(QTestState *s, QTestRecvFn recv) 1959 { 1960 s->ops.recv_line = recv; 1961 } 1962 /* A type-safe wrapper for s->send() */ 1963 static void send_wrapper(QTestState *s, const char *buf) 1964 { 1965 s->ops.external_send(s, buf); 1966 } 1967 1968 static GString *qtest_client_inproc_recv_line(QTestState *s) 1969 { 1970 GString *line; 1971 size_t offset; 1972 char *eol; 1973 1974 eol = strchr(s->rx->str, '\n'); 1975 offset = eol - s->rx->str; 1976 line = g_string_new_len(s->rx->str, offset); 1977 g_string_erase(s->rx, 0, offset + 1); 1978 return line; 1979 } 1980 1981 QTestState *qtest_inproc_init(QTestState **s, bool log, const char* arch, 1982 void (*send)(void*, const char*)) 1983 { 1984 QTestState *qts; 1985 qts = g_new0(QTestState, 1); 1986 qts->pending_events = NULL; 1987 *s = qts; /* Expose qts early on, since the query endianness relies on it */ 1988 qts->wstatus = 0; 1989 for (int i = 0; i < MAX_IRQ; i++) { 1990 qts->irq_level[i] = false; 1991 } 1992 1993 qtest_client_set_rx_handler(qts, qtest_client_inproc_recv_line); 1994 1995 /* send() may not have a matching prototype, so use a type-safe wrapper */ 1996 qts->ops.external_send = send; 1997 qtest_client_set_tx_handler(qts, send_wrapper); 1998 1999 qts->big_endian = qtest_query_target_endianness(qts); 2000 2001 /* 2002 * Set a dummy path for QTEST_QEMU_BINARY. Doesn't need to exist, but this 2003 * way, qtest_get_arch works for inproc qtest. 2004 */ 2005 gchar *bin_path = g_strconcat("/qemu-system-", arch, NULL); 2006 if (!g_setenv("QTEST_QEMU_BINARY", bin_path, 0)) { 2007 fprintf(stderr, 2008 "Could not set environment variable QTEST_QEMU_BINARY\n"); 2009 exit(1); 2010 } 2011 g_free(bin_path); 2012 2013 return qts; 2014 } 2015 2016 void qtest_client_inproc_recv(void *opaque, const char *str) 2017 { 2018 QTestState *qts = *(QTestState **)opaque; 2019 2020 if (!qts->rx) { 2021 qts->rx = g_string_new(NULL); 2022 } 2023 g_string_append(qts->rx, str); 2024 return; 2025 } 2026 2027 void qtest_qom_set_bool(QTestState *s, const char *path, const char *property, 2028 bool value) 2029 { 2030 QDict *r; 2031 2032 r = qtest_qmp(s, "{ 'execute': 'qom-set', 'arguments': " 2033 "{ 'path': %s, 'property': %s, 'value': %i } }", 2034 path, property, value); 2035 qobject_unref(r); 2036 } 2037 2038 bool qtest_qom_get_bool(QTestState *s, const char *path, const char *property) 2039 { 2040 QDict *r; 2041 bool b; 2042 2043 r = qtest_qmp(s, "{ 'execute': 'qom-get', 'arguments': " 2044 "{ 'path': %s, 'property': %s } }", path, property); 2045 b = qdict_get_bool(r, "return"); 2046 qobject_unref(r); 2047 2048 return b; 2049 } 2050 2051 bool have_qemu_img(void) 2052 { 2053 char *rpath; 2054 const char *path = getenv("QTEST_QEMU_IMG"); 2055 if (!path) { 2056 return false; 2057 } 2058 2059 rpath = realpath(path, NULL); 2060 if (!rpath) { 2061 return false; 2062 } else { 2063 free(rpath); 2064 return true; 2065 } 2066 } 2067 2068 bool mkimg(const char *file, const char *fmt, unsigned size_mb) 2069 { 2070 gchar *cli; 2071 bool ret; 2072 int rc; 2073 GError *err = NULL; 2074 char *qemu_img_path; 2075 gchar *out, *out2; 2076 char *qemu_img_abs_path; 2077 2078 qemu_img_path = getenv("QTEST_QEMU_IMG"); 2079 if (!qemu_img_path) { 2080 return false; 2081 } 2082 qemu_img_abs_path = realpath(qemu_img_path, NULL); 2083 if (!qemu_img_abs_path) { 2084 return false; 2085 } 2086 2087 cli = g_strdup_printf("%s create -f %s %s %uM", qemu_img_abs_path, 2088 fmt, file, size_mb); 2089 ret = g_spawn_command_line_sync(cli, &out, &out2, &rc, &err); 2090 if (err || !g_spawn_check_exit_status(rc, &err)) { 2091 fprintf(stderr, "%s\n", err->message); 2092 g_error_free(err); 2093 } 2094 2095 g_free(out); 2096 g_free(out2); 2097 g_free(cli); 2098 free(qemu_img_abs_path); 2099 2100 return ret && !err; 2101 } 2102