1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "CUnit/Basic.h" 37 #include "spdk_cunit.h" 38 #include "spdk/thread.h" 39 #include "spdk_internal/mock.h" 40 #include "common/lib/test_env.c" 41 #include "unit/lib/json_mock.c" 42 43 #include "vhost/vhost.c" 44 45 DEFINE_STUB(rte_vhost_driver_unregister, int, (const char *path), 0); 46 DEFINE_STUB(spdk_event_allocate, struct spdk_event *, 47 (uint32_t lcore, spdk_event_fn fn, void *arg1, void *arg2), NULL); 48 DEFINE_STUB(spdk_mem_register, int, (void *vaddr, size_t len), 0); 49 DEFINE_STUB(spdk_mem_unregister, int, (void *vaddr, size_t len), 0); 50 51 static struct spdk_cpuset *g_app_core_mask; 52 struct spdk_cpuset *spdk_app_get_core_mask(void) 53 { 54 if (g_app_core_mask == NULL) { 55 g_app_core_mask = spdk_cpuset_alloc(); 56 spdk_cpuset_set_cpu(g_app_core_mask, 0, true); 57 } 58 return g_app_core_mask; 59 } 60 61 int 62 spdk_app_parse_core_mask(const char *mask, struct spdk_cpuset *cpumask) 63 { 64 int ret; 65 struct spdk_cpuset *validmask; 66 67 ret = spdk_cpuset_parse(cpumask, mask); 68 if (ret < 0) { 69 return ret; 70 } 71 72 validmask = spdk_app_get_core_mask(); 73 spdk_cpuset_and(cpumask, validmask); 74 75 return 0; 76 } 77 78 DEFINE_STUB(spdk_env_get_first_core, uint32_t, (void), 0); 79 DEFINE_STUB(spdk_env_get_next_core, uint32_t, (uint32_t prev_core), 0); 80 DEFINE_STUB(spdk_env_get_last_core, uint32_t, (void), 0); 81 DEFINE_STUB_V(spdk_app_stop, (int rc)); 82 DEFINE_STUB_V(spdk_event_call, (struct spdk_event *event)); 83 DEFINE_STUB(spdk_poller_register, struct spdk_poller *, (spdk_poller_fn fn, void *arg, 84 uint64_t period_microseconds), NULL); 85 DEFINE_STUB_V(spdk_poller_unregister, (struct spdk_poller **ppoller)); 86 DEFINE_STUB(spdk_iommu_mem_unregister, int, (uint64_t addr, uint64_t len), 0); 87 DEFINE_STUB(rte_vhost_get_mem_table, int, (int vid, struct rte_vhost_memory **mem), 0); 88 DEFINE_STUB(rte_vhost_get_negotiated_features, int, (int vid, uint64_t *features), 0); 89 DEFINE_STUB(rte_vhost_get_vhost_vring, int, 90 (int vid, uint16_t vring_idx, struct rte_vhost_vring *vring), 0); 91 DEFINE_STUB(rte_vhost_enable_guest_notification, int, 92 (int vid, uint16_t queue_id, int enable), 0); 93 DEFINE_STUB(rte_vhost_get_ifname, int, (int vid, char *buf, size_t len), 0); 94 DEFINE_STUB(rte_vhost_get_vring_num, uint16_t, (int vid), 0); 95 DEFINE_STUB(rte_vhost_driver_start, int, (const char *name), 0); 96 DEFINE_STUB(rte_vhost_driver_callback_register, int, 97 (const char *path, struct vhost_device_ops const *const ops), 0); 98 DEFINE_STUB(rte_vhost_driver_disable_features, int, (const char *path, uint64_t features), 0); 99 DEFINE_STUB(rte_vhost_driver_set_features, int, (const char *path, uint64_t features), 0); 100 DEFINE_STUB(rte_vhost_driver_register, int, (const char *path, uint64_t flags), 0); 101 DEFINE_STUB_V(rte_vhost_log_used_vring, (int vid, uint16_t vring_idx, uint64_t offset, 102 uint64_t len)); 103 DEFINE_STUB_V(rte_vhost_log_write, (int vid, uint64_t addr, uint64_t len)); 104 DEFINE_STUB(spdk_vhost_scsi_controller_construct, int, (void), 0); 105 DEFINE_STUB(spdk_vhost_blk_controller_construct, int, (void), 0); 106 DEFINE_STUB(spdk_vhost_nvme_admin_passthrough, int, (int vid, void *cmd, void *cqe, void *buf), 0); 107 DEFINE_STUB(spdk_vhost_nvme_set_cq_call, int, (int vid, uint16_t qid, int fd), 0); 108 DEFINE_STUB(spdk_vhost_nvme_get_cap, int, (int vid, uint64_t *cap), 0); 109 DEFINE_STUB(spdk_vhost_nvme_controller_construct, int, (void), 0); 110 DEFINE_STUB(rte_vhost_set_vhost_vring_last_idx, int, 111 (int vid, uint16_t vring_idx, uint16_t last_avail_idx, uint16_t last_used_idx), 0); 112 DEFINE_STUB(spdk_env_get_current_core, uint32_t, (void), 0); 113 114 void * 115 spdk_call_unaffinitized(void *cb(void *arg), void *arg) 116 { 117 return cb(arg); 118 } 119 120 static struct spdk_vhost_dev_backend g_vdev_backend; 121 122 static int 123 test_setup(void) 124 { 125 return 0; 126 } 127 128 static int 129 alloc_vdev(struct spdk_vhost_dev **vdev_p, const char *name, const char *cpumask) 130 { 131 struct spdk_vhost_dev *vdev = NULL; 132 int rc; 133 134 /* spdk_vhost_dev must be allocated on a cache line boundary. */ 135 rc = posix_memalign((void **)&vdev, 64, sizeof(*vdev)); 136 CU_ASSERT(rc == 0); 137 SPDK_CU_ASSERT_FATAL(vdev != NULL); 138 memset(vdev, 0, sizeof(*vdev)); 139 rc = spdk_vhost_dev_register(vdev, name, cpumask, &g_vdev_backend); 140 if (rc == 0) { 141 *vdev_p = vdev; 142 } else { 143 free(vdev); 144 *vdev_p = NULL; 145 } 146 147 return rc; 148 } 149 150 static void 151 start_vdev(struct spdk_vhost_dev *vdev) 152 { 153 vdev->vid = 0; 154 vdev->lcore = 0; 155 vdev->mem = calloc(1, sizeof(*vdev->mem) + 2 * sizeof(struct rte_vhost_mem_region)); 156 SPDK_CU_ASSERT_FATAL(vdev->mem != NULL); 157 vdev->mem->nregions = 2; 158 vdev->mem->regions[0].guest_phys_addr = 0; 159 vdev->mem->regions[0].size = 0x400000; /* 4 MB */ 160 vdev->mem->regions[0].host_user_addr = 0x1000000; 161 vdev->mem->regions[1].guest_phys_addr = 0x400000; 162 vdev->mem->regions[1].size = 0x400000; /* 4 MB */ 163 vdev->mem->regions[1].host_user_addr = 0x2000000; 164 } 165 166 static void 167 stop_vdev(struct spdk_vhost_dev *vdev) 168 { 169 free(vdev->mem); 170 vdev->mem = NULL; 171 vdev->vid = -1; 172 } 173 174 static void 175 cleanup_vdev(struct spdk_vhost_dev *vdev) 176 { 177 stop_vdev(vdev); 178 spdk_vhost_dev_unregister(vdev); 179 free(vdev); 180 } 181 182 static void 183 desc_to_iov_test(void) 184 { 185 struct spdk_vhost_dev *vdev; 186 struct iovec iov[SPDK_VHOST_IOVS_MAX]; 187 uint16_t iov_index; 188 struct vring_desc desc; 189 int rc; 190 191 rc = alloc_vdev(&vdev, "vdev_name_0", "0x1"); 192 SPDK_CU_ASSERT_FATAL(rc == 0 && vdev); 193 start_vdev(vdev); 194 195 /* Test simple case where iov falls fully within a 2MB page. */ 196 desc.addr = 0x110000; 197 desc.len = 0x1000; 198 iov_index = 0; 199 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 200 CU_ASSERT(rc == 0); 201 CU_ASSERT(iov_index == 1); 202 CU_ASSERT(iov[0].iov_base == (void *)0x1110000); 203 CU_ASSERT(iov[0].iov_len == 0x1000); 204 /* 205 * Always memset the iov to ensure each test validates data written by its call 206 * to the function under test. 207 */ 208 memset(iov, 0, sizeof(iov)); 209 210 /* Same test, but ensure it respects the non-zero starting iov_index. */ 211 iov_index = SPDK_VHOST_IOVS_MAX - 1; 212 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 213 CU_ASSERT(rc == 0); 214 CU_ASSERT(iov_index == SPDK_VHOST_IOVS_MAX); 215 CU_ASSERT(iov[SPDK_VHOST_IOVS_MAX - 1].iov_base == (void *)0x1110000); 216 CU_ASSERT(iov[SPDK_VHOST_IOVS_MAX - 1].iov_len == 0x1000); 217 memset(iov, 0, sizeof(iov)); 218 219 /* Test for failure if iov_index already equals SPDK_VHOST_IOVS_MAX. */ 220 iov_index = SPDK_VHOST_IOVS_MAX; 221 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 222 CU_ASSERT(rc != 0); 223 memset(iov, 0, sizeof(iov)); 224 225 /* Test case where iov spans a 2MB boundary, but does not span a vhost memory region. */ 226 desc.addr = 0x1F0000; 227 desc.len = 0x20000; 228 iov_index = 0; 229 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 230 CU_ASSERT(rc == 0); 231 CU_ASSERT(iov_index == 1); 232 CU_ASSERT(iov[0].iov_base == (void *)0x11F0000); 233 CU_ASSERT(iov[0].iov_len == 0x20000); 234 memset(iov, 0, sizeof(iov)); 235 236 /* Same test, but ensure it respects the non-zero starting iov_index. */ 237 iov_index = SPDK_VHOST_IOVS_MAX - 1; 238 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 239 CU_ASSERT(rc == 0); 240 CU_ASSERT(iov_index == SPDK_VHOST_IOVS_MAX); 241 CU_ASSERT(iov[SPDK_VHOST_IOVS_MAX - 1].iov_base == (void *)0x11F0000); 242 CU_ASSERT(iov[SPDK_VHOST_IOVS_MAX - 1].iov_len == 0x20000); 243 memset(iov, 0, sizeof(iov)); 244 245 /* Test case where iov spans a vhost memory region. */ 246 desc.addr = 0x3F0000; 247 desc.len = 0x20000; 248 iov_index = 0; 249 rc = spdk_vhost_vring_desc_to_iov(vdev, iov, &iov_index, &desc); 250 CU_ASSERT(rc == 0); 251 CU_ASSERT(iov_index == 2); 252 CU_ASSERT(iov[0].iov_base == (void *)0x13F0000); 253 CU_ASSERT(iov[0].iov_len == 0x10000); 254 CU_ASSERT(iov[1].iov_base == (void *)0x2000000); 255 CU_ASSERT(iov[1].iov_len == 0x10000); 256 memset(iov, 0, sizeof(iov)); 257 258 cleanup_vdev(vdev); 259 260 CU_ASSERT(true); 261 } 262 263 static void 264 create_controller_test(void) 265 { 266 struct spdk_vhost_dev *vdev, *vdev2; 267 int ret; 268 char long_name[PATH_MAX]; 269 270 /* NOTE: spdk_app_get_core_mask stub always sets coremask 0x01 */ 271 272 /* Create device with no name */ 273 ret = alloc_vdev(&vdev, NULL, "0x1"); 274 CU_ASSERT(ret != 0); 275 276 /* Create device with incorrect cpumask */ 277 ret = alloc_vdev(&vdev, "vdev_name_0", "0x2"); 278 CU_ASSERT(ret != 0); 279 280 /* Create device with too long name and path */ 281 memset(long_name, 'x', sizeof(long_name)); 282 long_name[PATH_MAX - 1] = 0; 283 snprintf(dev_dirname, sizeof(dev_dirname), "some_path/"); 284 ret = alloc_vdev(&vdev, long_name, "0x1"); 285 CU_ASSERT(ret != 0); 286 dev_dirname[0] = 0; 287 288 /* Create device when device name is already taken */ 289 ret = alloc_vdev(&vdev, "vdev_name_0", "0x1"); 290 SPDK_CU_ASSERT_FATAL(ret == 0 && vdev); 291 ret = alloc_vdev(&vdev2, "vdev_name_0", "0x1"); 292 CU_ASSERT(ret != 0); 293 cleanup_vdev(vdev); 294 } 295 296 static void 297 dev_find_by_vid_test(void) 298 { 299 struct spdk_vhost_dev *vdev, *tmp; 300 int rc; 301 302 rc = alloc_vdev(&vdev, "vdev_name_0", "0x1"); 303 SPDK_CU_ASSERT_FATAL(rc == 0 && vdev); 304 305 tmp = spdk_vhost_dev_find_by_vid(vdev->vid); 306 CU_ASSERT(tmp == vdev); 307 308 /* Search for a device with incorrect vid */ 309 tmp = spdk_vhost_dev_find_by_vid(vdev->vid + 0xFF); 310 CU_ASSERT(tmp == NULL); 311 312 cleanup_vdev(vdev); 313 } 314 315 static void 316 remove_controller_test(void) 317 { 318 struct spdk_vhost_dev *vdev; 319 int ret; 320 321 ret = alloc_vdev(&vdev, "vdev_name_0", "0x1"); 322 SPDK_CU_ASSERT_FATAL(ret == 0 && vdev); 323 324 /* Remove device when controller is in use */ 325 start_vdev(vdev); 326 ret = spdk_vhost_dev_unregister(vdev); 327 CU_ASSERT(ret != 0); 328 329 cleanup_vdev(vdev); 330 } 331 332 int 333 main(int argc, char **argv) 334 { 335 CU_pSuite suite = NULL; 336 unsigned int num_failures; 337 338 if (CU_initialize_registry() != CUE_SUCCESS) { 339 return CU_get_error(); 340 } 341 342 suite = CU_add_suite("vhost_suite", test_setup, NULL); 343 if (suite == NULL) { 344 CU_cleanup_registry(); 345 return CU_get_error(); 346 } 347 348 if ( 349 CU_add_test(suite, "desc_to_iov", desc_to_iov_test) == NULL || 350 CU_add_test(suite, "create_controller", create_controller_test) == NULL || 351 CU_add_test(suite, "dev_find_by_vid", dev_find_by_vid_test) == NULL || 352 CU_add_test(suite, "remove_controller", remove_controller_test) == NULL 353 ) { 354 CU_cleanup_registry(); 355 return CU_get_error(); 356 } 357 358 CU_basic_set_mode(CU_BRM_VERBOSE); 359 CU_basic_run_tests(); 360 num_failures = CU_get_number_of_failures(); 361 CU_cleanup_registry(); 362 363 return num_failures; 364 } 365