tests/libqtest.c

   1 /*
   2  * QTest
   3  *
   4  * Copyright IBM, Corp. 2012
   5  * Copyright Red Hat, Inc. 2012
   6  *
   7  * Authors:
   8  *  Anthony Liguori   <aliguori@us.ibm.com>
   9  *  Paolo Bonzini     <pbonzini@redhat.com>
  10  *
  11  * This work is licensed under the terms of the GNU GPL, version 2 or later.
  12  * See the COPYING file in the top-level directory.
  13  *
  14  */
  15 #include "libqtest.h"
  16
  17 #include <glib.h>
  18 #include <sys/types.h>
  19 #include <sys/socket.h>
  20 #include <sys/wait.h>
  21 #include <sys/un.h>
  22 #include <inttypes.h>
  23 #include <errno.h>
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <unistd.h>
  27 #include <string.h>
  28
  29 #include "compiler.h"
  30 #include "osdep.h"
  31
  32 #define MAX_IRQ 256
  33
  34 QTestState *global_qtest;
  35
  36 struct QTestState
  37 {
  38     int fd;
  39     int qmp_fd;
  40     bool irq_level[MAX_IRQ];
  41     GString *rx;
  42     gchar *pid_file;
  43     char *socket_path, *qmp_socket_path;
  44 };
  45
  46 #define g_assert_no_errno(ret) do { \
  47     g_assert_cmpint(ret, !=, -1); \
  48 } while (0)
  49
  50 static int init_socket(const char *socket_path)
  51 {
  52     struct sockaddr_un addr;
  53     int sock;
  54     int ret;
  55
  56     sock = socket(PF_UNIX, SOCK_STREAM, 0);
  57     g_assert_no_errno(sock);
  58
  59     addr.sun_family = AF_UNIX;
  60     snprintf(addr.sun_path, sizeof(addr.sun_path), "%s", socket_path);
  61     qemu_set_cloexec(sock);
  62
  63     do {
  64         ret = bind(sock, (struct sockaddr *)&addr, sizeof(addr));
  65     } while (ret == -1 && errno == EINTR);
  66     g_assert_no_errno(ret);
  67     listen(sock, 1);
  68
  69     return sock;
  70 }
  71
  72 static int socket_accept(int sock)
  73 {
  74     struct sockaddr_un addr;
  75     socklen_t addrlen;
  76     int ret;
  77
  78     addrlen = sizeof(addr);
  79     do {
  80         ret = accept(sock, (struct sockaddr *)&addr, &addrlen);
  81     } while (ret == -1 && errno == EINTR);
  82     g_assert_no_errno(ret);
  83     close(sock);
  84
  85     return ret;
  86 }
  87
  88 QTestState *qtest_init(const char *extra_args)
  89 {
  90     QTestState *s;
  91     int sock, qmpsock, ret, i;
  92     gchar *pid_file;
  93     gchar *command;
  94     const char *qemu_binary;
  95     pid_t pid;
  96
  97     qemu_binary = getenv("QTEST_QEMU_BINARY");
  98     g_assert(qemu_binary != NULL);
  99
 100     s = g_malloc(sizeof(*s));
 101
 102     s->socket_path = g_strdup_printf("/tmp/qtest-%d.sock", getpid());
 103     s->qmp_socket_path = g_strdup_printf("/tmp/qtest-%d.qmp", getpid());
 104     pid_file = g_strdup_printf("/tmp/qtest-%d.pid", getpid());
 105
 106     sock = init_socket(s->socket_path);
 107     qmpsock = init_socket(s->qmp_socket_path);
 108
 109     pid = fork();
 110     if (pid == 0) {
 111         command = g_strdup_printf("%s "
 112                                   "-qtest unix:%s,nowait "
 113                                   "-qtest-log /dev/null "
 114                                   "-qmp unix:%s,nowait "
 115                                   "-pidfile %s "
 116                                   "-machine accel=qtest "
 117                                   "%s", qemu_binary, s->socket_path,
 118                                   s->qmp_socket_path, pid_file,
 119                                   extra_args ?: "");
 120
 121         ret = system(command);
 122         exit(ret);
 123         g_free(command);
 124     }
 125
 126     s->fd = socket_accept(sock);
 127     s->qmp_fd = socket_accept(qmpsock);
 128
 129     s->rx = g_string_new("");
 130     s->pid_file = pid_file;
 131     for (i = 0; i < MAX_IRQ; i++) {
 132         s->irq_level[i] = false;
 133     }
 134
 135     /* Read the QMP greeting and then do the handshake */
 136     qtest_qmp(s, "");
 137     qtest_qmp(s, "{ 'execute': 'qmp_capabilities' }");
 138
 139     return s;
 140 }
 141
 142 void qtest_quit(QTestState *s)
 143 {
 144     FILE *f;
 145     char buffer[1024];
 146
 147     f = fopen(s->pid_file, "r");
 148     if (f) {
 149         if (fgets(buffer, sizeof(buffer), f)) {
 150             pid_t pid = atoi(buffer);
 151             int status = 0;
 152
 153             kill(pid, SIGTERM);
 154             waitpid(pid, &status, 0);
 155         }
 156
 157         fclose(f);
 158     }
 159
 160     unlink(s->pid_file);
 161     unlink(s->socket_path);
 162     unlink(s->qmp_socket_path);
 163     g_free(s->pid_file);
 164     g_free(s->socket_path);
 165     g_free(s->qmp_socket_path);
 166 }
 167
 168 static void socket_sendf(int fd, const char *fmt, va_list ap)
 169 {
 170     gchar *str;
 171     size_t size, offset;
 172
 173     str = g_strdup_vprintf(fmt, ap);
 174     size = strlen(str);
 175
 176     offset = 0;
 177     while (offset < size) {
 178         ssize_t len;
 179
 180         len = write(fd, str + offset, size - offset);
 181         if (len == -1 && errno == EINTR) {
 182             continue;
 183         }
 184
 185         g_assert_no_errno(len);
 186         g_assert_cmpint(len, >, 0);
 187
 188         offset += len;
 189     }
 190 }
 191
 192 static void GCC_FMT_ATTR(2, 3) qtest_sendf(QTestState *s, const char *fmt, ...)
 193 {
 194     va_list ap;
 195
 196     va_start(ap, fmt);
 197     socket_sendf(s->fd, fmt, ap);
 198     va_end(ap);
 199 }
 200
 201 static GString *qtest_recv_line(QTestState *s)
 202 {
 203     GString *line;
 204     size_t offset;
 205     char *eol;
 206
 207     while ((eol = strchr(s->rx->str, '\n')) == NULL) {
 208         ssize_t len;
 209         char buffer[1024];
 210
 211         len = read(s->fd, buffer, sizeof(buffer));
 212         if (len == -1 && errno == EINTR) {
 213             continue;
 214         }
 215
 216         if (len == -1 || len == 0) {
 217             fprintf(stderr, "Broken pipe\n");
 218             exit(1);
 219         }
 220
 221         g_string_append_len(s->rx, buffer, len);
 222     }
 223
 224     offset = eol - s->rx->str;
 225     line = g_string_new_len(s->rx->str, offset);
 226     g_string_erase(s->rx, 0, offset + 1);
 227
 228     return line;
 229 }
 230
 231 static gchar **qtest_rsp(QTestState *s, int expected_args)
 232 {
 233     GString *line;
 234     gchar **words;
 235     int i;
 236
 237 redo:
 238     line = qtest_recv_line(s);
 239     words = g_strsplit(line->str, " ", 0);
 240     g_string_free(line, TRUE);
 241
 242     if (strcmp(words[0], "IRQ") == 0) {
 243         int irq;
 244
 245         g_assert(words[1] != NULL);
 246         g_assert(words[2] != NULL);
 247
 248         irq = strtoul(words[2], NULL, 0);
 249         g_assert_cmpint(irq, >=, 0);
 250         g_assert_cmpint(irq, <, MAX_IRQ);
 251
 252         if (strcmp(words[1], "raise") == 0) {
 253             s->irq_level[irq] = true;
 254         } else {
 255             s->irq_level[irq] = false;
 256         }
 257
 258         g_strfreev(words);
 259         goto redo;
 260     }
 261
 262     g_assert(words[0] != NULL);
 263     g_assert_cmpstr(words[0], ==, "OK");
 264
 265     if (expected_args) {
 266         for (i = 0; i < expected_args; i++) {
 267             g_assert(words[i] != NULL);
 268         }
 269     } else {
 270         g_strfreev(words);
 271     }
 272
 273     return words;
 274 }
 275
 276 void qtest_qmp(QTestState *s, const char *fmt, ...)
 277 {
 278     va_list ap;
 279     bool has_reply = false;
 280     int nesting = 0;
 281
 282     /* Send QMP request */
 283     va_start(ap, fmt);
 284     socket_sendf(s->qmp_fd, fmt, ap);
 285     va_end(ap);
 286
 287     /* Receive reply */
 288     while (!has_reply || nesting > 0) {
 289         ssize_t len;
 290         char c;
 291
 292         len = read(s->qmp_fd, &c, 1);
 293         if (len == -1 && errno == EINTR) {
 294             continue;
 295         }
 296
 297         if (len == -1 || len == 0) {
 298             fprintf(stderr, "Broken pipe\n");
 299             exit(1);
 300         }
 301
 302         switch (c) {
 303         case '{':
 304             nesting++;
 305             has_reply = true;
 306             break;
 307         case '}':
 308             nesting--;
 309             break;
 310         }
 311     }
 312 }
 313
 314 const char *qtest_get_arch(void)
 315 {
 316     const char *qemu = getenv("QTEST_QEMU_BINARY");
 317     const char *end = strrchr(qemu, '/');
 318
 319     return end + strlen("/qemu-system-");
 320 }
 321
 322 bool qtest_get_irq(QTestState *s, int num)
 323 {
 324     /* dummy operation in order to make sure irq is up to date */
 325     qtest_inb(s, 0);
 326
 327     return s->irq_level[num];
 328 }
 329
 330 static int64_t qtest_clock_rsp(QTestState *s)
 331 {
 332     gchar **words;
 333     int64_t clock;
 334     words = qtest_rsp(s, 2);
 335     clock = g_ascii_strtoll(words[1], NULL, 0);
 336     g_strfreev(words);
 337     return clock;
 338 }
 339
 340 int64_t qtest_clock_step_next(QTestState *s)
 341 {
 342     qtest_sendf(s, "clock_step\n");
 343     return qtest_clock_rsp(s);
 344 }
 345
 346 int64_t qtest_clock_step(QTestState *s, int64_t step)
 347 {
 348     qtest_sendf(s, "clock_step %"PRIi64"\n", step);
 349     return qtest_clock_rsp(s);
 350 }
 351
 352 int64_t qtest_clock_set(QTestState *s, int64_t val)
 353 {
 354     qtest_sendf(s, "clock_set %"PRIi64"\n", val);
 355     return qtest_clock_rsp(s);
 356 }
 357
 358 void qtest_irq_intercept_out(QTestState *s, const char *qom_path)
 359 {
 360     qtest_sendf(s, "irq_intercept_out %s\n", qom_path);
 361     qtest_rsp(s, 0);
 362 }
 363
 364 void qtest_irq_intercept_in(QTestState *s, const char *qom_path)
 365 {
 366     qtest_sendf(s, "irq_intercept_in %s\n", qom_path);
 367     qtest_rsp(s, 0);
 368 }
 369
 370 static void qtest_out(QTestState *s, const char *cmd, uint16_t addr, uint32_t value)
 371 {
 372     qtest_sendf(s, "%s 0x%x 0x%x\n", cmd, addr, value);
 373     qtest_rsp(s, 0);
 374 }
 375
 376 void qtest_outb(QTestState *s, uint16_t addr, uint8_t value)
 377 {
 378     qtest_out(s, "outb", addr, value);
 379 }
 380
 381 void qtest_outw(QTestState *s, uint16_t addr, uint16_t value)
 382 {
 383     qtest_out(s, "outw", addr, value);
 384 }
 385
 386 void qtest_outl(QTestState *s, uint16_t addr, uint32_t value)
 387 {
 388     qtest_out(s, "outl", addr, value);
 389 }
 390
 391 static uint32_t qtest_in(QTestState *s, const char *cmd, uint16_t addr)
 392 {
 393     gchar **args;
 394     uint32_t value;
 395
 396     qtest_sendf(s, "%s 0x%x\n", cmd, addr);
 397     args = qtest_rsp(s, 2);
 398     value = strtoul(args[1], NULL, 0);
 399     g_strfreev(args);
 400
 401     return value;
 402 }
 403
 404 uint8_t qtest_inb(QTestState *s, uint16_t addr)
 405 {
 406     return qtest_in(s, "inb", addr);
 407 }
 408
 409 uint16_t qtest_inw(QTestState *s, uint16_t addr)
 410 {
 411     return qtest_in(s, "inw", addr);
 412 }
 413
 414 uint32_t qtest_inl(QTestState *s, uint16_t addr)
 415 {
 416     return qtest_in(s, "inl", addr);
 417 }
 418
 419 static int hex2nib(char ch)
 420 {
 421     if (ch >= '0' && ch <= '9') {
 422         return ch - '0';
 423     } else if (ch >= 'a' && ch <= 'f') {
 424         return 10 + (ch - 'a');
 425     } else if (ch >= 'A' && ch <= 'F') {
 426         return 10 + (ch - 'a');
 427     } else {
 428         return -1;
 429     }
 430 }
 431
 432 void qtest_memread(QTestState *s, uint64_t addr, void *data, size_t size)
 433 {
 434     uint8_t *ptr = data;
 435     gchar **args;
 436     size_t i;
 437
 438     qtest_sendf(s, "read 0x%" PRIx64 " 0x%zx\n", addr, size);
 439     args = qtest_rsp(s, 2);
 440
 441     for (i = 0; i < size; i++) {
 442         ptr[i] = hex2nib(args[1][2 + (i * 2)]) << 4;
 443         ptr[i] |= hex2nib(args[1][2 + (i * 2) + 1]);
 444     }
 445
 446     g_strfreev(args);
 447 }
 448
 449 void qtest_add_func(const char *str, void (*fn))
 450 {
 451     gchar *path = g_strdup_printf("/%s/%s", qtest_get_arch(), str);
 452     g_test_add_func(path, fn);
 453 }
 454
 455 void qtest_memwrite(QTestState *s, uint64_t addr, const void *data, size_t size)
 456 {
 457     const uint8_t *ptr = data;
 458     size_t i;
 459
 460     qtest_sendf(s, "write 0x%" PRIx64 " 0x%zx 0x", addr, size);
 461     for (i = 0; i < size; i++) {
 462         qtest_sendf(s, "%02x", ptr[i]);
 463     }
 464     qtest_sendf(s, "\n");
 465     qtest_rsp(s, 0);
 466 }