Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 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 | |
Peter Maydell | 681c28a | 2016-02-08 18:08:51 +0000 | [diff] [blame] | 11 | #include "qemu/osdep.h" |
Nikolay Nikolaev | bd95939 | 2014-06-19 18:07:59 +0300 | [diff] [blame] | 12 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 13 | #include "libqtest.h" |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 14 | #include "qapi/error.h" |
Markus Armbruster | 452fcdb | 2018-02-01 12:18:39 +0100 | [diff] [blame] | 15 | #include "qapi/qmp/qdict.h" |
Marc-André Lureau | 213dcb0 | 2016-12-12 20:22:24 +0300 | [diff] [blame] | 16 | #include "qemu/config-file.h" |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 17 | #include "qemu/option.h" |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 18 | #include "qemu/range.h" |
Markus Armbruster | a9c9427 | 2016-06-22 19:11:19 +0200 | [diff] [blame] | 19 | #include "qemu/sockets.h" |
Marc-André Lureau | 4d43a60 | 2017-01-26 18:26:44 +0400 | [diff] [blame] | 20 | #include "chardev/char-fe.h" |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 21 | #include "qemu/memfd.h" |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 22 | #include "sysemu/sysemu.h" |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 23 | #include "libqos/libqos.h" |
| 24 | #include "libqos/pci-pc.h" |
| 25 | #include "libqos/virtio-pci.h" |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 26 | |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 27 | #include "libqos/malloc-pc.h" |
| 28 | #include "hw/virtio/virtio-net.h" |
| 29 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 30 | #include <linux/vhost.h> |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 31 | #include <linux/virtio_ids.h> |
| 32 | #include <linux/virtio_net.h> |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 33 | #include <sys/vfs.h> |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 34 | |
Gonglei | 30de46d | 2014-11-05 09:00:59 +0800 | [diff] [blame] | 35 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 36 | #define QEMU_CMD_MEM " -m %d -object memory-backend-file,id=mem,size=%dM," \ |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 37 | "mem-path=%s,share=on -numa node,memdev=mem" |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 38 | #define QEMU_CMD_MEMFD " -m %d -object memory-backend-memfd,id=mem,size=%dM," \ |
| 39 | " -numa node,memdev=mem" |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 40 | #define QEMU_CMD_CHR " -chardev socket,id=%s,path=%s%s" |
Marc-André Lureau | 704b216 | 2015-10-09 17:17:38 +0200 | [diff] [blame] | 41 | #define QEMU_CMD_NETDEV " -netdev vhost-user,id=net0,chardev=%s,vhostforce" |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 42 | #define QEMU_CMD_NET " -device virtio-net-pci,netdev=net0" |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 43 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 44 | #define HUGETLBFS_MAGIC 0x958458f6 |
| 45 | |
| 46 | /*********** FROM hw/virtio/vhost-user.c *************************************/ |
| 47 | |
| 48 | #define VHOST_MEMORY_MAX_NREGIONS 8 |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 49 | #define VHOST_MAX_VIRTQUEUES 0x100 |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 50 | |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 51 | #define VHOST_USER_F_PROTOCOL_FEATURES 30 |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 52 | #define VHOST_USER_PROTOCOL_F_MQ 0 |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 53 | #define VHOST_USER_PROTOCOL_F_LOG_SHMFD 1 |
| 54 | |
| 55 | #define VHOST_LOG_PAGE 0x1000 |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 56 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 57 | typedef enum VhostUserRequest { |
| 58 | VHOST_USER_NONE = 0, |
| 59 | VHOST_USER_GET_FEATURES = 1, |
| 60 | VHOST_USER_SET_FEATURES = 2, |
| 61 | VHOST_USER_SET_OWNER = 3, |
Yuanhan Liu | 60915dc | 2015-11-11 21:24:37 +0800 | [diff] [blame] | 62 | VHOST_USER_RESET_OWNER = 4, |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 63 | VHOST_USER_SET_MEM_TABLE = 5, |
| 64 | VHOST_USER_SET_LOG_BASE = 6, |
| 65 | VHOST_USER_SET_LOG_FD = 7, |
| 66 | VHOST_USER_SET_VRING_NUM = 8, |
| 67 | VHOST_USER_SET_VRING_ADDR = 9, |
| 68 | VHOST_USER_SET_VRING_BASE = 10, |
| 69 | VHOST_USER_GET_VRING_BASE = 11, |
| 70 | VHOST_USER_SET_VRING_KICK = 12, |
| 71 | VHOST_USER_SET_VRING_CALL = 13, |
| 72 | VHOST_USER_SET_VRING_ERR = 14, |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 73 | VHOST_USER_GET_PROTOCOL_FEATURES = 15, |
| 74 | VHOST_USER_SET_PROTOCOL_FEATURES = 16, |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 75 | VHOST_USER_GET_QUEUE_NUM = 17, |
Michael S. Tsirkin | 87656d5 | 2015-11-16 13:33:36 +0200 | [diff] [blame] | 76 | VHOST_USER_SET_VRING_ENABLE = 18, |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 77 | VHOST_USER_MAX |
| 78 | } VhostUserRequest; |
| 79 | |
| 80 | typedef struct VhostUserMemoryRegion { |
| 81 | uint64_t guest_phys_addr; |
| 82 | uint64_t memory_size; |
| 83 | uint64_t userspace_addr; |
Nikolay Nikolaev | d6970e3 | 2014-07-12 04:43:19 +0300 | [diff] [blame] | 84 | uint64_t mmap_offset; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 85 | } VhostUserMemoryRegion; |
| 86 | |
| 87 | typedef struct VhostUserMemory { |
| 88 | uint32_t nregions; |
| 89 | uint32_t padding; |
| 90 | VhostUserMemoryRegion regions[VHOST_MEMORY_MAX_NREGIONS]; |
| 91 | } VhostUserMemory; |
| 92 | |
Victor Kaplansky | 2b8819c | 2015-11-11 16:26:02 +0200 | [diff] [blame] | 93 | typedef struct VhostUserLog { |
| 94 | uint64_t mmap_size; |
| 95 | uint64_t mmap_offset; |
| 96 | } VhostUserLog; |
| 97 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 98 | typedef struct VhostUserMsg { |
| 99 | VhostUserRequest request; |
| 100 | |
| 101 | #define VHOST_USER_VERSION_MASK (0x3) |
| 102 | #define VHOST_USER_REPLY_MASK (0x1<<2) |
| 103 | uint32_t flags; |
| 104 | uint32_t size; /* the following payload size */ |
| 105 | union { |
Victor Kaplansky | 2b8819c | 2015-11-11 16:26:02 +0200 | [diff] [blame] | 106 | #define VHOST_USER_VRING_IDX_MASK (0xff) |
| 107 | #define VHOST_USER_VRING_NOFD_MASK (0x1<<8) |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 108 | uint64_t u64; |
| 109 | struct vhost_vring_state state; |
| 110 | struct vhost_vring_addr addr; |
| 111 | VhostUserMemory memory; |
Victor Kaplansky | 2b8819c | 2015-11-11 16:26:02 +0200 | [diff] [blame] | 112 | VhostUserLog log; |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 113 | } payload; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 114 | } QEMU_PACKED VhostUserMsg; |
| 115 | |
| 116 | static VhostUserMsg m __attribute__ ((unused)); |
| 117 | #define VHOST_USER_HDR_SIZE (sizeof(m.request) \ |
| 118 | + sizeof(m.flags) \ |
| 119 | + sizeof(m.size)) |
| 120 | |
| 121 | #define VHOST_USER_PAYLOAD_SIZE (sizeof(m) - VHOST_USER_HDR_SIZE) |
| 122 | |
| 123 | /* The version of the protocol we support */ |
| 124 | #define VHOST_USER_VERSION (0x1) |
| 125 | /*****************************************************************************/ |
| 126 | |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 127 | enum { |
| 128 | TEST_FLAGS_OK, |
| 129 | TEST_FLAGS_DISCONNECT, |
| 130 | TEST_FLAGS_BAD, |
| 131 | TEST_FLAGS_END, |
| 132 | }; |
| 133 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 134 | typedef struct TestServer { |
Marc-André Lureau | 0c0eb30 | 2017-02-03 16:06:12 +0400 | [diff] [blame] | 135 | QPCIBus *bus; |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 136 | QVirtioPCIDevice *dev; |
| 137 | QVirtQueue *vq[VHOST_MAX_VIRTQUEUES]; |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 138 | gchar *socket_path; |
Marc-André Lureau | a899b1e | 2015-11-27 15:41:19 +0100 | [diff] [blame] | 139 | gchar *mig_path; |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 140 | gchar *chr_name; |
Marc-André Lureau | 32a6ebe | 2016-10-22 12:52:52 +0300 | [diff] [blame] | 141 | CharBackend chr; |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 142 | int fds_num; |
| 143 | int fds[VHOST_MEMORY_MAX_NREGIONS]; |
| 144 | VhostUserMemory memory; |
Daniel P. Berrangé | e7b3af8 | 2018-05-04 15:34:46 +0100 | [diff] [blame] | 145 | GMutex data_mutex; |
| 146 | GCond data_cond; |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 147 | int log_fd; |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 148 | uint64_t rings; |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 149 | bool test_fail; |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 150 | int test_flags; |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 151 | int queues; |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 152 | QGuestAllocator *alloc; |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 153 | } TestServer; |
Nikolay Nikolaev | bd95939 | 2014-06-19 18:07:59 +0300 | [diff] [blame] | 154 | |
Marc-André Lureau | 8326514 | 2018-02-01 14:27:56 +0100 | [diff] [blame] | 155 | static TestServer *test_server_new(const gchar *name); |
| 156 | static void test_server_free(TestServer *server); |
| 157 | static void test_server_listen(TestServer *server); |
| 158 | |
Marc-André Lureau | 704b216 | 2015-10-09 17:17:38 +0200 | [diff] [blame] | 159 | static const char *tmpfs; |
| 160 | static const char *root; |
| 161 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 162 | enum test_memfd { |
| 163 | TEST_MEMFD_AUTO, |
| 164 | TEST_MEMFD_YES, |
| 165 | TEST_MEMFD_NO, |
| 166 | }; |
| 167 | |
| 168 | static char *get_qemu_cmd(TestServer *s, |
| 169 | int mem, enum test_memfd memfd, const char *mem_path, |
| 170 | const char *chr_opts, const char *extra) |
| 171 | { |
| 172 | if (memfd == TEST_MEMFD_AUTO && qemu_memfd_check()) { |
| 173 | memfd = TEST_MEMFD_YES; |
| 174 | } |
| 175 | |
| 176 | if (memfd == TEST_MEMFD_YES) { |
| 177 | return g_strdup_printf(QEMU_CMD_MEMFD QEMU_CMD_CHR |
| 178 | QEMU_CMD_NETDEV QEMU_CMD_NET "%s", mem, mem, |
| 179 | s->chr_name, s->socket_path, |
| 180 | chr_opts, s->chr_name, extra); |
| 181 | } else { |
| 182 | return g_strdup_printf(QEMU_CMD_MEM QEMU_CMD_CHR |
| 183 | QEMU_CMD_NETDEV QEMU_CMD_NET "%s", mem, mem, |
| 184 | mem_path, s->chr_name, s->socket_path, |
| 185 | chr_opts, s->chr_name, extra); |
| 186 | } |
| 187 | } |
| 188 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 189 | static void init_virtio_dev(TestServer *s, uint32_t features_mask) |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 190 | { |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 191 | uint32_t features; |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 192 | int i; |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 193 | |
Eric Blake | e5d1730 | 2017-09-11 12:19:52 -0500 | [diff] [blame] | 194 | s->bus = qpci_init_pc(global_qtest, NULL); |
Marc-André Lureau | 0c0eb30 | 2017-02-03 16:06:12 +0400 | [diff] [blame] | 195 | g_assert_nonnull(s->bus); |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 196 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 197 | s->dev = qvirtio_pci_device_find(s->bus, VIRTIO_ID_NET); |
| 198 | g_assert_nonnull(s->dev); |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 199 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 200 | qvirtio_pci_device_enable(s->dev); |
| 201 | qvirtio_reset(&s->dev->vdev); |
| 202 | qvirtio_set_acknowledge(&s->dev->vdev); |
| 203 | qvirtio_set_driver(&s->dev->vdev); |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 204 | |
Eric Blake | 05e520f | 2017-09-11 12:19:57 -0500 | [diff] [blame] | 205 | s->alloc = pc_alloc_init(global_qtest); |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 206 | |
| 207 | for (i = 0; i < s->queues * 2; i++) { |
| 208 | s->vq[i] = qvirtqueue_setup(&s->dev->vdev, s->alloc, i); |
| 209 | } |
| 210 | |
| 211 | features = qvirtio_get_features(&s->dev->vdev); |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 212 | features = features & features_mask; |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 213 | qvirtio_set_features(&s->dev->vdev, features); |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 214 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 215 | qvirtio_set_driver_ok(&s->dev->vdev); |
| 216 | } |
| 217 | |
| 218 | static void uninit_virtio_dev(TestServer *s) |
| 219 | { |
| 220 | int i; |
| 221 | |
| 222 | for (i = 0; i < s->queues * 2; i++) { |
| 223 | qvirtqueue_cleanup(s->dev->vdev.bus, s->vq[i], s->alloc); |
| 224 | } |
| 225 | pc_alloc_uninit(s->alloc); |
| 226 | |
| 227 | qvirtio_pci_device_free(s->dev); |
Eduardo Habkost | cdafe92 | 2016-09-02 15:59:43 -0300 | [diff] [blame] | 228 | } |
| 229 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 230 | static void wait_for_fds(TestServer *s) |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 231 | { |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 232 | gint64 end_time; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 233 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 234 | g_mutex_lock(&s->data_mutex); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 235 | |
Paolo Bonzini | ca06d9c | 2015-09-29 14:12:03 +0200 | [diff] [blame] | 236 | end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 237 | while (!s->fds_num) { |
| 238 | if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 239 | /* timeout has passed */ |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 240 | g_assert(s->fds_num); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 241 | break; |
| 242 | } |
| 243 | } |
| 244 | |
| 245 | /* check for sanity */ |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 246 | g_assert_cmpint(s->fds_num, >, 0); |
| 247 | g_assert_cmpint(s->fds_num, ==, s->memory.nregions); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 248 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 249 | g_mutex_unlock(&s->data_mutex); |
Marc-André Lureau | cf72b57 | 2015-10-09 17:17:35 +0200 | [diff] [blame] | 250 | } |
| 251 | |
Marc-André Lureau | 8326514 | 2018-02-01 14:27:56 +0100 | [diff] [blame] | 252 | static void read_guest_mem_server(TestServer *s) |
Marc-André Lureau | cf72b57 | 2015-10-09 17:17:35 +0200 | [diff] [blame] | 253 | { |
| 254 | uint32_t *guest_mem; |
| 255 | int i, j; |
| 256 | size_t size; |
| 257 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 258 | wait_for_fds(s); |
Marc-André Lureau | cf72b57 | 2015-10-09 17:17:35 +0200 | [diff] [blame] | 259 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 260 | g_mutex_lock(&s->data_mutex); |
Marc-André Lureau | cf72b57 | 2015-10-09 17:17:35 +0200 | [diff] [blame] | 261 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 262 | /* iterate all regions */ |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 263 | for (i = 0; i < s->fds_num; i++) { |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 264 | |
| 265 | /* We'll check only the region statring at 0x0*/ |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 266 | if (s->memory.regions[i].guest_phys_addr != 0x0) { |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 267 | continue; |
| 268 | } |
| 269 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 270 | g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 271 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 272 | size = s->memory.regions[i].memory_size + |
| 273 | s->memory.regions[i].mmap_offset; |
Nikolay Nikolaev | d6970e3 | 2014-07-12 04:43:19 +0300 | [diff] [blame] | 274 | |
| 275 | guest_mem = mmap(0, size, PROT_READ | PROT_WRITE, |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 276 | MAP_SHARED, s->fds[i], 0); |
Nikolay Nikolaev | d6970e3 | 2014-07-12 04:43:19 +0300 | [diff] [blame] | 277 | |
| 278 | g_assert(guest_mem != MAP_FAILED); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 279 | guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem)); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 280 | |
| 281 | for (j = 0; j < 256; j++) { |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 282 | uint32_t a = readl(s->memory.regions[i].guest_phys_addr + j*4); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 283 | uint32_t b = guest_mem[j]; |
| 284 | |
| 285 | g_assert_cmpint(a, ==, b); |
| 286 | } |
| 287 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 288 | munmap(guest_mem, s->memory.regions[i].memory_size); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 289 | } |
| 290 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 291 | g_mutex_unlock(&s->data_mutex); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | static void *thread_function(void *data) |
| 295 | { |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 296 | GMainLoop *loop = data; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 297 | g_main_loop_run(loop); |
| 298 | return NULL; |
| 299 | } |
| 300 | |
| 301 | static int chr_can_read(void *opaque) |
| 302 | { |
| 303 | return VHOST_USER_HDR_SIZE; |
| 304 | } |
| 305 | |
| 306 | static void chr_read(void *opaque, const uint8_t *buf, int size) |
| 307 | { |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 308 | TestServer *s = opaque; |
Marc-André Lureau | 32a6ebe | 2016-10-22 12:52:52 +0300 | [diff] [blame] | 309 | CharBackend *chr = &s->chr; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 310 | VhostUserMsg msg; |
| 311 | uint8_t *p = (uint8_t *) &msg; |
| 312 | int fd; |
| 313 | |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 314 | if (s->test_fail) { |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 315 | qemu_chr_fe_disconnect(chr); |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 316 | /* now switch to non-failure */ |
| 317 | s->test_fail = false; |
| 318 | } |
| 319 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 320 | if (size != VHOST_USER_HDR_SIZE) { |
| 321 | g_test_message("Wrong message size received %d\n", size); |
| 322 | return; |
| 323 | } |
| 324 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 325 | g_mutex_lock(&s->data_mutex); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 326 | memcpy(p, buf, VHOST_USER_HDR_SIZE); |
| 327 | |
| 328 | if (msg.size) { |
| 329 | p += VHOST_USER_HDR_SIZE; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 330 | size = qemu_chr_fe_read_all(chr, p, msg.size); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 331 | if (size != msg.size) { |
| 332 | g_test_message("Wrong message size received %d != %d\n", |
| 333 | size, msg.size); |
| 334 | return; |
| 335 | } |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 336 | } |
| 337 | |
| 338 | switch (msg.request) { |
| 339 | case VHOST_USER_GET_FEATURES: |
| 340 | /* send back features to qemu */ |
| 341 | msg.flags |= VHOST_USER_REPLY_MASK; |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 342 | msg.size = sizeof(m.payload.u64); |
| 343 | msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 344 | 0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES; |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 345 | if (s->queues > 1) { |
| 346 | msg.payload.u64 |= 0x1ULL << VIRTIO_NET_F_MQ; |
| 347 | } |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 348 | if (s->test_flags >= TEST_FLAGS_BAD) { |
| 349 | msg.payload.u64 = 0; |
| 350 | s->test_flags = TEST_FLAGS_END; |
| 351 | } |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 352 | p = (uint8_t *) &msg; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 353 | qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 354 | break; |
| 355 | |
| 356 | case VHOST_USER_SET_FEATURES: |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 357 | g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES), |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 358 | !=, 0ULL); |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 359 | if (s->test_flags == TEST_FLAGS_DISCONNECT) { |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 360 | qemu_chr_fe_disconnect(chr); |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 361 | s->test_flags = TEST_FLAGS_BAD; |
| 362 | } |
Michael S. Tsirkin | 8a9b6b3 | 2015-09-24 18:22:01 +0200 | [diff] [blame] | 363 | break; |
| 364 | |
| 365 | case VHOST_USER_GET_PROTOCOL_FEATURES: |
| 366 | /* send back features to qemu */ |
| 367 | msg.flags |= VHOST_USER_REPLY_MASK; |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 368 | msg.size = sizeof(m.payload.u64); |
| 369 | msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD; |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 370 | if (s->queues > 1) { |
| 371 | msg.payload.u64 |= 1 << VHOST_USER_PROTOCOL_F_MQ; |
| 372 | } |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 373 | p = (uint8_t *) &msg; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 374 | qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 375 | break; |
| 376 | |
| 377 | case VHOST_USER_GET_VRING_BASE: |
| 378 | /* send back vring base to qemu */ |
| 379 | msg.flags |= VHOST_USER_REPLY_MASK; |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 380 | msg.size = sizeof(m.payload.state); |
| 381 | msg.payload.state.num = 0; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 382 | p = (uint8_t *) &msg; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 383 | qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 384 | |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 385 | assert(msg.payload.state.index < s->queues * 2); |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 386 | s->rings &= ~(0x1ULL << msg.payload.state.index); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 387 | break; |
| 388 | |
| 389 | case VHOST_USER_SET_MEM_TABLE: |
| 390 | /* received the mem table */ |
Michael S. Tsirkin | 12ebf69 | 2015-10-22 22:28:37 +0300 | [diff] [blame] | 391 | memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory)); |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 392 | s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, |
Marc-André Lureau | 32a6ebe | 2016-10-22 12:52:52 +0300 | [diff] [blame] | 393 | G_N_ELEMENTS(s->fds)); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 394 | |
| 395 | /* signal the test that it can continue */ |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 396 | g_cond_signal(&s->data_cond); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 397 | break; |
| 398 | |
| 399 | case VHOST_USER_SET_VRING_KICK: |
| 400 | case VHOST_USER_SET_VRING_CALL: |
| 401 | /* consume the fd */ |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 402 | qemu_chr_fe_get_msgfds(chr, &fd, 1); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 403 | /* |
| 404 | * This is a non-blocking eventfd. |
| 405 | * The receive function forces it to be blocking, |
| 406 | * so revert it back to non-blocking. |
| 407 | */ |
| 408 | qemu_set_nonblock(fd); |
| 409 | break; |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 410 | |
| 411 | case VHOST_USER_SET_LOG_BASE: |
| 412 | if (s->log_fd != -1) { |
| 413 | close(s->log_fd); |
| 414 | s->log_fd = -1; |
| 415 | } |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 416 | qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 417 | msg.flags |= VHOST_USER_REPLY_MASK; |
| 418 | msg.size = 0; |
| 419 | p = (uint8_t *) &msg; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 420 | qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 421 | |
| 422 | g_cond_signal(&s->data_cond); |
| 423 | break; |
| 424 | |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 425 | case VHOST_USER_SET_VRING_BASE: |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 426 | assert(msg.payload.state.index < s->queues * 2); |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 427 | s->rings |= 0x1ULL << msg.payload.state.index; |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 428 | break; |
| 429 | |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 430 | case VHOST_USER_GET_QUEUE_NUM: |
| 431 | msg.flags |= VHOST_USER_REPLY_MASK; |
| 432 | msg.size = sizeof(m.payload.u64); |
| 433 | msg.payload.u64 = s->queues; |
| 434 | p = (uint8_t *) &msg; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 435 | qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 436 | break; |
| 437 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 438 | default: |
| 439 | break; |
| 440 | } |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 441 | |
| 442 | g_mutex_unlock(&s->data_mutex); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 443 | } |
| 444 | |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 445 | static const char *init_hugepagefs(const char *path) |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 446 | { |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 447 | struct statfs fs; |
| 448 | int ret; |
| 449 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 450 | if (access(path, R_OK | W_OK | X_OK)) { |
| 451 | g_test_message("access on path (%s): %s\n", path, strerror(errno)); |
| 452 | return NULL; |
| 453 | } |
| 454 | |
| 455 | do { |
| 456 | ret = statfs(path, &fs); |
| 457 | } while (ret != 0 && errno == EINTR); |
| 458 | |
| 459 | if (ret != 0) { |
| 460 | g_test_message("statfs on path (%s): %s\n", path, strerror(errno)); |
| 461 | return NULL; |
| 462 | } |
| 463 | |
| 464 | if (fs.f_type != HUGETLBFS_MAGIC) { |
| 465 | g_test_message("Warning: path not on HugeTLBFS: %s\n", path); |
| 466 | return NULL; |
| 467 | } |
| 468 | |
| 469 | return path; |
| 470 | } |
| 471 | |
Marc-André Lureau | 704b216 | 2015-10-09 17:17:38 +0200 | [diff] [blame] | 472 | static TestServer *test_server_new(const gchar *name) |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 473 | { |
| 474 | TestServer *server = g_new0(TestServer, 1); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 475 | |
| 476 | server->socket_path = g_strdup_printf("%s/%s.sock", tmpfs, name); |
Marc-André Lureau | a899b1e | 2015-11-27 15:41:19 +0100 | [diff] [blame] | 477 | server->mig_path = g_strdup_printf("%s/%s.mig", tmpfs, name); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 478 | server->chr_name = g_strdup_printf("chr-%s", name); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 479 | |
| 480 | g_mutex_init(&server->data_mutex); |
| 481 | g_cond_init(&server->data_cond); |
| 482 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 483 | server->log_fd = -1; |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 484 | server->queues = 1; |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 485 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 486 | return server; |
| 487 | } |
| 488 | |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 489 | static void chr_event(void *opaque, int event) |
| 490 | { |
| 491 | TestServer *s = opaque; |
| 492 | |
| 493 | if (s->test_flags == TEST_FLAGS_END && |
| 494 | event == CHR_EVENT_CLOSED) { |
| 495 | s->test_flags = TEST_FLAGS_OK; |
| 496 | } |
| 497 | } |
| 498 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 499 | static void test_server_create_chr(TestServer *server, const gchar *opt) |
| 500 | { |
| 501 | gchar *chr_path; |
Marc-André Lureau | 0ec7b3e | 2016-12-07 16:20:22 +0300 | [diff] [blame] | 502 | Chardev *chr; |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 503 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 504 | chr_path = g_strdup_printf("unix:%s%s", server->socket_path, opt); |
Marc-André Lureau | 32a6ebe | 2016-10-22 12:52:52 +0300 | [diff] [blame] | 505 | chr = qemu_chr_new(server->chr_name, chr_path); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 506 | g_free(chr_path); |
| 507 | |
Marc-André Lureau | 642e065 | 2018-02-15 22:25:50 +0100 | [diff] [blame] | 508 | g_assert_nonnull(chr); |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 509 | qemu_chr_fe_init(&server->chr, chr, &error_abort); |
| 510 | qemu_chr_fe_set_handlers(&server->chr, chr_can_read, chr_read, |
Anton Nefedov | 81517ba | 2017-07-06 15:08:49 +0300 | [diff] [blame] | 511 | chr_event, NULL, server, NULL, true); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 512 | } |
| 513 | |
| 514 | static void test_server_listen(TestServer *server) |
| 515 | { |
| 516 | test_server_create_chr(server, ",server,nowait"); |
| 517 | } |
| 518 | |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 519 | static gboolean _test_server_free(TestServer *server) |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 520 | { |
| 521 | int i; |
| 522 | |
Marc-André Lureau | 1ce2610 | 2017-01-27 00:49:13 +0400 | [diff] [blame] | 523 | qemu_chr_fe_deinit(&server->chr, true); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 524 | |
| 525 | for (i = 0; i < server->fds_num; i++) { |
| 526 | close(server->fds[i]); |
| 527 | } |
| 528 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 529 | if (server->log_fd != -1) { |
| 530 | close(server->log_fd); |
| 531 | } |
| 532 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 533 | unlink(server->socket_path); |
| 534 | g_free(server->socket_path); |
| 535 | |
Marc-André Lureau | a899b1e | 2015-11-27 15:41:19 +0100 | [diff] [blame] | 536 | unlink(server->mig_path); |
| 537 | g_free(server->mig_path); |
| 538 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 539 | g_free(server->chr_name); |
Emanuele Giuseppe Esposito | 9ee8a69 | 2018-06-26 16:18:53 +0200 | [diff] [blame] | 540 | g_assert(server->bus); |
Marc-André Lureau | 0c0eb30 | 2017-02-03 16:06:12 +0400 | [diff] [blame] | 541 | qpci_free_pc(server->bus); |
| 542 | |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 543 | g_free(server); |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 544 | |
| 545 | return FALSE; |
| 546 | } |
| 547 | |
| 548 | static void test_server_free(TestServer *server) |
| 549 | { |
| 550 | g_idle_add((GSourceFunc)_test_server_free, server); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 551 | } |
| 552 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 553 | static void wait_for_log_fd(TestServer *s) |
| 554 | { |
| 555 | gint64 end_time; |
| 556 | |
| 557 | g_mutex_lock(&s->data_mutex); |
| 558 | end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; |
| 559 | while (s->log_fd == -1) { |
| 560 | if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { |
| 561 | /* timeout has passed */ |
| 562 | g_assert(s->log_fd != -1); |
| 563 | break; |
| 564 | } |
| 565 | } |
| 566 | |
| 567 | g_mutex_unlock(&s->data_mutex); |
| 568 | } |
| 569 | |
Peter Maydell | 3a87d00 | 2016-01-22 15:09:21 +0000 | [diff] [blame] | 570 | static void write_guest_mem(TestServer *s, uint32_t seed) |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 571 | { |
| 572 | uint32_t *guest_mem; |
| 573 | int i, j; |
| 574 | size_t size; |
| 575 | |
| 576 | wait_for_fds(s); |
| 577 | |
| 578 | /* iterate all regions */ |
| 579 | for (i = 0; i < s->fds_num; i++) { |
| 580 | |
| 581 | /* We'll write only the region statring at 0x0 */ |
| 582 | if (s->memory.regions[i].guest_phys_addr != 0x0) { |
| 583 | continue; |
| 584 | } |
| 585 | |
| 586 | g_assert_cmpint(s->memory.regions[i].memory_size, >, 1024); |
| 587 | |
| 588 | size = s->memory.regions[i].memory_size + |
| 589 | s->memory.regions[i].mmap_offset; |
| 590 | |
| 591 | guest_mem = mmap(0, size, PROT_READ | PROT_WRITE, |
| 592 | MAP_SHARED, s->fds[i], 0); |
| 593 | |
| 594 | g_assert(guest_mem != MAP_FAILED); |
| 595 | guest_mem += (s->memory.regions[i].mmap_offset / sizeof(*guest_mem)); |
| 596 | |
| 597 | for (j = 0; j < 256; j++) { |
| 598 | guest_mem[j] = seed + j; |
| 599 | } |
| 600 | |
| 601 | munmap(guest_mem, s->memory.regions[i].memory_size); |
| 602 | break; |
| 603 | } |
| 604 | } |
| 605 | |
| 606 | static guint64 get_log_size(TestServer *s) |
| 607 | { |
| 608 | guint64 log_size = 0; |
| 609 | int i; |
| 610 | |
| 611 | for (i = 0; i < s->memory.nregions; ++i) { |
| 612 | VhostUserMemoryRegion *reg = &s->memory.regions[i]; |
| 613 | guint64 last = range_get_last(reg->guest_phys_addr, |
| 614 | reg->memory_size); |
| 615 | log_size = MAX(log_size, last / (8 * VHOST_LOG_PAGE) + 1); |
| 616 | } |
| 617 | |
| 618 | return log_size; |
| 619 | } |
| 620 | |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 621 | typedef struct TestMigrateSource { |
| 622 | GSource source; |
| 623 | TestServer *src; |
| 624 | TestServer *dest; |
| 625 | } TestMigrateSource; |
| 626 | |
| 627 | static gboolean |
| 628 | test_migrate_source_check(GSource *source) |
| 629 | { |
| 630 | TestMigrateSource *t = (TestMigrateSource *)source; |
Michael S. Tsirkin | d08e42a | 2015-11-26 15:14:02 +0200 | [diff] [blame] | 631 | gboolean overlap = t->src->rings && t->dest->rings; |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 632 | |
| 633 | g_assert(!overlap); |
| 634 | |
| 635 | return FALSE; |
| 636 | } |
| 637 | |
| 638 | GSourceFuncs test_migrate_source_funcs = { |
Marc-André Lureau | 45ce512 | 2015-11-30 17:44:49 +0100 | [diff] [blame] | 639 | .check = test_migrate_source_check, |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 640 | }; |
| 641 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 642 | static void test_read_guest_mem(const void *arg) |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 643 | { |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 644 | enum test_memfd memfd = GPOINTER_TO_INT(arg); |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 645 | TestServer *server = NULL; |
| 646 | char *qemu_cmd = NULL; |
| 647 | QTestState *s = NULL; |
| 648 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 649 | server = test_server_new(memfd == TEST_MEMFD_YES ? |
| 650 | "read-guest-memfd" : "read-guest-mem"); |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 651 | test_server_listen(server); |
| 652 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 653 | qemu_cmd = get_qemu_cmd(server, 512, memfd, root, "", ""); |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 654 | |
| 655 | s = qtest_start(qemu_cmd); |
| 656 | g_free(qemu_cmd); |
| 657 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 658 | init_virtio_dev(server, 1u << VIRTIO_NET_F_MAC); |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 659 | |
Marc-André Lureau | 8326514 | 2018-02-01 14:27:56 +0100 | [diff] [blame] | 660 | read_guest_mem_server(server); |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 661 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 662 | uninit_virtio_dev(server); |
| 663 | |
Maxime Coquelin | e364c70 | 2017-12-21 22:21:22 +0100 | [diff] [blame] | 664 | qtest_quit(s); |
| 665 | test_server_free(server); |
| 666 | } |
| 667 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 668 | static void test_migrate(void) |
| 669 | { |
| 670 | TestServer *s = test_server_new("src"); |
| 671 | TestServer *dest = test_server_new("dest"); |
Marc-André Lureau | a899b1e | 2015-11-27 15:41:19 +0100 | [diff] [blame] | 672 | char *uri = g_strdup_printf("%s%s", "unix:", dest->mig_path); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 673 | QTestState *global = global_qtest, *from, *to; |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 674 | GSource *source; |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 675 | gchar *cmd, *tmp; |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 676 | QDict *rsp; |
| 677 | guint8 *log; |
| 678 | guint64 size; |
| 679 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 680 | test_server_listen(s); |
| 681 | test_server_listen(dest); |
| 682 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 683 | cmd = get_qemu_cmd(s, 2, TEST_MEMFD_AUTO, root, "", ""); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 684 | from = qtest_start(cmd); |
| 685 | g_free(cmd); |
| 686 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 687 | init_virtio_dev(s, 1u << VIRTIO_NET_F_MAC); |
Emanuele Giuseppe Esposito | 9ee8a69 | 2018-06-26 16:18:53 +0200 | [diff] [blame] | 688 | init_virtio_dev(dest, 1u << VIRTIO_NET_F_MAC); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 689 | wait_for_fds(s); |
| 690 | size = get_log_size(s); |
| 691 | g_assert_cmpint(size, ==, (2 * 1024 * 1024) / (VHOST_LOG_PAGE * 8)); |
| 692 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 693 | tmp = g_strdup_printf(" -incoming %s", uri); |
| 694 | cmd = get_qemu_cmd(dest, 2, TEST_MEMFD_AUTO, root, "", tmp); |
| 695 | g_free(tmp); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 696 | to = qtest_init(cmd); |
| 697 | g_free(cmd); |
| 698 | |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 699 | source = g_source_new(&test_migrate_source_funcs, |
| 700 | sizeof(TestMigrateSource)); |
| 701 | ((TestMigrateSource *)source)->src = s; |
| 702 | ((TestMigrateSource *)source)->dest = dest; |
| 703 | g_source_attach(source, NULL); |
| 704 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 705 | /* slow down migration to have time to fiddle with log */ |
| 706 | /* TODO: qtest could learn to break on some places */ |
| 707 | rsp = qmp("{ 'execute': 'migrate_set_speed'," |
| 708 | "'arguments': { 'value': 10 } }"); |
| 709 | g_assert(qdict_haskey(rsp, "return")); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 710 | qobject_unref(rsp); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 711 | |
| 712 | cmd = g_strdup_printf("{ 'execute': 'migrate'," |
| 713 | "'arguments': { 'uri': '%s' } }", |
| 714 | uri); |
| 715 | rsp = qmp(cmd); |
| 716 | g_free(cmd); |
| 717 | g_assert(qdict_haskey(rsp, "return")); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 718 | qobject_unref(rsp); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 719 | |
| 720 | wait_for_log_fd(s); |
| 721 | |
| 722 | log = mmap(0, size, PROT_READ | PROT_WRITE, MAP_SHARED, s->log_fd, 0); |
| 723 | g_assert(log != MAP_FAILED); |
| 724 | |
| 725 | /* modify first page */ |
| 726 | write_guest_mem(s, 0x42); |
| 727 | log[0] = 1; |
| 728 | munmap(log, size); |
| 729 | |
| 730 | /* speed things up */ |
| 731 | rsp = qmp("{ 'execute': 'migrate_set_speed'," |
| 732 | "'arguments': { 'value': 0 } }"); |
| 733 | g_assert(qdict_haskey(rsp, "return")); |
Marc-André Lureau | cb3e7f0 | 2018-04-19 17:01:43 +0200 | [diff] [blame] | 734 | qobject_unref(rsp); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 735 | |
| 736 | qmp_eventwait("STOP"); |
| 737 | |
| 738 | global_qtest = to; |
| 739 | qmp_eventwait("RESUME"); |
| 740 | |
Marc-André Lureau | 8326514 | 2018-02-01 14:27:56 +0100 | [diff] [blame] | 741 | read_guest_mem_server(dest); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 742 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 743 | uninit_virtio_dev(s); |
Emanuele Giuseppe Esposito | 9ee8a69 | 2018-06-26 16:18:53 +0200 | [diff] [blame] | 744 | uninit_virtio_dev(dest); |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 745 | |
Marc-André Lureau | 1d9edff | 2015-10-09 17:17:40 +0200 | [diff] [blame] | 746 | g_source_destroy(source); |
| 747 | g_source_unref(source); |
| 748 | |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 749 | qtest_quit(to); |
| 750 | test_server_free(dest); |
| 751 | qtest_quit(from); |
| 752 | test_server_free(s); |
Marc-André Lureau | a899b1e | 2015-11-27 15:41:19 +0100 | [diff] [blame] | 753 | g_free(uri); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 754 | |
| 755 | global_qtest = global; |
| 756 | } |
| 757 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 758 | static void wait_for_rings_started(TestServer *s, size_t count) |
| 759 | { |
| 760 | gint64 end_time; |
| 761 | |
| 762 | g_mutex_lock(&s->data_mutex); |
| 763 | end_time = g_get_monotonic_time() + 5 * G_TIME_SPAN_SECOND; |
| 764 | while (ctpop64(s->rings) != count) { |
| 765 | if (!g_cond_wait_until(&s->data_cond, &s->data_mutex, end_time)) { |
| 766 | /* timeout has passed */ |
| 767 | g_assert_cmpint(ctpop64(s->rings), ==, count); |
| 768 | break; |
| 769 | } |
| 770 | } |
| 771 | |
| 772 | g_mutex_unlock(&s->data_mutex); |
| 773 | } |
| 774 | |
Marc-André Lureau | 7a9ec65 | 2018-02-01 14:27:55 +0100 | [diff] [blame] | 775 | #if defined(CONFIG_HAS_GLIB_SUBPROCESS_TESTS) |
Philippe Mathieu-Daudé | 2078408 | 2017-09-05 15:06:02 -0300 | [diff] [blame] | 776 | static inline void test_server_connect(TestServer *server) |
| 777 | { |
| 778 | test_server_create_chr(server, ",reconnect=1"); |
| 779 | } |
| 780 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 781 | static gboolean |
| 782 | reconnect_cb(gpointer user_data) |
| 783 | { |
| 784 | TestServer *s = user_data; |
| 785 | |
Marc-André Lureau | 5345fdb | 2016-10-22 12:52:55 +0300 | [diff] [blame] | 786 | qemu_chr_fe_disconnect(&s->chr); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 787 | |
| 788 | return FALSE; |
| 789 | } |
| 790 | |
| 791 | static gpointer |
| 792 | connect_thread(gpointer data) |
| 793 | { |
| 794 | TestServer *s = data; |
| 795 | |
| 796 | /* wait for qemu to start before first try, to avoid extra warnings */ |
| 797 | g_usleep(G_USEC_PER_SEC); |
| 798 | test_server_connect(s); |
| 799 | |
| 800 | return NULL; |
| 801 | } |
| 802 | |
| 803 | static void test_reconnect_subprocess(void) |
| 804 | { |
| 805 | TestServer *s = test_server_new("reconnect"); |
| 806 | char *cmd; |
| 807 | |
| 808 | g_thread_new("connect", connect_thread, s); |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 809 | cmd = get_qemu_cmd(s, 2, TEST_MEMFD_AUTO, root, ",server", ""); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 810 | qtest_start(cmd); |
| 811 | g_free(cmd); |
| 812 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 813 | init_virtio_dev(s, 1u << VIRTIO_NET_F_MAC); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 814 | wait_for_fds(s); |
| 815 | wait_for_rings_started(s, 2); |
| 816 | |
| 817 | /* reconnect */ |
| 818 | s->fds_num = 0; |
| 819 | s->rings = 0; |
| 820 | g_idle_add(reconnect_cb, s); |
| 821 | wait_for_fds(s); |
| 822 | wait_for_rings_started(s, 2); |
| 823 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 824 | uninit_virtio_dev(s); |
| 825 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 826 | qtest_end(); |
| 827 | test_server_free(s); |
| 828 | return; |
| 829 | } |
| 830 | |
| 831 | static void test_reconnect(void) |
| 832 | { |
| 833 | gchar *path = g_strdup_printf("/%s/vhost-user/reconnect/subprocess", |
| 834 | qtest_get_arch()); |
| 835 | g_test_trap_subprocess(path, 0, 0); |
| 836 | g_test_trap_assert_passed(); |
Marc-André Lureau | 69179fe | 2016-07-27 01:15:21 +0400 | [diff] [blame] | 837 | g_free(path); |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 838 | } |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 839 | |
| 840 | static void test_connect_fail_subprocess(void) |
| 841 | { |
| 842 | TestServer *s = test_server_new("connect-fail"); |
| 843 | char *cmd; |
| 844 | |
| 845 | s->test_fail = true; |
| 846 | g_thread_new("connect", connect_thread, s); |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 847 | cmd = get_qemu_cmd(s, 2, TEST_MEMFD_AUTO, root, ",server", ""); |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 848 | qtest_start(cmd); |
| 849 | g_free(cmd); |
| 850 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 851 | init_virtio_dev(s, 1u << VIRTIO_NET_F_MAC); |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 852 | wait_for_fds(s); |
| 853 | wait_for_rings_started(s, 2); |
| 854 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 855 | uninit_virtio_dev(s); |
| 856 | |
Marc-André Lureau | 5d443f5 | 2016-09-09 15:34:43 +0400 | [diff] [blame] | 857 | qtest_end(); |
| 858 | test_server_free(s); |
| 859 | } |
| 860 | |
| 861 | static void test_connect_fail(void) |
| 862 | { |
| 863 | gchar *path = g_strdup_printf("/%s/vhost-user/connect-fail/subprocess", |
| 864 | qtest_get_arch()); |
| 865 | g_test_trap_subprocess(path, 0, 0); |
| 866 | g_test_trap_assert_passed(); |
| 867 | g_free(path); |
| 868 | } |
| 869 | |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 870 | static void test_flags_mismatch_subprocess(void) |
| 871 | { |
| 872 | TestServer *s = test_server_new("flags-mismatch"); |
| 873 | char *cmd; |
| 874 | |
| 875 | s->test_flags = TEST_FLAGS_DISCONNECT; |
| 876 | g_thread_new("connect", connect_thread, s); |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 877 | cmd = get_qemu_cmd(s, 2, TEST_MEMFD_AUTO, root, ",server", ""); |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 878 | qtest_start(cmd); |
| 879 | g_free(cmd); |
| 880 | |
Maxime Coquelin | d3b2a5d | 2017-12-21 22:21:24 +0100 | [diff] [blame] | 881 | init_virtio_dev(s, 1u << VIRTIO_NET_F_MAC); |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 882 | wait_for_fds(s); |
| 883 | wait_for_rings_started(s, 2); |
| 884 | |
Maxime Coquelin | 026eb17 | 2017-12-21 22:21:23 +0100 | [diff] [blame] | 885 | uninit_virtio_dev(s); |
| 886 | |
Marc-André Lureau | 9294d76 | 2016-09-09 15:34:45 +0400 | [diff] [blame] | 887 | qtest_end(); |
| 888 | test_server_free(s); |
| 889 | } |
| 890 | |
| 891 | static void test_flags_mismatch(void) |
| 892 | { |
| 893 | gchar *path = g_strdup_printf("/%s/vhost-user/flags-mismatch/subprocess", |
| 894 | qtest_get_arch()); |
| 895 | g_test_trap_subprocess(path, 0, 0); |
| 896 | g_test_trap_assert_passed(); |
| 897 | g_free(path); |
| 898 | } |
| 899 | |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 900 | #endif |
| 901 | |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 902 | static void test_multiqueue(void) |
| 903 | { |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 904 | TestServer *s = test_server_new("mq"); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 905 | char *cmd; |
Maxime Coquelin | 459f5d2 | 2017-12-21 22:21:25 +0100 | [diff] [blame] | 906 | uint32_t features_mask = ~(QVIRTIO_F_BAD_FEATURE | |
| 907 | (1u << VIRTIO_RING_F_INDIRECT_DESC) | |
| 908 | (1u << VIRTIO_RING_F_EVENT_IDX)); |
| 909 | s->queues = 2; |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 910 | test_server_listen(s); |
| 911 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 912 | if (qemu_memfd_check()) { |
| 913 | cmd = g_strdup_printf( |
| 914 | QEMU_CMD_MEMFD QEMU_CMD_CHR QEMU_CMD_NETDEV ",queues=%d " |
| 915 | "-device virtio-net-pci,netdev=net0,mq=on,vectors=%d", |
| 916 | 512, 512, s->chr_name, |
| 917 | s->socket_path, "", s->chr_name, |
| 918 | s->queues, s->queues * 2 + 2); |
| 919 | } else { |
| 920 | cmd = g_strdup_printf( |
| 921 | QEMU_CMD_MEM QEMU_CMD_CHR QEMU_CMD_NETDEV ",queues=%d " |
| 922 | "-device virtio-net-pci,netdev=net0,mq=on,vectors=%d", |
| 923 | 512, 512, root, s->chr_name, |
| 924 | s->socket_path, "", s->chr_name, |
| 925 | s->queues, s->queues * 2 + 2); |
| 926 | } |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 927 | qtest_start(cmd); |
| 928 | g_free(cmd); |
| 929 | |
Maxime Coquelin | 459f5d2 | 2017-12-21 22:21:25 +0100 | [diff] [blame] | 930 | init_virtio_dev(s, features_mask); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 931 | |
Maxime Coquelin | 459f5d2 | 2017-12-21 22:21:25 +0100 | [diff] [blame] | 932 | wait_for_rings_started(s, s->queues * 2); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 933 | |
Maxime Coquelin | 459f5d2 | 2017-12-21 22:21:25 +0100 | [diff] [blame] | 934 | uninit_virtio_dev(s); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 935 | |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 936 | qtest_end(); |
| 937 | |
| 938 | test_server_free(s); |
| 939 | } |
| 940 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 941 | int main(int argc, char **argv) |
| 942 | { |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 943 | const char *hugefs; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 944 | int ret; |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 945 | char template[] = "/tmp/vhost-test-XXXXXX"; |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 946 | GMainLoop *loop; |
| 947 | GThread *thread; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 948 | |
| 949 | g_test_init(&argc, &argv, NULL); |
| 950 | |
| 951 | module_call_init(MODULE_INIT_QOM); |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 952 | qemu_add_opts(&qemu_chardev_opts); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 953 | |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 954 | tmpfs = mkdtemp(template); |
| 955 | if (!tmpfs) { |
Marc-André Lureau | ae31fb5 | 2015-10-09 17:17:37 +0200 | [diff] [blame] | 956 | g_test_message("mkdtemp on path (%s): %s\n", template, strerror(errno)); |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 957 | } |
| 958 | g_assert(tmpfs); |
| 959 | |
| 960 | hugefs = getenv("QTEST_HUGETLBFS_PATH"); |
| 961 | if (hugefs) { |
| 962 | root = init_hugepagefs(hugefs); |
| 963 | g_assert(root); |
| 964 | } else { |
| 965 | root = tmpfs; |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 966 | } |
| 967 | |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 968 | loop = g_main_loop_new(NULL, FALSE); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 969 | /* run the main loop thread so the chardev may operate */ |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 970 | thread = g_thread_new(NULL, thread_function, loop); |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 971 | |
Marc-André Lureau | 8e029fd | 2018-02-15 22:25:49 +0100 | [diff] [blame] | 972 | if (qemu_memfd_check()) { |
| 973 | qtest_add_data_func("/vhost-user/read-guest-mem/memfd", |
| 974 | GINT_TO_POINTER(TEST_MEMFD_YES), |
| 975 | test_read_guest_mem); |
| 976 | } |
| 977 | qtest_add_data_func("/vhost-user/read-guest-mem/memfile", |
| 978 | GINT_TO_POINTER(TEST_MEMFD_NO), test_read_guest_mem); |
Marc-André Lureau | b181974 | 2015-10-09 17:17:39 +0200 | [diff] [blame] | 979 | qtest_add_func("/vhost-user/migrate", test_migrate); |
Marc-André Lureau | ed0a8d9 | 2016-09-09 15:34:44 +0400 | [diff] [blame] | 980 | qtest_add_func("/vhost-user/multiqueue", test_multiqueue); |
Philippe Mathieu-Daudé | 2078408 | 2017-09-05 15:06:02 -0300 | [diff] [blame] | 981 | |
Marc-André Lureau | 7a9ec65 | 2018-02-01 14:27:55 +0100 | [diff] [blame] | 982 | #if defined(CONFIG_HAS_GLIB_SUBPROCESS_TESTS) |
| 983 | /* keeps failing on build-system since Aug 15 2017 */ |
| 984 | if (getenv("QTEST_VHOST_USER_FIXME")) { |
| 985 | qtest_add_func("/vhost-user/reconnect/subprocess", |
| 986 | test_reconnect_subprocess); |
| 987 | qtest_add_func("/vhost-user/reconnect", test_reconnect); |
| 988 | qtest_add_func("/vhost-user/connect-fail/subprocess", |
| 989 | test_connect_fail_subprocess); |
| 990 | qtest_add_func("/vhost-user/connect-fail", test_connect_fail); |
| 991 | qtest_add_func("/vhost-user/flags-mismatch/subprocess", |
| 992 | test_flags_mismatch_subprocess); |
| 993 | qtest_add_func("/vhost-user/flags-mismatch", test_flags_mismatch); |
| 994 | } |
Marc-André Lureau | 4616e35 | 2016-06-06 18:45:08 +0200 | [diff] [blame] | 995 | #endif |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 996 | |
| 997 | ret = g_test_run(); |
| 998 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 999 | /* cleanup */ |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 1000 | |
Marc-André Lureau | 9732baf | 2015-11-27 15:41:18 +0100 | [diff] [blame] | 1001 | /* finish the helper thread and dispatch pending sources */ |
| 1002 | g_main_loop_quit(loop); |
| 1003 | g_thread_join(thread); |
| 1004 | while (g_main_context_pending(NULL)) { |
| 1005 | g_main_context_iteration (NULL, TRUE); |
| 1006 | } |
| 1007 | g_main_loop_unref(loop); |
| 1008 | |
Michael S. Tsirkin | 1b7e1e3 | 2015-09-30 18:01:21 +0300 | [diff] [blame] | 1009 | ret = rmdir(tmpfs); |
| 1010 | if (ret != 0) { |
| 1011 | g_test_message("unable to rmdir: path (%s): %s\n", |
| 1012 | tmpfs, strerror(errno)); |
| 1013 | } |
| 1014 | g_assert_cmpint(ret, ==, 0); |
| 1015 | |
Nikolay Nikolaev | a77e6b1 | 2014-06-10 13:03:23 +0300 | [diff] [blame] | 1016 | return ret; |
| 1017 | } |