tests/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 <glib.h>
  12
  13 #include "libqtest.h"
  14 #include "qemu/option.h"
  15 #include "sysemu/char.h"
  16 #include "sysemu/sysemu.h"
  17
  18 #include <linux/vhost.h>
  19 #include <sys/mman.h>
  20 #include <sys/vfs.h>
  21 #include <qemu/sockets.h>
  22
  23 /* GLIB version compatibility flags */
  24 #if !GLIB_CHECK_VERSION(2, 26, 0)
  25 #define G_TIME_SPAN_SECOND              (G_GINT64_CONSTANT(1000000))
  26 #endif
  27
  28 #if GLIB_CHECK_VERSION(2, 28, 0)
  29 #define HAVE_MONOTONIC_TIME
  30 #endif
  31
  32 #define QEMU_CMD_ACCEL  " -machine accel=tcg"
  33 #define QEMU_CMD_MEM    " -m 512 -object memory-backend-file,id=mem,size=512M,"\
  34                         "mem-path=%s,share=on -numa node,memdev=mem"
  35 #define QEMU_CMD_CHR    " -chardev socket,id=chr0,path=%s"
  36 #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=chr0,vhostforce"
  37 #define QEMU_CMD_NET    " -device virtio-net-pci,netdev=net0 "
  38 #define QEMU_CMD_ROM    " -option-rom ../pc-bios/pxe-virtio.rom"
  39
  40 #define QEMU_CMD        QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \
  41                         QEMU_CMD_NETDEV QEMU_CMD_NET QEMU_CMD_ROM
  42
  43 #define HUGETLBFS_MAGIC       0x958458f6
  44
  45 /*********** FROM hw/virtio/vhost-user.c *************************************/
  46
  47 #define VHOST_MEMORY_MAX_NREGIONS    8
  48
  49 #define VHOST_USER_F_PROTOCOL_FEATURES 30
  50
  51 typedef enum VhostUserRequest {
  52     VHOST_USER_NONE = 0,
  53     VHOST_USER_GET_FEATURES = 1,
  54     VHOST_USER_SET_FEATURES = 2,
  55     VHOST_USER_SET_OWNER = 3,
  56     VHOST_USER_RESET_DEVICE = 4,
  57     VHOST_USER_SET_MEM_TABLE = 5,
  58     VHOST_USER_SET_LOG_BASE = 6,
  59     VHOST_USER_SET_LOG_FD = 7,
  60     VHOST_USER_SET_VRING_NUM = 8,
  61     VHOST_USER_SET_VRING_ADDR = 9,
  62     VHOST_USER_SET_VRING_BASE = 10,
  63     VHOST_USER_GET_VRING_BASE = 11,
  64     VHOST_USER_SET_VRING_KICK = 12,
  65     VHOST_USER_SET_VRING_CALL = 13,
  66     VHOST_USER_SET_VRING_ERR = 14,
  67     VHOST_USER_GET_PROTOCOL_FEATURES = 15,
  68     VHOST_USER_SET_PROTOCOL_FEATURES = 16,
  69     VHOST_USER_MAX
  70 } VhostUserRequest;
  71
  72 typedef struct VhostUserMemoryRegion {
  73     uint64_t guest_phys_addr;
  74     uint64_t memory_size;
  75     uint64_t userspace_addr;
  76     uint64_t mmap_offset;
  77 } VhostUserMemoryRegion;
  78
  79 typedef struct VhostUserMemory {
  80     uint32_t nregions;
  81     uint32_t padding;
  82     VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
  83 } VhostUserMemory;
  84
  85 typedef struct VhostUserMsg {
  86     VhostUserRequest request;
  87
  88 #define VHOST_USER_VERSION_MASK     (0x3)
  89 #define VHOST_USER_REPLY_MASK       (0x1<<2)
  90     uint32_t flags;
  91     uint32_t size; /* the following payload size */
  92     union {
  93         uint64_t u64;
  94         struct vhost_vring_state state;
  95         struct vhost_vring_addr addr;
  96         VhostUserMemory memory;
  97     };
  98 } QEMU_PACKED VhostUserMsg;
  99
 100 static VhostUserMsg m __attribute__ ((unused));
 101 #define VHOST_USER_HDR_SIZE (sizeof(m.request) \
 102                             + sizeof(m.flags) \
 103                             + sizeof(m.size))
 104
 105 #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
 106
 107 /* The version of the protocol we support */
 108 #define VHOST_USER_VERSION    (0x1)
 109 /*****************************************************************************/
 110
 111 int fds_num = 0, fds[VHOST_MEMORY_MAX_NREGIONS];
 112 static VhostUserMemory memory;
 113 static CompatGMutex data_mutex;
 114 static CompatGCond data_cond;
 115
 116 #if !GLIB_CHECK_VERSION(2, 32, 0)
 117 static gboolean g_cond_wait_until(CompatGCond cond, CompatGMutex mutex,
 118                                   gint64 end_time)
 119 {
 120     gboolean ret = FALSE;
 121     end_time -= g_get_monotonic_time();
 122     GTimeVal time = { end_time / G_TIME_SPAN_SECOND,
 123                       end_time % G_TIME_SPAN_SECOND };
 124     ret = g_cond_timed_wait(cond, mutex, &time);
 125     return ret;
 126 }
 127 #endif
 128
 129 static void read_guest_mem(void)
 130 {
 131     uint32_t *guest_mem;
 132     gint64 end_time;
 133     int i, j;
 134     size_t size;
 135
 136     g_mutex_lock(&data_mutex);
 137
 138     end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
 139     while (!fds_num) {
 140         if (!g_cond_wait_until(&data_cond, &data_mutex, end_time)) {
 141             /* timeout has passed */
 142             g_assert(fds_num);
 143             break;
 144         }
 145     }
 146
 147     /* check for sanity */
 148     g_assert_cmpint(fds_num, >, 0);
 149     g_assert_cmpint(fds_num, ==, memory.nregions);
 150
 151     /* iterate all regions */
 152     for (i = 0; i < fds_num; i++) {
 153
 154         /* We'll check only the region statring at 0x0*/
 155         if (memory.regions[i].guest_phys_addr != 0x0) {
 156             continue;
 157         }
 158
 159         g_assert_cmpint(memory.regions[i].memory_size, >, 1024);
 160
 161         size =  memory.regions[i].memory_size + memory.regions[i].mmap_offset;
 162
 163         guest_mem = mmap(0, size, PROT_READ | PROT_WRITE,
 164                          MAP_SHARED, fds[i], 0);
 165
 166         g_assert(guest_mem != MAP_FAILED);
 167         guest_mem += (memory.regions[i].mmap_offset / sizeof(*guest_mem));
 168
 169         for (j = 0; j < 256; j++) {
 170             uint32_t a = readl(memory.regions[i].guest_phys_addr + j*4);
 171             uint32_t b = guest_mem[j];
 172
 173             g_assert_cmpint(a, ==, b);
 174         }
 175
 176         munmap(guest_mem, memory.regions[i].memory_size);
 177     }
 178
 179     g_assert_cmpint(1, ==, 1);
 180     g_mutex_unlock(&data_mutex);
 181 }
 182
 183 static void *thread_function(void *data)
 184 {
 185     GMainLoop *loop;
 186     loop = g_main_loop_new(NULL, FALSE);
 187     g_main_loop_run(loop);
 188     return NULL;
 189 }
 190
 191 static int chr_can_read(void *opaque)
 192 {
 193     return VHOST_USER_HDR_SIZE;
 194 }
 195
 196 static void chr_read(void *opaque, const uint8_t *buf, int size)
 197 {
 198     CharDriverState *chr = opaque;
 199     VhostUserMsg msg;
 200     uint8_t *p = (uint8_t *) &msg;
 201     int fd;
 202
 203     if (size != VHOST_USER_HDR_SIZE) {
 204         g_test_message("Wrong message size received %d\n", size);
 205         return;
 206     }
 207
 208     g_mutex_lock(&data_mutex);
 209     memcpy(p, buf, VHOST_USER_HDR_SIZE);
 210
 211     if (msg.size) {
 212         p += VHOST_USER_HDR_SIZE;
 213         qemu_chr_fe_read_all(chr, p, msg.size);
 214     }
 215
 216     switch (msg.request) {
 217     case VHOST_USER_GET_FEATURES:
 218         /* send back features to qemu */
 219         msg.flags |= VHOST_USER_REPLY_MASK;
 220         msg.size = sizeof(m.u64);
 221         msg.u64 = 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
 222         p = (uint8_t *) &msg;
 223         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 224         break;
 225
 226     case VHOST_USER_SET_FEATURES:
 227         g_assert_cmpint(msg.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
 228                         !=, 0ULL);
 229         break;
 230
 231     case VHOST_USER_GET_PROTOCOL_FEATURES:
 232         /* send back features to qemu */
 233         msg.flags |= VHOST_USER_REPLY_MASK;
 234         msg.size = sizeof(m.u64);
 235         msg.u64 = 0;
 236         p = (uint8_t *) &msg;
 237         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 238         break;
 239
 240     case VHOST_USER_GET_VRING_BASE:
 241         /* send back vring base to qemu */
 242         msg.flags |= VHOST_USER_REPLY_MASK;
 243         msg.size = sizeof(m.state);
 244         msg.state.num = 0;
 245         p = (uint8_t *) &msg;
 246         qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
 247         break;
 248
 249     case VHOST_USER_SET_MEM_TABLE:
 250         /* received the mem table */
 251         memcpy(&memory, &msg.memory, sizeof(msg.memory));
 252         fds_num = qemu_chr_fe_get_msgfds(chr, fds, sizeof(fds) / sizeof(int));
 253
 254         /* signal the test that it can continue */
 255         g_cond_signal(&data_cond);
 256         break;
 257
 258     case VHOST_USER_SET_VRING_KICK:
 259     case VHOST_USER_SET_VRING_CALL:
 260         /* consume the fd */
 261         qemu_chr_fe_get_msgfds(chr, &fd, 1);
 262         /*
 263          * This is a non-blocking eventfd.
 264          * The receive function forces it to be blocking,
 265          * so revert it back to non-blocking.
 266          */
 267         qemu_set_nonblock(fd);
 268         break;
 269     default:
 270         break;
 271     }
 272     g_mutex_unlock(&data_mutex);
 273 }
 274
 275 static const char *init_hugepagefs(const char *path)
 276 {
 277     struct statfs fs;
 278     int ret;
 279
 280     if (access(path, R_OK | W_OK | X_OK)) {
 281         g_test_message("access on path (%s): %s\n", path, strerror(errno));
 282         return NULL;
 283     }
 284
 285     do {
 286         ret = statfs(path, &fs);
 287     } while (ret != 0 && errno == EINTR);
 288
 289     if (ret != 0) {
 290         g_test_message("statfs on path (%s): %s\n", path, strerror(errno));
 291         return NULL;
 292     }
 293
 294     if (fs.f_type != HUGETLBFS_MAGIC) {
 295         g_test_message("Warning: path not on HugeTLBFS: %s\n", path);
 296         return NULL;
 297     }
 298
 299     return path;
 300 }
 301
 302 int main(int argc, char **argv)
 303 {
 304     QTestState *s = NULL;
 305     CharDriverState *chr = NULL;
 306     const char *hugefs;
 307     char *socket_path = 0;
 308     char *qemu_cmd = 0;
 309     char *chr_path = 0;
 310     int ret;
 311     char template[] = "/tmp/vhost-test-XXXXXX";
 312     const char *tmpfs;
 313     const char *root;
 314
 315     g_test_init(&argc, &argv, NULL);
 316
 317     module_call_init(MODULE_INIT_QOM);
 318
 319     tmpfs = mkdtemp(template);
 320     if (!tmpfs) {
 321           g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
 322     }
 323     g_assert(tmpfs);
 324
 325     hugefs = getenv("QTEST_HUGETLBFS_PATH");
 326     if (hugefs) {
 327         root = init_hugepagefs(hugefs);
 328         g_assert(root);
 329     } else {
 330         root = tmpfs;
 331     }
 332
 333     socket_path = g_strdup_printf("%s/vhost.sock", tmpfs);
 334
 335     /* create char dev and add read handlers */
 336     qemu_add_opts(&qemu_chardev_opts);
 337     chr_path = g_strdup_printf("unix:%s,server,nowait", socket_path);
 338     chr = qemu_chr_new("chr0", chr_path, NULL);
 339     g_free(chr_path);
 340     qemu_chr_add_handlers(chr, chr_can_read, chr_read, NULL, chr);
 341
 342     /* run the main loop thread so the chardev may operate */
 343     g_mutex_init(&data_mutex);
 344     g_cond_init(&data_cond);
 345     g_thread_new(NULL, thread_function, NULL);
 346
 347     qemu_cmd = g_strdup_printf(QEMU_CMD, root, socket_path);
 348     s = qtest_start(qemu_cmd);
 349     g_free(qemu_cmd);
 350
 351     qtest_add_func("/vhost-user/read-guest-mem", read_guest_mem);
 352
 353     ret = g_test_run();
 354
 355     if (s) {
 356         qtest_quit(s);
 357     }
 358
 359     /* cleanup */
 360     unlink(socket_path);
 361     g_free(socket_path);
 362
 363     ret = rmdir(tmpfs);
 364     if (ret != 0) {
 365         g_test_message("unable to rmdir: path (%s): %s\n",
 366                        tmpfs, strerror(errno));
 367     }
 368     g_assert_cmpint(ret, ==, 0);
 369
 370     return ret;
 371 }