[mirror_qemu.git] / tests / vhost-user-test.c

/*
 * 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 <glib.h>

#include "libqtest.h"
#include "qemu/option.h"
#include "qemu/range.h"
#include "sysemu/char.h"
#include "sysemu/sysemu.h"

#include <linux/vhost.h>
#include <sys/mman.h>
#include <sys/vfs.h>
#include <qemu/sockets.h>

/* 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_DEVICE = 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_DEVICE:
        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;
}
Commit	Line	Data
a77e6b14 NN	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
bd95939f NN	11	#include <glib.h>
bd95939f NN	12
a77e6b14 NN	13	#include "libqtest.h"
a77e6b14 NN	14	#include "qemu/option.h"
b1819747	15	#include "qemu/range.h"
a77e6b14 NN	16	#include "sysemu/char.h"
	17	#include "sysemu/sysemu.h"
	18
a77e6b14 NN	19	#include <linux/vhost.h>
	20	#include <sys/mman.h>
	21	#include <sys/vfs.h>
	22	#include <qemu/sockets.h>
	23
30de46db GA	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
a77e6b14	33	#define QEMU_CMD_ACCEL " -machine accel=tcg"
704b2168	34	#define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM,"\
a77e6b14	35	"mem-path=%s,share=on -numa node,memdev=mem"
704b2168 MAL	36	#define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s"
704b2168 MAL	37	#define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce"
a77e6b14 NN	38	#define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0 "
	39	#define QEMU_CMD_ROM " -option-rom ../pc-bios/pxe-virtio.rom"
	40
	41	#define QEMU_CMD QEMU_CMD_ACCEL QEMU_CMD_MEM QEMU_CMD_CHR \
	42	QEMU_CMD_NETDEV QEMU_CMD_NET QEMU_CMD_ROM
	43
	44	#define HUGETLBFS_MAGIC 0x958458f6
	45
	46	/********* FROM hw/virtio/vhost-user.c ***********************************/
	47
	48	#define VHOST_MEMORY_MAX_NREGIONS 8
	49
8a9b6b37	50	#define VHOST_USER_F_PROTOCOL_FEATURES 30
b1819747 MAL	51	#define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1
	52
	53	#define VHOST_LOG_PAGE 0x1000
8a9b6b37	54
a77e6b14 NN	55	typedef enum VhostUserRequest {
	56	VHOST_USER_NONE = 0,
	57	VHOST_USER_GET_FEATURES = 1,
	58	VHOST_USER_SET_FEATURES = 2,
	59	VHOST_USER_SET_OWNER = 3,
d1f8b30e	60	VHOST_USER_RESET_DEVICE = 4,
a77e6b14 NN	61	VHOST_USER_SET_MEM_TABLE = 5,
	62	VHOST_USER_SET_LOG_BASE = 6,
	63	VHOST_USER_SET_LOG_FD = 7,
	64	VHOST_USER_SET_VRING_NUM = 8,
	65	VHOST_USER_SET_VRING_ADDR = 9,
	66	VHOST_USER_SET_VRING_BASE = 10,
	67	VHOST_USER_GET_VRING_BASE = 11,
	68	VHOST_USER_SET_VRING_KICK = 12,
	69	VHOST_USER_SET_VRING_CALL = 13,
	70	VHOST_USER_SET_VRING_ERR = 14,
8a9b6b37 MT	71	VHOST_USER_GET_PROTOCOL_FEATURES = 15,
8a9b6b37 MT	72	VHOST_USER_SET_PROTOCOL_FEATURES = 16,
a77e6b14 NN	73	VHOST_USER_MAX
	74	} VhostUserRequest;
	75
	76	typedef struct VhostUserMemoryRegion {
	77	uint64_t guest_phys_addr;
	78	uint64_t memory_size;
	79	uint64_t userspace_addr;
d6970e3b	80	uint64_t mmap_offset;
a77e6b14 NN	81	} VhostUserMemoryRegion;
	82
	83	typedef struct VhostUserMemory {
	84	uint32_t nregions;
	85	uint32_t padding;
	86	VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS];
	87	} VhostUserMemory;
	88
2b8819c6 VK	89	typedef struct VhostUserLog {
	90	uint64_t mmap_size;
	91	uint64_t mmap_offset;
	92	} VhostUserLog;
	93
