tests/libqtest.c

   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 "libqtest.h"
  18
  19 #include <glib.h>
  20 #include <sys/types.h>
  21 #include <sys/socket.h>
  22 #include <sys/wait.h>
  23 #include <sys/un.h>
  24 #include <inttypes.h>
  25 #include <errno.h>
  26 #include <stdio.h>
  27 #include <stdlib.h>
  28 #include <unistd.h>
  29 #include <string.h>
  30
  31 #include "qemu/compiler.h"
  32 #include "qemu/osdep.h"
  33 #include "qapi/qmp/json-streamer.h"
  34 #include "qapi/qmp/json-parser.h"
  35
  36 #define MAX_IRQ 256
  37 #define SOCKET_TIMEOUT 5
  38
  39 QTestState *global_qtest;
  40
  41 struct QTestState
  42 {
  43     int fd;
  44     int qmp_fd;
  45     bool irq_level[MAX_IRQ];
  46     GString *rx;
  47     pid_t qemu_pid;  /* our child QEMU process */
  48     struct sigaction sigact_old; /* restored on exit */
  49 };
  50
  51 static GList *qtest_instances;
  52 static struct sigaction sigact_old;
  53
  54 #define g_assert_no_errno(ret) do { \
  55     g_assert_cmpint(ret, !=, -1); \
  56 } while (0)
  57
  58 static int init_socket(const char *socket_path)
  59 {
  60     struct sockaddr_un addr;
  61     int sock;
  62     int ret;
  63
  64     sock = socket(PF_UNIX, SOCK_STREAM, 0);
  65     g_assert_no_errno(sock);
  66
  67     addr.sun_family = AF_UNIX;
  68     snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
  69     qemu_set_cloexec(sock);
  70
  71     do {
  72         ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
  73     } while (ret == -1 && errno == EINTR);
  74     g_assert_no_errno(ret);
  75     listen(sock, 1);
  76
  77     return sock;
  78 }
  79
  80 static int socket_accept(int sock)
  81 {
  82     struct sockaddr_un addr;
  83     socklen_t addrlen;
  84     int ret;
  85     struct timeval timeout = { .tv_sec = SOCKET_TIMEOUT,
  86                                .tv_usec = 0 };
  87
  88     setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (void *)&timeout,
  89                sizeof(timeout));
  90
  91     addrlen = sizeof(addr);
  92     do {
  93         ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
  94     } while (ret == -1 && errno == EINTR);
  95     close(sock);
  96
  97     return ret;
  98 }
  99
 100 static void kill_qemu(QTestState *s)
 101 {
 102     if (s->qemu_pid != -1) {
 103         kill(s->qemu_pid, SIGTERM);
 104         waitpid(s->qemu_pid, NULL, 0);
 105     }
 106 }
 107
 108 static void sigabrt_handler(int signo)
 109 {
 110     GList *elem;
 111     for (elem = qtest_instances; elem; elem = elem->next) {
 112         kill_qemu(elem->data);
 113     }
 114 }
 115
 116 static void setup_sigabrt_handler(void)
 117 {
 118     struct sigaction sigact;
 119
 120     /* Catch SIGABRT to clean up on g_assert() failure */
 121     sigact = (struct sigaction){
 122         .sa_handler = sigabrt_handler,
 123         .sa_flags = SA_RESETHAND,
 124     };
 125     sigemptyset(&sigact.sa_mask);
 126     sigaction(SIGABRT, &sigact, &sigact_old);
 127 }
 128
 129 static void cleanup_sigabrt_handler(void)
 130 {
 131     sigaction(SIGABRT, &sigact_old, NULL);
 132 }
 133
 134 QTestState *qtest_init(const char *extra_args)
 135 {
 136     QTestState *s;
 137     int sock, qmpsock, i;
 138     gchar *socket_path;
 139     gchar *qmp_socket_path;
 140     gchar *command;
 141     const char *qemu_binary;
 142
 143     qemu_binary = getenv("QTEST_QEMU_BINARY");
 144     g_assert(qemu_binary != NULL);
 145
 146     s = g_malloc(sizeof(*s));
 147
 148     socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
 149     qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
 150
 151     sock = init_socket(socket_path);
 152     qmpsock = init_socket(qmp_socket_path);
 153
 154     /* Only install SIGABRT handler once */
 155     if (!qtest_instances) {
 156         setup_sigabrt_handler();
 157     }
 158
 159     qtest_instances = g_list_prepend(qtest_instances, s);
 160
 161     s->qemu_pid = fork();
 162     if (s->qemu_pid == 0) {
 163         command = g_strdup_printf("exec %s "
 164                                   "-qtest unix:%s,nowait "
 165                                   "-qtest-log /dev/null "
 166                                   "-qmp unix:%s,nowait "
 167                                   "-machine accel=qtest "
 168                                   "-display none "
 169                                   "%s", qemu_binary, socket_path,
 170                                   qmp_socket_path,
 171                                   extra_args ?: "");
 172         execlp("/bin/sh", "sh", "-c", command, NULL);
 173         exit(1);
 174     }
 175
 176     s->fd = socket_accept(sock);
 177     if (s->fd >= 0) {
 178         s->qmp_fd = socket_accept(qmpsock);
 179     }
 180     unlink(socket_path);
 181     unlink(qmp_socket_path);
 182     g_free(socket_path);
 183     g_free(qmp_socket_path);
 184
 185     g_assert(s->fd >= 0 && s->qmp_fd >= 0);
 186
 187     s->rx = g_string_new("");
 188     for (i = 0; i < MAX_IRQ; i++) {
 189         s->irq_level[i] = false;
 190     }
 191
 192     /* Read the QMP greeting and then do the handshake */
 193     qtest_qmp_discard_response(s, "");
 194     qtest_qmp_discard_response(s, "{ 'execute': 'qmp_capabilities' }");
 195
 196     if (getenv("QTEST_STOP")) {
 197         kill(s->qemu_pid, SIGSTOP);
 198     }
 199
 200     return s;
 201 }
 202
 203 void qtest_quit(QTestState *s)
 204 {
 205     /* Uninstall SIGABRT handler on last instance */
 206     if (qtest_instances && !qtest_instances->next) {
 207         cleanup_sigabrt_handler();
 208     }
 209
 210     qtest_instances = g_list_remove(qtest_instances, s);
 211
 212     kill_qemu(s);
 213     close(s->fd);
 214     close(s->qmp_fd);
 215     g_string_free(s->rx, true);
 216     g_free(s);
 217 }
 218
 219 static void socket_sendf(int fd, const char *fmt, va_list ap)
 220 {
 221     gchar *str;
 222     size_t size, offset;
 223
 224     str = g_strdup_vprintf(fmt, ap);
 225     size = strlen(str);
 226
 227     offset = 0;
 228     while (offset < size) {
 229         ssize_t len;
 230
 231         len = write(fd, str + offset, size - offset);
 232         if (len == -1 && errno == EINTR) {
 233             continue;
 234         }
 235
 236         g_assert_no_errno(len);
 237         g_assert_cmpint(len, >, 0);
 238
 239         offset += len;
 240     }
 241 }
 242
 243 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
 244 {
 245     va_list ap;
 246
 247     va_start(ap, fmt);
 248     socket_sendf(s->fd, fmt, ap);
 249     va_end(ap);
 250 }
 251
 252 static GString *qtest_recv_line(QTestState *s)
 253 {
 254     GString *line;
 255     size_t offset;
 256     char *eol;
 257
 258     while ((eol = strchr(s->rx->str, '\n')) == NULL) {
 259         ssize_t len;
 260         char buffer[1024];
 261
 262         len = read(s->fd, buffer, sizeof(buffer));
 263         if (len == -1 && errno == EINTR) {
 264             continue;
 265         }
 266
 267         if (len == -1 || len == 0) {
 268             fprintf(stderr, "Broken pipe\n");
 269             exit(1);
 270         }
 271
 272         g_string_append_len(s->rx, buffer, len);
 273     }
 274
 275     offset = eol - s->rx->str;
 276     line = g_string_new_len(s->rx->str, offset);
 277     g_string_erase(s->rx, 0, offset + 1);
 278
 279     return line;
 280 }
 281
 282 static gchar **qtest_rsp(QTestState *s, int expected_args)
 283 {
 284     GString *line;
 285     gchar **words;
 286     int i;
 287
 288 redo:
 289     line = qtest_recv_line(s);
 290     words = g_strsplit(line->str, " ", 0);
 291     g_string_free(line, TRUE);
 292
 293     if (strcmp(words[0], "IRQ") == 0) {
 294         int irq;
 295
 296         g_assert(words[1] != NULL);
 297         g_assert(words[2] != NULL);
 298
 299         irq = strtoul(words[2], NULL, 0);
 300         g_assert_cmpint(irq, >=, 0);
 301         g_assert_cmpint(irq, <, MAX_IRQ);
 302
 303         if (strcmp(words[1], "raise") == 0) {
 304             s->irq_level[irq] = true;
 305         } else {
 306             s->irq_level[irq] = false;
 307         }
 308
 309         g_strfreev(words);
 310         goto redo;
 311     }
 312
 313     g_assert(words[0] != NULL);
 314     g_assert_cmpstr(words[0], ==, "OK");
 315
 316     if (expected_args) {
 317         for (i = 0; i < expected_args; i++) {
 318             g_assert(words[i] != NULL);
 319         }
 320     } else {
 321         g_strfreev(words);
 322     }
 323
 324     return words;
 325 }
 326
 327 typedef struct {
 328     JSONMessageParser parser;
 329     QDict *response;
 330 } QMPResponseParser;
 331
 332 static void qmp_response(JSONMessageParser *parser, QList *tokens)
 333 {
 334     QMPResponseParser *qmp = container_of(parser, QMPResponseParser, parser);
 335     QObject *obj;
 336
 337     obj = json_parser_parse(tokens, NULL);
 338     if (!obj) {
 339         fprintf(stderr, "QMP JSON response parsing failed\n");
 340         exit(1);
 341     }
 342
 343     g_assert(qobject_type(obj) == QTYPE_QDICT);
 344     g_assert(!qmp->response);
 345     qmp->response = (QDict *)obj;
 346 }
 347
 348 QDict *qtest_qmpv(QTestState *s, const char *fmt, va_list ap)
 349 {
 350     QMPResponseParser qmp;
 351
 352     /* Send QMP request */
 353     socket_sendf(s->qmp_fd, fmt, ap);
 354
 355     /* Receive reply */
 356     qmp.response = NULL;
 357     json_message_parser_init(&qmp.parser, qmp_response);
 358     while (!qmp.response) {
 359         ssize_t len;
 360         char c;
 361
 362         len = read(s->qmp_fd, &c, 1);
 363         if (len == -1 && errno == EINTR) {
 364             continue;
 365         }
 366
 367         if (len == -1 || len == 0) {
 368             fprintf(stderr, "Broken pipe\n");
 369             exit(1);
 370         }
 371
 372         json_message_parser_feed(&qmp.parser, &c, 1);
 373     }
 374     json_message_parser_destroy(&qmp.parser);
 375
 376     return qmp.response;
 377 }
 378
 379 QDict *qtest_qmp(QTestState *s, const char *fmt, ...)
 380 {
 381     va_list ap;
 382     QDict *response;
 383
 384     va_start(ap, fmt);
 385     response = qtest_qmpv(s, fmt, ap);
 386     va_end(ap);
 387     return response;
 388 }
 389
 390 void qtest_qmpv_discard_response(QTestState *s, const char *fmt, va_list ap)
 391 {
 392     QDict *response = qtest_qmpv(s, fmt, ap);
 393     QDECREF(response);
 394 }
 395
 396 void qtest_qmp_discard_response(QTestState *s, const char *fmt, ...)
 397 {
 398     va_list ap;
 399     QDict *response;
 400
 401     va_start(ap, fmt);
 402     response = qtest_qmpv(s, fmt, ap);
 403     va_end(ap);
 404     QDECREF(response);
 405 }
 406
 407 const char *qtest_get_arch(void)
 408 {
 409     const char *qemu = getenv("QTEST_QEMU_BINARY");
 410     const char *end = strrchr(qemu, '/');
 411
 412     return end + strlen("/qemu-system-");
 413 }
 414
 415 bool qtest_get_irq(QTestState *s, int num)
 416 {
 417     /* dummy operation in order to make sure irq is up to date */
 418     qtest_inb(s, 0);
 419
 420     return s->irq_level[num];
 421 }
 422
 423 static int64_t qtest_clock_rsp(QTestState *s)
 424 {
 425     gchar **words;
 426     int64_t clock;
 427     words = qtest_rsp(s, 2);
 428     clock = g_ascii_strtoll(words[1], NULL, 0);
 429     g_strfreev(words);
 430     return clock;
 431 }
 432
 433 int64_t qtest_clock_step_next(QTestState *s)
 434 {
 435     qtest_sendf(s, "clock_step\n");
 436     return qtest_clock_rsp(s);
 437 }
 438
 439 int64_t qtest_clock_step(QTestState *s, int64_t step)
 440 {
 441     qtest_sendf(s, "clock_step %"PRIi64"\n", step);
 442     return qtest_clock_rsp(s);
 443 }
 444
 445 int64_t qtest_clock_set(QTestState *s, int64_t val)
 446 {
 447     qtest_sendf(s, "clock_set %"PRIi64"\n", val);
 448     return qtest_clock_rsp(s);
 449 }
 450
 451 void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
 452 {
 453     qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
 454     qtest_rsp(s, 0);
 455 }
 456
 457 void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
 458 {
 459     qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
 460     qtest_rsp(s, 0);
 461 }
 462
 463 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
 464 {
 465     qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
 466     qtest_rsp(s, 0);
 467 }
 468
 469 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
 470 {
 471     qtest_out(s, "outb", addr, value);
 472 }
 473
 474 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
 475 {
 476     qtest_out(s, "outw", addr, value);
 477 }
 478
 479 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
 480 {
 481     qtest_out(s, "outl", addr, value);
 482 }
 483
 484 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
 485 {
 486     gchar **args;
 487     uint32_t value;
 488
 489     qtest_sendf(s, "%s 0x%x\n", cmd, addr);
 490     args = qtest_rsp(s, 2);
 491     value = strtoul(args[1], NULL, 0);
 492     g_strfreev(args);
 493
 494     return value;
 495 }
 496
 497 uint8_t qtest_inb(QTestState *s, uint16_t addr)
 498 {
 499     return qtest_in(s, "inb", addr);
 500 }
 501
 502 uint16_t qtest_inw(QTestState *s, uint16_t addr)
 503 {
 504     return qtest_in(s, "inw", addr);
 505 }
 506
 507 uint32_t qtest_inl(QTestState *s, uint16_t addr)
 508 {
 509     return qtest_in(s, "inl", addr);
 510 }
 511
 512 static void qtest_write(QTestState *s, const char *cmd, uint64_t addr,
 513                         uint64_t value)
 514 {
 515     qtest_sendf(s, "%s 0x%" PRIx64 " 0x%" PRIx64 "\n", cmd, addr, value);
 516     qtest_rsp(s, 0);
 517 }
 518
 519 void qtest_writeb(QTestState *s, uint64_t addr, uint8_t value)
 520 {
 521     qtest_write(s, "writeb", addr, value);
 522 }
 523
 524 void qtest_writew(QTestState *s, uint64_t addr, uint16_t value)
 525 {
 526     qtest_write(s, "writew", addr, value);
 527 }
 528
 529 void qtest_writel(QTestState *s, uint64_t addr, uint32_t value)
 530 {
 531     qtest_write(s, "writel", addr, value);
 532 }
 533
 534 void qtest_writeq(QTestState *s, uint64_t addr, uint64_t value)
 535 {
 536     qtest_write(s, "writeq", addr, value);
 537 }
 538
 539 static uint64_t qtest_read(QTestState *s, const char *cmd, uint64_t addr)
 540 {
 541     gchar **args;
 542     uint64_t value;
 543
 544     qtest_sendf(s, "%s 0x%" PRIx64 "\n", cmd, addr);
 545     args = qtest_rsp(s, 2);
 546     value = strtoull(args[1], NULL, 0);
 547     g_strfreev(args);
 548
 549     return value;
 550 }
 551
 552 uint8_t qtest_readb(QTestState *s, uint64_t addr)
 553 {
 554     return qtest_read(s, "readb", addr);
 555 }
 556
 557 uint16_t qtest_readw(QTestState *s, uint64_t addr)
 558 {
 559     return qtest_read(s, "readw", addr);
 560 }
 561
 562 uint32_t qtest_readl(QTestState *s, uint64_t addr)
 563 {
 564     return qtest_read(s, "readl", addr);
 565 }
 566
 567 uint64_t qtest_readq(QTestState *s, uint64_t addr)
 568 {
 569     return qtest_read(s, "readq", addr);
 570 }
 571
 572 static int hex2nib(char ch)
 573 {
 574     if (ch >= '0' && ch <= '9') {
 575         return ch - '0';
 576     } else if (ch >= 'a' && ch <= 'f') {
 577         return 10 + (ch - 'a');
 578     } else if (ch >= 'A' && ch <= 'F') {
 579         return 10 + (ch - 'a');
 580     } else {
 581         return -1;
 582     }
 583 }
 584
 585 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
 586 {
 587     uint8_t *ptr = data;
 588     gchar **args;
 589     size_t i;
 590
 591     qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
 592     args = qtest_rsp(s, 2);
 593
 594     for (i = 0; i < size; i++) {
 595         ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
 596         ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
 597     }
 598
 599     g_strfreev(args);
 600 }
 601
 602 void qtest_add_func(const char *str, void (*fn))
 603 {
 604     gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
 605     g_test_add_func(path, fn);
 606 }
 607
 608 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
 609 {
 610     const uint8_t *ptr = data;
 611     size_t i;
 612
 613     qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x", addr, size);
 614     for (i = 0; i < size; i++) {
 615         qtest_sendf(s, "%02x", ptr[i]);
 616     }
 617     qtest_sendf(s, "\n");
 618     qtest_rsp(s, 0);
 619 }
 620
 621 QDict *qmp(const char *fmt, ...)
 622 {
 623     va_list ap;
 624     QDict *response;
 625
 626     va_start(ap, fmt);
 627     response = qtest_qmpv(global_qtest, fmt, ap);
 628     va_end(ap);
 629     return response;
 630 }
 631
 632 void qmp_discard_response(const char *fmt, ...)
 633 {
 634     va_list ap;
 635
 636     va_start(ap, fmt);
 637     qtest_qmpv_discard_response(global_qtest, fmt, ap);
 638     va_end(ap);
 639 }