/* * QTest testcase for the vhost-user * * Copyright (c) 2014 Virtual Open Systems Sarl. * * This work is licensed under the terms of the GNU GPL, version 2 or later. * See the COPYING file in the top-level directory. * */ #include #include "libqtest.h" #include "qemu/option.h" #include "qemu/range.h" #include "sysemu/char.h" #include "sysemu/sysemu.h" #include #include #include #include /* GLIB version compatibility flags */ #if !GLIB_CHECK_VERSION(2, 26, 0) #define G_TIME_SPAN_SECOND (G_GINT64_CONSTANT(1000000)) #endif #if GLIB_CHECK_VERSION(2, 28, 0) #define HAVE_MONOTONIC_TIME #endif #define QEMU_CMD_ACCEL " -machine accel=tcg" #define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\ "mem-path=%s,share=on -numa node,memdev=mem" #define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s" #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce" #define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0 " #define QEMU_CMD_ROM " -option-rom ../pc-bios/pxe-virtio.rom" #define QEMU_CMD QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \ QEMU_CMD_NETDEV QEMU_CMD_NET QEMU_CMD_ROM #define HUGETLBFS_MAGIC 0x958458f6 /*********** FROM hw/virtio/vhost-user.c *************************************/ #define VHOST_MEMORY_MAX_NREGIONS 8 #define VHOST_USER_F_PROTOCOL_FEATURES 30 #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1 #define VHOST_LOG_PAGE 0x1000 typedef enum VhostUserRequest { VHOST_USER_NONE = 0, VHOST_USER_GET_FEATURES = 1, VHOST_USER_SET_FEATURES = 2, VHOST_USER_SET_OWNER = 3, VHOST_USER_RESET_OWNER = 4, VHOST_USER_SET_MEM_TABLE = 5, VHOST_USER_SET_LOG_BASE = 6, VHOST_USER_SET_LOG_FD = 7, VHOST_USER_SET_VRING_NUM = 8, VHOST_USER_SET_VRING_ADDR = 9, VHOST_USER_SET_VRING_BASE = 10, VHOST_USER_GET_VRING_BASE = 11, VHOST_USER_SET_VRING_KICK = 12, VHOST_USER_SET_VRING_CALL = 13, VHOST_USER_SET_VRING_ERR = 14, VHOST_USER_GET_PROTOCOL_FEATURES = 15, VHOST_USER_SET_PROTOCOL_FEATURES = 16, VHOST_USER_MAX } VhostUserRequest; typedef struct VhostUserMemoryRegion { uint64_t guest_phys_addr; uint64_t memory_size; uint64_t userspace_addr; uint64_t mmap_offset; } VhostUserMemoryRegion; typedef struct VhostUserMemory { uint32_t nregions; uint32_t padding; VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS]; } VhostUserMemory; typedef struct VhostUserLog { uint64_t mmap_size; uint64_t mmap_offset; } VhostUserLog; typedef struct VhostUserMsg { VhostUserRequest request; #define VHOST_USER_VERSION_MASK (0x3) #define VHOST_USER_REPLY_MASK (0x1<<2) uint32_t flags; uint32_t size; /* the following payload size */ union { #define VHOST_USER_VRING_IDX_MASK (0xff) #define VHOST_USER_VRING_NOFD_MASK (0x1<<8) uint64_t u64; struct vhost_vring_state state; struct vhost_vring_addr addr; VhostUserMemory memory; VhostUserLog log; } payload; } QEMU_PACKED VhostUserMsg; static VhostUserMsg m __attribute__ ((unused)); #define VHOST_USER_HDR_SIZE (sizeof(m.request) \ + sizeof(m.flags) \ + sizeof(m.size)) #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE) /* The version of the protocol we support */ #define VHOST_USER_VERSION (0x1) /*****************************************************************************/ typedef struct TestServer { gchar *socket_path; gchar *chr_name; CharDriverState *chr; int fds_num; int fds[VHOST_MEMORY_MAX_NREGIONS]; VhostUserMemory memory; GMutex data_mutex; GCond data_cond; int log_fd; } TestServer; #if !GLIB_CHECK_VERSION(2, 32, 0) static gboolean g_cond_wait_until(CompatGCond cond, CompatGMutex mutex, gint64 end_time) { gboolean ret = FALSE; end_time -= g_get_monotonic_time(); GTimeVal time = { end_time / G_TIME_SPAN_SECOND, end_time % G_TIME_SPAN_SECOND }; ret = g_cond_timed_wait(cond, mutex, &time); return ret; } #endif static const char *tmpfs; static const char *root; static void wait_for_fds(TestServer *s) { gint64 end_time; g_mutex_lock(&s->data_mutex); end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; while (!s->fds_num) { if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { /* timeout has passed */ g_assert(s->fds_num); break; } } /* check for sanity */ g_assert_cmpint(s->fds_num, >, 0); g_assert_cmpint(s->fds_num, ==, s->memory.nregions); g_mutex_unlock(&s->data_mutex); } static void read_guest_mem(TestServer *s) { uint32_t *guest_mem; int i, j; size_t size; wait_for_fds(s); g_mutex_lock(&s->data_mutex); /* iterate all regions */ for (i = 0; i < s->fds_num; i++) { /* We'll check only the region statring at 0x0*/ if (s->memory.regions[i].guest_phys_addr != 0x0) { continue; } g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024); size = s->memory.regions[i].memory_size + s->memory.regions[i].mmap_offset; guest_mem = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->fds[i], 0); g_assert(guest_mem != MAP_FAILED); guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem)); for (j = 0; j < 256; j++) { uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4); uint32_t b = guest_mem[j]; g_assert_cmpint(a, ==, b); } munmap(guest_mem, s->memory.regions[i].memory_size); } g_mutex_unlock(&s->data_mutex); } static void *thread_function(void *data) { GMainLoop *loop; loop = g_main_loop_new(NULL, FALSE); g_main_loop_run(loop); return NULL; } static int chr_can_read(void *opaque) { return VHOST_USER_HDR_SIZE; } static void chr_read(void *opaque, const uint8_t *buf, int size) { TestServer *s = opaque; CharDriverState *chr = s->chr; VhostUserMsg msg; uint8_t *p = (uint8_t *) &msg; int fd; if (size != VHOST_USER_HDR_SIZE) { g_test_message("Wrong message size received %d\n", size); return; } g_mutex_lock(&s->data_mutex); memcpy(p, buf, VHOST_USER_HDR_SIZE); if (msg.size) { p += VHOST_USER_HDR_SIZE; g_assert_cmpint(qemu_chr_fe_read_all(chr, p, msg.size), ==, msg.size); } switch (msg.request) { case VHOST_USER_GET_FEATURES: /* send back features to qemu */ msg.flags |= VHOST_USER_REPLY_MASK; msg.size = sizeof(m.payload.u64); msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL | 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES; p = (uint8_t *) &msg; qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); break; case VHOST_USER_SET_FEATURES: g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES), !=, 0ULL); break; case VHOST_USER_GET_PROTOCOL_FEATURES: /* send back features to qemu */ msg.flags |= VHOST_USER_REPLY_MASK; msg.size = sizeof(m.payload.u64); msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD; p = (uint8_t *) &msg; qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); break; case VHOST_USER_GET_VRING_BASE: /* send back vring base to qemu */ msg.flags |= VHOST_USER_REPLY_MASK; msg.size = sizeof(m.payload.state); msg.payload.state.num = 0; p = (uint8_t *) &msg; qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); break; case VHOST_USER_SET_MEM_TABLE: /* received the mem table */ memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory)); s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds)); /* signal the test that it can continue */ g_cond_signal(&s->data_cond); break; case VHOST_USER_SET_VRING_KICK: case VHOST_USER_SET_VRING_CALL: /* consume the fd */ qemu_chr_fe_get_msgfds(chr, &fd, 1); /* * This is a non-blocking eventfd. * The receive function forces it to be blocking, * so revert it back to non-blocking. */ qemu_set_nonblock(fd); break; case VHOST_USER_SET_LOG_BASE: if (s->log_fd != -1) { close(s->log_fd); s->log_fd = -1; } qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1); msg.flags |= VHOST_USER_REPLY_MASK; msg.size = 0; p = (uint8_t *) &msg; qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE); g_cond_signal(&s->data_cond); break; case VHOST_USER_RESET_OWNER: s->fds_num = 0; break; default: break; } g_mutex_unlock(&s->data_mutex); } static const char *init_hugepagefs(const char *path) { struct statfs fs; int ret; if (access(path, R_OK | W_OK | X_OK)) { g_test_message("access on path (%s): %s\n", path, strerror(errno)); return NULL; } do { ret = statfs(path, &fs); } while (ret != 0 && errno == EINTR); if (ret != 0) { g_test_message("statfs on path (%s): %s\n", path, strerror(errno)); return NULL; } if (fs.f_type != HUGETLBFS_MAGIC) { g_test_message("Warning: path not on HugeTLBFS: %s\n", path); return NULL; } return path; } static TestServer *test_server_new(const gchar *name) { TestServer *server = g_new0(TestServer, 1); gchar *chr_path; server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name); chr_path = g_strdup_printf("unix:%s,server,nowait", server->socket_path); server->chr_name = g_strdup_printf("chr-%s", name); server->chr = qemu_chr_new(server->chr_name, chr_path, NULL); g_free(chr_path); qemu_chr_add_handlers(server->chr, chr_can_read, chr_read, NULL, server); g_mutex_init(&server->data_mutex); g_cond_init(&server->data_cond); server->log_fd = -1; return server; } #define GET_QEMU_CMD(s) \ g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \ (s)->socket_path, (s)->chr_name) #define GET_QEMU_CMDE(s, mem, extra, ...) \ g_strdup_printf(QEMU_CMD extra, (mem), (mem), (root), (s)->chr_name, \ (s)->socket_path, (s)->chr_name, ##__VA_ARGS__) static void test_server_free(TestServer *server) { int i; qemu_chr_delete(server->chr); for (i = 0; i < server->fds_num; i++) { close(server->fds[i]); } if (server->log_fd != -1) { close(server->log_fd); } unlink(server->socket_path); g_free(server->socket_path); g_free(server->chr_name); g_free(server); } static void wait_for_log_fd(TestServer *s) { gint64 end_time; g_mutex_lock(&s->data_mutex); end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; while (s->log_fd == -1) { if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { /* timeout has passed */ g_assert(s->log_fd != -1); break; } } g_mutex_unlock(&s->data_mutex); } static void write_guest_mem(TestServer *s, uint32 seed) { uint32_t *guest_mem; int i, j; size_t size; wait_for_fds(s); /* iterate all regions */ for (i = 0; i < s->fds_num; i++) { /* We'll write only the region statring at 0x0 */ if (s->memory.regions[i].guest_phys_addr != 0x0) { continue; } g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024); size = s->memory.regions[i].memory_size + s->memory.regions[i].mmap_offset; guest_mem = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->fds[i], 0); g_assert(guest_mem != MAP_FAILED); guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem)); for (j = 0; j < 256; j++) { guest_mem[j] = seed + j; } munmap(guest_mem, s->memory.regions[i].memory_size); break; } } static guint64 get_log_size(TestServer *s) { guint64 log_size = 0; int i; for (i = 0; i < s->memory.nregions; ++i) { VhostUserMemoryRegion *reg = &s->memory.regions[i]; guint64 last = range_get_last(reg->guest_phys_addr, reg->memory_size); log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1); } return log_size; } typedef struct TestMigrateSource { GSource source; TestServer *src; TestServer *dest; } TestMigrateSource; static gboolean test_migrate_source_check(GSource *source) { TestMigrateSource *t = (TestMigrateSource *)source; gboolean overlap = t->src->fds_num > 0 && t->dest->fds_num > 0; g_assert(!overlap); return FALSE; } GSourceFuncs test_migrate_source_funcs = { NULL, test_migrate_source_check, NULL, NULL }; static void test_migrate(void) { TestServer *s = test_server_new("src"); TestServer *dest = test_server_new("dest"); const char *uri = "tcp:127.0.0.1:1234"; QTestState *global = global_qtest, *from, *to; GSource *source; gchar *cmd; QDict *rsp; guint8 *log; guint64 size; cmd = GET_QEMU_CMDE(s, 2, ""); from = qtest_start(cmd); g_free(cmd); wait_for_fds(s); size = get_log_size(s); g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8)); cmd = GET_QEMU_CMDE(dest, 2, " -incoming %s", uri); to = qtest_init(cmd); g_free(cmd); source = g_source_new(&test_migrate_source_funcs, sizeof(TestMigrateSource)); ((TestMigrateSource *)source)->src = s; ((TestMigrateSource *)source)->dest = dest; g_source_attach(source, NULL); /* slow down migration to have time to fiddle with log */ /* TODO: qtest could learn to break on some places */ rsp = qmp("{ 'execute': 'migrate_set_speed'," "'arguments': { 'value': 10 } }"); g_assert(qdict_haskey(rsp, "return")); QDECREF(rsp); cmd = g_strdup_printf("{ 'execute': 'migrate'," "'arguments': { 'uri': '%s' } }", uri); rsp = qmp(cmd); g_free(cmd); g_assert(qdict_haskey(rsp, "return")); QDECREF(rsp); wait_for_log_fd(s); log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0); g_assert(log != MAP_FAILED); /* modify first page */ write_guest_mem(s, 0x42); log[0] = 1; munmap(log, size); /* speed things up */ rsp = qmp("{ 'execute': 'migrate_set_speed'," "'arguments': { 'value': 0 } }"); g_assert(qdict_haskey(rsp, "return")); QDECREF(rsp); qmp_eventwait("STOP"); global_qtest = to; qmp_eventwait("RESUME"); read_guest_mem(dest); g_source_destroy(source); g_source_unref(source); qtest_quit(to); test_server_free(dest); qtest_quit(from); test_server_free(s); global_qtest = global; } int main(int argc, char **argv) { QTestState *s = NULL; TestServer *server = NULL; const char *hugefs; char *qemu_cmd = NULL; int ret; char template[] = "/tmp/vhost-test-XXXXXX"; g_test_init(&argc, &argv, NULL); module_call_init(MODULE_INIT_QOM); qemu_add_opts(&qemu_chardev_opts); tmpfs = mkdtemp(template); if (!tmpfs) { g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno)); } g_assert(tmpfs); hugefs = getenv("QTEST_HUGETLBFS_PATH"); if (hugefs) { root = init_hugepagefs(hugefs); g_assert(root); } else { root = tmpfs; } server = test_server_new("test"); /* run the main loop thread so the chardev may operate */ g_thread_new(NULL, thread_function, NULL); qemu_cmd = GET_QEMU_CMD(server); s = qtest_start(qemu_cmd); g_free(qemu_cmd); qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem); qtest_add_func("/vhost-user/migrate", test_migrate); ret = g_test_run(); if (s) { qtest_quit(s); } /* cleanup */ test_server_free(server); ret = rmdir(tmpfs); if (ret != 0) { g_test_message("unable to rmdir: path (%s): %s\n", tmpfs, strerror(errno)); } g_assert_cmpint(ret, ==, 0); return ret; }