a77e6b14 NN	94	typedef struct VhostUserMsg {
	95	VhostUserRequest request;
	96
	97	#define VHOST_USER_VERSION_MASK (0x3)
	98	#define VHOST_USER_REPLY_MASK (0x1<<2)
	99	uint32_t flags;
	100	uint32_t size; /* the following payload size */
	101	union {
2b8819c6 VK	102	#define VHOST_USER_VRING_IDX_MASK (0xff)
2b8819c6 VK	103	#define VHOST_USER_VRING_NOFD_MASK (0x1<<8)
a77e6b14 NN	104	uint64_t u64;
	105	struct vhost_vring_state state;
	106	struct vhost_vring_addr addr;
	107	VhostUserMemory memory;
2b8819c6	108	VhostUserLog log;
12ebf690	109	} payload;
a77e6b14 NN	110	} QEMU_PACKED VhostUserMsg;
	111
	112	static VhostUserMsg m __attribute__ ((unused));
	113	#define VHOST_USER_HDR_SIZE (sizeof(m.request) \
	114	+ sizeof(m.flags) \
	115	+ sizeof(m.size))
	116
	117	#define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE)
	118
	119	/* The version of the protocol we support */
	120	#define VHOST_USER_VERSION (0x1)
	121	/*****************************************************************************/
	122
ae31fb54 MAL	123	typedef struct TestServer {
	124	gchar *socket_path;
	125	gchar *chr_name;
	126	CharDriverState *chr;
	127	int fds_num;
	128	int fds[VHOST_MEMORY_MAX_NREGIONS];
	129	VhostUserMemory memory;
	130	GMutex data_mutex;
	131	GCond data_cond;
b1819747	132	int log_fd;
ae31fb54	133	} TestServer;
bd95939f	134
ca06d9cc PB	135	#if !GLIB_CHECK_VERSION(2, 32, 0)
	136	static gboolean g_cond_wait_until(CompatGCond cond, CompatGMutex mutex,
	137	gint64 end_time)
bd95939f NN	138	{
bd95939f NN	139	gboolean ret = FALSE;
ca06d9cc	140	end_time -= g_get_monotonic_time();
bd95939f NN	141	GTimeVal time = { end_time / G_TIME_SPAN_SECOND,
	142	end_time % G_TIME_SPAN_SECOND };
	143	ret = g_cond_timed_wait(cond, mutex, &time);
bd95939f NN	144	return ret;
bd95939f NN	145	}
bd95939f	146	#endif
a77e6b14	147
704b2168 MAL	148	static const char *tmpfs;
	149	static const char *root;
	150
ae31fb54	151	static void wait_for_fds(TestServer *s)
a77e6b14	152	{
a77e6b14	153	gint64 end_time;
a77e6b14	154
ae31fb54	155	g_mutex_lock(&s->data_mutex);
a77e6b14	156
ca06d9cc	157	end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
ae31fb54 MAL	158	while (!s->fds_num) {
ae31fb54 MAL	159	if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
a77e6b14	160	/* timeout has passed */
ae31fb54	161	g_assert(s->fds_num);
a77e6b14 NN	162	break;
	163	}
	164	}
	165
	166	/* check for sanity */
