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