1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2018 Intel Corporation. 3 * All rights reserved. 4 */ 5 6 #include "spdk_cunit.h" 7 8 #include "common/lib/test_env.c" 9 #include "spdk_internal/mock.h" 10 #include "thread/thread_internal.h" 11 #include "unit/lib/json_mock.c" 12 13 #include <rte_crypto.h> 14 #include <rte_cryptodev.h> 15 #include <rte_version.h> 16 17 #define MAX_TEST_BLOCKS 8192 18 struct rte_crypto_op *g_test_crypto_ops[MAX_TEST_BLOCKS]; 19 struct rte_crypto_op *g_test_dev_full_ops[MAX_TEST_BLOCKS]; 20 21 uint16_t g_dequeue_mock; 22 uint16_t g_enqueue_mock; 23 unsigned ut_rte_crypto_op_bulk_alloc; 24 int ut_rte_crypto_op_attach_sym_session = 0; 25 #define MOCK_INFO_GET_1QP_AESNI 0 26 #define MOCK_INFO_GET_1QP_QAT 1 27 #define MOCK_INFO_GET_1QP_MLX5 2 28 #define MOCK_INFO_GET_1QP_BOGUS_PMD 3 29 int ut_rte_cryptodev_info_get = 0; 30 bool ut_rte_cryptodev_info_get_mocked = false; 31 32 void mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt); 33 #define rte_pktmbuf_free_bulk mock_rte_pktmbuf_free_bulk 34 void 35 mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt) 36 { 37 spdk_mempool_put_bulk((struct spdk_mempool *)m[0]->pool, (void **)m, cnt); 38 } 39 40 void mock_rte_pktmbuf_free(struct rte_mbuf *m); 41 #define rte_pktmbuf_free mock_rte_pktmbuf_free 42 void 43 mock_rte_pktmbuf_free(struct rte_mbuf *m) 44 { 45 spdk_mempool_put((struct spdk_mempool *)m->pool, (void *)m); 46 } 47 48 void 49 rte_mempool_free(struct rte_mempool *mp) 50 { 51 spdk_mempool_free((struct spdk_mempool *)mp); 52 } 53 54 int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs, 55 unsigned count); 56 #define rte_pktmbuf_alloc_bulk mock_rte_pktmbuf_alloc_bulk 57 int 58 mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs, 59 unsigned count) 60 { 61 int rc; 62 63 rc = spdk_mempool_get_bulk((struct spdk_mempool *)pool, (void **)mbufs, count); 64 if (rc) { 65 return rc; 66 } 67 for (unsigned i = 0; i < count; i++) { 68 rte_pktmbuf_reset(mbufs[i]); 69 mbufs[i]->pool = pool; 70 } 71 return rc; 72 } 73 74 struct rte_mempool * 75 rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts, 76 uint32_t elt_size, uint32_t cache_size, 77 uint16_t priv_size, int socket_id) 78 { 79 struct spdk_mempool *tmp; 80 81 tmp = spdk_mempool_create(name, nb_elts, elt_size + priv_size, 82 cache_size, socket_id); 83 84 return (struct rte_mempool *)tmp; 85 86 } 87 88 struct rte_mempool * 89 rte_pktmbuf_pool_create(const char *name, unsigned n, unsigned cache_size, 90 uint16_t priv_size, uint16_t data_room_size, int socket_id) 91 { 92 struct spdk_mempool *tmp; 93 94 tmp = spdk_mempool_create(name, n, sizeof(struct rte_mbuf) + priv_size, 95 cache_size, socket_id); 96 97 return (struct rte_mempool *)tmp; 98 } 99 100 struct rte_mempool * 101 rte_mempool_create(const char *name, unsigned n, unsigned elt_size, 102 unsigned cache_size, unsigned private_data_size, 103 rte_mempool_ctor_t *mp_init, void *mp_init_arg, 104 rte_mempool_obj_cb_t *obj_init, void *obj_init_arg, 105 int socket_id, unsigned flags) 106 { 107 struct spdk_mempool *tmp; 108 109 tmp = spdk_mempool_create(name, n, elt_size + private_data_size, 110 cache_size, socket_id); 111 112 return (struct rte_mempool *)tmp; 113 } 114 115 DEFINE_RETURN_MOCK(rte_crypto_op_pool_create, struct rte_mempool *); 116 struct rte_mempool * 117 rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type, 118 unsigned nb_elts, unsigned cache_size, 119 uint16_t priv_size, int socket_id) 120 { 121 struct spdk_mempool *tmp; 122 123 HANDLE_RETURN_MOCK(rte_crypto_op_pool_create); 124 125 tmp = spdk_mempool_create(name, nb_elts, 126 sizeof(struct rte_crypto_op) + priv_size, 127 cache_size, socket_id); 128 129 return (struct rte_mempool *)tmp; 130 131 } 132 133 /* Those functions are defined as static inline in DPDK, so we can't 134 * mock them straight away. We use defines to redirect them into 135 * our custom functions. 136 */ 137 static bool g_resubmit_test = false; 138 #define rte_cryptodev_enqueue_burst mock_rte_cryptodev_enqueue_burst 139 static inline uint16_t 140 mock_rte_cryptodev_enqueue_burst(uint8_t dev_id, uint16_t qp_id, 141 struct rte_crypto_op **ops, uint16_t nb_ops) 142 { 143 int i; 144 145 CU_ASSERT(nb_ops > 0); 146 147 for (i = 0; i < nb_ops; i++) { 148 /* Use this empty (til now) array of pointers to store 149 * enqueued operations for assertion in dev_full test. 150 */ 151 g_test_dev_full_ops[i] = *ops++; 152 if (g_resubmit_test == true) { 153 CU_ASSERT(g_test_dev_full_ops[i] == (void *)0xDEADBEEF); 154 } 155 } 156 157 return g_enqueue_mock; 158 } 159 160 #define rte_cryptodev_dequeue_burst mock_rte_cryptodev_dequeue_burst 161 static inline uint16_t 162 mock_rte_cryptodev_dequeue_burst(uint8_t dev_id, uint16_t qp_id, 163 struct rte_crypto_op **ops, uint16_t nb_ops) 164 { 165 int i; 166 167 CU_ASSERT(nb_ops > 0); 168 169 for (i = 0; i < g_dequeue_mock; i++) { 170 *ops++ = g_test_crypto_ops[i]; 171 } 172 173 return g_dequeue_mock; 174 } 175 176 /* Instead of allocating real memory, assign the allocations to our 177 * test array for assertion in tests. 178 */ 179 #define rte_crypto_op_bulk_alloc mock_rte_crypto_op_bulk_alloc 180 static inline unsigned 181 mock_rte_crypto_op_bulk_alloc(struct rte_mempool *mempool, 182 enum rte_crypto_op_type type, 183 struct rte_crypto_op **ops, uint16_t nb_ops) 184 { 185 int i; 186 187 for (i = 0; i < nb_ops; i++) { 188 *ops++ = g_test_crypto_ops[i]; 189 } 190 return ut_rte_crypto_op_bulk_alloc; 191 } 192 193 #define rte_mempool_put_bulk mock_rte_mempool_put_bulk 194 static __rte_always_inline void 195 mock_rte_mempool_put_bulk(struct rte_mempool *mp, void *const *obj_table, 196 unsigned int n) 197 { 198 return; 199 } 200 201 #define rte_crypto_op_attach_sym_session mock_rte_crypto_op_attach_sym_session 202 #if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0) 203 static inline int 204 mock_rte_crypto_op_attach_sym_session(struct rte_crypto_op *op, void *sess) 205 #else 206 static inline int 207 mock_rte_crypto_op_attach_sym_session(struct rte_crypto_op *op, 208 struct rte_cryptodev_sym_session *sess) 209 #endif 210 { 211 return ut_rte_crypto_op_attach_sym_session; 212 } 213 214 #define rte_lcore_count mock_rte_lcore_count 215 static inline unsigned 216 mock_rte_lcore_count(void) 217 { 218 return 1; 219 } 220 221 #include "bdev/crypto/vbdev_crypto.c" 222 223 /* SPDK stubs */ 224 DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch, 225 struct spdk_bdev_io_wait_entry *entry), 0); 226 DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module)); 227 DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *g_bdev_io)); 228 DEFINE_STUB_V(spdk_bdev_io_put_aux_buf, (struct spdk_bdev_io *bdev_io, void *aux_buf)); 229 DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev, 230 enum spdk_bdev_io_type io_type), 0); 231 DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev)); 232 DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc)); 233 DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), 0); 234 DEFINE_STUB(spdk_bdev_get_buf_align, size_t, (const struct spdk_bdev *bdev), 64); 235 DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc), 0); 236 DEFINE_STUB_V(spdk_bdev_unregister, (struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn, 237 void *cb_arg)); 238 DEFINE_STUB(spdk_bdev_unregister_by_name, int, (const char *bdev_name, 239 struct spdk_bdev_module *module, 240 spdk_bdev_unregister_cb cb_fn, void *cb_arg), 0); 241 DEFINE_STUB(spdk_bdev_open_ext, int, (const char *bdev_name, bool write, 242 spdk_bdev_event_cb_t event_cb, 243 void *event_ctx, struct spdk_bdev_desc **_desc), 0); 244 DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL); 245 DEFINE_STUB(spdk_bdev_module_claim_bdev, int, (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc, 246 struct spdk_bdev_module *module), 0); 247 DEFINE_STUB_V(spdk_bdev_module_examine_done, (struct spdk_bdev_module *module)); 248 DEFINE_STUB(spdk_bdev_register, int, (struct spdk_bdev *vbdev), 0); 249 DEFINE_STUB_V(spdk_bdev_destruct_done, (struct spdk_bdev *bdev, int bdeverrno)); 250 251 /* DPDK stubs */ 252 #define DPDK_DYNFIELD_OFFSET offsetof(struct rte_mbuf, dynfield1[1]) 253 DEFINE_STUB(rte_mbuf_dynfield_register, int, (const struct rte_mbuf_dynfield *params), 254 DPDK_DYNFIELD_OFFSET); 255 DEFINE_STUB(rte_cryptodev_count, uint8_t, (void), 0); 256 DEFINE_STUB(rte_socket_id, unsigned, (void), 0); 257 DEFINE_STUB(rte_cryptodev_device_count_by_driver, uint8_t, (uint8_t driver_id), 0); 258 DEFINE_STUB(rte_cryptodev_configure, int, (uint8_t dev_id, struct rte_cryptodev_config *config), 0); 259 DEFINE_STUB(rte_cryptodev_queue_pair_setup, int, (uint8_t dev_id, uint16_t queue_pair_id, 260 const struct rte_cryptodev_qp_conf *qp_conf, int socket_id), 0); 261 DEFINE_STUB(rte_cryptodev_start, int, (uint8_t dev_id), 0); 262 DEFINE_STUB_V(rte_cryptodev_stop, (uint8_t dev_id)); 263 DEFINE_STUB(rte_cryptodev_close, int, (uint8_t dev_id), 0); 264 DEFINE_STUB(rte_vdev_init, int, (const char *name, const char *args), 0); 265 DEFINE_STUB(rte_vdev_uninit, int, (const char *name), 0); 266 267 #if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0) 268 DEFINE_STUB(rte_cryptodev_sym_session_create, void *, 269 (uint8_t dev_id, struct rte_crypto_sym_xform *xforms, struct rte_mempool *mempool), (void *)1); 270 DEFINE_STUB(rte_cryptodev_sym_session_free, int, (uint8_t dev_id, void *sess), 0); 271 #else 272 DEFINE_STUB(rte_cryptodev_sym_session_create, struct rte_cryptodev_sym_session *, 273 (struct rte_mempool *mempool), (void *)1); 274 DEFINE_STUB(rte_cryptodev_sym_session_init, int, (uint8_t dev_id, 275 struct rte_cryptodev_sym_session *sess, 276 struct rte_crypto_sym_xform *xforms, struct rte_mempool *mempool), 0); 277 DEFINE_STUB(rte_cryptodev_sym_session_free, int, (struct rte_cryptodev_sym_session *sess), 0); 278 #endif 279 280 struct rte_cryptodev *rte_cryptodevs; 281 282 /* global vars and setup/cleanup functions used for all test functions */ 283 struct spdk_bdev_io *g_bdev_io; 284 struct crypto_bdev_io *g_io_ctx; 285 struct crypto_io_channel *g_crypto_ch; 286 struct spdk_io_channel *g_io_ch; 287 struct vbdev_dev g_device; 288 struct vbdev_crypto g_crypto_bdev; 289 struct vbdev_crypto_opts g_crypto_bdev_opts; 290 struct device_qp g_dev_qp; 291 292 void 293 rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info) 294 { 295 dev_info->max_nb_queue_pairs = 1; 296 if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_AESNI) { 297 dev_info->driver_name = g_driver_names[0]; 298 } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_QAT) { 299 dev_info->driver_name = g_driver_names[1]; 300 } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_MLX5) { 301 dev_info->driver_name = g_driver_names[2]; 302 } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_BOGUS_PMD) { 303 dev_info->driver_name = "junk"; 304 } 305 } 306 307 unsigned int 308 rte_cryptodev_sym_get_private_session_size(uint8_t dev_id) 309 { 310 return (unsigned int)dev_id; 311 } 312 313 void 314 spdk_bdev_io_get_aux_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_aux_buf_cb cb) 315 { 316 cb(g_io_ch, g_bdev_io, (void *)0xDEADBEEF); 317 } 318 319 void 320 spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len) 321 { 322 cb(g_io_ch, g_bdev_io, true); 323 } 324 325 /* Mock these functions to call the callback and then return the value we require */ 326 int ut_spdk_bdev_readv_blocks = 0; 327 bool ut_spdk_bdev_readv_blocks_mocked = false; 328 int 329 spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 330 struct iovec *iov, int iovcnt, 331 uint64_t offset_blocks, uint64_t num_blocks, 332 spdk_bdev_io_completion_cb cb, void *cb_arg) 333 { 334 cb(g_bdev_io, !ut_spdk_bdev_readv_blocks, cb_arg); 335 return ut_spdk_bdev_readv_blocks; 336 } 337 338 int ut_spdk_bdev_writev_blocks = 0; 339 bool ut_spdk_bdev_writev_blocks_mocked = false; 340 int 341 spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 342 struct iovec *iov, int iovcnt, 343 uint64_t offset_blocks, uint64_t num_blocks, 344 spdk_bdev_io_completion_cb cb, void *cb_arg) 345 { 346 cb(g_bdev_io, !ut_spdk_bdev_writev_blocks, cb_arg); 347 return ut_spdk_bdev_writev_blocks; 348 } 349 350 int ut_spdk_bdev_unmap_blocks = 0; 351 bool ut_spdk_bdev_unmap_blocks_mocked = false; 352 int 353 spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 354 uint64_t offset_blocks, uint64_t num_blocks, 355 spdk_bdev_io_completion_cb cb, void *cb_arg) 356 { 357 cb(g_bdev_io, !ut_spdk_bdev_unmap_blocks, cb_arg); 358 return ut_spdk_bdev_unmap_blocks; 359 } 360 361 int ut_spdk_bdev_flush_blocks = 0; 362 bool ut_spdk_bdev_flush_blocks_mocked = false; 363 int 364 spdk_bdev_flush_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 365 uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb, 366 void *cb_arg) 367 { 368 cb(g_bdev_io, !ut_spdk_bdev_flush_blocks, cb_arg); 369 return ut_spdk_bdev_flush_blocks; 370 } 371 372 int ut_spdk_bdev_reset = 0; 373 bool ut_spdk_bdev_reset_mocked = false; 374 int 375 spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch, 376 spdk_bdev_io_completion_cb cb, void *cb_arg) 377 { 378 cb(g_bdev_io, !ut_spdk_bdev_reset, cb_arg); 379 return ut_spdk_bdev_reset; 380 } 381 382 bool g_completion_called = false; 383 void 384 spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status) 385 { 386 bdev_io->internal.status = status; 387 g_completion_called = true; 388 } 389 390 /* Global setup for all tests that share a bunch of preparation... */ 391 static int 392 test_setup(void) 393 { 394 int i, rc; 395 396 /* Prepare essential variables for test routines */ 397 g_bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct crypto_bdev_io)); 398 g_bdev_io->u.bdev.iovs = calloc(1, sizeof(struct iovec) * 128); 399 g_bdev_io->bdev = &g_crypto_bdev.crypto_bdev; 400 g_io_ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct crypto_io_channel)); 401 g_crypto_ch = (struct crypto_io_channel *)spdk_io_channel_get_ctx(g_io_ch); 402 g_io_ctx = (struct crypto_bdev_io *)g_bdev_io->driver_ctx; 403 memset(&g_device, 0, sizeof(struct vbdev_dev)); 404 memset(&g_crypto_bdev, 0, sizeof(struct vbdev_crypto)); 405 memset(&g_crypto_bdev_opts, 0, sizeof(struct vbdev_crypto_opts)); 406 g_dev_qp.device = &g_device; 407 g_io_ctx->crypto_ch = g_crypto_ch; 408 g_io_ctx->crypto_bdev = &g_crypto_bdev; 409 g_io_ctx->crypto_bdev->qp_desc_nr = CRYPTO_QP_DESCRIPTORS; 410 g_io_ctx->crypto_bdev->opts = &g_crypto_bdev_opts; 411 g_crypto_ch->device_qp = &g_dev_qp; 412 TAILQ_INIT(&g_crypto_ch->pending_cry_ios); 413 TAILQ_INIT(&g_crypto_ch->queued_cry_ops); 414 415 /* Allocate a real mbuf pool so we can test error paths */ 416 g_mbuf_mp = rte_pktmbuf_pool_create("mbuf_mp", NUM_MBUFS, 417 (unsigned)SPDK_MEMPOOL_DEFAULT_CACHE_SIZE, 418 0, 0, SPDK_ENV_SOCKET_ID_ANY); 419 /* Instead of allocating real rte mempools for these, it's easier and provides the 420 * same coverage just calloc them here. 421 */ 422 for (i = 0; i < MAX_TEST_BLOCKS; i++) { 423 size_t size = IV_OFFSET + IV_LENGTH + QUEUED_OP_LENGTH; 424 rc = posix_memalign((void **)&g_test_crypto_ops[i], 64, size); 425 if (rc != 0) { 426 assert(false); 427 } 428 memset(g_test_crypto_ops[i], 0, IV_OFFSET + QUEUED_OP_LENGTH); 429 } 430 g_mbuf_offset = DPDK_DYNFIELD_OFFSET; 431 432 return 0; 433 } 434 435 /* Global teardown for all tests */ 436 static int 437 test_cleanup(void) 438 { 439 int i; 440 441 if (g_crypto_op_mp) { 442 rte_mempool_free(g_crypto_op_mp); 443 g_crypto_op_mp = NULL; 444 } 445 if (g_mbuf_mp) { 446 rte_mempool_free(g_mbuf_mp); 447 g_mbuf_mp = NULL; 448 } 449 if (g_session_mp) { 450 rte_mempool_free(g_session_mp); 451 g_session_mp = NULL; 452 } 453 if (g_session_mp_priv != NULL) { 454 /* g_session_mp_priv may or may not be set depending on the DPDK version */ 455 rte_mempool_free(g_session_mp_priv); 456 g_session_mp_priv = NULL; 457 } 458 459 for (i = 0; i < MAX_TEST_BLOCKS; i++) { 460 free(g_test_crypto_ops[i]); 461 } 462 free(g_bdev_io->u.bdev.iovs); 463 free(g_bdev_io); 464 free(g_io_ch); 465 return 0; 466 } 467 468 static void 469 test_error_paths(void) 470 { 471 /* Single element block size write, just to test error paths 472 * in vbdev_crypto_submit_request(). 473 */ 474 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 475 g_bdev_io->u.bdev.iovcnt = 1; 476 g_bdev_io->u.bdev.num_blocks = 1; 477 g_bdev_io->u.bdev.iovs[0].iov_len = 512; 478 g_bdev_io->u.bdev.iovs[0].iov_base = (void *)0xDEADBEEF; 479 g_crypto_bdev.crypto_bdev.blocklen = 512; 480 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 481 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1; 482 483 /* test failure of spdk_mempool_get_bulk(), will result in success because it 484 * will get queued. 485 */ 486 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 487 MOCK_SET(spdk_mempool_get, NULL); 488 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 489 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 490 491 /* same thing but switch to reads to test error path in _crypto_complete_io() */ 492 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 493 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 494 TAILQ_INSERT_TAIL(&g_crypto_ch->pending_cry_ios, g_bdev_io, module_link); 495 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 496 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 497 /* Now with the read_blocks failing */ 498 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 499 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 500 MOCK_SET(spdk_bdev_readv_blocks, -1); 501 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 502 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 503 MOCK_SET(spdk_bdev_readv_blocks, 0); 504 MOCK_CLEAR(spdk_mempool_get); 505 506 /* test failure of rte_crypto_op_bulk_alloc() */ 507 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 508 ut_rte_crypto_op_bulk_alloc = 0; 509 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 510 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 511 ut_rte_crypto_op_bulk_alloc = 1; 512 513 /* test failure of rte_crypto_op_attach_sym_session() */ 514 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 515 ut_rte_crypto_op_attach_sym_session = -1; 516 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 517 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 518 ut_rte_crypto_op_attach_sym_session = 0; 519 } 520 521 static void 522 test_simple_write(void) 523 { 524 /* Single element block size write */ 525 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 526 g_bdev_io->u.bdev.iovcnt = 1; 527 g_bdev_io->u.bdev.num_blocks = 1; 528 g_bdev_io->u.bdev.offset_blocks = 0; 529 g_bdev_io->u.bdev.iovs[0].iov_len = 512; 530 g_bdev_io->u.bdev.iovs[0].iov_base = &test_simple_write; 531 g_crypto_bdev.crypto_bdev.blocklen = 512; 532 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 533 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1; 534 535 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 536 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 537 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == 1); 538 CU_ASSERT(g_io_ctx->aux_buf_iov.iov_len == 512); 539 CU_ASSERT(g_io_ctx->aux_buf_iov.iov_base != NULL); 540 CU_ASSERT(g_io_ctx->aux_offset_blocks == 0); 541 CU_ASSERT(g_io_ctx->aux_num_blocks == 1); 542 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == &test_simple_write); 543 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == 512); 544 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL); 545 CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512); 546 CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0); 547 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset, 548 uint64_t *) == (uint64_t)g_bdev_io); 549 CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->buf_addr != NULL); 550 CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->data_len == 512); 551 552 rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src); 553 rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_dst); 554 } 555 556 static void 557 test_simple_read(void) 558 { 559 /* Single element block size read */ 560 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 561 g_bdev_io->u.bdev.iovcnt = 1; 562 g_bdev_io->u.bdev.num_blocks = 1; 563 g_bdev_io->u.bdev.iovs[0].iov_len = 512; 564 g_bdev_io->u.bdev.iovs[0].iov_base = &test_simple_read; 565 g_crypto_bdev.crypto_bdev.blocklen = 512; 566 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 567 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1; 568 569 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 570 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 571 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == 1); 572 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == &test_simple_read); 573 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == 512); 574 CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL); 575 CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512); 576 CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0); 577 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset, 578 uint64_t *) == (uint64_t)g_bdev_io); 579 CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL); 580 581 rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src); 582 } 583 584 static void 585 test_large_rw(void) 586 { 587 unsigned block_len = 512; 588 unsigned num_blocks = CRYPTO_MAX_IO / block_len; 589 unsigned io_len = block_len * num_blocks; 590 unsigned i; 591 592 /* Multi block size read, multi-element */ 593 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 594 g_bdev_io->u.bdev.iovcnt = 1; 595 g_bdev_io->u.bdev.num_blocks = num_blocks; 596 g_bdev_io->u.bdev.iovs[0].iov_len = io_len; 597 g_bdev_io->u.bdev.iovs[0].iov_base = &test_large_rw; 598 g_crypto_bdev.crypto_bdev.blocklen = block_len; 599 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 600 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks; 601 602 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 603 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 604 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == (int)num_blocks); 605 606 for (i = 0; i < num_blocks; i++) { 607 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == &test_large_rw + (i * block_len)); 608 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len); 609 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL); 610 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len); 611 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0); 612 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset, 613 uint64_t *) == (uint64_t)g_bdev_io); 614 CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL); 615 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src); 616 } 617 618 /* Multi block size write, multi-element */ 619 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 620 g_bdev_io->u.bdev.iovcnt = 1; 621 g_bdev_io->u.bdev.num_blocks = num_blocks; 622 g_bdev_io->u.bdev.iovs[0].iov_len = io_len; 623 g_bdev_io->u.bdev.iovs[0].iov_base = &test_large_rw; 624 g_crypto_bdev.crypto_bdev.blocklen = block_len; 625 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 626 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks; 627 628 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 629 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 630 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == (int)num_blocks); 631 632 for (i = 0; i < num_blocks; i++) { 633 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == &test_large_rw + (i * block_len)); 634 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len); 635 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL); 636 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len); 637 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0); 638 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset, 639 uint64_t *) == (uint64_t)g_bdev_io); 640 CU_ASSERT(g_io_ctx->aux_buf_iov.iov_len == io_len); 641 CU_ASSERT(g_io_ctx->aux_buf_iov.iov_base != NULL); 642 CU_ASSERT(g_io_ctx->aux_offset_blocks == 0); 643 CU_ASSERT(g_io_ctx->aux_num_blocks == num_blocks); 644 CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->buf_addr != NULL); 645 CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->data_len == block_len); 646 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src); 647 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst); 648 } 649 } 650 651 static void 652 test_dev_full(void) 653 { 654 struct vbdev_crypto_op *queued_op; 655 struct rte_crypto_sym_op *sym_op; 656 struct crypto_bdev_io *io_ctx; 657 658 /* Two element block size read */ 659 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 660 g_bdev_io->u.bdev.iovcnt = 1; 661 g_bdev_io->u.bdev.num_blocks = 2; 662 g_bdev_io->u.bdev.iovs[0].iov_len = 512; 663 g_bdev_io->u.bdev.iovs[0].iov_base = (void *)0xDEADBEEF; 664 g_bdev_io->u.bdev.iovs[1].iov_len = 512; 665 g_bdev_io->u.bdev.iovs[1].iov_base = (void *)0xFEEDBEEF; 666 g_crypto_bdev.crypto_bdev.blocklen = 512; 667 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 668 g_enqueue_mock = g_dequeue_mock = 1; 669 ut_rte_crypto_op_bulk_alloc = 2; 670 671 g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 672 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == true); 673 674 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 675 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 676 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == 2); 677 sym_op = g_test_crypto_ops[0]->sym; 678 CU_ASSERT(sym_op->m_src->buf_addr == (void *)0xDEADBEEF); 679 CU_ASSERT(sym_op->m_src->data_len == 512); 680 CU_ASSERT(sym_op->m_src->next == NULL); 681 CU_ASSERT(sym_op->cipher.data.length == 512); 682 CU_ASSERT(sym_op->cipher.data.offset == 0); 683 CU_ASSERT(*RTE_MBUF_DYNFIELD(sym_op->m_src, g_mbuf_offset, uint64_t *) == (uint64_t)g_bdev_io); 684 CU_ASSERT(sym_op->m_dst == NULL); 685 686 /* make sure one got queued and confirm its values */ 687 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == false); 688 queued_op = TAILQ_FIRST(&g_crypto_ch->queued_cry_ops); 689 sym_op = queued_op->crypto_op->sym; 690 TAILQ_REMOVE(&g_crypto_ch->queued_cry_ops, queued_op, link); 691 CU_ASSERT(queued_op->bdev_io == g_bdev_io); 692 CU_ASSERT(queued_op->crypto_op == g_test_crypto_ops[1]); 693 CU_ASSERT(sym_op->m_src->buf_addr == (void *)0xFEEDBEEF); 694 CU_ASSERT(sym_op->m_src->data_len == 512); 695 CU_ASSERT(sym_op->m_src->next == NULL); 696 CU_ASSERT(sym_op->cipher.data.length == 512); 697 CU_ASSERT(sym_op->cipher.data.offset == 0); 698 CU_ASSERT(*RTE_MBUF_DYNFIELD(sym_op->m_src, g_mbuf_offset, uint64_t *) == (uint64_t)g_bdev_io); 699 CU_ASSERT(sym_op->m_dst == NULL); 700 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == true); 701 rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src); 702 rte_pktmbuf_free(g_test_crypto_ops[1]->sym->m_src); 703 704 /* Non-busy reason for enqueue failure, all were rejected. */ 705 g_enqueue_mock = 0; 706 g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_ERROR; 707 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 708 io_ctx = (struct crypto_bdev_io *)g_bdev_io->driver_ctx; 709 CU_ASSERT(io_ctx->bdev_io_status == SPDK_BDEV_IO_STATUS_FAILED); 710 } 711 712 static void 713 test_crazy_rw(void) 714 { 715 unsigned block_len = 512; 716 int num_blocks = 4; 717 int i; 718 719 /* Multi block size read, single element, strange IOV makeup */ 720 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 721 g_bdev_io->u.bdev.iovcnt = 3; 722 g_bdev_io->u.bdev.num_blocks = num_blocks; 723 g_bdev_io->u.bdev.iovs[0].iov_len = 512; 724 g_bdev_io->u.bdev.iovs[0].iov_base = &test_crazy_rw; 725 g_bdev_io->u.bdev.iovs[1].iov_len = 1024; 726 g_bdev_io->u.bdev.iovs[1].iov_base = &test_crazy_rw + 512; 727 g_bdev_io->u.bdev.iovs[2].iov_len = 512; 728 g_bdev_io->u.bdev.iovs[2].iov_base = &test_crazy_rw + 512 + 1024; 729 730 g_crypto_bdev.crypto_bdev.blocklen = block_len; 731 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 732 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks; 733 734 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 735 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 736 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == num_blocks); 737 738 for (i = 0; i < num_blocks; i++) { 739 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == &test_crazy_rw + (i * block_len)); 740 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len); 741 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL); 742 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len); 743 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0); 744 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset, 745 uint64_t *) == (uint64_t)g_bdev_io); 746 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src == g_test_crypto_ops[i]->sym->m_src); 747 CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL); 748 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src); 749 } 750 751 /* Multi block size write, single element strange IOV makeup */ 752 num_blocks = 8; 753 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 754 g_bdev_io->u.bdev.iovcnt = 4; 755 g_bdev_io->u.bdev.num_blocks = num_blocks; 756 g_bdev_io->u.bdev.iovs[0].iov_len = 2048; 757 g_bdev_io->u.bdev.iovs[0].iov_base = &test_crazy_rw; 758 g_bdev_io->u.bdev.iovs[1].iov_len = 512; 759 g_bdev_io->u.bdev.iovs[1].iov_base = &test_crazy_rw + 2048; 760 g_bdev_io->u.bdev.iovs[2].iov_len = 512; 761 g_bdev_io->u.bdev.iovs[2].iov_base = &test_crazy_rw + 2048 + 512; 762 g_bdev_io->u.bdev.iovs[3].iov_len = 1024; 763 g_bdev_io->u.bdev.iovs[3].iov_base = &test_crazy_rw + 2048 + 512 + 512; 764 765 g_crypto_bdev.crypto_bdev.blocklen = block_len; 766 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 767 g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks; 768 769 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 770 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 771 CU_ASSERT(g_io_ctx->cryop_cnt_remaining == num_blocks); 772 773 for (i = 0; i < num_blocks; i++) { 774 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == &test_crazy_rw + (i * block_len)); 775 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len); 776 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL); 777 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len); 778 CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0); 779 CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset, 780 uint64_t *) == (uint64_t)g_bdev_io); 781 CU_ASSERT(g_test_crypto_ops[i]->sym->m_src == g_test_crypto_ops[i]->sym->m_src); 782 CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == g_test_crypto_ops[i]->sym->m_dst); 783 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src); 784 rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst); 785 } 786 } 787 788 static void 789 test_passthru(void) 790 { 791 /* Make sure these follow our completion callback, test success & fail. */ 792 g_bdev_io->type = SPDK_BDEV_IO_TYPE_UNMAP; 793 MOCK_SET(spdk_bdev_unmap_blocks, 0); 794 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 795 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 796 MOCK_SET(spdk_bdev_unmap_blocks, -1); 797 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 798 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 799 MOCK_CLEAR(spdk_bdev_unmap_blocks); 800 801 g_bdev_io->type = SPDK_BDEV_IO_TYPE_FLUSH; 802 MOCK_SET(spdk_bdev_flush_blocks, 0); 803 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 804 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 805 MOCK_SET(spdk_bdev_flush_blocks, -1); 806 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 807 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 808 MOCK_CLEAR(spdk_bdev_flush_blocks); 809 810 /* We should never get a WZ command, we report that we don't support it. */ 811 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE_ZEROES; 812 vbdev_crypto_submit_request(g_io_ch, g_bdev_io); 813 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 814 } 815 816 static void 817 test_reset(void) 818 { 819 /* TODO: There are a few different ways to do this given that 820 * the code uses spdk_for_each_channel() to implement reset 821 * handling. Submitting w/o UT for this function for now and 822 * will follow up with something shortly. 823 */ 824 } 825 826 static void 827 init_cleanup(void) 828 { 829 if (g_crypto_op_mp) { 830 rte_mempool_free(g_crypto_op_mp); 831 g_crypto_op_mp = NULL; 832 } 833 if (g_mbuf_mp) { 834 rte_mempool_free(g_mbuf_mp); 835 g_mbuf_mp = NULL; 836 } 837 if (g_session_mp) { 838 rte_mempool_free(g_session_mp); 839 g_session_mp = NULL; 840 } 841 if (g_session_mp_priv != NULL) { 842 /* g_session_mp_priv may or may not be set depending on the DPDK version */ 843 rte_mempool_free(g_session_mp_priv); 844 g_session_mp_priv = NULL; 845 } 846 } 847 848 static void 849 test_initdrivers(void) 850 { 851 int rc; 852 static struct rte_mempool *orig_mbuf_mp; 853 static struct rte_mempool *orig_session_mp; 854 static struct rte_mempool *orig_session_mp_priv; 855 856 /* These tests will alloc and free our g_mbuf_mp 857 * so save that off here and restore it after each test is over. 858 */ 859 orig_mbuf_mp = g_mbuf_mp; 860 orig_session_mp = g_session_mp; 861 orig_session_mp_priv = g_session_mp_priv; 862 863 g_session_mp_priv = NULL; 864 g_session_mp = NULL; 865 g_mbuf_mp = NULL; 866 867 /* No drivers available, not an error though */ 868 MOCK_SET(rte_cryptodev_count, 0); 869 rc = vbdev_crypto_init_crypto_drivers(); 870 CU_ASSERT(rc == 0); 871 CU_ASSERT(g_mbuf_mp == NULL); 872 CU_ASSERT(g_session_mp == NULL); 873 CU_ASSERT(g_session_mp_priv == NULL); 874 875 /* Can't create session pool. */ 876 MOCK_SET(rte_cryptodev_count, 2); 877 MOCK_SET(spdk_mempool_create, NULL); 878 rc = vbdev_crypto_init_crypto_drivers(); 879 CU_ASSERT(rc == -ENOMEM); 880 CU_ASSERT(g_mbuf_mp == NULL); 881 CU_ASSERT(g_session_mp == NULL); 882 CU_ASSERT(g_session_mp_priv == NULL); 883 MOCK_CLEAR(spdk_mempool_create); 884 885 /* Can't create op pool. */ 886 MOCK_SET(rte_crypto_op_pool_create, NULL); 887 rc = vbdev_crypto_init_crypto_drivers(); 888 CU_ASSERT(rc == -ENOMEM); 889 CU_ASSERT(g_mbuf_mp == NULL); 890 CU_ASSERT(g_session_mp == NULL); 891 CU_ASSERT(g_session_mp_priv == NULL); 892 MOCK_CLEAR(rte_crypto_op_pool_create); 893 894 /* Check resources are not sufficient */ 895 MOCK_CLEARED_ASSERT(spdk_mempool_create); 896 rc = vbdev_crypto_init_crypto_drivers(); 897 CU_ASSERT(rc == -EINVAL); 898 899 /* Test crypto dev configure failure. */ 900 MOCK_SET(rte_cryptodev_device_count_by_driver, 2); 901 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_AESNI); 902 MOCK_SET(rte_cryptodev_configure, -1); 903 MOCK_CLEARED_ASSERT(spdk_mempool_create); 904 rc = vbdev_crypto_init_crypto_drivers(); 905 MOCK_SET(rte_cryptodev_configure, 0); 906 CU_ASSERT(g_mbuf_mp == NULL); 907 CU_ASSERT(g_session_mp == NULL); 908 CU_ASSERT(g_session_mp_priv == NULL); 909 CU_ASSERT(rc == -EINVAL); 910 911 /* Test failure of qp setup. */ 912 MOCK_SET(rte_cryptodev_queue_pair_setup, -1); 913 MOCK_CLEARED_ASSERT(spdk_mempool_create); 914 rc = vbdev_crypto_init_crypto_drivers(); 915 CU_ASSERT(rc == -EINVAL); 916 CU_ASSERT(g_mbuf_mp == NULL); 917 CU_ASSERT(g_session_mp == NULL); 918 CU_ASSERT(g_session_mp_priv == NULL); 919 MOCK_SET(rte_cryptodev_queue_pair_setup, 0); 920 921 /* Test failure of dev start. */ 922 MOCK_SET(rte_cryptodev_start, -1); 923 MOCK_CLEARED_ASSERT(spdk_mempool_create); 924 rc = vbdev_crypto_init_crypto_drivers(); 925 CU_ASSERT(rc == -EINVAL); 926 CU_ASSERT(g_mbuf_mp == NULL); 927 CU_ASSERT(g_session_mp == NULL); 928 CU_ASSERT(g_session_mp_priv == NULL); 929 MOCK_SET(rte_cryptodev_start, 0); 930 931 /* Test bogus PMD */ 932 MOCK_CLEARED_ASSERT(spdk_mempool_create); 933 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_BOGUS_PMD); 934 rc = vbdev_crypto_init_crypto_drivers(); 935 CU_ASSERT(g_mbuf_mp == NULL); 936 CU_ASSERT(g_session_mp == NULL); 937 CU_ASSERT(rc == -EINVAL); 938 939 /* Test happy path QAT. */ 940 MOCK_CLEARED_ASSERT(spdk_mempool_create); 941 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_QAT); 942 rc = vbdev_crypto_init_crypto_drivers(); 943 CU_ASSERT(g_mbuf_mp != NULL); 944 CU_ASSERT(g_session_mp != NULL); 945 init_cleanup(); 946 CU_ASSERT(rc == 0); 947 948 /* Test happy path AESNI. */ 949 MOCK_CLEARED_ASSERT(spdk_mempool_create); 950 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_AESNI); 951 rc = vbdev_crypto_init_crypto_drivers(); 952 CU_ASSERT(g_mbuf_offset == DPDK_DYNFIELD_OFFSET); 953 init_cleanup(); 954 CU_ASSERT(rc == 0); 955 956 /* Test happy path MLX5. */ 957 MOCK_CLEARED_ASSERT(spdk_mempool_create); 958 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_MLX5); 959 rc = vbdev_crypto_init_crypto_drivers(); 960 CU_ASSERT(g_mbuf_offset == DPDK_DYNFIELD_OFFSET); 961 init_cleanup(); 962 CU_ASSERT(rc == 0); 963 964 /* Test failure of DPDK dev init. By now it is not longer an error 965 * situation for entire crypto framework. */ 966 MOCK_SET(rte_cryptodev_count, 2); 967 MOCK_SET(rte_cryptodev_device_count_by_driver, 2); 968 MOCK_SET(rte_vdev_init, -1); 969 MOCK_CLEARED_ASSERT(spdk_mempool_create); 970 MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_QAT); 971 rc = vbdev_crypto_init_crypto_drivers(); 972 CU_ASSERT(rc == 0); 973 CU_ASSERT(g_mbuf_mp != NULL); 974 CU_ASSERT(g_session_mp != NULL); 975 #if RTE_VERSION < RTE_VERSION_NUM(22, 11, 0, 0) 976 CU_ASSERT(g_session_mp_priv != NULL); 977 #endif 978 init_cleanup(); 979 MOCK_SET(rte_vdev_init, 0); 980 MOCK_CLEAR(rte_cryptodev_device_count_by_driver); 981 982 /* restore our initial values. */ 983 g_mbuf_mp = orig_mbuf_mp; 984 g_session_mp = orig_session_mp; 985 g_session_mp_priv = orig_session_mp_priv; 986 } 987 988 static void 989 test_crypto_op_complete(void) 990 { 991 /* Make sure completion code respects failure. */ 992 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED; 993 g_completion_called = false; 994 _crypto_operation_complete(g_bdev_io); 995 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 996 CU_ASSERT(g_completion_called == true); 997 998 /* Test read completion. */ 999 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1000 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 1001 g_completion_called = false; 1002 _crypto_operation_complete(g_bdev_io); 1003 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1004 CU_ASSERT(g_completion_called == true); 1005 1006 /* Test write completion success. */ 1007 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1008 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 1009 g_completion_called = false; 1010 MOCK_SET(spdk_bdev_writev_blocks, 0); 1011 _crypto_operation_complete(g_bdev_io); 1012 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS); 1013 CU_ASSERT(g_completion_called == true); 1014 1015 /* Test write completion failed. */ 1016 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1017 g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE; 1018 g_completion_called = false; 1019 MOCK_SET(spdk_bdev_writev_blocks, -1); 1020 _crypto_operation_complete(g_bdev_io); 1021 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1022 CU_ASSERT(g_completion_called == true); 1023 1024 /* Test bogus type for this completion. */ 1025 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1026 g_bdev_io->type = SPDK_BDEV_IO_TYPE_RESET; 1027 g_completion_called = false; 1028 _crypto_operation_complete(g_bdev_io); 1029 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1030 CU_ASSERT(g_completion_called == true); 1031 } 1032 1033 static void 1034 test_supported_io(void) 1035 { 1036 void *ctx = NULL; 1037 bool rc = true; 1038 1039 /* Make sure we always report false to WZ, we need the bdev layer to 1040 * send real 0's so we can encrypt/decrypt them. 1041 */ 1042 rc = vbdev_crypto_io_type_supported(ctx, SPDK_BDEV_IO_TYPE_WRITE_ZEROES); 1043 CU_ASSERT(rc == false); 1044 } 1045 1046 static void 1047 test_poller(void) 1048 { 1049 int rc; 1050 struct rte_mbuf *src_mbufs[2]; 1051 struct vbdev_crypto_op *op_to_resubmit; 1052 1053 /* test regular 1 op to dequeue and complete */ 1054 g_dequeue_mock = g_enqueue_mock = 1; 1055 rte_pktmbuf_alloc_bulk(g_mbuf_mp, src_mbufs, 1); 1056 g_test_crypto_ops[0]->sym->m_src = src_mbufs[0]; 1057 *RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset, 1058 uint64_t *) = (uintptr_t)g_bdev_io; 1059 g_test_crypto_ops[0]->sym->m_dst = NULL; 1060 g_io_ctx->cryop_cnt_remaining = 1; 1061 g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ; 1062 rc = crypto_dev_poller(g_crypto_ch); 1063 CU_ASSERT(rc == 1); 1064 1065 /* We have nothing dequeued but have some to resubmit */ 1066 g_dequeue_mock = 0; 1067 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == true); 1068 1069 /* add an op to the queued list. */ 1070 g_resubmit_test = true; 1071 op_to_resubmit = (struct vbdev_crypto_op *)((uint8_t *)g_test_crypto_ops[0] + QUEUED_OP_OFFSET); 1072 op_to_resubmit->crypto_op = (void *)0xDEADBEEF; 1073 op_to_resubmit->bdev_io = g_bdev_io; 1074 TAILQ_INSERT_TAIL(&g_crypto_ch->queued_cry_ops, 1075 op_to_resubmit, 1076 link); 1077 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == false); 1078 rc = crypto_dev_poller(g_crypto_ch); 1079 g_resubmit_test = false; 1080 CU_ASSERT(rc == 0); 1081 CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_cry_ops) == true); 1082 1083 /* 2 to dequeue but 2nd one failed */ 1084 g_dequeue_mock = g_enqueue_mock = 2; 1085 g_io_ctx->cryop_cnt_remaining = 2; 1086 rte_pktmbuf_alloc_bulk(g_mbuf_mp, src_mbufs, 2); 1087 g_test_crypto_ops[0]->sym->m_src = src_mbufs[0]; 1088 *RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset, 1089 uint64_t *) = (uint64_t)g_bdev_io; 1090 g_test_crypto_ops[0]->sym->m_dst = NULL; 1091 g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_SUCCESS; 1092 g_test_crypto_ops[1]->sym->m_src = src_mbufs[1]; 1093 *RTE_MBUF_DYNFIELD(g_test_crypto_ops[1]->sym->m_src, g_mbuf_offset, 1094 uint64_t *) = (uint64_t)g_bdev_io; 1095 g_test_crypto_ops[1]->sym->m_dst = NULL; 1096 g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED; 1097 g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_SUCCESS; 1098 rc = crypto_dev_poller(g_crypto_ch); 1099 CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED); 1100 CU_ASSERT(rc == 2); 1101 } 1102 1103 /* Helper function for test_assign_device_qp() */ 1104 static void 1105 _clear_device_qp_lists(void) 1106 { 1107 struct device_qp *device_qp = NULL; 1108 1109 while (!TAILQ_EMPTY(&g_device_qp_qat)) { 1110 device_qp = TAILQ_FIRST(&g_device_qp_qat); 1111 TAILQ_REMOVE(&g_device_qp_qat, device_qp, link); 1112 free(device_qp); 1113 1114 } 1115 CU_ASSERT(TAILQ_EMPTY(&g_device_qp_qat) == true); 1116 while (!TAILQ_EMPTY(&g_device_qp_aesni_mb)) { 1117 device_qp = TAILQ_FIRST(&g_device_qp_aesni_mb); 1118 TAILQ_REMOVE(&g_device_qp_aesni_mb, device_qp, link); 1119 free(device_qp); 1120 } 1121 CU_ASSERT(TAILQ_EMPTY(&g_device_qp_aesni_mb) == true); 1122 while (!TAILQ_EMPTY(&g_device_qp_mlx5)) { 1123 device_qp = TAILQ_FIRST(&g_device_qp_mlx5); 1124 TAILQ_REMOVE(&g_device_qp_mlx5, device_qp, link); 1125 free(device_qp); 1126 } 1127 CU_ASSERT(TAILQ_EMPTY(&g_device_qp_mlx5) == true); 1128 } 1129 1130 /* Helper function for test_assign_device_qp() */ 1131 static void 1132 _check_expected_values(struct vbdev_crypto *crypto_bdev, struct device_qp *device_qp, 1133 struct crypto_io_channel *crypto_ch, uint8_t expected_index, 1134 uint8_t current_index) 1135 { 1136 _assign_device_qp(&g_crypto_bdev, device_qp, g_crypto_ch); 1137 CU_ASSERT(g_crypto_ch->device_qp->index == expected_index); 1138 CU_ASSERT(g_next_qat_index == current_index); 1139 } 1140 1141 static void 1142 test_assign_device_qp(void) 1143 { 1144 struct device_qp *device_qp = NULL; 1145 int i; 1146 1147 /* start with a known state, clear the device/qp lists */ 1148 _clear_device_qp_lists(); 1149 1150 /* make sure that one AESNI_MB qp is found */ 1151 device_qp = calloc(1, sizeof(struct device_qp)); 1152 TAILQ_INSERT_TAIL(&g_device_qp_aesni_mb, device_qp, link); 1153 g_crypto_ch->device_qp = NULL; 1154 g_crypto_bdev.opts->drv_name = AESNI_MB; 1155 _assign_device_qp(&g_crypto_bdev, device_qp, g_crypto_ch); 1156 CU_ASSERT(g_crypto_ch->device_qp != NULL); 1157 1158 /* QAT testing is more complex as the code under test load balances by 1159 * assigning each subsequent device/qp to every QAT_VF_SPREAD modulo 1160 * g_qat_total_qp. For the current latest QAT we'll have 48 virtual functions 1161 * each with 2 qp so the "spread" between assignments is 32. 1162 */ 1163 g_qat_total_qp = 96; 1164 for (i = 0; i < g_qat_total_qp; i++) { 1165 device_qp = calloc(1, sizeof(struct device_qp)); 1166 device_qp->index = i; 1167 TAILQ_INSERT_TAIL(&g_device_qp_qat, device_qp, link); 1168 } 1169 g_crypto_ch->device_qp = NULL; 1170 g_crypto_bdev.opts->drv_name = QAT; 1171 1172 /* First assignment will assign to 0 and next at 32. */ 1173 _check_expected_values(&g_crypto_bdev, device_qp, g_crypto_ch, 1174 0, QAT_VF_SPREAD); 1175 1176 /* Second assignment will assign to 32 and next at 64. */ 1177 _check_expected_values(&g_crypto_bdev, device_qp, g_crypto_ch, 1178 QAT_VF_SPREAD, QAT_VF_SPREAD * 2); 1179 1180 /* Third assignment will assign to 64 and next at 0. */ 1181 _check_expected_values(&g_crypto_bdev, device_qp, g_crypto_ch, 1182 QAT_VF_SPREAD * 2, 0); 1183 1184 /* Fourth assignment will assign to 1 and next at 33. */ 1185 _check_expected_values(&g_crypto_bdev, device_qp, g_crypto_ch, 1186 1, QAT_VF_SPREAD + 1); 1187 1188 /* make sure that one MLX5 qp is found */ 1189 device_qp = calloc(1, sizeof(struct device_qp)); 1190 TAILQ_INSERT_TAIL(&g_device_qp_mlx5, device_qp, link); 1191 g_crypto_ch->device_qp = NULL; 1192 g_crypto_bdev.opts->drv_name = MLX5; 1193 _assign_device_qp(&g_crypto_bdev, device_qp, g_crypto_ch); 1194 CU_ASSERT(g_crypto_ch->device_qp == device_qp); 1195 1196 _clear_device_qp_lists(); 1197 } 1198 1199 int 1200 main(int argc, char **argv) 1201 { 1202 CU_pSuite suite = NULL; 1203 unsigned int num_failures; 1204 1205 CU_set_error_action(CUEA_ABORT); 1206 CU_initialize_registry(); 1207 1208 suite = CU_add_suite("crypto", test_setup, test_cleanup); 1209 CU_ADD_TEST(suite, test_error_paths); 1210 CU_ADD_TEST(suite, test_simple_write); 1211 CU_ADD_TEST(suite, test_simple_read); 1212 CU_ADD_TEST(suite, test_large_rw); 1213 CU_ADD_TEST(suite, test_dev_full); 1214 CU_ADD_TEST(suite, test_crazy_rw); 1215 CU_ADD_TEST(suite, test_passthru); 1216 CU_ADD_TEST(suite, test_initdrivers); 1217 CU_ADD_TEST(suite, test_crypto_op_complete); 1218 CU_ADD_TEST(suite, test_supported_io); 1219 CU_ADD_TEST(suite, test_reset); 1220 CU_ADD_TEST(suite, test_poller); 1221 CU_ADD_TEST(suite, test_assign_device_qp); 1222 1223 CU_basic_set_mode(CU_BRM_VERBOSE); 1224 CU_basic_run_tests(); 1225 num_failures = CU_get_number_of_failures(); 1226 CU_cleanup_registry(); 1227 return num_failures; 1228 } 1229