ae31fb54 MAL	167	g_assert_cmpint(s->fds_num, >, 0);
ae31fb54 MAL	168	g_assert_cmpint(s->fds_num, ==, s->memory.nregions);
a77e6b14	169
ae31fb54	170	g_mutex_unlock(&s->data_mutex);
cf72b57f MAL	171	}
cf72b57f MAL	172
ae31fb54	173	static void read_guest_mem(TestServer *s)
cf72b57f MAL	174	{
	175	uint32_t *guest_mem;
	176	int i, j;
	177	size_t size;
	178
ae31fb54	179	wait_for_fds(s);
cf72b57f	180
ae31fb54	181	g_mutex_lock(&s->data_mutex);
cf72b57f	182
a77e6b14	183	/* iterate all regions */
ae31fb54	184	for (i = 0; i < s->fds_num; i++) {
a77e6b14 NN	185
a77e6b14 NN	186	/* We'll check only the region statring at 0x0*/
ae31fb54	187	if (s->memory.regions[i].guest_phys_addr != 0x0) {
a77e6b14 NN	188	continue;
	189	}
	190
ae31fb54	191	g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
a77e6b14	192
ae31fb54 MAL	193	size = s->memory.regions[i].memory_size +
ae31fb54 MAL	194	s->memory.regions[i].mmap_offset;
d6970e3b NN	195
d6970e3b NN	196	guest_mem = mmap(0, size, PROT_READ \| PROT_WRITE,
ae31fb54	197	MAP_SHARED, s->fds[i], 0);
d6970e3b NN	198
d6970e3b NN	199	g_assert(guest_mem != MAP_FAILED);
ae31fb54	200	guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
a77e6b14 NN	201
a77e6b14 NN	202	for (j = 0; j < 256; j++) {
ae31fb54	203	uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4);
a77e6b14 NN	204	uint32_t b = guest_mem[j];
	205
	206	g_assert_cmpint(a, ==, b);
	207	}
	208
ae31fb54	209	munmap(guest_mem, s->memory.regions[i].memory_size);
a77e6b14 NN	210	}
a77e6b14 NN	211
ae31fb54	212	g_mutex_unlock(&s->data_mutex);
a77e6b14 NN	213	}
	214
	215	static void thread_function(void data)
	216	{
	217	GMainLoop *loop;
	218	loop = g_main_loop_new(NULL, FALSE);
	219	g_main_loop_run(loop);
	220	return NULL;
	221	}
	222
	223	static int chr_can_read(void *opaque)
	224	{
	225	return VHOST_USER_HDR_SIZE;
	226	}
	227
	228	static void chr_read(void opaque, const uint8_t buf, int size)
	229	{
ae31fb54 MAL	230	TestServer *s = opaque;
ae31fb54 MAL	231	CharDriverState *chr = s->chr;
a77e6b14 NN	232	VhostUserMsg msg;
	233	uint8_t p = (uint8_t ) &msg;
	234	int fd;
	235
	236	if (size != VHOST_USER_HDR_SIZE) {
	237	g_test_message("Wrong message size received %d\n", size);
	238	return;
	239	}
	240
ae31fb54	241	g_mutex_lock(&s->data_mutex);
a77e6b14 NN	242	memcpy(p, buf, VHOST_USER_HDR_SIZE);
	243
	244	if (msg.size) {
	245	p += VHOST_USER_HDR_SIZE;
ae31fb54	246	g_assert_cmpint(qemu_chr_fe_read_all(chr, p, msg.size), ==, msg.size);
a77e6b14 NN	247	}
	248
	249	switch (msg.request) {
	250	case VHOST_USER_GET_FEATURES:
8a9b6b37 MT	251	/* send back features to qemu */
8a9b6b37 MT	252	msg.flags \|= VHOST_USER_REPLY_MASK;
12ebf690 MT	253	msg.size = sizeof(m.payload.u64);
12ebf690 MT	254	msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL \|
b1819747	255	0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
8a9b6b37 MT	256	p = (uint8_t *) &msg;
	257	qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
	258	break;
	259
	260	case VHOST_USER_SET_FEATURES:
12ebf690	261	g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
8a9b6b37 MT	262	!=, 0ULL);
	263	break;
	264
	265	case VHOST_USER_GET_PROTOCOL_FEATURES:
a77e6b14 NN	266	/* send back features to qemu */
a77e6b14 NN	267	msg.flags \|= VHOST_USER_REPLY_MASK;
12ebf690 MT	268	msg.size = sizeof(m.payload.u64);
12ebf690 MT	269	msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
a77e6b14 NN	270	p = (uint8_t *) &msg;
	271	qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
	272	break;
	273
	274	case VHOST_USER_GET_VRING_BASE:
	275	/* send back vring base to qemu */
	276	msg.flags \|= VHOST_USER_REPLY_MASK;
12ebf690 MT	277	msg.size = sizeof(m.payload.state);
12ebf690 MT	278	msg.payload.state.num = 0;
a77e6b14 NN	279	p = (uint8_t *) &msg;
	280	qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
	281	break;
	282
	283	case VHOST_USER_SET_MEM_TABLE:
	284	/* received the mem table */
12ebf690	285	memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
ae31fb54	286	s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
a77e6b14 NN	287
a77e6b14 NN	288	/* signal the test that it can continue */
ae31fb54	289	g_cond_signal(&s->data_cond);
a77e6b14 NN	290	break;
	291
	292	case VHOST_USER_SET_VRING_KICK:
	293	case VHOST_USER_SET_VRING_CALL:
	294	/* consume the fd */
	295	qemu_chr_fe_get_msgfds(chr, &fd, 1);
	296	/*
	297	* This is a non-blocking eventfd.
	298	* The receive function forces it to be blocking,
	299	* so revert it back to non-blocking.
	300	*/
	301	qemu_set_nonblock(fd);
	302	break;
b1819747 MAL	303
	304	case VHOST_USER_SET_LOG_BASE:
	305	if (s->log_fd != -1) {
	306	close(s->log_fd);
	307	s->log_fd = -1;
	308	}
	309	qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
	310	msg.flags \|= VHOST_USER_REPLY_MASK;
	311	msg.size = 0;
	312	p = (uint8_t *) &msg;
	313	qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
	314
	315	g_cond_signal(&s->data_cond);
	316	break;
	317
1d9edff7 MAL	318	case VHOST_USER_RESET_DEVICE:
	319	s->fds_num = 0;
	320	break;
	321
a77e6b14 NN	322	default:
	323	break;
	324	}
