1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (c) Intel Corporation. 3 * All rights reserved. 4 * Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. 5 */ 6 7 #include "spdk_cunit.h" 8 /* We have our own mock for this */ 9 #define UNIT_TEST_NO_VTOPHYS 10 #include "common/lib/test_env.c" 11 #include "spdk_internal/mock.h" 12 #include "thread/thread_internal.h" 13 #include "unit/lib/json_mock.c" 14 #include "spdk/reduce.h" 15 16 #include <rte_compressdev.h> 17 18 /* There will be one if the data perfectly matches the chunk size, 19 * or there could be an offset into the data and a remainder after 20 * the data or both for a max of 3. 21 */ 22 #define UT_MBUFS_PER_OP 3 23 /* For testing the crossing of a huge page boundary on address translation, 24 * we'll have an extra one but we only test on the source side. 25 */ 26 #define UT_MBUFS_PER_OP_BOUND_TEST 4 27 28 struct spdk_bdev_io *g_bdev_io; 29 struct spdk_io_channel *g_io_ch; 30 struct rte_comp_op g_comp_op[2]; 31 struct vbdev_compress g_comp_bdev; 32 struct comp_device_qp g_device_qp; 33 struct compress_dev g_device; 34 struct rte_compressdev_capabilities g_cdev_cap; 35 static struct rte_mbuf *g_src_mbufs[UT_MBUFS_PER_OP_BOUND_TEST]; 36 static struct rte_mbuf *g_dst_mbufs[UT_MBUFS_PER_OP]; 37 static struct rte_mbuf g_expected_src_mbufs[UT_MBUFS_PER_OP_BOUND_TEST]; 38 static struct rte_mbuf g_expected_dst_mbufs[UT_MBUFS_PER_OP]; 39 struct comp_bdev_io *g_io_ctx; 40 struct comp_io_channel *g_comp_ch; 41 42 /* Those functions are defined as static inline in DPDK, so we can't 43 * mock them straight away. We use defines to redirect them into 44 * our custom functions. 45 */ 46 47 static void mock_rte_pktmbuf_attach_extbuf(struct rte_mbuf *m, void *buf_addr, rte_iova_t buf_iova, 48 uint16_t buf_len, struct rte_mbuf_ext_shared_info *shinfo); 49 #define rte_pktmbuf_attach_extbuf mock_rte_pktmbuf_attach_extbuf 50 static void mock_rte_pktmbuf_attach_extbuf(struct rte_mbuf *m, void *buf_addr, rte_iova_t buf_iova, 51 uint16_t buf_len, struct rte_mbuf_ext_shared_info *shinfo) 52 { 53 assert(m != NULL); 54 m->buf_addr = buf_addr; 55 m->buf_iova = buf_iova; 56 m->buf_len = buf_len; 57 m->data_len = m->pkt_len = 0; 58 } 59 60 static char *mock_rte_pktmbuf_append(struct rte_mbuf *m, uint16_t len); 61 #define rte_pktmbuf_append mock_rte_pktmbuf_append 62 static char *mock_rte_pktmbuf_append(struct rte_mbuf *m, uint16_t len) 63 { 64 m->pkt_len = m->pkt_len + len; 65 return NULL; 66 } 67 68 static inline int mock_rte_pktmbuf_chain(struct rte_mbuf *head, struct rte_mbuf *tail); 69 #define rte_pktmbuf_chain mock_rte_pktmbuf_chain 70 static inline int mock_rte_pktmbuf_chain(struct rte_mbuf *head, struct rte_mbuf *tail) 71 { 72 struct rte_mbuf *cur_tail; 73 74 cur_tail = rte_pktmbuf_lastseg(head); 75 cur_tail->next = tail; 76 77 return 0; 78 } 79 80 uint16_t ut_max_nb_queue_pairs = 0; 81 void __rte_experimental mock_rte_compressdev_info_get(uint8_t dev_id, 82 struct rte_compressdev_info *dev_info); 83 #define rte_compressdev_info_get mock_rte_compressdev_info_get 84 void __rte_experimental 85 mock_rte_compressdev_info_get(uint8_t dev_id, struct rte_compressdev_info *dev_info) 86 { 87 dev_info->max_nb_queue_pairs = ut_max_nb_queue_pairs; 88 dev_info->capabilities = &g_cdev_cap; 89 dev_info->driver_name = "compress_isal"; 90 } 91 92 int ut_rte_compressdev_configure = 0; 93 int __rte_experimental mock_rte_compressdev_configure(uint8_t dev_id, 94 struct rte_compressdev_config *config); 95 #define rte_compressdev_configure mock_rte_compressdev_configure 96 int __rte_experimental 97 mock_rte_compressdev_configure(uint8_t dev_id, struct rte_compressdev_config *config) 98 { 99 return ut_rte_compressdev_configure; 100 } 101 102 int ut_rte_compressdev_queue_pair_setup = 0; 103 int __rte_experimental mock_rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id, 104 uint32_t max_inflight_ops, int socket_id); 105 #define rte_compressdev_queue_pair_setup mock_rte_compressdev_queue_pair_setup 106 int __rte_experimental 107 mock_rte_compressdev_queue_pair_setup(uint8_t dev_id, uint16_t queue_pair_id, 108 uint32_t max_inflight_ops, int socket_id) 109 { 110 return ut_rte_compressdev_queue_pair_setup; 111 } 112 113 int ut_rte_compressdev_start = 0; 114 int __rte_experimental mock_rte_compressdev_start(uint8_t dev_id); 115 #define rte_compressdev_start mock_rte_compressdev_start 116 int __rte_experimental 117 mock_rte_compressdev_start(uint8_t dev_id) 118 { 119 return ut_rte_compressdev_start; 120 } 121 122 int ut_rte_compressdev_private_xform_create = 0; 123 int __rte_experimental mock_rte_compressdev_private_xform_create(uint8_t dev_id, 124 const struct rte_comp_xform *xform, void **private_xform); 125 #define rte_compressdev_private_xform_create mock_rte_compressdev_private_xform_create 126 int __rte_experimental 127 mock_rte_compressdev_private_xform_create(uint8_t dev_id, 128 const struct rte_comp_xform *xform, void **private_xform) 129 { 130 return ut_rte_compressdev_private_xform_create; 131 } 132 133 uint8_t ut_rte_compressdev_count = 0; 134 uint8_t __rte_experimental mock_rte_compressdev_count(void); 135 #define rte_compressdev_count mock_rte_compressdev_count 136 uint8_t __rte_experimental 137 mock_rte_compressdev_count(void) 138 { 139 return ut_rte_compressdev_count; 140 } 141 142 struct rte_mempool *ut_rte_comp_op_pool_create = NULL; 143 struct rte_mempool *__rte_experimental mock_rte_comp_op_pool_create(const char *name, 144 unsigned int nb_elts, unsigned int cache_size, uint16_t user_size, 145 int socket_id); 146 #define rte_comp_op_pool_create mock_rte_comp_op_pool_create 147 struct rte_mempool *__rte_experimental 148 mock_rte_comp_op_pool_create(const char *name, unsigned int nb_elts, 149 unsigned int cache_size, uint16_t user_size, int socket_id) 150 { 151 return ut_rte_comp_op_pool_create; 152 } 153 154 void mock_rte_pktmbuf_free(struct rte_mbuf *m); 155 #define rte_pktmbuf_free mock_rte_pktmbuf_free 156 void mock_rte_pktmbuf_free(struct rte_mbuf *m) 157 { 158 } 159 160 void mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt); 161 #define rte_pktmbuf_free_bulk mock_rte_pktmbuf_free_bulk 162 void mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt) 163 { 164 } 165 166 static bool ut_boundary_alloc = false; 167 static int ut_rte_pktmbuf_alloc_bulk = 0; 168 int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs, 169 unsigned count); 170 #define rte_pktmbuf_alloc_bulk mock_rte_pktmbuf_alloc_bulk 171 int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs, 172 unsigned count) 173 { 174 int i; 175 176 /* This mocked function only supports the alloc of up to 3 src and 3 dst. */ 177 ut_rte_pktmbuf_alloc_bulk += count; 178 179 if (ut_rte_pktmbuf_alloc_bulk == 1) { 180 /* allocation of an extra mbuf for boundary cross test */ 181 ut_boundary_alloc = true; 182 g_src_mbufs[UT_MBUFS_PER_OP_BOUND_TEST - 1]->next = NULL; 183 *mbufs = g_src_mbufs[UT_MBUFS_PER_OP_BOUND_TEST - 1]; 184 ut_rte_pktmbuf_alloc_bulk = 0; 185 } else if (ut_rte_pktmbuf_alloc_bulk == UT_MBUFS_PER_OP) { 186 /* first test allocation, src mbufs */ 187 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 188 g_src_mbufs[i]->next = NULL; 189 *mbufs++ = g_src_mbufs[i]; 190 } 191 } else if (ut_rte_pktmbuf_alloc_bulk == UT_MBUFS_PER_OP * 2) { 192 /* second test allocation, dst mbufs */ 193 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 194 g_dst_mbufs[i]->next = NULL; 195 *mbufs++ = g_dst_mbufs[i]; 196 } 197 ut_rte_pktmbuf_alloc_bulk = 0; 198 } else { 199 return -1; 200 } 201 return 0; 202 } 203 204 struct rte_mempool * 205 rte_pktmbuf_pool_create(const char *name, unsigned n, unsigned cache_size, 206 uint16_t priv_size, uint16_t data_room_size, int socket_id) 207 { 208 struct spdk_mempool *tmp; 209 210 tmp = spdk_mempool_create("mbuf_mp", 1024, sizeof(struct rte_mbuf), 211 SPDK_MEMPOOL_DEFAULT_CACHE_SIZE, 212 SPDK_ENV_SOCKET_ID_ANY); 213 214 return (struct rte_mempool *)tmp; 215 } 216 217 void 218 rte_mempool_free(struct rte_mempool *mp) 219 { 220 if (mp) { 221 spdk_mempool_free((struct spdk_mempool *)mp); 222 } 223 } 224 225 static int ut_spdk_reduce_vol_op_complete_err = 0; 226 void 227 spdk_reduce_vol_writev(struct spdk_reduce_vol *vol, struct iovec *iov, int iovcnt, 228 uint64_t offset, uint64_t length, spdk_reduce_vol_op_complete cb_fn, 229 void *cb_arg) 230 { 231 cb_fn(cb_arg, ut_spdk_reduce_vol_op_complete_err); 232 } 233 234 void 235 spdk_reduce_vol_readv(struct spdk_reduce_vol *vol, struct iovec *iov, int iovcnt, 236 uint64_t offset, uint64_t length, spdk_reduce_vol_op_complete cb_fn, 237 void *cb_arg) 238 { 239 cb_fn(cb_arg, ut_spdk_reduce_vol_op_complete_err); 240 } 241 242 #include "bdev/compress/vbdev_compress.c" 243 244 /* SPDK stubs */ 245 DEFINE_STUB(spdk_bdev_get_aliases, const struct spdk_bdev_aliases_list *, 246 (const struct spdk_bdev *bdev), NULL); 247 DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module)); 248 DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *g_bdev_io)); 249 DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, 250 enum spdk_bdev_io_type io_type), 0); 251 DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); 252 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 253 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), 0); 254 DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc), 0); 255 DEFINE_STUB_V(spdk_bdev_unregister, (struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, 256 void *cb_arg)); 257 DEFINE_STUB(spdk_bdev_open_ext, int, (const char *bdev_name, bool write, 258 spdk_bdev_event_cb_t event_cb, 259 void *event_ctx, struct spdk_bdev_desc **_desc), 0); 260 DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL); 261 DEFINE_STUB(spdk_bdev_module_claim_bdev, int, (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 262 struct spdk_bdev_module *module), 0); 263 DEFINE_STUB_V(spdk_bdev_module_examine_done, (struct spdk_bdev_module *module)); 264 DEFINE_STUB(spdk_bdev_register, int, (struct spdk_bdev *bdev), 0); 265 DEFINE_STUB(spdk_bdev_get_by_name, struct spdk_bdev *, (const char *bdev_name), NULL); 266 DEFINE_STUB(spdk_bdev_io_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_io *bdev_io), 267 0); 268 DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch, 269 struct spdk_bdev_io_wait_entry *entry), 0); 270 DEFINE_STUB_V(spdk_reduce_vol_unload, (struct spdk_reduce_vol *vol, 271 spdk_reduce_vol_op_complete cb_fn, void *cb_arg)); 272 DEFINE_STUB_V(spdk_reduce_vol_load, (struct spdk_reduce_backing_dev *backing_dev, 273 spdk_reduce_vol_op_with_handle_complete cb_fn, void *cb_arg)); 274 DEFINE_STUB(spdk_reduce_vol_get_params, const struct spdk_reduce_vol_params *, 275 (struct spdk_reduce_vol *vol), NULL); 276 DEFINE_STUB_V(spdk_reduce_vol_init, (struct spdk_reduce_vol_params *params, 277 struct spdk_reduce_backing_dev *backing_dev, 278 const char *pm_file_dir, 279 spdk_reduce_vol_op_with_handle_complete cb_fn, void *cb_arg)); 280 DEFINE_STUB_V(spdk_reduce_vol_destroy, (struct spdk_reduce_backing_dev *backing_dev, 281 spdk_reduce_vol_op_complete cb_fn, void *cb_arg)); 282 283 /* DPDK stubs */ 284 #define DPDK_DYNFIELD_OFFSET offsetof(struct rte_mbuf, dynfield1[1]) 285 DEFINE_STUB(rte_mbuf_dynfield_register, int, (const struct rte_mbuf_dynfield *params), 286 DPDK_DYNFIELD_OFFSET); 287 DEFINE_STUB(rte_socket_id, unsigned, (void), 0); 288 DEFINE_STUB(rte_vdev_init, int, (const char *name, const char *args), 0); 289 DEFINE_STUB_V(rte_comp_op_free, (struct rte_comp_op *op)); 290 DEFINE_STUB(rte_comp_op_alloc, struct rte_comp_op *, (struct rte_mempool *mempool), NULL); 291 292 int g_small_size_counter = 0; 293 int g_small_size_modify = 0; 294 uint64_t g_small_size = 0; 295 uint64_t 296 spdk_vtophys(const void *buf, uint64_t *size) 297 { 298 g_small_size_counter++; 299 if (g_small_size_counter == g_small_size_modify) { 300 *size = g_small_size; 301 g_small_size_counter = 0; 302 g_small_size_modify = 0; 303 } 304 return (uint64_t)buf; 305 } 306 307 void 308 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 309 { 310 cb(g_io_ch, g_bdev_io, true); 311 } 312 313 /* Mock these functions to call the callback and then return the value we require */ 314 int ut_spdk_bdev_readv_blocks = 0; 315 int 316 spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 317 struct iovec *iov, int iovcnt, 318 uint64_t offset_blocks, uint64_t num_blocks, 319 spdk_bdev_io_completion_cb cb, void *cb_arg) 320 { 321 cb(g_bdev_io, !ut_spdk_bdev_readv_blocks, cb_arg); 322 return ut_spdk_bdev_readv_blocks; 323 } 324 325 int ut_spdk_bdev_writev_blocks = 0; 326 bool ut_spdk_bdev_writev_blocks_mocked = false; 327 int 328 spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 329 struct iovec *iov, int iovcnt, 330 uint64_t offset_blocks, uint64_t num_blocks, 331 spdk_bdev_io_completion_cb cb, void *cb_arg) 332 { 333 cb(g_bdev_io, !ut_spdk_bdev_writev_blocks, cb_arg); 334 return ut_spdk_bdev_writev_blocks; 335 } 336 337 int ut_spdk_bdev_unmap_blocks = 0; 338 bool ut_spdk_bdev_unmap_blocks_mocked = false; 339 int 340 spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 341 uint64_t offset_blocks, uint64_t num_blocks, 342 spdk_bdev_io_completion_cb cb, void *cb_arg) 343 { 344 cb(g_bdev_io, !ut_spdk_bdev_unmap_blocks, cb_arg); 345 return ut_spdk_bdev_unmap_blocks; 346 } 347 348 int ut_spdk_bdev_flush_blocks = 0; 349 bool ut_spdk_bdev_flush_blocks_mocked = false; 350 int 351 spdk_bdev_flush_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 352 uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, 353 void *cb_arg) 354 { 355 cb(g_bdev_io, !ut_spdk_bdev_flush_blocks, cb_arg); 356 return ut_spdk_bdev_flush_blocks; 357 } 358 359 int ut_spdk_bdev_reset = 0; 360 bool ut_spdk_bdev_reset_mocked = false; 361 int 362 spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 363 spdk_bdev_io_completion_cb cb, void *cb_arg) 364 { 365 cb(g_bdev_io, !ut_spdk_bdev_reset, cb_arg); 366 return ut_spdk_bdev_reset; 367 } 368 369 bool g_completion_called = false; 370 void 371 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 372 { 373 bdev_io->internal.status = status; 374 g_completion_called = true; 375 } 376 377 static uint16_t ut_rte_compressdev_dequeue_burst = 0; 378 uint16_t 379 rte_compressdev_dequeue_burst(uint8_t dev_id, uint16_t qp_id, struct rte_comp_op **ops, 380 uint16_t nb_op) 381 { 382 if (ut_rte_compressdev_dequeue_burst == 0) { 383 return 0; 384 } 385 386 ops[0] = &g_comp_op[0]; 387 ops[1] = &g_comp_op[1]; 388 389 return ut_rte_compressdev_dequeue_burst; 390 } 391 392 static int ut_compress_done[2]; 393 /* done_count and done_idx together control which expected assertion 394 * value to use when dequeuing 2 operations. 395 */ 396 static uint16_t done_count = 1; 397 static uint16_t done_idx = 0; 398 static void 399 _compress_done(void *_req, int reduce_errno) 400 { 401 if (done_count == 1) { 402 CU_ASSERT(reduce_errno == ut_compress_done[0]); 403 } else if (done_count == 2) { 404 CU_ASSERT(reduce_errno == ut_compress_done[done_idx++]); 405 } 406 } 407 408 static void 409 _get_mbuf_array(struct rte_mbuf **mbuf_array, struct rte_mbuf *mbuf_head, 410 int mbuf_count, bool null_final) 411 { 412 int i; 413 414 for (i = 0; i < mbuf_count; i++) { 415 mbuf_array[i] = mbuf_head; 416 if (mbuf_head) { 417 mbuf_head = mbuf_head->next; 418 } 419 } 420 if (null_final) { 421 mbuf_array[i - 1] = NULL; 422 } 423 } 424 425 #define FAKE_ENQUEUE_SUCCESS 255 426 #define FAKE_ENQUEUE_ERROR 128 427 #define FAKE_ENQUEUE_BUSY 64 428 static uint16_t ut_enqueue_value = FAKE_ENQUEUE_SUCCESS; 429 static struct rte_comp_op ut_expected_op; 430 uint16_t 431 rte_compressdev_enqueue_burst(uint8_t dev_id, uint16_t qp_id, struct rte_comp_op **ops, 432 uint16_t nb_ops) 433 { 434 struct rte_comp_op *op = *ops; 435 struct rte_mbuf *op_mbuf[UT_MBUFS_PER_OP_BOUND_TEST]; 436 struct rte_mbuf *exp_mbuf[UT_MBUFS_PER_OP_BOUND_TEST]; 437 int i, num_src_mbufs = UT_MBUFS_PER_OP; 438 439 switch (ut_enqueue_value) { 440 case FAKE_ENQUEUE_BUSY: 441 op->status = RTE_COMP_OP_STATUS_NOT_PROCESSED; 442 return 0; 443 case FAKE_ENQUEUE_SUCCESS: 444 op->status = RTE_COMP_OP_STATUS_SUCCESS; 445 return 1; 446 case FAKE_ENQUEUE_ERROR: 447 op->status = RTE_COMP_OP_STATUS_ERROR; 448 return 0; 449 default: 450 break; 451 } 452 453 /* by design the compress module will never send more than 1 op at a time */ 454 CU_ASSERT(op->private_xform == ut_expected_op.private_xform); 455 456 /* setup our local pointers to the chained mbufs, those pointed to in the 457 * operation struct and the expected values. 458 */ 459 _get_mbuf_array(op_mbuf, op->m_src, SPDK_COUNTOF(op_mbuf), true); 460 _get_mbuf_array(exp_mbuf, ut_expected_op.m_src, SPDK_COUNTOF(exp_mbuf), true); 461 462 if (ut_boundary_alloc == true) { 463 /* if we crossed a boundary, we need to check the 4th src mbuf and 464 * reset the global that is used to identify whether we crossed 465 * or not 466 */ 467 num_src_mbufs = UT_MBUFS_PER_OP_BOUND_TEST; 468 exp_mbuf[UT_MBUFS_PER_OP_BOUND_TEST - 1] = ut_expected_op.m_src->next->next->next; 469 op_mbuf[UT_MBUFS_PER_OP_BOUND_TEST - 1] = op->m_src->next->next->next; 470 ut_boundary_alloc = false; 471 } 472 473 for (i = 0; i < num_src_mbufs; i++) { 474 CU_ASSERT(op_mbuf[i]->buf_addr == exp_mbuf[i]->buf_addr); 475 CU_ASSERT(op_mbuf[i]->buf_iova == exp_mbuf[i]->buf_iova); 476 CU_ASSERT(op_mbuf[i]->buf_len == exp_mbuf[i]->buf_len); 477 CU_ASSERT(op_mbuf[i]->pkt_len == exp_mbuf[i]->pkt_len); 478 } 479 480 /* if only 3 mbufs were used in the test, the 4th should be zeroed */ 481 if (num_src_mbufs == UT_MBUFS_PER_OP) { 482 CU_ASSERT(op_mbuf[UT_MBUFS_PER_OP_BOUND_TEST - 1] == NULL); 483 CU_ASSERT(exp_mbuf[UT_MBUFS_PER_OP_BOUND_TEST - 1] == NULL); 484 } 485 CU_ASSERT(*RTE_MBUF_DYNFIELD(op->m_src, g_mbuf_offset, uint64_t *) == 486 *RTE_MBUF_DYNFIELD(ut_expected_op.m_src, g_mbuf_offset, uint64_t *)); 487 CU_ASSERT(op->src.offset == ut_expected_op.src.offset); 488 CU_ASSERT(op->src.length == ut_expected_op.src.length); 489 490 /* check dst mbuf values */ 491 _get_mbuf_array(op_mbuf, op->m_dst, SPDK_COUNTOF(op_mbuf), true); 492 _get_mbuf_array(exp_mbuf, ut_expected_op.m_dst, SPDK_COUNTOF(exp_mbuf), true); 493 494 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 495 CU_ASSERT(op_mbuf[i]->buf_addr == exp_mbuf[i]->buf_addr); 496 CU_ASSERT(op_mbuf[i]->buf_iova == exp_mbuf[i]->buf_iova); 497 CU_ASSERT(op_mbuf[i]->buf_len == exp_mbuf[i]->buf_len); 498 CU_ASSERT(op_mbuf[i]->pkt_len == exp_mbuf[i]->pkt_len); 499 } 500 CU_ASSERT(op->dst.offset == ut_expected_op.dst.offset); 501 502 return ut_enqueue_value; 503 } 504 505 /* Global setup for all tests that share a bunch of preparation... */ 506 static int 507 test_setup(void) 508 { 509 struct spdk_thread *thread; 510 int i; 511 512 spdk_thread_lib_init(NULL, 0); 513 514 thread = spdk_thread_create(NULL, NULL); 515 spdk_set_thread(thread); 516 517 g_comp_bdev.drv_name = "test"; 518 g_comp_bdev.reduce_thread = thread; 519 g_comp_bdev.backing_dev.unmap = _comp_reduce_unmap; 520 g_comp_bdev.backing_dev.readv = _comp_reduce_readv; 521 g_comp_bdev.backing_dev.writev = _comp_reduce_writev; 522 g_comp_bdev.backing_dev.compress = _comp_reduce_compress; 523 g_comp_bdev.backing_dev.decompress = _comp_reduce_decompress; 524 g_comp_bdev.backing_dev.blocklen = 512; 525 g_comp_bdev.backing_dev.blockcnt = 1024 * 16; 526 g_comp_bdev.backing_dev.sgl_in = true; 527 g_comp_bdev.backing_dev.sgl_out = true; 528 529 g_comp_bdev.device_qp = &g_device_qp; 530 g_comp_bdev.device_qp->device = &g_device; 531 532 TAILQ_INIT(&g_comp_bdev.queued_comp_ops); 533 534 g_comp_xform = (struct rte_comp_xform) { 535 .type = RTE_COMP_COMPRESS, 536 .compress = { 537 .algo = RTE_COMP_ALGO_DEFLATE, 538 .deflate.huffman = RTE_COMP_HUFFMAN_DEFAULT, 539 .level = RTE_COMP_LEVEL_MAX, 540 .window_size = DEFAULT_WINDOW_SIZE, 541 .chksum = RTE_COMP_CHECKSUM_NONE, 542 .hash_algo = RTE_COMP_HASH_ALGO_NONE 543 } 544 }; 545 546 g_decomp_xform = (struct rte_comp_xform) { 547 .type = RTE_COMP_DECOMPRESS, 548 .decompress = { 549 .algo = RTE_COMP_ALGO_DEFLATE, 550 .chksum = RTE_COMP_CHECKSUM_NONE, 551 .window_size = DEFAULT_WINDOW_SIZE, 552 .hash_algo = RTE_COMP_HASH_ALGO_NONE 553 } 554 }; 555 g_device.comp_xform = &g_comp_xform; 556 g_device.decomp_xform = &g_decomp_xform; 557 g_cdev_cap.comp_feature_flags = RTE_COMP_FF_SHAREABLE_PRIV_XFORM; 558 g_device.cdev_info.driver_name = "compress_isal"; 559 g_device.cdev_info.capabilities = &g_cdev_cap; 560 for (i = 0; i < UT_MBUFS_PER_OP_BOUND_TEST; i++) { 561 g_src_mbufs[i] = calloc(1, sizeof(struct rte_mbuf)); 562 } 563 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 564 g_dst_mbufs[i] = calloc(1, sizeof(struct rte_mbuf)); 565 } 566 567 g_bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct comp_bdev_io)); 568 g_bdev_io->u.bdev.iovs = calloc(128, sizeof(struct iovec)); 569 g_bdev_io->bdev = &g_comp_bdev.comp_bdev; 570 g_io_ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct comp_io_channel)); 571 g_io_ch->thread = thread; 572 g_comp_ch = (struct comp_io_channel *)spdk_io_channel_get_ctx(g_io_ch); 573 g_io_ctx = (struct comp_bdev_io *)g_bdev_io->driver_ctx; 574 575 g_io_ctx->comp_ch = g_comp_ch; 576 g_io_ctx->comp_bdev = &g_comp_bdev; 577 g_comp_bdev.device_qp = &g_device_qp; 578 579 for (i = 0; i < UT_MBUFS_PER_OP_BOUND_TEST - 1; i++) { 580 g_expected_src_mbufs[i].next = &g_expected_src_mbufs[i + 1]; 581 } 582 g_expected_src_mbufs[UT_MBUFS_PER_OP_BOUND_TEST - 1].next = NULL; 583 584 /* we only test w/4 mbufs on src side */ 585 for (i = 0; i < UT_MBUFS_PER_OP - 1; i++) { 586 g_expected_dst_mbufs[i].next = &g_expected_dst_mbufs[i + 1]; 587 } 588 g_expected_dst_mbufs[UT_MBUFS_PER_OP - 1].next = NULL; 589 g_mbuf_offset = DPDK_DYNFIELD_OFFSET; 590 591 return 0; 592 } 593 594 /* Global teardown for all tests */ 595 static int 596 test_cleanup(void) 597 { 598 struct spdk_thread *thread; 599 int i; 600 601 for (i = 0; i < UT_MBUFS_PER_OP_BOUND_TEST; i++) { 602 free(g_src_mbufs[i]); 603 } 604 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 605 free(g_dst_mbufs[i]); 606 } 607 free(g_bdev_io->u.bdev.iovs); 608 free(g_bdev_io); 609 free(g_io_ch); 610 611 thread = spdk_get_thread(); 612 spdk_thread_exit(thread); 613 while (!spdk_thread_is_exited(thread)) { 614 spdk_thread_poll(thread, 0, 0); 615 } 616 spdk_thread_destroy(thread); 617 618 spdk_thread_lib_fini(); 619 620 return 0; 621 } 622 623 static void 624 test_compress_operation(void) 625 { 626 struct iovec src_iovs[3] = {}; 627 int src_iovcnt; 628 struct iovec dst_iovs[3] = {}; 629 int dst_iovcnt; 630 struct spdk_reduce_vol_cb_args cb_arg; 631 int rc, i; 632 struct vbdev_comp_op *op; 633 struct rte_mbuf *exp_src_mbuf[UT_MBUFS_PER_OP]; 634 struct rte_mbuf *exp_dst_mbuf[UT_MBUFS_PER_OP]; 635 636 src_iovcnt = dst_iovcnt = 3; 637 for (i = 0; i < dst_iovcnt; i++) { 638 src_iovs[i].iov_len = 0x1000; 639 dst_iovs[i].iov_len = 0x1000; 640 src_iovs[i].iov_base = (void *)0x10000000 + 0x1000 * i; 641 dst_iovs[i].iov_base = (void *)0x20000000 + 0x1000 * i; 642 } 643 644 /* test rte_comp_op_alloc failure */ 645 MOCK_SET(rte_comp_op_alloc, NULL); 646 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 647 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 648 &dst_iovs[0], dst_iovcnt, true, &cb_arg); 649 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == false); 650 while (!TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops)) { 651 op = TAILQ_FIRST(&g_comp_bdev.queued_comp_ops); 652 TAILQ_REMOVE(&g_comp_bdev.queued_comp_ops, op, link); 653 free(op); 654 } 655 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 656 CU_ASSERT(rc == 0); 657 MOCK_SET(rte_comp_op_alloc, &g_comp_op[0]); 658 659 /* test mempool get failure */ 660 ut_rte_pktmbuf_alloc_bulk = -1; 661 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 662 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 663 &dst_iovs[0], dst_iovcnt, true, &cb_arg); 664 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == false); 665 while (!TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops)) { 666 op = TAILQ_FIRST(&g_comp_bdev.queued_comp_ops); 667 TAILQ_REMOVE(&g_comp_bdev.queued_comp_ops, op, link); 668 free(op); 669 } 670 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 671 CU_ASSERT(rc == 0); 672 ut_rte_pktmbuf_alloc_bulk = 0; 673 674 /* test enqueue failure busy */ 675 ut_enqueue_value = FAKE_ENQUEUE_BUSY; 676 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 677 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 678 &dst_iovs[0], dst_iovcnt, true, &cb_arg); 679 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == false); 680 while (!TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops)) { 681 op = TAILQ_FIRST(&g_comp_bdev.queued_comp_ops); 682 TAILQ_REMOVE(&g_comp_bdev.queued_comp_ops, op, link); 683 free(op); 684 } 685 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 686 CU_ASSERT(rc == 0); 687 ut_enqueue_value = 1; 688 689 /* test enqueue failure error */ 690 ut_enqueue_value = FAKE_ENQUEUE_ERROR; 691 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 692 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 693 &dst_iovs[0], dst_iovcnt, true, &cb_arg); 694 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 695 CU_ASSERT(rc == -EINVAL); 696 ut_enqueue_value = FAKE_ENQUEUE_SUCCESS; 697 698 /* test success with 3 vector iovec */ 699 ut_expected_op.private_xform = &g_decomp_xform; 700 ut_expected_op.src.offset = 0; 701 ut_expected_op.src.length = src_iovs[0].iov_len + src_iovs[1].iov_len + src_iovs[2].iov_len; 702 703 /* setup the src expected values */ 704 _get_mbuf_array(exp_src_mbuf, &g_expected_src_mbufs[0], SPDK_COUNTOF(exp_src_mbuf), false); 705 ut_expected_op.m_src = exp_src_mbuf[0]; 706 707 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 708 *RTE_MBUF_DYNFIELD(exp_src_mbuf[i], g_mbuf_offset, uint64_t *) = (uint64_t)&cb_arg; 709 exp_src_mbuf[i]->buf_addr = src_iovs[i].iov_base; 710 exp_src_mbuf[i]->buf_iova = spdk_vtophys(src_iovs[i].iov_base, &src_iovs[i].iov_len); 711 exp_src_mbuf[i]->buf_len = src_iovs[i].iov_len; 712 exp_src_mbuf[i]->pkt_len = src_iovs[i].iov_len; 713 } 714 715 /* setup the dst expected values */ 716 _get_mbuf_array(exp_dst_mbuf, &g_expected_dst_mbufs[0], SPDK_COUNTOF(exp_dst_mbuf), false); 717 ut_expected_op.dst.offset = 0; 718 ut_expected_op.m_dst = exp_dst_mbuf[0]; 719 720 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 721 exp_dst_mbuf[i]->buf_addr = dst_iovs[i].iov_base; 722 exp_dst_mbuf[i]->buf_iova = spdk_vtophys(dst_iovs[i].iov_base, &dst_iovs[i].iov_len); 723 exp_dst_mbuf[i]->buf_len = dst_iovs[i].iov_len; 724 exp_dst_mbuf[i]->pkt_len = dst_iovs[i].iov_len; 725 } 726 727 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 728 &dst_iovs[0], dst_iovcnt, false, &cb_arg); 729 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 730 CU_ASSERT(rc == 0); 731 732 /* test sgl out failure */ 733 g_comp_bdev.backing_dev.sgl_out = false; 734 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 735 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], 1, 736 &dst_iovs[0], dst_iovcnt, true, &cb_arg); 737 CU_ASSERT(rc == -EINVAL); 738 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 739 g_comp_bdev.backing_dev.sgl_out = true; 740 741 /* test sgl in failure */ 742 g_comp_bdev.backing_dev.sgl_in = false; 743 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 744 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 745 &dst_iovs[0], 1, true, &cb_arg); 746 CU_ASSERT(rc == -EINVAL); 747 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 748 g_comp_bdev.backing_dev.sgl_in = true; 749 750 751 } 752 753 static void 754 test_compress_operation_cross_boundary(void) 755 { 756 struct iovec src_iovs[3] = {}; 757 int src_iovcnt; 758 struct iovec dst_iovs[3] = {}; 759 int dst_iovcnt; 760 struct spdk_reduce_vol_cb_args cb_arg; 761 int rc, i; 762 struct rte_mbuf *exp_src_mbuf[UT_MBUFS_PER_OP_BOUND_TEST]; 763 struct rte_mbuf *exp_dst_mbuf[UT_MBUFS_PER_OP_BOUND_TEST]; 764 765 /* Setup the same basic 3 IOV test as used in the simple success case 766 * but then we'll start testing a vtophy boundary crossing at each 767 * position. 768 */ 769 src_iovcnt = dst_iovcnt = 3; 770 for (i = 0; i < dst_iovcnt; i++) { 771 src_iovs[i].iov_len = 0x1000; 772 dst_iovs[i].iov_len = 0x1000; 773 src_iovs[i].iov_base = (void *)0x10000000 + 0x1000 * i; 774 dst_iovs[i].iov_base = (void *)0x20000000 + 0x1000 * i; 775 } 776 777 ut_expected_op.private_xform = &g_decomp_xform; 778 ut_expected_op.src.offset = 0; 779 ut_expected_op.src.length = src_iovs[0].iov_len + src_iovs[1].iov_len + src_iovs[2].iov_len; 780 781 /* setup the src expected values */ 782 _get_mbuf_array(exp_src_mbuf, &g_expected_src_mbufs[0], SPDK_COUNTOF(exp_src_mbuf), false); 783 ut_expected_op.m_src = exp_src_mbuf[0]; 784 785 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 786 *RTE_MBUF_DYNFIELD(exp_src_mbuf[i], g_mbuf_offset, uint64_t *) = (uint64_t)&cb_arg; 787 exp_src_mbuf[i]->buf_addr = src_iovs[i].iov_base; 788 exp_src_mbuf[i]->buf_iova = spdk_vtophys(src_iovs[i].iov_base, &src_iovs[i].iov_len); 789 exp_src_mbuf[i]->buf_len = src_iovs[i].iov_len; 790 exp_src_mbuf[i]->pkt_len = src_iovs[i].iov_len; 791 } 792 793 /* setup the dst expected values, we don't test needing a 4th dst mbuf */ 794 _get_mbuf_array(exp_dst_mbuf, &g_expected_dst_mbufs[0], SPDK_COUNTOF(exp_dst_mbuf), false); 795 ut_expected_op.dst.offset = 0; 796 ut_expected_op.m_dst = exp_dst_mbuf[0]; 797 798 for (i = 0; i < UT_MBUFS_PER_OP; i++) { 799 exp_dst_mbuf[i]->buf_addr = dst_iovs[i].iov_base; 800 exp_dst_mbuf[i]->buf_iova = spdk_vtophys(dst_iovs[i].iov_base, &dst_iovs[i].iov_len); 801 exp_dst_mbuf[i]->buf_len = dst_iovs[i].iov_len; 802 exp_dst_mbuf[i]->pkt_len = dst_iovs[i].iov_len; 803 } 804 805 /* force the 1st IOV to get partial length from spdk_vtophys */ 806 g_small_size_counter = 0; 807 g_small_size_modify = 1; 808 g_small_size = 0x800; 809 *RTE_MBUF_DYNFIELD(exp_src_mbuf[3], g_mbuf_offset, uint64_t *) = (uint64_t)&cb_arg; 810 811 /* first only has shorter length */ 812 exp_src_mbuf[0]->pkt_len = exp_src_mbuf[0]->buf_len = 0x800; 813 814 /* 2nd was inserted by the boundary crossing condition and finishes off 815 * the length from the first */ 816 exp_src_mbuf[1]->buf_addr = (void *)0x10000800; 817 exp_src_mbuf[1]->buf_iova = 0x10000800; 818 exp_src_mbuf[1]->pkt_len = exp_src_mbuf[1]->buf_len = 0x800; 819 820 /* 3rd looks like that the 2nd would have */ 821 exp_src_mbuf[2]->buf_addr = (void *)0x10001000; 822 exp_src_mbuf[2]->buf_iova = 0x10001000; 823 exp_src_mbuf[2]->pkt_len = exp_src_mbuf[2]->buf_len = 0x1000; 824 825 /* a new 4th looks like what the 3rd would have */ 826 exp_src_mbuf[3]->buf_addr = (void *)0x10002000; 827 exp_src_mbuf[3]->buf_iova = 0x10002000; 828 exp_src_mbuf[3]->pkt_len = exp_src_mbuf[3]->buf_len = 0x1000; 829 830 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 831 &dst_iovs[0], dst_iovcnt, false, &cb_arg); 832 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 833 CU_ASSERT(rc == 0); 834 835 /* Now force the 2nd IOV to get partial length from spdk_vtophys */ 836 g_small_size_counter = 0; 837 g_small_size_modify = 2; 838 g_small_size = 0x800; 839 840 /* first is normal */ 841 exp_src_mbuf[0]->buf_addr = (void *)0x10000000; 842 exp_src_mbuf[0]->buf_iova = 0x10000000; 843 exp_src_mbuf[0]->pkt_len = exp_src_mbuf[0]->buf_len = 0x1000; 844 845 /* second only has shorter length */ 846 exp_src_mbuf[1]->buf_addr = (void *)0x10001000; 847 exp_src_mbuf[1]->buf_iova = 0x10001000; 848 exp_src_mbuf[1]->pkt_len = exp_src_mbuf[1]->buf_len = 0x800; 849 850 /* 3rd was inserted by the boundary crossing condition and finishes off 851 * the length from the first */ 852 exp_src_mbuf[2]->buf_addr = (void *)0x10001800; 853 exp_src_mbuf[2]->buf_iova = 0x10001800; 854 exp_src_mbuf[2]->pkt_len = exp_src_mbuf[2]->buf_len = 0x800; 855 856 /* a new 4th looks like what the 3rd would have */ 857 exp_src_mbuf[3]->buf_addr = (void *)0x10002000; 858 exp_src_mbuf[3]->buf_iova = 0x10002000; 859 exp_src_mbuf[3]->pkt_len = exp_src_mbuf[3]->buf_len = 0x1000; 860 861 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 862 &dst_iovs[0], dst_iovcnt, false, &cb_arg); 863 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 864 CU_ASSERT(rc == 0); 865 866 /* Finally force the 3rd IOV to get partial length from spdk_vtophys */ 867 g_small_size_counter = 0; 868 g_small_size_modify = 3; 869 g_small_size = 0x800; 870 871 /* first is normal */ 872 exp_src_mbuf[0]->buf_addr = (void *)0x10000000; 873 exp_src_mbuf[0]->buf_iova = 0x10000000; 874 exp_src_mbuf[0]->pkt_len = exp_src_mbuf[0]->buf_len = 0x1000; 875 876 /* second is normal */ 877 exp_src_mbuf[1]->buf_addr = (void *)0x10001000; 878 exp_src_mbuf[1]->buf_iova = 0x10001000; 879 exp_src_mbuf[1]->pkt_len = exp_src_mbuf[1]->buf_len = 0x1000; 880 881 /* 3rd has shorter length */ 882 exp_src_mbuf[2]->buf_addr = (void *)0x10002000; 883 exp_src_mbuf[2]->buf_iova = 0x10002000; 884 exp_src_mbuf[2]->pkt_len = exp_src_mbuf[2]->buf_len = 0x800; 885 886 /* a new 4th handles the remainder from the 3rd */ 887 exp_src_mbuf[3]->buf_addr = (void *)0x10002800; 888 exp_src_mbuf[3]->buf_iova = 0x10002800; 889 exp_src_mbuf[3]->pkt_len = exp_src_mbuf[3]->buf_len = 0x800; 890 891 rc = _compress_operation(&g_comp_bdev.backing_dev, &src_iovs[0], src_iovcnt, 892 &dst_iovs[0], dst_iovcnt, false, &cb_arg); 893 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 894 CU_ASSERT(rc == 0); 895 896 /* Single input iov is split on page boundary, sgl_in is not supported */ 897 g_comp_bdev.backing_dev.sgl_in = false; 898 g_small_size_counter = 0; 899 g_small_size_modify = 1; 900 g_small_size = 0x800; 901 rc = _compress_operation(&g_comp_bdev.backing_dev, src_iovs, 1, 902 dst_iovs, 1, false, &cb_arg); 903 CU_ASSERT(rc == -EINVAL); 904 g_comp_bdev.backing_dev.sgl_in = true; 905 906 /* Single output iov is split on page boundary, sgl_out is not supported */ 907 g_comp_bdev.backing_dev.sgl_out = false; 908 g_small_size_counter = 0; 909 g_small_size_modify = 2; 910 g_small_size = 0x800; 911 rc = _compress_operation(&g_comp_bdev.backing_dev, src_iovs, 1, 912 dst_iovs, 1, false, &cb_arg); 913 CU_ASSERT(rc == -EINVAL); 914 g_comp_bdev.backing_dev.sgl_out = true; 915 } 916 917 static void 918 test_poller(void) 919 { 920 int rc; 921 struct spdk_reduce_vol_cb_args *cb_args; 922 struct rte_mbuf mbuf[4]; /* one src, one dst, 2 ops */ 923 struct vbdev_comp_op *op_to_queue; 924 struct iovec src_iovs[3] = {}; 925 struct iovec dst_iovs[3] = {}; 926 int i; 927 928 cb_args = calloc(1, sizeof(*cb_args)); 929 SPDK_CU_ASSERT_FATAL(cb_args != NULL); 930 cb_args->cb_fn = _compress_done; 931 memset(&g_comp_op[0], 0, sizeof(struct rte_comp_op)); 932 g_comp_op[0].m_src = &mbuf[0]; 933 g_comp_op[1].m_src = &mbuf[1]; 934 g_comp_op[0].m_dst = &mbuf[2]; 935 g_comp_op[1].m_dst = &mbuf[3]; 936 for (i = 0; i < 3; i++) { 937 src_iovs[i].iov_len = 0x1000; 938 dst_iovs[i].iov_len = 0x1000; 939 src_iovs[i].iov_base = (void *)0x10000000 + 0x1000 * i; 940 dst_iovs[i].iov_base = (void *)0x20000000 + 0x1000 * i; 941 } 942 943 /* Error from dequeue, nothing needing to be resubmitted. 944 */ 945 ut_rte_compressdev_dequeue_burst = 1; 946 /* setup what we want dequeue to return for the op */ 947 *RTE_MBUF_DYNFIELD(g_comp_op[0].m_src, g_mbuf_offset, uint64_t *) = (uint64_t)cb_args; 948 g_comp_op[0].produced = 1; 949 g_comp_op[0].status = 1; 950 /* value asserted in the reduce callback */ 951 ut_compress_done[0] = -EINVAL; 952 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 953 rc = comp_dev_poller((void *)&g_comp_bdev); 954 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 955 CU_ASSERT(rc == SPDK_POLLER_BUSY); 956 957 /* Success from dequeue, 2 ops. nothing needing to be resubmitted. 958 */ 959 ut_rte_compressdev_dequeue_burst = 2; 960 /* setup what we want dequeue to return for the op */ 961 *RTE_MBUF_DYNFIELD(g_comp_op[0].m_src, g_mbuf_offset, uint64_t *) = (uint64_t)cb_args; 962 g_comp_op[0].produced = 16; 963 g_comp_op[0].status = 0; 964 *RTE_MBUF_DYNFIELD(g_comp_op[1].m_src, g_mbuf_offset, uint64_t *) = (uint64_t)cb_args; 965 g_comp_op[1].produced = 32; 966 g_comp_op[1].status = 0; 967 /* value asserted in the reduce callback */ 968 ut_compress_done[0] = 16; 969 ut_compress_done[1] = 32; 970 done_count = 2; 971 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 972 rc = comp_dev_poller((void *)&g_comp_bdev); 973 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 974 CU_ASSERT(rc == SPDK_POLLER_BUSY); 975 976 /* Success from dequeue, one op to be resubmitted. 977 */ 978 ut_rte_compressdev_dequeue_burst = 1; 979 /* setup what we want dequeue to return for the op */ 980 *RTE_MBUF_DYNFIELD(g_comp_op[0].m_src, g_mbuf_offset, uint64_t *) = (uint64_t)cb_args; 981 g_comp_op[0].produced = 16; 982 g_comp_op[0].status = 0; 983 /* value asserted in the reduce callback */ 984 ut_compress_done[0] = 16; 985 done_count = 1; 986 op_to_queue = calloc(1, sizeof(struct vbdev_comp_op)); 987 SPDK_CU_ASSERT_FATAL(op_to_queue != NULL); 988 op_to_queue->backing_dev = &g_comp_bdev.backing_dev; 989 op_to_queue->src_iovs = &src_iovs[0]; 990 op_to_queue->src_iovcnt = 3; 991 op_to_queue->dst_iovs = &dst_iovs[0]; 992 op_to_queue->dst_iovcnt = 3; 993 op_to_queue->compress = true; 994 op_to_queue->cb_arg = cb_args; 995 ut_enqueue_value = FAKE_ENQUEUE_SUCCESS; 996 TAILQ_INSERT_TAIL(&g_comp_bdev.queued_comp_ops, 997 op_to_queue, 998 link); 999 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == false); 1000 rc = comp_dev_poller((void *)&g_comp_bdev); 1001 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev.queued_comp_ops) == true); 1002 CU_ASSERT(rc == SPDK_POLLER_BUSY); 1003 1004 /* op_to_queue is freed in code under test */ 1005 free(cb_args); 1006 } 1007 1008 static void 1009 test_vbdev_compress_submit_request(void) 1010 { 1011 /* Single element block size write */ 1012 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 1013 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 1014 g_completion_called = false; 1015 vbdev_compress_submit_request(g_io_ch, g_bdev_io); 1016 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1017 CU_ASSERT(g_completion_called == true); 1018 CU_ASSERT(g_io_ctx->orig_io == g_bdev_io); 1019 CU_ASSERT(g_io_ctx->comp_bdev == &g_comp_bdev); 1020 CU_ASSERT(g_io_ctx->comp_ch == g_comp_ch); 1021 1022 /* same write but now fail it */ 1023 ut_spdk_reduce_vol_op_complete_err = 1; 1024 g_completion_called = false; 1025 vbdev_compress_submit_request(g_io_ch, g_bdev_io); 1026 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1027 CU_ASSERT(g_completion_called == true); 1028 1029 /* test a read success */ 1030 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 1031 ut_spdk_reduce_vol_op_complete_err = 0; 1032 g_completion_called = false; 1033 vbdev_compress_submit_request(g_io_ch, g_bdev_io); 1034 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1035 CU_ASSERT(g_completion_called == true); 1036 1037 /* test a read failure */ 1038 ut_spdk_reduce_vol_op_complete_err = 1; 1039 g_completion_called = false; 1040 vbdev_compress_submit_request(g_io_ch, g_bdev_io); 1041 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1042 CU_ASSERT(g_completion_called == true); 1043 } 1044 1045 static void 1046 test_passthru(void) 1047 { 1048 1049 } 1050 1051 static void 1052 test_reset(void) 1053 { 1054 /* TODO: There are a few different ways to do this given that 1055 * the code uses spdk_for_each_channel() to implement reset 1056 * handling. SUbmitting w/o UT for this function for now and 1057 * will follow up with something shortly. 1058 */ 1059 } 1060 1061 static void 1062 test_initdrivers(void) 1063 { 1064 int rc; 1065 1066 /* test return values from rte_vdev_init() */ 1067 MOCK_SET(rte_vdev_init, -EEXIST); 1068 rc = vbdev_init_compress_drivers(); 1069 /* This is not an error condition, we already have one */ 1070 CU_ASSERT(rc == 0); 1071 1072 /* error */ 1073 MOCK_SET(rte_vdev_init, -2); 1074 rc = vbdev_init_compress_drivers(); 1075 CU_ASSERT(rc == -EINVAL); 1076 CU_ASSERT(g_mbuf_mp == NULL); 1077 CU_ASSERT(g_comp_op_mp == NULL); 1078 1079 /* compressdev count 0 */ 1080 ut_rte_compressdev_count = 0; 1081 MOCK_SET(rte_vdev_init, 0); 1082 rc = vbdev_init_compress_drivers(); 1083 CU_ASSERT(rc == 0); 1084 1085 /* bogus count */ 1086 ut_rte_compressdev_count = RTE_COMPRESS_MAX_DEVS + 1; 1087 rc = vbdev_init_compress_drivers(); 1088 CU_ASSERT(rc == -EINVAL); 1089 1090 /* can't get mbuf pool */ 1091 ut_rte_compressdev_count = 1; 1092 MOCK_SET(spdk_mempool_create, NULL); 1093 rc = vbdev_init_compress_drivers(); 1094 CU_ASSERT(rc == -ENOMEM); 1095 MOCK_CLEAR(spdk_mempool_create); 1096 1097 /* can't get comp op pool */ 1098 ut_rte_comp_op_pool_create = NULL; 1099 rc = vbdev_init_compress_drivers(); 1100 CU_ASSERT(rc == -ENOMEM); 1101 1102 /* error on create_compress_dev() */ 1103 ut_rte_comp_op_pool_create = (struct rte_mempool *)&test_initdrivers; 1104 ut_rte_compressdev_configure = -1; 1105 rc = vbdev_init_compress_drivers(); 1106 CU_ASSERT(rc == -1); 1107 1108 /* error on create_compress_dev() but coverage for large num queues */ 1109 ut_max_nb_queue_pairs = 99; 1110 rc = vbdev_init_compress_drivers(); 1111 CU_ASSERT(rc == -1); 1112 1113 /* qpair setup fails */ 1114 ut_rte_compressdev_configure = 0; 1115 ut_max_nb_queue_pairs = 0; 1116 ut_rte_compressdev_queue_pair_setup = -1; 1117 rc = vbdev_init_compress_drivers(); 1118 CU_ASSERT(rc == -EINVAL); 1119 1120 /* rte_compressdev_start fails */ 1121 ut_rte_compressdev_queue_pair_setup = 0; 1122 ut_rte_compressdev_start = -1; 1123 rc = vbdev_init_compress_drivers(); 1124 CU_ASSERT(rc == -1); 1125 1126 /* rte_compressdev_private_xform_create() fails */ 1127 ut_rte_compressdev_start = 0; 1128 ut_rte_compressdev_private_xform_create = -2; 1129 rc = vbdev_init_compress_drivers(); 1130 CU_ASSERT(rc == -2); 1131 1132 /* success */ 1133 ut_rte_compressdev_private_xform_create = 0; 1134 rc = vbdev_init_compress_drivers(); 1135 CU_ASSERT(rc == 0); 1136 CU_ASSERT(g_mbuf_offset == DPDK_DYNFIELD_OFFSET); 1137 spdk_mempool_free((struct spdk_mempool *)g_mbuf_mp); 1138 } 1139 1140 static void 1141 test_supported_io(void) 1142 { 1143 1144 } 1145 1146 int 1147 main(int argc, char **argv) 1148 { 1149 CU_pSuite suite = NULL; 1150 unsigned int num_failures; 1151 1152 CU_set_error_action(CUEA_ABORT); 1153 CU_initialize_registry(); 1154 1155 suite = CU_add_suite("compress", test_setup, test_cleanup); 1156 CU_ADD_TEST(suite, test_compress_operation); 1157 CU_ADD_TEST(suite, test_compress_operation_cross_boundary); 1158 CU_ADD_TEST(suite, test_vbdev_compress_submit_request); 1159 CU_ADD_TEST(suite, test_passthru); 1160 CU_ADD_TEST(suite, test_initdrivers); 1161 CU_ADD_TEST(suite, test_supported_io); 1162 CU_ADD_TEST(suite, test_poller); 1163 CU_ADD_TEST(suite, test_reset); 1164 1165 CU_basic_set_mode(CU_BRM_VERBOSE); 1166 CU_basic_run_tests(); 1167 num_failures = CU_get_number_of_failures(); 1168 CU_cleanup_registry(); 1169 return num_failures; 1170 } 1171