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