ae31fb54 MAL	325
ae31fb54 MAL	326	g_mutex_unlock(&s->data_mutex);
a77e6b14 NN	327	}
a77e6b14 NN	328
1b7e1e3b	329	static const char init_hugepagefs(const char path)
a77e6b14	330	{
a77e6b14 NN	331	struct statfs fs;
	332	int ret;
	333
a77e6b14 NN	334	if (access(path, R_OK \| W_OK \| X_OK)) {
	335	g_test_message("access on path (%s): %s\n", path, strerror(errno));
	336	return NULL;
	337	}
	338
	339	do {
	340	ret = statfs(path, &fs);
	341	} while (ret != 0 && errno == EINTR);
	342
	343	if (ret != 0) {
	344	g_test_message("statfs on path (%s): %s\n", path, strerror(errno));
	345	return NULL;
	346	}
	347
	348	if (fs.f_type != HUGETLBFS_MAGIC) {
	349	g_test_message("Warning: path not on HugeTLBFS: %s\n", path);
	350	return NULL;
	351	}
	352
	353	return path;
	354	}
	355
704b2168	356	static TestServer test_server_new(const gchar name)
ae31fb54 MAL	357	{
	358	TestServer *server = g_new0(TestServer, 1);
	359	gchar *chr_path;
	360
	361	server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name);
	362
	363	chr_path = g_strdup_printf("unix:%s,server,nowait", server->socket_path);
	364	server->chr_name = g_strdup_printf("chr-%s", name);
	365	server->chr = qemu_chr_new(server->chr_name, chr_path, NULL);
	366	g_free(chr_path);
	367
	368	qemu_chr_add_handlers(server->chr, chr_can_read, chr_read, NULL, server);
	369
	370	g_mutex_init(&server->data_mutex);
	371	g_cond_init(&server->data_cond);
	372
b1819747 MAL	373	server->log_fd = -1;
b1819747 MAL	374
ae31fb54 MAL	375	return server;
	376	}
	377
704b2168 MAL	378	#define GET_QEMU_CMD(s) \
	379	g_strdup_printf(QEMU_CMD, 512, 512, (root), (s)->chr_name, \
	380	(s)->socket_path, (s)->chr_name)
