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