tests/qtest/vhost-user-test.c

   1 /*
   2  * QTest testcase for the vhost-user
   3  *
   4  * Copyright (c) 2014 Virtual Open Systems Sarl.
   5  *
   6  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   7  * See the COPYING file in the top-level directory.
   8  *
   9  */
  10
  11 #include "qemu/osdep.h"
  12
  13 #include "libqtest-single.h"
  14 #include "qapi/error.h"
  15 #include "qapi/qmp/qdict.h"
  16 #include "qemu/config-file.h"
  17 #include "qemu/option.h"
  18 #include "qemu/range.h"
  19 #include "qemu/sockets.h"
  20 #include "chardev/char-fe.h"
  21 #include "qemu/memfd.h"
  22 #include "qemu/module.h"
  23 #include "sysemu/sysemu.h"
  24 #include "libqos/libqos.h"
  25 #include "libqos/pci-pc.h"
  26 #include "libqos/virtio-pci.h"
  27
  28 #include "libqos/malloc-pc.h"
  29 #include "libqos/qgraph_internal.h"
  30 #include "hw/virtio/virtio-net.h"
  31
  32 #include "standard-headers/linux/vhost_types.h"
  33 #include "standard-headers/linux/virtio_ids.h"
  34 #include "standard-headers/linux/virtio_net.h"
  35 #include "standard-headers/linux/virtio_gpio.h"
  36 #include "standard-headers/linux/virtio_scmi.h"
  37
  38 #ifdef CONFIG_LINUX
  39 #include <sys/vfs.h>
  40 #endif
  41
  42
  43 #define QEMU_CMD_MEM    " -m %d -object memory-backend-file,id=mem,size=%dM," \
  44                         "mem-path=%s,share=on -numa node,memdev=mem"
  45 #define QEMU_CMD_MEMFD  " -m %d -object memory-backend-memfd,id=mem,size=%dM," \
  46                         " -numa node,memdev=mem"
  47 #define QEMU_CMD_SHM    " -m %d -object memory-backend-shm,id=mem,size=%dM," \
  48                         " -numa node,memdev=mem"
  49 #define QEMU_CMD_CHR    " -chardev socket,id=%s,path=%s%s"
  50 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=hs0,chardev=%s,vhostforce=on"
  51
  52 #define HUGETLBFS_MAGIC       0x958458f6
  53
  54 /*********** FROM hw/virtio/vhost-user.c *************************************/
  55
  56 #define VHOST_MEMORY_MAX_NREGIONS    8
  57 #define VHOST_MAX_VIRTQUEUES    0x100
  58
  59 #define VHOST_USER_F_PROTOCOL_FEATURES 30
  60 #define VIRTIO_F_VERSION_1 32
  61
  62 #define VHOST_USER_PROTOCOL_F_MQ 0
  63 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
  64 #define VHOST_USER_PROTOCOL_F_CROSS_ENDIAN   6
  65 #define VHOST_USER_PROTOCOL_F_CONFIG 9
  66
  67 #define VHOST_LOG_PAGE 0x1000
  68
  69 typedef enum VhostUserRequest {
  70     VHOST_USER_NONE = 0,
  71     VHOST_USER_GET_FEATURES = 1,
  72     VHOST_USER_SET_FEATURES = 2,
  73     VHOST_USER_SET_OWNER = 3,
  74     VHOST_USER_RESET_OWNER = 4,
  75     VHOST_USER_SET_MEM_TABLE = 5,
  76     VHOST_USER_SET_LOG_BASE = 6,
  77     VHOST_USER_SET_LOG_FD = 7,
  78     VHOST_USER_SET_VRING_NUM = 8,
  79     VHOST_USER_SET_VRING_ADDR = 9,
  80     VHOST_USER_SET_VRING_BASE = 10,
  81     VHOST_USER_GET_VRING_BASE = 11,
  82     VHOST_USER_SET_VRING_KICK = 12,
  83     VHOST_USER_SET_VRING_CALL = 13,
  84     VHOST_USER_SET_VRING_ERR = 14,
  85     VHOST_USER_GET_PROTOCOL_FEATURES = 15,
  86     VHOST_USER_SET_PROTOCOL_FEATURES = 16,
  87     VHOST_USER_GET_QUEUE_NUM = 17,
  88     VHOST_USER_SET_VRING_ENABLE = 18,
  89     VHOST_USER_GET_CONFIG = 24,
  90     VHOST_USER_SET_CONFIG = 25,
  91     VHOST_USER_MAX
  92 } VhostUserRequest;
  93
  94 typedef struct VhostUserMemoryRegion {
  95     uint64_t guest_phys_addr;
  96     uint64_t memory_size;
  97     uint64_t userspace_addr;
  98     uint64_t mmap_offset;
  99 } VhostUserMemoryRegion;
 100
 101 typedef struct VhostUserMemory {
 102     uint32_t nregions;
 103     uint32_t padding;
 104     VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
 105 } VhostUserMemory;
 106
 107 typedef struct VhostUserLog {
 108     uint64_t mmap_size;
 109     uint64_t mmap_offset;
 110 } VhostUserLog;
 111
 112 typedef struct VhostUserMsg {
 113     VhostUserRequest request;
 114
 115 #define VHOST_USER_VERSION_MASK     (0x3)
 116 #define VHOST_USER_REPLY_MASK       (0x1<<2)
 117     uint32_t flags;
 118     uint32_t size; /* the following payload size */
 119     union {
 120 #define VHOST_USER_VRING_IDX_MASK   (0xff)
 121 #define VHOST_USER_VRING_NOFD_MASK  (0x1<<8)
 122         uint64_t u64;
 123         struct vhost_vring_state state;
 124         struct vhost_vring_addr addr;
 125         VhostUserMemory memory;
 126         VhostUserLog log;
 127     } payload;
 128 } QEMU_PACKED VhostUserMsg;
 129
 130 static VhostUserMsg m __attribute__ ((unused));
 131 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
 132                             + sizeof(m.flags) \
 133                             + sizeof(m.size))
 134
 135 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
 136
 137 /* The version of the protocol we support */
 138 #define VHOST_USER_VERSION    (0x1)
 139 /*****************************************************************************/
 140
 141 enum {
 142     TEST_FLAGS_OK,
 143     TEST_FLAGS_DISCONNECT,
 144     TEST_FLAGS_BAD,
 145     TEST_FLAGS_END,
 146 };
 147
 148 enum {
 149     VHOST_USER_NET,
 150     VHOST_USER_GPIO,
 151     VHOST_USER_SCMI,
 152 };
 153
 154 typedef struct TestServer {
 155     gchar *socket_path;
 156     gchar *mig_path;
 157     gchar *chr_name;
 158     gchar *tmpfs;
 159     CharBackend chr;
 160     int fds_num;
 161     int fds[VHOST_MEMORY_MAX_NREGIONS];
 162     VhostUserMemory memory;
 163     GMainContext *context;
 164     GMainLoop *loop;
 165     GThread *thread;
 166     GMutex data_mutex;
 167     GCond data_cond;
 168     int log_fd;
 169     uint64_t rings;
 170     bool test_fail;
 171     int test_flags;
 172     int queues;
 173     struct vhost_user_ops *vu_ops;
 174 } TestServer;
 175
 176 struct vhost_user_ops {
 177     /* Device types. */
 178     int type;
 179     void (*append_opts)(TestServer *s, GString *cmd_line,
 180             const char *chr_opts);
 181
 182     /* VHOST-USER commands. */
 183     uint64_t (*get_features)(TestServer *s);
 184     void (*set_features)(TestServer *s, CharBackend *chr,
 185                          VhostUserMsg *msg);
 186     void (*get_protocol_features)(TestServer *s,
 187                                   CharBackend *chr, VhostUserMsg *msg);
 188 };
 189
 190 static const char *init_hugepagefs(void);
 191 static TestServer *test_server_new(const gchar *name,
 192         struct vhost_user_ops *ops);
 193 static void test_server_free(TestServer *server);
 194 static void test_server_listen(TestServer *server);
 195
 196 enum test_memfd {
 197     TEST_MEMFD_AUTO,
 198     TEST_MEMFD_YES,
 199     TEST_MEMFD_NO,
 200     TEST_MEMFD_SHM,
 201 };
 202
 203 static void append_vhost_net_opts(TestServer *s, GString *cmd_line,
 204                              const char *chr_opts)
 205 {
 206     g_string_append_printf(cmd_line, QEMU_CMD_CHR QEMU_CMD_NETDEV,
 207                            s->chr_name, s->socket_path,
 208                            chr_opts, s->chr_name);
 209 }
 210
 211 /*
 212  * For GPIO there are no other magic devices we need to add (like
 213  * block or netdev) so all we need to worry about is the vhost-user
 214  * chardev socket.
 215  */
 216 static void append_vhost_gpio_opts(TestServer *s, GString *cmd_line,
 217                              const char *chr_opts)
 218 {
 219     g_string_append_printf(cmd_line, QEMU_CMD_CHR,
 220                            s->chr_name, s->socket_path,
 221                            chr_opts);
 222 }
 223
 224 static void append_mem_opts(TestServer *server, GString *cmd_line,
 225                             int size, enum test_memfd memfd)
 226 {
 227     if (memfd == TEST_MEMFD_AUTO) {
 228         memfd = qemu_memfd_check(MFD_ALLOW_SEALING) ? TEST_MEMFD_YES
 229                                                     : TEST_MEMFD_NO;
 230     }
 231
 232     if (memfd == TEST_MEMFD_YES) {
 233         g_string_append_printf(cmd_line, QEMU_CMD_MEMFD, size, size);
 234     } else if (memfd == TEST_MEMFD_SHM) {
 235         g_string_append_printf(cmd_line, QEMU_CMD_SHM, size, size);
 236     } else {
 237         const char *root = init_hugepagefs() ? : server->tmpfs;
 238
 239         g_string_append_printf(cmd_line, QEMU_CMD_MEM, size, size, root);
 240     }
 241 }
 242
 243 static bool wait_for_fds(TestServer *s)
 244 {
 245     gint64 end_time;
 246     bool got_region;
 247     int i;
 248
 249     g_mutex_lock(&s->data_mutex);
 250
 251     end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
 252     while (!s->fds_num) {
 253         if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
 254             /* timeout has passed */
 255             g_assert(s->fds_num);
 256             break;
 257         }
 258     }
 259
 260     /* check for sanity */
 261     g_assert_cmpint(s->fds_num, >, 0);
 262     g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
 263
 264     g_mutex_unlock(&s->data_mutex);
 265
 266     got_region = false;
 267     for (i = 0; i < s->memory.nregions; ++i) {
 268         VhostUserMemoryRegion *reg = &s->memory.regions[i];
 269         if (reg->guest_phys_addr == 0) {
 270             got_region = true;
 271             break;
 272         }
 273     }
 274     if (!got_region) {
 275         g_test_skip("No memory at address 0x0");
 276     }
 277     return got_region;
 278 }
 279
 280 static void read_guest_mem_server(QTestState *qts, TestServer *s)
 281 {
 282     uint8_t *guest_mem;
 283     int i, j;
 284     size_t size;
 285
 286     g_mutex_lock(&s->data_mutex);
 287
 288     /* iterate all regions */
 289     for (i = 0; i < s->fds_num; i++) {
 290
 291         /* We'll check only the region starting at 0x0 */
 292         if (s->memory.regions[i].guest_phys_addr != 0x0) {
 293             continue;
 294         }
 295
 296         g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
 297
 298         size = s->memory.regions[i].memory_size +
 299             s->memory.regions[i].mmap_offset;
 300
 301         guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
 302                          MAP_SHARED, s->fds[i], 0);
 303
 304         g_assert(guest_mem != MAP_FAILED);
 305         guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
 306
 307         for (j = 0; j < 1024; j++) {
 308             uint32_t a = qtest_readb(qts, s->memory.regions[i].guest_phys_addr + j);
 309             uint32_t b = guest_mem[j];
 310
 311             g_assert_cmpint(a, ==, b);
 312         }
 313
 314         munmap(guest_mem, s->memory.regions[i].memory_size);
 315     }
 316
 317     g_mutex_unlock(&s->data_mutex);
 318 }
 319
 320 static void *thread_function(void *data)
 321 {
 322     GMainLoop *loop = data;
 323     g_main_loop_run(loop);
 324     return NULL;
 325 }
 326
 327 static int chr_can_read(void *opaque)
 328 {
 329     return VHOST_USER_HDR_SIZE;
 330 }
 331
 332 static void chr_read(void *opaque, const uint8_t *buf, int size)
 333 {
 334     g_autoptr(GError) err = NULL;
 335     TestServer *s = opaque;
 336     CharBackend *chr = &s->chr;
 337     VhostUserMsg msg;
 338     uint8_t *p = (uint8_t *) &msg;
 339     int fd = -1;
 340
 341     if (s->test_fail) {
 342         qemu_chr_fe_disconnect(chr);
 343         /* now switch to non-failure */
 344         s->test_fail = false;
 345     }
 346
 347     if (size != VHOST_USER_HDR_SIZE) {
 348         qos_printf("%s: Wrong message size received %d\n", __func__, size);
 349         return;
 350     }
 351
 352     g_mutex_lock(&s->data_mutex);
 353     memcpy(p, buf, VHOST_USER_HDR_SIZE);
 354
 355     if (msg.size) {
 356         p += VHOST_USER_HDR_SIZE;
 357         size = qemu_chr_fe_read_all(chr, p, msg.size);
 358         if (size != msg.size) {
 359             qos_printf("%s: Wrong message size received %d != %d\n",
 360                        __func__, size, msg.size);
 361             goto out;
 362         }
 363     }
 364
 365     switch (msg.request) {
 366     case VHOST_USER_GET_FEATURES:
 367         /* Mandatory for tests to define get_features */
 368         g_assert(s->vu_ops->get_features);
 369
 370         /* send back features to qemu */
 371         msg.flags |= VHOST_USER_REPLY_MASK;
 372         msg.size = sizeof(m.payload.u64);
 373
 374         if (s->test_flags >= TEST_FLAGS_BAD) {
 375             msg.payload.u64 = 0;
 376             s->test_flags = TEST_FLAGS_END;
 377         } else {
 378             msg.payload.u64 = s->vu_ops->get_features(s);
 379         }
 380
 381         qemu_chr_fe_write_all(chr, (uint8_t *) &msg,
 382                               VHOST_USER_HDR_SIZE + msg.size);
 383         break;
 384
 385     case VHOST_USER_SET_FEATURES:
 386         if (s->vu_ops->set_features) {
 387             s->vu_ops->set_features(s, chr, &msg);
 388         }
 389         break;
 390
 391     case VHOST_USER_SET_OWNER:
 392         /*
 393          * We don't need to do anything here, the remote is just
 394          * letting us know it is in charge. Just log it.
 395          */
 396         qos_printf("set_owner: start of session\n");
 397         break;
 398
 399     case VHOST_USER_GET_PROTOCOL_FEATURES:
 400         if (s->vu_ops->get_protocol_features) {
 401             s->vu_ops->get_protocol_features(s, chr, &msg);
 402         }
 403         break;
 404
 405     case VHOST_USER_GET_CONFIG:
 406         /*
 407          * Treat GET_CONFIG as a NOP and just reply and let the guest
 408          * consider we have updated its memory. Tests currently don't
 409          * require working configs.
 410          */
 411         msg.flags |= VHOST_USER_REPLY_MASK;
 412         p = (uint8_t *) &msg;
 413         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 414         break;
 415
 416     case VHOST_USER_SET_PROTOCOL_FEATURES:
 417         /*
 418          * We did set VHOST_USER_F_PROTOCOL_FEATURES so its valid for
 419          * the remote end to send this. There is no handshake reply so
 420          * just log the details for debugging.
 421          */
 422         qos_printf("set_protocol_features: 0x%"PRIx64 "\n", msg.payload.u64);
 423         break;
 424
 425         /*
 426          * A real vhost-user backend would actually set the size and
 427          * address of the vrings but we can simply report them.
 428          */
 429     case VHOST_USER_SET_VRING_NUM:
 430         qos_printf("set_vring_num: %d/%d\n",
 431                    msg.payload.state.index, msg.payload.state.num);
 432         break;
 433     case VHOST_USER_SET_VRING_ADDR:
 434         qos_printf("set_vring_addr: 0x%"PRIx64"/0x%"PRIx64"/0x%"PRIx64"\n",
 435                    msg.payload.addr.avail_user_addr,
 436                    msg.payload.addr.desc_user_addr,
 437                    msg.payload.addr.used_user_addr);
 438         break;
 439
 440     case VHOST_USER_GET_VRING_BASE:
 441         /* send back vring base to qemu */
 442         msg.flags |= VHOST_USER_REPLY_MASK;
 443         msg.size = sizeof(m.payload.state);
 444         msg.payload.state.num = 0;
 445         p = (uint8_t *) &msg;
 446         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 447
 448         assert(msg.payload.state.index < s->queues * 2);
 449         s->rings &= ~(0x1ULL << msg.payload.state.index);
 450         g_cond_broadcast(&s->data_cond);
 451         break;
 452
 453     case VHOST_USER_SET_MEM_TABLE:
 454         /* received the mem table */
 455         memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
 456         s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds,
 457                                             G_N_ELEMENTS(s->fds));
 458
 459         /* signal the test that it can continue */
 460         g_cond_broadcast(&s->data_cond);
 461         break;
 462
 463     case VHOST_USER_SET_VRING_KICK:
 464     case VHOST_USER_SET_VRING_CALL:
 465         /* consume the fd */
 466         if (!qemu_chr_fe_get_msgfds(chr, &fd, 1) && fd < 0) {
 467             qos_printf("call fd: %d, do not set non-blocking\n", fd);
 468             break;
 469         }
 470         /*
 471          * This is a non-blocking eventfd.
 472          * The receive function forces it to be blocking,
 473          * so revert it back to non-blocking.
 474          */
 475         g_unix_set_fd_nonblocking(fd, true, &err);
 476         g_assert_no_error(err);
 477         break;
 478
 479     case VHOST_USER_SET_LOG_BASE:
 480         if (s->log_fd != -1) {
 481             close(s->log_fd);
 482             s->log_fd = -1;
 483         }
 484         qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
 485         msg.flags |= VHOST_USER_REPLY_MASK;
 486         msg.size = 0;
 487         p = (uint8_t *) &msg;
 488         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
 489
 490         g_cond_broadcast(&s->data_cond);
 491         break;
 492
 493     case VHOST_USER_SET_VRING_BASE:
 494         assert(msg.payload.state.index < s->queues * 2);
 495         s->rings |= 0x1ULL << msg.payload.state.index;
 496         g_cond_broadcast(&s->data_cond);
 497         break;
 498
 499     case VHOST_USER_GET_QUEUE_NUM:
 500         msg.flags |= VHOST_USER_REPLY_MASK;
 501         msg.size = sizeof(m.payload.u64);
 502         msg.payload.u64 = s->queues;
 503         p = (uint8_t *) &msg;
 504         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 505         break;
 506
 507     case VHOST_USER_SET_VRING_ENABLE:
 508         /*
 509          * Another case we ignore as we don't need to respond. With a
 510          * fully functioning vhost-user we would enable/disable the
 511          * vring monitoring.
 512          */
 513         qos_printf("set_vring(%d)=%s\n", msg.payload.state.index,
 514                    msg.payload.state.num ? "enabled" : "disabled");
 515         break;
 516
 517     default:
 518         qos_printf("vhost-user: un-handled message: %d\n", msg.request);
 519         break;
 520     }
 521
 522 out:
 523     g_mutex_unlock(&s->data_mutex);
 524 }
 525
 526 static const char *init_hugepagefs(void)
 527 {
 528 #ifdef CONFIG_LINUX
 529     static const char *hugepagefs;
 530     const char *path = getenv("QTEST_HUGETLBFS_PATH");
 531     struct statfs fs;
 532     int ret;
 533
 534     if (hugepagefs) {
 535         return hugepagefs;
 536     }
 537     if (!path) {
 538         return NULL;
 539     }
 540
 541     if (access(path, R_OK | W_OK | X_OK)) {
 542         qos_printf("access on path (%s): %s", path, strerror(errno));
 543         g_test_fail();
 544         return NULL;
 545     }
 546
 547     do {
 548         ret = statfs(path, &fs);
 549     } while (ret != 0 && errno == EINTR);
 550
 551     if (ret != 0) {
 552         qos_printf("statfs on path (%s): %s", path, strerror(errno));
 553         g_test_fail();
 554         return NULL;
 555     }
 556
 557     if (fs.f_type != HUGETLBFS_MAGIC) {
 558         qos_printf("Warning: path not on HugeTLBFS: %s", path);
 559         g_test_fail();
 560         return NULL;
 561     }
 562
 563     hugepagefs = path;
 564     return hugepagefs;
 565 #else
 566     return NULL;
 567 #endif
 568 }
 569
 570 static TestServer *test_server_new(const gchar *name,
 571         struct vhost_user_ops *ops)
 572 {
 573     TestServer *server = g_new0(TestServer, 1);
 574     g_autofree const char *tmpfs = NULL;
 575     GError *err = NULL;
 576
 577     server->context = g_main_context_new();
 578     server->loop = g_main_loop_new(server->context, FALSE);
 579
 580     /* run the main loop thread so the chardev may operate */
 581     server->thread = g_thread_new(NULL, thread_function, server->loop);
 582
 583     tmpfs = g_dir_make_tmp("vhost-test-XXXXXX", &err);
 584     if (!tmpfs) {
 585         g_test_message("Can't create temporary directory in %s: %s",
 586                        g_get_tmp_dir(), err->message);
 587         g_error_free(err);
 588     }
 589     g_assert(tmpfs);
 590
 591     server->tmpfs = g_strdup(tmpfs);
 592     server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
 593     server->mig_path = g_strdup_printf("%s/%s.mig", tmpfs, name);
 594     server->chr_name = g_strdup_printf("chr-%s", name);
 595
 596     g_mutex_init(&server->data_mutex);
 597     g_cond_init(&server->data_cond);
 598
 599     server->log_fd = -1;
 600     server->queues = 1;
 601     server->vu_ops = ops;
 602
 603     return server;
 604 }
 605
 606 static void chr_event(void *opaque, QEMUChrEvent event)
 607 {
 608     TestServer *s = opaque;
 609
 610     if (s->test_flags == TEST_FLAGS_END &&
 611         event == CHR_EVENT_CLOSED) {
 612         s->test_flags = TEST_FLAGS_OK;
 613     }
 614 }
 615
 616 static void test_server_create_chr(TestServer *server, const gchar *opt)
 617 {
 618     g_autofree gchar *chr_path = g_strdup_printf("unix:%s%s",
 619                                                  server->socket_path, opt);
 620     Chardev *chr;
 621
 622     chr = qemu_chr_new(server->chr_name, chr_path, server->context);
 623     g_assert(chr);
 624
 625     qemu_chr_fe_init(&server->chr, chr, &error_abort);
 626     qemu_chr_fe_set_handlers(&server->chr, chr_can_read, chr_read,
 627                              chr_event, NULL, server, server->context, true);
 628 }
 629
 630 static void test_server_listen(TestServer *server)
 631 {
 632     test_server_create_chr(server, ",server=on,wait=off");
 633 }
 634
 635 static void test_server_free(TestServer *server)
 636 {
 637     int i, ret;
 638
 639     /* finish the helper thread and dispatch pending sources */
 640     g_main_loop_quit(server->loop);
 641     g_thread_join(server->thread);
 642     while (g_main_context_pending(NULL)) {
 643         g_main_context_iteration(NULL, TRUE);
 644     }
 645
 646     unlink(server->socket_path);
 647     g_free(server->socket_path);
 648
 649     unlink(server->mig_path);
 650     g_free(server->mig_path);
 651
 652     ret = rmdir(server->tmpfs);
 653     if (ret != 0) {
 654         g_test_message("unable to rmdir: path (%s): %s",
 655                        server->tmpfs, strerror(errno));
 656     }
 657     g_free(server->tmpfs);
 658
 659     qemu_chr_fe_deinit(&server->chr, true);
 660
 661     for (i = 0; i < server->fds_num; i++) {
 662         close(server->fds[i]);
 663     }
 664
 665     if (server->log_fd != -1) {
 666         close(server->log_fd);
 667     }
 668
 669     g_free(server->chr_name);
 670
 671     g_main_loop_unref(server->loop);
 672     g_main_context_unref(server->context);
 673     g_cond_clear(&server->data_cond);
 674     g_mutex_clear(&server->data_mutex);
 675     g_free(server);
 676 }
 677
 678 static void wait_for_log_fd(TestServer *s)
 679 {
 680     gint64 end_time;
 681
 682     g_mutex_lock(&s->data_mutex);
 683     end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
 684     while (s->log_fd == -1) {
 685         if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
 686             /* timeout has passed */
 687             g_assert(s->log_fd != -1);
 688             break;
 689         }
 690     }
 691
 692     g_mutex_unlock(&s->data_mutex);
 693 }
 694
 695 static void write_guest_mem(TestServer *s, uint32_t seed)
 696 {
 697     uint32_t *guest_mem;
 698     int i, j;
 699     size_t size;
 700
 701     /* iterate all regions */
 702     for (i = 0; i < s->fds_num; i++) {
 703
 704         /* We'll write only the region statring at 0x0 */
 705         if (s->memory.regions[i].guest_phys_addr != 0x0) {
 706             continue;
 707         }
 708
 709         g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
 710
 711         size = s->memory.regions[i].memory_size +
 712             s->memory.regions[i].mmap_offset;
 713
 714         guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
 715                          MAP_SHARED, s->fds[i], 0);
 716
 717         g_assert(guest_mem != MAP_FAILED);
 718         guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
 719
 720         for (j = 0; j < 256; j++) {
 721             guest_mem[j] = seed + j;
 722         }
 723
 724         munmap(guest_mem, s->memory.regions[i].memory_size);
 725         break;
 726     }
 727 }
 728
 729 static guint64 get_log_size(TestServer *s)
 730 {
 731     guint64 log_size = 0;
 732     int i;
 733
 734     for (i = 0; i < s->memory.nregions; ++i) {
 735         VhostUserMemoryRegion *reg = &s->memory.regions[i];
 736         guint64 last = range_get_last(reg->guest_phys_addr,
 737                                        reg->memory_size);
 738         log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
 739     }
 740
 741     return log_size;
 742 }
 743
 744 typedef struct TestMigrateSource {
 745     GSource source;
 746     TestServer *src;
 747     TestServer *dest;
 748 } TestMigrateSource;
 749
 750 static gboolean
 751 test_migrate_source_check(GSource *source)
 752 {
 753     TestMigrateSource *t = (TestMigrateSource *)source;
 754     gboolean overlap = t->src->rings && t->dest->rings;
 755
 756     g_assert(!overlap);
 757
 758     return FALSE;
 759 }
 760
 761 GSourceFuncs test_migrate_source_funcs = {
 762     .check = test_migrate_source_check,
 763 };
 764
 765 static void vhost_user_test_cleanup(void *s)
 766 {
 767     TestServer *server = s;
 768
 769     qos_invalidate_command_line();
 770     test_server_free(server);
 771 }
 772
 773 static void *vhost_user_test_setup(GString *cmd_line, void *arg)
 774 {
 775     TestServer *server = test_server_new("vhost-user-test", arg);
 776     test_server_listen(server);
 777
 778     append_mem_opts(server, cmd_line, 256, TEST_MEMFD_AUTO);
 779     server->vu_ops->append_opts(server, cmd_line, "");
 780
 781     g_test_queue_destroy(vhost_user_test_cleanup, server);
 782
 783     return server;
 784 }
 785
 786 static void *vhost_user_test_setup_memfd(GString *cmd_line, void *arg)
 787 {
 788     TestServer *server = test_server_new("vhost-user-test", arg);
 789     test_server_listen(server);
 790
 791     append_mem_opts(server, cmd_line, 256, TEST_MEMFD_YES);
 792     server->vu_ops->append_opts(server, cmd_line, "");
 793
 794     g_test_queue_destroy(vhost_user_test_cleanup, server);
 795
 796     return server;
 797 }
 798
 799 static void *vhost_user_test_setup_shm(GString *cmd_line, void *arg)
 800 {
 801     TestServer *server = test_server_new("vhost-user-test", arg);
 802     test_server_listen(server);
 803
 804     append_mem_opts(server, cmd_line, 256, TEST_MEMFD_SHM);
 805     server->vu_ops->append_opts(server, cmd_line, "");
 806
 807     g_test_queue_destroy(vhost_user_test_cleanup, server);
 808
 809     return server;
 810 }
 811
 812 static void test_read_guest_mem(void *obj, void *arg, QGuestAllocator *alloc)
 813 {
 814     TestServer *server = arg;
 815
 816     if (!wait_for_fds(server)) {
 817         return;
 818     }
 819
 820     read_guest_mem_server(global_qtest, server);
 821 }
 822
 823 static void test_migrate(void *obj, void *arg, QGuestAllocator *alloc)
 824 {
 825     TestServer *s = arg;
 826     TestServer *dest;
 827     GString *dest_cmdline;
 828     char *uri;
 829     QTestState *to;
 830     GSource *source;
 831     QDict *rsp;
 832     guint8 *log;
 833     guint64 size;
 834
 835     if (!wait_for_fds(s)) {
 836         return;
 837     }
 838
 839     dest = test_server_new("dest", s->vu_ops);
 840     dest_cmdline = g_string_new(qos_get_current_command_line());
 841     uri = g_strdup_printf("%s%s", "unix:", dest->mig_path);
 842
 843     size = get_log_size(s);
 844     g_assert_cmpint(size, ==, (256 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
 845
 846     test_server_listen(dest);
 847     g_string_append_printf(dest_cmdline, " -incoming %s", uri);
 848     append_mem_opts(dest, dest_cmdline, 256, TEST_MEMFD_AUTO);
 849     dest->vu_ops->append_opts(dest, dest_cmdline, "");
 850     to = qtest_init(dest_cmdline->str);
 851
 852     /* This would be where you call qos_allocate_objects(to, NULL), if you want
 853      * to talk to the QVirtioNet object on the destination.
 854      */
 855
 856     source = g_source_new(&test_migrate_source_funcs,
 857                           sizeof(TestMigrateSource));
 858     ((TestMigrateSource *)source)->src = s;
 859     ((TestMigrateSource *)source)->dest = dest;
 860     g_source_attach(source, s->context);
 861
 862     /* slow down migration to have time to fiddle with log */
 863     /* TODO: qtest could learn to break on some places */
 864     rsp = qmp("{ 'execute': 'migrate-set-parameters',"
 865               "'arguments': { 'max-bandwidth': 10 } }");
 866     g_assert(qdict_haskey(rsp, "return"));
 867     qobject_unref(rsp);
 868
 869     rsp = qmp("{ 'execute': 'migrate', 'arguments': { 'uri': %s } }", uri);
 870     g_assert(qdict_haskey(rsp, "return"));
 871     qobject_unref(rsp);
 872
 873     wait_for_log_fd(s);
 874
 875     log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0);
 876     g_assert(log != MAP_FAILED);
 877
 878     /* modify first page */
 879     write_guest_mem(s, 0x42);
 880     log[0] = 1;
 881     munmap(log, size);
 882
 883     /* speed things up */
 884     rsp = qmp("{ 'execute': 'migrate-set-parameters',"
 885               "'arguments': { 'max-bandwidth': 0 } }");
 886     g_assert(qdict_haskey(rsp, "return"));
 887     qobject_unref(rsp);
 888
 889     qmp_eventwait("STOP");
 890     qtest_qmp_eventwait(to, "RESUME");
 891
 892     g_assert(wait_for_fds(dest));
 893     read_guest_mem_server(to, dest);
 894
 895     g_source_destroy(source);
 896     g_source_unref(source);
 897
 898     qtest_quit(to);
 899     test_server_free(dest);
 900     g_free(uri);
 901     g_string_free(dest_cmdline, true);
 902 }
 903
 904 static void wait_for_rings_started(TestServer *s, size_t count)
 905 {
 906     gint64 end_time;
 907
 908     g_mutex_lock(&s->data_mutex);
 909     end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
 910     while (ctpop64(s->rings) != count) {
 911         if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
 912             /* timeout has passed */
 913             g_assert_cmpint(ctpop64(s->rings), ==, count);
 914             break;
 915         }
 916     }
 917
 918     g_mutex_unlock(&s->data_mutex);
 919 }
 920
 921 static inline void test_server_connect(TestServer *server)
 922 {
 923     test_server_create_chr(server, ",reconnect=1");
 924 }
 925
 926 static gboolean
 927 reconnect_cb(gpointer user_data)
 928 {
 929     TestServer *s = user_data;
 930
 931     qemu_chr_fe_disconnect(&s->chr);
 932
 933     return FALSE;
 934 }
 935
 936 static gpointer
 937 connect_thread(gpointer data)
 938 {
 939     TestServer *s = data;
 940
 941     /* wait for qemu to start before first try, to avoid extra warnings */
 942     g_usleep(G_USEC_PER_SEC);
 943     test_server_connect(s);
 944
 945     return NULL;
 946 }
 947
 948 static void *vhost_user_test_setup_reconnect(GString *cmd_line, void *arg)
 949 {
 950     TestServer *s = test_server_new("reconnect", arg);
 951
 952     g_thread_unref(g_thread_new("connect", connect_thread, s));
 953     append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
 954     s->vu_ops->append_opts(s, cmd_line, ",server=on");
 955
 956     g_test_queue_destroy(vhost_user_test_cleanup, s);
 957
 958     return s;
 959 }
 960
 961 static void test_reconnect(void *obj, void *arg, QGuestAllocator *alloc)
 962 {
 963     TestServer *s = arg;
 964     GSource *src;
 965
 966     if (!wait_for_fds(s)) {
 967         return;
 968     }
 969
 970     wait_for_rings_started(s, 2);
 971
 972     /* reconnect */
 973     s->fds_num = 0;
 974     s->rings = 0;
 975     src = g_idle_source_new();
 976     g_source_set_callback(src, reconnect_cb, s, NULL);
 977     g_source_attach(src, s->context);
 978     g_source_unref(src);
 979     g_assert(wait_for_fds(s));
 980     wait_for_rings_started(s, 2);
 981 }
 982
 983 static void *vhost_user_test_setup_connect_fail(GString *cmd_line, void *arg)
 984 {
 985     TestServer *s = test_server_new("connect-fail", arg);
 986
 987     s->test_fail = true;
 988
 989     g_thread_unref(g_thread_new("connect", connect_thread, s));
 990     append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
 991     s->vu_ops->append_opts(s, cmd_line, ",server=on");
 992
 993     g_test_queue_destroy(vhost_user_test_cleanup, s);
 994
 995     return s;
 996 }
 997
 998 static void *vhost_user_test_setup_flags_mismatch(GString *cmd_line, void *arg)
 999 {
1000     TestServer *s = test_server_new("flags-mismatch", arg);
1001
1002     s->test_flags = TEST_FLAGS_DISCONNECT;
1003
1004     g_thread_unref(g_thread_new("connect", connect_thread, s));
1005     append_mem_opts(s, cmd_line, 256, TEST_MEMFD_AUTO);
1006     s->vu_ops->append_opts(s, cmd_line, ",server=on");
1007
1008     g_test_queue_destroy(vhost_user_test_cleanup, s);
1009
1010     return s;
1011 }
1012
1013 static void test_vhost_user_started(void *obj, void *arg, QGuestAllocator *alloc)
1014 {
1015     TestServer *s = arg;
1016
1017     if (!wait_for_fds(s)) {
1018         return;
1019     }
1020     wait_for_rings_started(s, 2);
1021 }
1022
1023 static void *vhost_user_test_setup_multiqueue(GString *cmd_line, void *arg)
1024 {
1025     TestServer *s = vhost_user_test_setup(cmd_line, arg);
1026
1027     s->queues = 2;
1028     g_string_append_printf(cmd_line,
1029                            " -set netdev.hs0.queues=%d"
1030                            " -global virtio-net-pci.vectors=%d",
1031                            s->queues, s->queues * 2 + 2);
1032
1033     return s;
1034 }
1035
1036 static void test_multiqueue(void *obj, void *arg, QGuestAllocator *alloc)
1037 {
1038     TestServer *s = arg;
1039
1040     wait_for_rings_started(s, s->queues * 2);
1041 }
1042
1043
1044 static uint64_t vu_net_get_features(TestServer *s)
1045 {
1046     uint64_t features = 0x1ULL << VHOST_F_LOG_ALL |
1047         0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1048
1049     if (s->queues > 1) {
1050         features |= 0x1ULL << VIRTIO_NET_F_MQ;
1051     }
1052
1053     return features;
1054 }
1055
1056 static void vu_net_set_features(TestServer *s, CharBackend *chr,
1057                                 VhostUserMsg *msg)
1058 {
1059     g_assert(msg->payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES));
1060     if (s->test_flags == TEST_FLAGS_DISCONNECT) {
1061         qemu_chr_fe_disconnect(chr);
1062         s->test_flags = TEST_FLAGS_BAD;
1063     }
1064 }
1065
1066 static void vu_net_get_protocol_features(TestServer *s, CharBackend *chr,
1067         VhostUserMsg *msg)
1068 {
1069     /* send back features to qemu */
1070     msg->flags |= VHOST_USER_REPLY_MASK;
1071     msg->size = sizeof(m.payload.u64);
1072     msg->payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
1073     msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_CROSS_ENDIAN;
1074     if (s->queues > 1) {
1075         msg->payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ;
1076     }
1077     qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1078 }
1079
1080 /* Each VHOST-USER device should have its ops structure defined. */
1081 static struct vhost_user_ops g_vu_net_ops = {
1082     .type = VHOST_USER_NET,
1083
1084     .append_opts = append_vhost_net_opts,
1085
1086     .get_features = vu_net_get_features,
1087     .set_features = vu_net_set_features,
1088     .get_protocol_features = vu_net_get_protocol_features,
1089 };
1090
1091 static void register_vhost_user_test(void)
1092 {
1093     QOSGraphTestOptions opts = {
1094         .before = vhost_user_test_setup,
1095         .subprocess = true,
1096         .arg = &g_vu_net_ops,
1097     };
1098
1099     qemu_add_opts(&qemu_chardev_opts);
1100
1101     qos_add_test("vhost-user/read-guest-mem/memfile",
1102                  "virtio-net",
1103                  test_read_guest_mem, &opts);
1104
1105     opts.before = vhost_user_test_setup_shm;
1106     qos_add_test("vhost-user/read-guest-mem/shm",
1107                  "virtio-net",
1108                  test_read_guest_mem, &opts);
1109
1110     if (qemu_memfd_check(MFD_ALLOW_SEALING)) {
1111         opts.before = vhost_user_test_setup_memfd;
1112         qos_add_test("vhost-user/read-guest-mem/memfd",
1113                      "virtio-net",
1114                      test_read_guest_mem, &opts);
1115     }
1116
1117     qos_add_test("vhost-user/migrate",
1118                  "virtio-net",
1119                  test_migrate, &opts);
1120
1121     opts.before = vhost_user_test_setup_reconnect;
1122     qos_add_test("vhost-user/reconnect", "virtio-net",
1123                  test_reconnect, &opts);
1124
1125     opts.before = vhost_user_test_setup_connect_fail;
1126     qos_add_test("vhost-user/connect-fail", "virtio-net",
1127                  test_vhost_user_started, &opts);
1128
1129     opts.before = vhost_user_test_setup_flags_mismatch;
1130     qos_add_test("vhost-user/flags-mismatch", "virtio-net",
1131                  test_vhost_user_started, &opts);
1132
1133     opts.before = vhost_user_test_setup_multiqueue;
1134     opts.edge.extra_device_opts = "mq=on";
1135     qos_add_test("vhost-user/multiqueue",
1136                  "virtio-net",
1137                  test_multiqueue, &opts);
1138 }
1139 libqos_init(register_vhost_user_test);
1140
1141 static uint64_t vu_gpio_get_features(TestServer *s)
1142 {
1143     return 0x1ULL << VIRTIO_F_VERSION_1 |
1144         0x1ULL << VIRTIO_GPIO_F_IRQ |
1145         0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1146 }
1147
1148 /*
1149  * This stub can't handle all the message types but we should reply
1150  * that we support VHOST_USER_PROTOCOL_F_CONFIG as gpio would use it
1151  * talking to a read vhost-user daemon.
1152  */
1153 static void vu_gpio_get_protocol_features(TestServer *s, CharBackend *chr,
1154                                           VhostUserMsg *msg)
1155 {
1156     /* send back features to qemu */
1157     msg->flags |= VHOST_USER_REPLY_MASK;
1158     msg->size = sizeof(m.payload.u64);
1159     msg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_CONFIG;
1160
1161     qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1162 }
1163
1164 static struct vhost_user_ops g_vu_gpio_ops = {
1165     .type = VHOST_USER_GPIO,
1166
1167     .append_opts = append_vhost_gpio_opts,
1168
1169     .get_features = vu_gpio_get_features,
1170     .set_features = vu_net_set_features,
1171     .get_protocol_features = vu_gpio_get_protocol_features,
1172 };
1173
1174 static void register_vhost_gpio_test(void)
1175 {
1176     QOSGraphTestOptions opts = {
1177         .before = vhost_user_test_setup,
1178         .subprocess = true,
1179         .arg = &g_vu_gpio_ops,
1180     };
1181
1182     qemu_add_opts(&qemu_chardev_opts);
1183
1184     qos_add_test("read-guest-mem/memfile",
1185                  "vhost-user-gpio", test_read_guest_mem, &opts);
1186 }
1187 libqos_init(register_vhost_gpio_test);
1188
1189 static uint64_t vu_scmi_get_features(TestServer *s)
1190 {
1191     return 0x1ULL << VIRTIO_F_VERSION_1 |
1192         0x1ULL << VIRTIO_SCMI_F_P2A_CHANNELS |
1193         0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
1194 }
1195
1196 static void vu_scmi_get_protocol_features(TestServer *s, CharBackend *chr,
1197                                           VhostUserMsg *msg)
1198 {
1199     msg->flags |= VHOST_USER_REPLY_MASK;
1200     msg->size = sizeof(m.payload.u64);
1201     msg->payload.u64 = 1ULL << VHOST_USER_PROTOCOL_F_MQ;
1202
1203     qemu_chr_fe_write_all(chr, (uint8_t *)msg, VHOST_USER_HDR_SIZE + msg->size);
1204 }
1205
1206 static struct vhost_user_ops g_vu_scmi_ops = {
1207     .type = VHOST_USER_SCMI,
1208
1209     .append_opts = append_vhost_gpio_opts,
1210
1211     .get_features = vu_scmi_get_features,
1212     .set_features = vu_net_set_features,
1213     .get_protocol_features = vu_scmi_get_protocol_features,
1214 };
1215
1216 static void register_vhost_scmi_test(void)
1217 {
1218     QOSGraphTestOptions opts = {
1219         .before = vhost_user_test_setup,
1220         .subprocess = true,
1221         .arg = &g_vu_scmi_ops,
1222     };
1223
1224     qemu_add_opts(&qemu_chardev_opts);
1225
1226     qos_add_test("scmi/read-guest-mem/memfile",
1227                  "vhost-user-scmi", test_read_guest_mem, &opts);
1228 }
1229 libqos_init(register_vhost_scmi_test);