ae31fb54	381
704b2168 MAL	382	#define GET_QEMU_CMDE(s, mem, extra, ...) \
	383	g_strdup_printf(QEMU_CMD extra, (mem), (mem), (root), (s)->chr_name, \
	384	(s)->socket_path, (s)->chr_name, ##__VA_ARGS__)
ae31fb54 MAL	385
	386	static void test_server_free(TestServer *server)
	387	{
	388	int i;
	389
	390	qemu_chr_delete(server->chr);
	391
	392	for (i = 0; i < server->fds_num; i++) {
	393	close(server->fds[i]);
	394	}
	395
b1819747 MAL	396	if (server->log_fd != -1) {
	397	close(server->log_fd);
	398	}
	399
ae31fb54 MAL	400	unlink(server->socket_path);
	401	g_free(server->socket_path);
	402
b1819747 MAL	403
b1819747 MAL	404	g_free(server->chr_name);
ae31fb54 MAL	405	g_free(server);
	406	}
	407
b1819747 MAL	408	static void wait_for_log_fd(TestServer *s)
	409	{
	410	gint64 end_time;
	411
	412	g_mutex_lock(&s->data_mutex);
	413	end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND;
	414	while (s->log_fd == -1) {
	415	if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) {
	416	/* timeout has passed */
	417	g_assert(s->log_fd != -1);
	418	break;
	419	}
	420	}
	421
	422	g_mutex_unlock(&s->data_mutex);
	423	}
	424
	425	static void write_guest_mem(TestServer *s, uint32 seed)
	426	{
	427	uint32_t *guest_mem;
	428	int i, j;
	429	size_t size;
	430
	431	wait_for_fds(s);
	432
	433	/* iterate all regions */
	434	for (i = 0; i < s->fds_num; i++) {
	435
	436	/* We'll write only the region statring at 0x0 */
	437	if (s->memory.regions[i].guest_phys_addr != 0x0) {
	438	continue;
	439	}
	440
	441	g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024);
	442
	443	size = s->memory.regions[i].memory_size +
	444	s->memory.regions[i].mmap_offset;
	445
	446	guest_mem = mmap(0, size, PROT_READ \| PROT_WRITE,
	447	MAP_SHARED, s->fds[i], 0);
	448
	449	g_assert(guest_mem != MAP_FAILED);
	450	guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem));
	451
	452	for (j = 0; j < 256; j++) {
	453	guest_mem[j] = seed + j;
	454	}
	455
	456	munmap(guest_mem, s->memory.regions[i].memory_size);
	457	break;
	458	}
	459	}
	460
	461	static guint64 get_log_size(TestServer *s)
	462	{
	463	guint64 log_size = 0;
	464	int i;
	465
	466	for (i = 0; i < s->memory.nregions; ++i) {
	467	VhostUserMemoryRegion *reg = &s->memory.regions[i];
	468	guint64 last = range_get_last(reg->guest_phys_addr,
	469	reg->memory_size);
	470	log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1);
	471	}
472
473	return log_size;
474	}
475
1d9edff7 MAL	476	typedef struct TestMigrateSource {
	477	GSource source;
	478	TestServer *src;
	479	TestServer *dest;
	480	} TestMigrateSource;
	481
	482	static gboolean
	483	test_migrate_source_check(GSource *source)
	484	{
	485	TestMigrateSource t = (TestMigrateSource )source;
	486	gboolean overlap = t->src->fds_num > 0 && t->dest->fds_num > 0;
	487
	488	g_assert(!overlap);
	489
	490	return FALSE;
	491	}
	492
	493	GSourceFuncs test_migrate_source_funcs = {
	494	NULL,
	495	test_migrate_source_check,
	496	NULL,
	497	NULL
	498	};
	499
b1819747 MAL	500	static void test_migrate(void)
	501	{
	502	TestServer *s = test_server_new("src");
	503	TestServer *dest = test_server_new("dest");
	504	const char *uri = "tcp:127.0.0.1:1234";
	505	QTestState global = global_qtest, from, *to;
1d9edff7	506	GSource *source;
b1819747 MAL	507	gchar *cmd;
	508	QDict *rsp;
	509	guint8 *log;
	510	guint64 size;
	511
	512	cmd = GET_QEMU_CMDE(s, 2, "");
	513	from = qtest_start(cmd);
	514	g_free(cmd);
	515
	516	wait_for_fds(s);
	517	size = get_log_size(s);
	518	g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8));
	519
	520	cmd = GET_QEMU_CMDE(dest, 2, " -incoming %s", uri);
	521	to = qtest_init(cmd);
	522	g_free(cmd);
	523
1d9edff7 MAL	524	source = g_source_new(&test_migrate_source_funcs,
	525	sizeof(TestMigrateSource));
	526	((TestMigrateSource *)source)->src = s;
	527	((TestMigrateSource *)source)->dest = dest;
	528	g_source_attach(source, NULL);
	529
