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