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