b1819747 MAL	530	/* slow down migration to have time to fiddle with log */
	531	/* TODO: qtest could learn to break on some places */
	532	rsp = qmp("{ 'execute': 'migrate_set_speed',"
	533	"'arguments': { 'value': 10 } }");
	534	g_assert(qdict_haskey(rsp, "return"));
	535	QDECREF(rsp);
	536
	537	cmd = g_strdup_printf("{ 'execute': 'migrate',"
	538	"'arguments': { 'uri': '%s' } }",
	539	uri);
	540	rsp = qmp(cmd);
	541	g_free(cmd);
	542	g_assert(qdict_haskey(rsp, "return"));
	543	QDECREF(rsp);
	544
	545	wait_for_log_fd(s);
	546
	547	log = mmap(0, size, PROT_READ \| PROT_WRITE, MAP_SHARED, s->log_fd, 0);
	548	g_assert(log != MAP_FAILED);
	549
	550	/* modify first page */
	551	write_guest_mem(s, 0x42);
	552	log[0] = 1;
	553	munmap(log, size);
	554
	555	/* speed things up */
	556	rsp = qmp("{ 'execute': 'migrate_set_speed',"
	557	"'arguments': { 'value': 0 } }");
	558	g_assert(qdict_haskey(rsp, "return"));
	559	QDECREF(rsp);
	560
	561	qmp_eventwait("STOP");
	562
	563	global_qtest = to;
	564	qmp_eventwait("RESUME");
	565
	566	read_guest_mem(dest);
	567
1d9edff7 MAL	568	g_source_destroy(source);
	569	g_source_unref(source);
	570
b1819747 MAL	571	qtest_quit(to);
	572	test_server_free(dest);
	573	qtest_quit(from);
	574	test_server_free(s);
	575
	576	global_qtest = global;
	577	}
	578
a77e6b14 NN	579	int main(int argc, char **argv)
	580	{
	581	QTestState *s = NULL;
ae31fb54	582	TestServer *server = NULL;
1b7e1e3b	583	const char *hugefs;
ae31fb54	584	char *qemu_cmd = NULL;
a77e6b14	585	int ret;
1b7e1e3b	586	char template[] = "/tmp/vhost-test-XXXXXX";
a77e6b14 NN	587
	588	g_test_init(&argc, &argv, NULL);
	589
	590	module_call_init(MODULE_INIT_QOM);
ae31fb54	591	qemu_add_opts(&qemu_chardev_opts);
a77e6b14	592
1b7e1e3b MT	593	tmpfs = mkdtemp(template);
1b7e1e3b MT	594	if (!tmpfs) {
ae31fb54	595	g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno));
1b7e1e3b MT	596	}
	597	g_assert(tmpfs);
	598
	599	hugefs = getenv("QTEST_HUGETLBFS_PATH");
	600	if (hugefs) {
	601	root = init_hugepagefs(hugefs);
	602	g_assert(root);
	603	} else {
	604	root = tmpfs;
a77e6b14 NN	605	}
a77e6b14 NN	606
704b2168	607	server = test_server_new("test");
a77e6b14 NN	608
a77e6b14 NN	609	/* run the main loop thread so the chardev may operate */
ca06d9cc	610	g_thread_new(NULL, thread_function, NULL);
a77e6b14	611
704b2168	612	qemu_cmd = GET_QEMU_CMD(server);
ae31fb54	613
a77e6b14 NN	614	s = qtest_start(qemu_cmd);
	615	g_free(qemu_cmd);
	616
ae31fb54	617	qtest_add_data_func("/vhost-user/read-guest-mem", server, read_guest_mem);
b1819747	618	qtest_add_func("/vhost-user/migrate", test_migrate);
a77e6b14 NN	619
	620	ret = g_test_run();
	621
	622	if (s) {
	623	qtest_quit(s);
	624	}
	625
	626	/* cleanup */
ae31fb54	627	test_server_free(server);
a77e6b14	628
1b7e1e3b MT	629	ret = rmdir(tmpfs);
	630	if (ret != 0) {
	631	g_test_message("unable to rmdir: path (%s): %s\n",
	632	tmpfs, strerror(errno));
	633	}
	634	g_assert_cmpint(ret, ==, 0);
	635
a77e6b14 NN	636	return ret;
a77e6b14 NN	637	}