Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2018 Intel Corporation.
3 : : * Copyright (c) 2022, 2023 NVIDIA CORPORATION & AFFILIATES.
4 : : * All rights reserved.
5 : : */
6 : :
7 : : #include "spdk_internal/cunit.h"
8 : :
9 : : #include "spdk_internal/mock.h"
10 : : #include "thread/thread_internal.h"
11 : : #include "unit/lib/json_mock.c"
12 : : #include "common/lib/ut_multithread.c"
13 : :
14 : : #include <rte_crypto.h>
15 : : #include <rte_cryptodev.h>
16 : : #include <rte_version.h>
17 : :
18 : : #define MAX_TEST_BLOCKS 8192
19 : : struct rte_crypto_op *g_test_crypto_ops[MAX_TEST_BLOCKS];
20 : : struct rte_crypto_op *g_test_dev_full_ops[MAX_TEST_BLOCKS];
21 : :
22 : : uint16_t g_dequeue_mock;
23 : : uint16_t g_enqueue_mock;
24 : : unsigned ut_rte_crypto_op_bulk_alloc;
25 : : int ut_rte_crypto_op_attach_sym_session = 0;
26 : : #define MOCK_INFO_GET_1QP_AESNI 0
27 : : #define MOCK_INFO_GET_1QP_QAT 1
28 : : #define MOCK_INFO_GET_1QP_MLX5 2
29 : : #define MOCK_INFO_GET_1QP_BOGUS_PMD 3
30 : : int ut_rte_cryptodev_info_get = 0;
31 : : bool ut_rte_cryptodev_info_get_mocked = false;
32 : :
33 : : void mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt);
34 : : #define rte_pktmbuf_free_bulk mock_rte_pktmbuf_free_bulk
35 : : void
36 : 20 : mock_rte_pktmbuf_free_bulk(struct rte_mbuf **m, unsigned int cnt)
37 : : {
38 : 20 : spdk_mempool_put_bulk((struct spdk_mempool *)m[0]->pool, (void **)m, cnt);
39 : 20 : }
40 : :
41 : : void mock_rte_pktmbuf_free(struct rte_mbuf *m);
42 : : #define rte_pktmbuf_free mock_rte_pktmbuf_free
43 : : void
44 : 3152 : mock_rte_pktmbuf_free(struct rte_mbuf *m)
45 : : {
46 : 3152 : spdk_mempool_put((struct spdk_mempool *)m->pool, (void *)m);
47 : 3152 : }
48 : :
49 : : void
50 : 60 : rte_mempool_free(struct rte_mempool *mp)
51 : : {
52 : 60 : spdk_mempool_free((struct spdk_mempool *)mp);
53 : 60 : }
54 : :
55 : : int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs,
56 : : unsigned count);
57 : : #define rte_pktmbuf_alloc_bulk mock_rte_pktmbuf_alloc_bulk
58 : : int
59 : 102 : mock_rte_pktmbuf_alloc_bulk(struct rte_mempool *pool, struct rte_mbuf **mbufs,
60 : : unsigned count)
61 : : {
62 : : int rc;
63 : :
64 : 102 : rc = spdk_mempool_get_bulk((struct spdk_mempool *)pool, (void **)mbufs, count);
65 [ + + ]: 102 : if (rc) {
66 : 2 : return rc;
67 : : }
68 [ + + ]: 3280 : for (unsigned i = 0; i < count; i++) {
69 : 3180 : rte_pktmbuf_reset(mbufs[i]);
70 : 3180 : mbufs[i]->pool = pool;
71 : : }
72 : 100 : return rc;
73 : : }
74 : :
75 : : struct rte_mempool *
76 : 22 : rte_cryptodev_sym_session_pool_create(const char *name, uint32_t nb_elts,
77 : : uint32_t elt_size, uint32_t cache_size,
78 : : uint16_t priv_size, int socket_id)
79 : : {
80 : : struct spdk_mempool *tmp;
81 : :
82 : 22 : tmp = spdk_mempool_create(name, nb_elts, elt_size + priv_size,
83 : : cache_size, socket_id);
84 : :
85 : 22 : return (struct rte_mempool *)tmp;
86 : :
87 : : }
88 : :
89 : : struct rte_mempool *
90 : 22 : rte_pktmbuf_pool_create(const char *name, unsigned n, unsigned cache_size,
91 : : uint16_t priv_size, uint16_t data_room_size, int socket_id)
92 : : {
93 : : struct spdk_mempool *tmp;
94 : :
95 : 22 : tmp = spdk_mempool_create(name, n, sizeof(struct rte_mbuf) + priv_size,
96 : : cache_size, socket_id);
97 : :
98 : 22 : return (struct rte_mempool *)tmp;
99 : : }
100 : :
101 : : struct rte_mempool *
102 : 0 : rte_mempool_create(const char *name, unsigned n, unsigned elt_size,
103 : : unsigned cache_size, unsigned private_data_size,
104 : : rte_mempool_ctor_t *mp_init, void *mp_init_arg,
105 : : rte_mempool_obj_cb_t *obj_init, void *obj_init_arg,
106 : : int socket_id, unsigned flags)
107 : : {
108 : : struct spdk_mempool *tmp;
109 : :
110 : 0 : tmp = spdk_mempool_create(name, n, elt_size + private_data_size,
111 : : cache_size, socket_id);
112 : :
113 : 0 : return (struct rte_mempool *)tmp;
114 : : }
115 : :
116 : : DEFINE_RETURN_MOCK(rte_crypto_op_pool_create, struct rte_mempool *);
117 : : struct rte_mempool *
118 : 20 : rte_crypto_op_pool_create(const char *name, enum rte_crypto_op_type type,
119 : : unsigned nb_elts, unsigned cache_size,
120 : : uint16_t priv_size, int socket_id)
121 : : {
122 : : struct spdk_mempool *tmp;
123 : :
124 [ - + + + ]: 20 : HANDLE_RETURN_MOCK(rte_crypto_op_pool_create);
125 : :
126 : 18 : tmp = spdk_mempool_create(name, nb_elts,
127 : : sizeof(struct rte_crypto_op) + priv_size,
128 : : cache_size, socket_id);
129 : :
130 : 18 : return (struct rte_mempool *)tmp;
131 : :
132 : : }
133 : :
134 : : /* Those functions are defined as static inline in DPDK, so we can't
135 : : * mock them straight away. We use defines to redirect them into
136 : : * our custom functions.
137 : : */
138 : : static bool g_resubmit_test = false;
139 : : #define rte_cryptodev_enqueue_burst mock_rte_cryptodev_enqueue_burst
140 : : static inline uint16_t
141 : 52 : mock_rte_cryptodev_enqueue_burst(uint8_t dev_id, uint16_t qp_id,
142 : : struct rte_crypto_op **ops, uint16_t nb_ops)
143 : : {
144 : : int i;
145 : :
146 : 52 : CU_ASSERT(nb_ops > 0);
147 : :
148 [ + + ]: 2166 : for (i = 0; i < nb_ops; i++) {
149 : : /* Use this empty (til now) array of pointers to store
150 : : * enqueued operations for assertion in dev_full test.
151 : : */
152 : 2114 : g_test_dev_full_ops[i] = *ops++;
153 [ - + - + ]: 2114 : if (g_resubmit_test == true) {
154 : 0 : CU_ASSERT(g_test_dev_full_ops[i] == (void *)0xDEADBEEF);
155 : : }
156 : : }
157 : :
158 : 52 : return g_enqueue_mock;
159 : : }
160 : :
161 : : #define rte_cryptodev_dequeue_burst mock_rte_cryptodev_dequeue_burst
162 : : static inline uint16_t
163 : 10 : mock_rte_cryptodev_dequeue_burst(uint8_t dev_id, uint16_t qp_id,
164 : : struct rte_crypto_op **ops, uint16_t nb_ops)
165 : : {
166 : : int i;
167 : :
168 : 10 : CU_ASSERT(nb_ops > 0);
169 : :
170 [ + + ]: 18 : for (i = 0; i < g_dequeue_mock; i++) {
171 : 8 : *ops++ = g_test_crypto_ops[i];
172 : : }
173 : :
174 : 10 : return g_dequeue_mock;
175 : : }
176 : :
177 : : /* Instead of allocating real memory, assign the allocations to our
178 : : * test array for assertion in tests.
179 : : */
180 : : #define rte_crypto_op_bulk_alloc mock_rte_crypto_op_bulk_alloc
181 : : static inline unsigned
182 : 54 : mock_rte_crypto_op_bulk_alloc(struct rte_mempool *mempool,
183 : : enum rte_crypto_op_type type,
184 : : struct rte_crypto_op **ops, uint16_t nb_ops)
185 : : {
186 : : int i;
187 : :
188 [ + + ]: 2170 : for (i = 0; i < nb_ops; i++) {
189 : 2116 : *ops++ = g_test_crypto_ops[i];
190 : : }
191 : 54 : return ut_rte_crypto_op_bulk_alloc;
192 : : }
193 : :
194 : : #define rte_mempool_put_bulk mock_rte_mempool_put_bulk
195 : : static __rte_always_inline void
196 : : mock_rte_mempool_put_bulk(struct rte_mempool *mp, void *const *obj_table,
197 : : unsigned int n)
198 : : {
199 : 20 : return;
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 : 2114 : 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 : 2114 : return ut_rte_crypto_op_attach_sym_session;
212 : : }
213 : :
214 : : #define rte_lcore_count mock_rte_lcore_count
215 : : static inline unsigned
216 : 24 : mock_rte_lcore_count(void)
217 : : {
218 : 24 : return 1;
219 : : }
220 : :
221 : : #include "accel/dpdk_cryptodev/accel_dpdk_cryptodev.c"
222 : :
223 : : /* accel stubs */
224 : 6 : DEFINE_STUB_V(spdk_accel_task_complete, (struct spdk_accel_task *task, int status));
225 : 0 : DEFINE_STUB_V(spdk_accel_module_finish, (void));
226 : 0 : DEFINE_STUB_V(spdk_accel_module_list_add, (struct spdk_accel_module_if *accel_module));
227 : :
228 : : /* DPDK stubs */
229 : : #define DPDK_DYNFIELD_OFFSET offsetof(struct rte_mbuf, dynfield1[1])
230 : 22 : DEFINE_STUB(rte_mbuf_dynfield_register, int, (const struct rte_mbuf_dynfield *params),
231 : : DPDK_DYNFIELD_OFFSET);
232 : 24 : DEFINE_STUB(rte_cryptodev_count, uint8_t, (void), 0);
233 : 20 : DEFINE_STUB(rte_socket_id, unsigned, (void), 0);
234 : 24 : DEFINE_STUB(rte_cryptodev_device_count_by_driver, uint8_t, (uint8_t driver_id), 0);
235 : 22 : DEFINE_STUB(rte_cryptodev_configure, int, (uint8_t dev_id, struct rte_cryptodev_config *config), 0);
236 : 20 : DEFINE_STUB(rte_cryptodev_queue_pair_setup, int, (uint8_t dev_id, uint16_t queue_pair_id,
237 : : const struct rte_cryptodev_qp_conf *qp_conf, int socket_id), 0);
238 : 18 : DEFINE_STUB(rte_cryptodev_start, int, (uint8_t dev_id), 0);
239 : 16 : DEFINE_STUB_V(rte_cryptodev_stop, (uint8_t dev_id));
240 : 20 : DEFINE_STUB(rte_cryptodev_close, int, (uint8_t dev_id), 0);
241 : 24 : DEFINE_STUB(rte_vdev_init, int, (const char *name, const char *args), 0);
242 : 0 : DEFINE_STUB(rte_vdev_uninit, int, (const char *name), 0);
243 : :
244 : : #if RTE_VERSION >= RTE_VERSION_NUM(22, 11, 0, 0)
245 : 0 : DEFINE_STUB(rte_cryptodev_sym_session_create, void *,
246 : : (uint8_t dev_id, struct rte_crypto_sym_xform *xforms, struct rte_mempool *mempool), (void *)1);
247 : 0 : DEFINE_STUB(rte_cryptodev_sym_session_free, int, (uint8_t dev_id, void *sess), 0);
248 : : #else
249 : : DEFINE_STUB(rte_cryptodev_sym_session_create, struct rte_cryptodev_sym_session *,
250 : : (struct rte_mempool *mempool), (void *)1);
251 : : DEFINE_STUB(rte_cryptodev_sym_session_init, int, (uint8_t dev_id,
252 : : struct rte_cryptodev_sym_session *sess,
253 : : struct rte_crypto_sym_xform *xforms, struct rte_mempool *mempool), 0);
254 : : DEFINE_STUB(rte_cryptodev_sym_session_free, int, (struct rte_cryptodev_sym_session *sess), 0);
255 : : #endif
256 : :
257 : : struct rte_cryptodev *rte_cryptodevs;
258 : :
259 : : /* global vars and setup/cleanup functions used for all test functions */
260 : : struct spdk_io_channel *g_io_ch;
261 : : struct accel_dpdk_cryptodev_io_channel *g_crypto_ch;
262 : : struct accel_dpdk_cryptodev_device g_aesni_crypto_dev;
263 : : struct accel_dpdk_cryptodev_qp g_aesni_qp;
264 : : struct accel_dpdk_cryptodev_key_handle g_key_handle;
265 : : struct accel_dpdk_cryptodev_key_priv g_key_priv;
266 : : struct spdk_accel_crypto_key g_key;
267 : :
268 : : void
269 : 26 : rte_cryptodev_info_get(uint8_t dev_id, struct rte_cryptodev_info *dev_info)
270 : : {
271 : 26 : dev_info->max_nb_queue_pairs = 1;
272 [ + + ]: 26 : if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_AESNI) {
273 : 12 : dev_info->driver_name = g_driver_names[0];
274 [ + + ]: 14 : } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_QAT) {
275 : 8 : dev_info->driver_name = g_driver_names[1];
276 [ + + ]: 6 : } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_MLX5) {
277 : 4 : dev_info->driver_name = g_driver_names[2];
278 [ + - ]: 2 : } else if (ut_rte_cryptodev_info_get == MOCK_INFO_GET_1QP_BOGUS_PMD) {
279 : 2 : dev_info->driver_name = "junk";
280 : : }
281 : 26 : }
282 : :
283 : : unsigned int
284 : 44 : rte_cryptodev_sym_get_private_session_size(uint8_t dev_id)
285 : : {
286 : 44 : return (unsigned int)dev_id;
287 : : }
288 : :
289 : : /* Global setup for all tests that share a bunch of preparation... */
290 : : static int
291 : 2 : test_setup(void)
292 : : {
293 : : int i, rc;
294 : :
295 : : /* Prepare essential variables for test routines */
296 : 2 : g_io_ch = calloc(1, sizeof(*g_io_ch) + sizeof(struct accel_dpdk_cryptodev_io_channel));
297 : 2 : g_crypto_ch = (struct accel_dpdk_cryptodev_io_channel *)spdk_io_channel_get_ctx(g_io_ch);
298 : 2 : TAILQ_INIT(&g_crypto_ch->queued_tasks);
299 : 2 : TAILQ_INIT(&g_crypto_ch->completed_tasks);
300 : :
301 : 2 : g_aesni_crypto_dev.type = ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB;
302 : 2 : g_aesni_crypto_dev.qp_desc_nr = ACCEL_DPDK_CRYPTODEV_QP_DESCRIPTORS;
303 : 2 : TAILQ_INIT(&g_aesni_crypto_dev.qpairs);
304 : :
305 : 2 : g_aesni_qp.device = &g_aesni_crypto_dev;
306 : 2 : g_crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB] = &g_aesni_qp;
307 : :
308 : 2 : g_key_handle.device = &g_aesni_crypto_dev;
309 : 2 : g_key_priv.driver = ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB;
310 : 2 : g_key_priv.cipher = SPDK_ACCEL_CIPHER_AES_CBC;
311 : 2 : TAILQ_INIT(&g_key_priv.dev_keys);
312 : 2 : TAILQ_INSERT_TAIL(&g_key_priv.dev_keys, &g_key_handle, link);
313 : 2 : g_key.priv = &g_key_priv;
314 : 2 : g_key.module_if = &g_accel_dpdk_cryptodev_module;
315 : :
316 : :
317 : : /* Allocate a real mbuf pool so we can test error paths */
318 : 2 : g_mbuf_mp = rte_pktmbuf_pool_create("mbuf_mp", ACCEL_DPDK_CRYPTODEV_NUM_MBUFS,
319 : : (unsigned)SPDK_MEMPOOL_DEFAULT_CACHE_SIZE,
320 : : 0, 0, SPDK_ENV_SOCKET_ID_ANY);
321 : : /* Instead of allocating real rte mempools for these, it's easier and provides the
322 : : * same coverage just calloc them here.
323 : : */
324 [ + + ]: 16386 : for (i = 0; i < MAX_TEST_BLOCKS; i++) {
325 : 16384 : size_t size = ACCEL_DPDK_CRYPTODEV_IV_OFFSET + ACCEL_DPDK_CRYPTODEV_IV_LENGTH;
326 [ - + ]: 16384 : rc = posix_memalign((void **)&g_test_crypto_ops[i], 64, size);
327 [ - + ]: 16384 : if (rc != 0) {
328 : 0 : assert(false);
329 : : }
330 [ - + ]: 16384 : memset(g_test_crypto_ops[i], 0, ACCEL_DPDK_CRYPTODEV_IV_OFFSET);
331 : : }
332 : 2 : g_mbuf_offset = DPDK_DYNFIELD_OFFSET;
333 : :
334 : 2 : return 0;
335 : : }
336 : :
337 : : /* Global teardown for all tests */
338 : : static int
339 : 2 : test_cleanup(void)
340 : : {
341 : : int i;
342 : :
343 [ - + ]: 2 : if (g_crypto_op_mp) {
344 : 0 : rte_mempool_free(g_crypto_op_mp);
345 : 0 : g_crypto_op_mp = NULL;
346 : : }
347 [ + - ]: 2 : if (g_mbuf_mp) {
348 : 2 : rte_mempool_free(g_mbuf_mp);
349 : 2 : g_mbuf_mp = NULL;
350 : : }
351 [ - + ]: 2 : if (g_session_mp) {
352 : 0 : rte_mempool_free(g_session_mp);
353 : 0 : g_session_mp = NULL;
354 : : }
355 [ - + ]: 2 : if (g_session_mp_priv != NULL) {
356 : : /* g_session_mp_priv may or may not be set depending on the DPDK version */
357 : 0 : rte_mempool_free(g_session_mp_priv);
358 : 0 : g_session_mp_priv = NULL;
359 : : }
360 : :
361 [ + + ]: 16386 : for (i = 0; i < MAX_TEST_BLOCKS; i++) {
362 : 16384 : free(g_test_crypto_ops[i]);
363 : : }
364 : 2 : free(g_io_ch);
365 : 2 : return 0;
366 : : }
367 : :
368 : : static void
369 : 2 : test_error_paths(void)
370 : : {
371 : : /* Single element block size encrypt, just to test error paths
372 : : * in accel_dpdk_cryptodev_submit_tasks() */
373 : 2 : struct iovec src_iov = {.iov_base = (void *)0xDEADBEEF, .iov_len = 512 };
374 : 2 : struct iovec dst_iov = src_iov;
375 : 2 : struct accel_dpdk_cryptodev_task task = {};
376 : 2 : struct accel_dpdk_cryptodev_key_priv key_priv = {};
377 : 2 : struct spdk_accel_crypto_key key = {};
378 : : int rc;
379 : :
380 : 2 : task.base.op_code = SPDK_ACCEL_OPC_ENCRYPT;
381 : 2 : task.base.s.iovcnt = 1;
382 : 2 : task.base.s.iovs = &src_iov;
383 : 2 : task.base.d.iovcnt = 1;
384 : 2 : task.base.d.iovs = &dst_iov;
385 : 2 : task.base.block_size = 512;
386 : 2 : task.base.crypto_key = &g_key;
387 : 2 : task.base.iv = 1;
388 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;
389 : :
390 : : /* case 1 - no crypto key */
391 : 2 : task.base.crypto_key = NULL;
392 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
393 : 2 : CU_ASSERT(rc == -EINVAL);
394 : 2 : task.base.crypto_key = &g_key;
395 : :
396 : : /* case 2 - crypto key with wrong module_if */
397 : 2 : key_priv.driver = ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB;
398 : 2 : key_priv.cipher = SPDK_ACCEL_CIPHER_AES_CBC;
399 : 2 : TAILQ_INIT(&key_priv.dev_keys);
400 : 2 : key.priv = &key_priv;
401 : 2 : key.module_if = (struct spdk_accel_module_if *) 0x1;
402 : 2 : task.base.crypto_key = &key;
403 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
404 : 2 : CU_ASSERT(rc == -EINVAL);
405 : 2 : key.module_if = &g_accel_dpdk_cryptodev_module;
406 : :
407 : : /* case 3 - no key handle in the channel */
408 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
409 : 2 : CU_ASSERT(rc == -EINVAL);
410 : 2 : task.base.crypto_key = &g_key;
411 : :
412 : : /* case 4 - invalid op */
413 : 2 : task.base.op_code = SPDK_ACCEL_OPC_COMPARE;
414 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
415 : 2 : CU_ASSERT(rc == -EINVAL);
416 : 2 : task.base.op_code = SPDK_ACCEL_OPC_ENCRYPT;
417 : :
418 : : /* case 5 - no entries in g_mbuf_mp */
419 : 2 : MOCK_SET(spdk_mempool_get, NULL);
420 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks) == true);
421 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
422 : 2 : CU_ASSERT(rc == 0);
423 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks) == false);
424 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->queued_tasks) == &task);
425 : 2 : MOCK_CLEAR(spdk_mempool_get);
426 : 2 : TAILQ_INIT(&g_crypto_ch->queued_tasks);
427 : :
428 : : /* case 6 - vtophys error in accel_dpdk_cryptodev_mbuf_attach_buf */
429 : 2 : MOCK_SET(spdk_vtophys, SPDK_VTOPHYS_ERROR);
430 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
431 : 2 : CU_ASSERT(rc == -EFAULT);
432 : 2 : MOCK_CLEAR(spdk_vtophys);
433 : 2 : }
434 : :
435 : : static void
436 : 2 : test_simple_encrypt(void)
437 : : {
438 : 2 : struct iovec src_iov[4] = {[0] = {.iov_base = (void *)0xDEADBEEF, .iov_len = 512 }};
439 : 2 : struct iovec dst_iov = src_iov[0];
440 : 2 : struct accel_dpdk_cryptodev_task task = {};
441 : : struct rte_mbuf *mbuf, *next;
442 : : int rc, i;
443 : :
444 : 2 : task.base.op_code = SPDK_ACCEL_OPC_ENCRYPT;
445 : 2 : task.base.s.iovcnt = 1;
446 : 2 : task.base.s.iovs = src_iov;
447 : 2 : task.base.d.iovcnt = 1;
448 : 2 : task.base.d.iovs = &dst_iov;
449 : 2 : task.base.block_size = 512;
450 : 2 : task.base.crypto_key = &g_key;
451 : 2 : task.base.iv = 1;
452 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;
453 : :
454 : : /* Inplace encryption */
455 : 2 : g_aesni_qp.num_enqueued_ops = 0;
456 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
457 : 2 : CU_ASSERT(rc == 0);
458 : 2 : CU_ASSERT(task.cryop_submitted == 1);
459 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov[0].iov_base);
460 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == src_iov[0].iov_len);
461 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
462 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
463 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
464 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
465 : : uint64_t *) == (uint64_t)&task);
466 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
467 : :
468 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
469 : :
470 : : /* out-of-place encryption */
471 : 2 : g_aesni_qp.num_enqueued_ops = 0;
472 : 2 : task.cryop_submitted = 0;
473 : 2 : dst_iov.iov_base = (void *)0xFEEDBEEF;
474 : :
475 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
476 : 2 : CU_ASSERT(rc == 0);
477 : 2 : CU_ASSERT(task.cryop_submitted == 1);
478 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov[0].iov_base);
479 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == src_iov[0].iov_len);
480 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
481 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
482 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
483 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
484 : : uint64_t *) == (uint64_t)&task);
485 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->buf_addr == dst_iov.iov_base);
486 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->data_len == dst_iov.iov_len);
487 : :
488 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
489 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_dst);
490 : :
491 : : /* out-of-place encryption, fragmented payload */
492 : 2 : g_aesni_qp.num_enqueued_ops = 0;
493 : 2 : task.base.s.iovcnt = 4;
494 [ + + ]: 10 : for (i = 0; i < 4; i++) {
495 : 8 : src_iov[i].iov_base = (void *)0xDEADBEEF + i * 128;
496 : 8 : src_iov[i].iov_len = 128;
497 : : }
498 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
499 : 2 : CU_ASSERT(rc == 0);
500 : 2 : CU_ASSERT(task.cryop_submitted == 1);
501 : 2 : mbuf = g_test_crypto_ops[0]->sym->m_src;
502 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
503 : 2 : CU_ASSERT(mbuf->buf_addr == src_iov[0].iov_base);
504 : 2 : CU_ASSERT(mbuf->data_len == src_iov[0].iov_len);
505 : 2 : mbuf = mbuf->next;
506 [ + + ]: 8 : for (i = 1; i < 4; i++) {
507 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
508 : 6 : CU_ASSERT(mbuf->buf_addr == src_iov[i].iov_base);
509 : 6 : CU_ASSERT(mbuf->data_len == src_iov[i].iov_len);
510 : 6 : next = mbuf->next;
511 : 6 : rte_pktmbuf_free(mbuf);
512 : 6 : mbuf = next;
513 : : }
514 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
515 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
516 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
517 : : uint64_t *) == (uint64_t)&task);
518 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->buf_addr == dst_iov.iov_base);
519 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->data_len == dst_iov.iov_len);
520 : :
521 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
522 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_dst);
523 : :
524 : : /* Big logical block size, inplace encryption */
525 : 2 : src_iov[0].iov_len = ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4;
526 : 2 : dst_iov = src_iov[0];
527 : 2 : task.base.block_size = ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4;
528 : 2 : task.base.s.iovcnt = 1;
529 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;
530 : :
531 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
532 : 2 : CU_ASSERT(rc == 0);
533 : 2 : CU_ASSERT(task.cryop_submitted == 1);
534 : 2 : mbuf = g_test_crypto_ops[0]->sym->m_src;
535 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
536 : 2 : CU_ASSERT(mbuf->buf_addr == src_iov[0].iov_base);
537 : 2 : CU_ASSERT(mbuf->data_len == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
538 : 2 : mbuf = mbuf->next;
539 [ + + ]: 8 : for (i = 1; i < 4; i++) {
540 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
541 : 6 : CU_ASSERT(mbuf->buf_addr == (char *)src_iov[0].iov_base + i * ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
542 : 6 : CU_ASSERT(mbuf->data_len == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
543 : 6 : next = mbuf->next;
544 : 6 : rte_pktmbuf_free(mbuf);
545 : 6 : mbuf = next;
546 : : }
547 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4);
548 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
549 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
550 : : uint64_t *) == (uint64_t)&task);
551 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
552 : :
553 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
554 : 2 : }
555 : :
556 : : static void
557 : 2 : test_simple_decrypt(void)
558 : : {
559 : 2 : struct iovec src_iov[4] = {[0] = {.iov_base = (void *)0xDEADBEEF, .iov_len = 512 }};
560 : 2 : struct iovec dst_iov = src_iov[0];
561 : 2 : struct accel_dpdk_cryptodev_task task = {};
562 : : struct rte_mbuf *mbuf, *next;
563 : : int rc, i;
564 : :
565 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
566 : 2 : task.base.s.iovcnt = 1;
567 : 2 : task.base.s.iovs = src_iov;
568 : 2 : task.base.d.iovcnt = 1;
569 : 2 : task.base.d.iovs = &dst_iov;
570 : 2 : task.base.block_size = 512;
571 : 2 : task.base.crypto_key = &g_key;
572 : 2 : task.base.iv = 1;
573 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;
574 : :
575 : : /* Inplace decryption */
576 : 2 : g_aesni_qp.num_enqueued_ops = 0;
577 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
578 : 2 : CU_ASSERT(rc == 0);
579 : 2 : CU_ASSERT(task.cryop_submitted == 1);
580 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov[0].iov_base);
581 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == src_iov[0].iov_len);
582 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
583 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
584 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
585 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
586 : : uint64_t *) == (uint64_t)&task);
587 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
588 : :
589 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
590 : :
591 : : /* out-of-place decryption */
592 : 2 : g_aesni_qp.num_enqueued_ops = 0;
593 : 2 : task.cryop_submitted = 0;
594 : 2 : dst_iov.iov_base = (void *)0xFEEDBEEF;
595 : :
596 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
597 : 2 : CU_ASSERT(rc == 0);
598 : 2 : CU_ASSERT(task.cryop_submitted == 1);
599 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov[0].iov_base);
600 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == src_iov[0].iov_len);
601 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
602 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
603 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
604 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
605 : : uint64_t *) == (uint64_t)&task);
606 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->buf_addr == dst_iov.iov_base);
607 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->data_len == dst_iov.iov_len);
608 : :
609 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
610 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_dst);
611 : :
612 : : /* out-of-place decryption, fragmented payload */
613 : 2 : g_aesni_qp.num_enqueued_ops = 0;
614 : 2 : task.base.s.iovcnt = 4;
615 [ + + ]: 10 : for (i = 0; i < 4; i++) {
616 : 8 : src_iov[i].iov_base = (void *)0xDEADBEEF + i * 128;
617 : 8 : src_iov[i].iov_len = 128;
618 : : }
619 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
620 : 2 : CU_ASSERT(rc == 0);
621 : 2 : CU_ASSERT(task.cryop_submitted == 1);
622 : 2 : mbuf = g_test_crypto_ops[0]->sym->m_src;
623 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
624 : 2 : CU_ASSERT(mbuf->buf_addr == src_iov[0].iov_base);
625 : 2 : CU_ASSERT(mbuf->data_len == src_iov[0].iov_len);
626 : 2 : mbuf = mbuf->next;
627 [ + + ]: 8 : for (i = 1; i < 4; i++) {
628 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
629 : 6 : CU_ASSERT(mbuf->buf_addr == src_iov[i].iov_base);
630 : 6 : CU_ASSERT(mbuf->data_len == src_iov[i].iov_len);
631 : 6 : next = mbuf->next;
632 : 6 : rte_pktmbuf_free(mbuf);
633 : 6 : mbuf = next;
634 : : }
635 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == 512);
636 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
637 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
638 : : uint64_t *) == (uint64_t)&task);
639 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->buf_addr == dst_iov.iov_base);
640 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst->data_len == dst_iov.iov_len);
641 : :
642 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
643 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_dst);
644 : :
645 : : /* Big logical block size, inplace encryption */
646 : 2 : src_iov[0].iov_len = ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4;
647 : 2 : dst_iov = src_iov[0];
648 : 2 : task.base.block_size = ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4;
649 : 2 : task.base.s.iovcnt = 1;
650 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = 1;
651 : :
652 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
653 : 2 : CU_ASSERT(rc == 0);
654 : 2 : CU_ASSERT(task.cryop_submitted == 1);
655 : 2 : mbuf = g_test_crypto_ops[0]->sym->m_src;
656 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
657 : 2 : CU_ASSERT(mbuf->buf_addr == src_iov[0].iov_base);
658 : 2 : CU_ASSERT(mbuf->data_len == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
659 : 2 : mbuf = mbuf->next;
660 [ + + ]: 8 : for (i = 1; i < 4; i++) {
661 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(mbuf != NULL);
662 : 6 : CU_ASSERT(mbuf->buf_addr == (char *)src_iov[0].iov_base + i * ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
663 : 6 : CU_ASSERT(mbuf->data_len == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN);
664 : 6 : next = mbuf->next;
665 : 6 : rte_pktmbuf_free(mbuf);
666 : 6 : mbuf = next;
667 : : }
668 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == ACCEL_DPDK_CRYPTODEV_MAX_MBUF_LEN * 4);
669 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
670 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
671 : : uint64_t *) == (uint64_t)&task);
672 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
673 : :
674 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
675 : 2 : }
676 : :
677 : : static void
678 : 2 : test_large_enc_dec(void)
679 : : {
680 : 2 : struct accel_dpdk_cryptodev_task task = {};
681 : 2 : uint32_t block_len = 512;
682 : 2 : uint32_t num_blocks = ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE * 2;
683 : 2 : uint32_t iov_len = num_blocks * block_len / 16;
684 : 2 : uint32_t blocks_in_iov = num_blocks / 16;
685 : : uint32_t iov_idx;
686 : 1 : struct iovec src_iov[16];
687 : 1 : struct iovec dst_iov[16];
688 : : uint32_t i;
689 : : int rc;
690 : :
691 [ + + ]: 34 : for (i = 0; i < 16; i++) {
692 : 32 : src_iov[i].iov_base = (void *)0xDEADBEEF + i * iov_len;
693 : 32 : src_iov[i].iov_len = iov_len;
694 : :
695 : 32 : dst_iov[i].iov_base = (void *)0xDEADBEEF + i * iov_len;
696 : 32 : dst_iov[i].iov_len = iov_len;
697 : : }
698 : :
699 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
700 : 2 : task.base.s.iovcnt = 16;
701 : 2 : task.base.s.iovs = src_iov;
702 : 2 : task.base.d.iovcnt = 16;
703 : 2 : task.base.d.iovs = dst_iov;
704 : 2 : task.base.block_size = 512;
705 : 2 : task.base.crypto_key = &g_key;
706 : 2 : task.base.iv = 1;
707 : :
708 : : /* Test 1. Multi block size decryption, multi-element, inplace */
709 : 2 : g_aesni_qp.num_enqueued_ops = 0;
710 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc =
711 : : ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE;
712 : :
713 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
714 : 2 : CU_ASSERT(rc == 0);
715 [ - + ]: 2 : CU_ASSERT(task.inplace == true);
716 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE);
717 : 2 : CU_ASSERT(task.cryop_total == num_blocks);
718 : 2 : CU_ASSERT(task.cryop_completed == 0);
719 : :
720 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
721 [ - + ]: 256 : iov_idx = i / blocks_in_iov;
722 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
723 : : i % blocks_in_iov) * block_len));
724 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
725 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
726 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
727 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
728 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
729 : : uint64_t *) == (uint64_t)&task);
730 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
731 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
732 : : }
733 : :
734 : : /* Call accel_dpdk_cryptodev_process_task like it was called by completion poller */
735 : 2 : g_aesni_qp.num_enqueued_ops = 0;
736 : 2 : task.cryop_completed = task.cryop_submitted;
737 : 2 : rc = accel_dpdk_cryptodev_process_task(g_crypto_ch, &task);
738 : :
739 : 2 : CU_ASSERT(rc == 0);
740 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE * 2);
741 : 2 : CU_ASSERT(task.cryop_total == task.cryop_submitted);
742 : :
743 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
744 [ - + ]: 256 : iov_idx = i / blocks_in_iov + 8;
745 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
746 : : i % blocks_in_iov) * block_len));
747 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
748 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
749 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
750 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
751 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
752 : : uint64_t *) == (uint64_t)&task);
753 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
754 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
755 : : }
756 : :
757 : : /* Test 2. Multi block size decryption, multi-element, out-of-place */
758 : 2 : g_aesni_qp.num_enqueued_ops = 0;
759 : : /* Modify dst to make payload out-of-place */
760 : 2 : dst_iov[0].iov_base -= 1;
761 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc =
762 : : ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE;
763 : :
764 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
765 : 2 : CU_ASSERT(rc == 0);
766 [ - + ]: 2 : CU_ASSERT(task.inplace == false);
767 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE);
768 : 2 : CU_ASSERT(task.cryop_total == num_blocks);
769 : 2 : CU_ASSERT(task.cryop_completed == 0);
770 : :
771 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
772 [ - + ]: 256 : iov_idx = i / blocks_in_iov;
773 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
774 : : i % blocks_in_iov) * block_len));
775 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
776 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
777 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
778 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
779 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
780 : : uint64_t *) == (uint64_t)&task);
781 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->buf_addr == dst_iov[iov_idx].iov_base + ((
782 : : i % blocks_in_iov) * block_len));
783 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->data_len == block_len);
784 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->next == NULL);
785 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
786 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst);
787 : : }
788 : :
789 : : /* Call accel_dpdk_cryptodev_process_task like it was called by completion poller */
790 : 2 : g_aesni_qp.num_enqueued_ops = 0;
791 : 2 : task.cryop_completed = task.cryop_submitted;
792 : 2 : rc = accel_dpdk_cryptodev_process_task(g_crypto_ch, &task);
793 : :
794 : 2 : CU_ASSERT(rc == 0);
795 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE * 2);
796 : 2 : CU_ASSERT(task.cryop_total == task.cryop_submitted);
797 : :
798 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
799 [ - + ]: 256 : iov_idx = i / blocks_in_iov + 8;
800 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
801 : : i % blocks_in_iov) * block_len));
802 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
803 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
804 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
805 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
806 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
807 : : uint64_t *) == (uint64_t)&task);
808 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->buf_addr == dst_iov[iov_idx].iov_base + ((
809 : : i % blocks_in_iov) * block_len));
810 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->data_len == block_len);
811 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->next == NULL);
812 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
813 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst);
814 : : }
815 : :
816 : : /* Test 3. Multi block size encryption, multi-element, inplace */
817 : 2 : g_aesni_qp.num_enqueued_ops = 0;
818 : 2 : task.base.op_code = SPDK_ACCEL_OPC_ENCRYPT;
819 : 2 : task.cryop_submitted = 0;
820 : : /* Modify dst to make payload iplace */
821 : 2 : dst_iov[0].iov_base += 1;
822 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc =
823 : : ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE;
824 : :
825 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
826 : 2 : CU_ASSERT(rc == 0);
827 [ - + ]: 2 : CU_ASSERT(task.inplace == true);
828 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE);
829 : 2 : CU_ASSERT(task.cryop_total == num_blocks);
830 : 2 : CU_ASSERT(task.cryop_completed == 0);
831 : :
832 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
833 [ - + ]: 256 : iov_idx = i / blocks_in_iov;
834 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
835 : : i % blocks_in_iov) * block_len));
836 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
837 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
838 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
839 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
840 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
841 : : uint64_t *) == (uint64_t)&task);
842 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
843 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
844 : : }
845 : :
846 : : /* Call accel_dpdk_cryptodev_process_task like it was called by completion poller */
847 : 2 : g_aesni_qp.num_enqueued_ops = 0;
848 : 2 : task.cryop_completed = task.cryop_submitted;
849 : 2 : rc = accel_dpdk_cryptodev_process_task(g_crypto_ch, &task);
850 : :
851 : 2 : CU_ASSERT(rc == 0);
852 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE * 2);
853 : 2 : CU_ASSERT(task.cryop_total == task.cryop_submitted);
854 : :
855 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
856 [ - + ]: 256 : iov_idx = i / blocks_in_iov + 8;
857 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
858 : : i % blocks_in_iov) * block_len));
859 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
860 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
861 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
862 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
863 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
864 : : uint64_t *) == (uint64_t)&task);
865 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
866 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
867 : : }
868 : :
869 : : /* Multi block size encryption, multi-element, out-of-place */
870 : 2 : g_aesni_qp.num_enqueued_ops = 0;
871 : 2 : task.cryop_submitted = 0;
872 : : /* Modify dst to make payload out-of-place */
873 : 2 : dst_iov[0].iov_base -= 1;
874 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc =
875 : : ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE;
876 : :
877 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
878 [ - + ]: 2 : CU_ASSERT(task.inplace == false);
879 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE);
880 : 2 : CU_ASSERT(task.cryop_total == num_blocks);
881 : 2 : CU_ASSERT(task.cryop_completed == 0);
882 : :
883 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
884 [ - + ]: 256 : iov_idx = i / blocks_in_iov;
885 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
886 : : i % blocks_in_iov) * block_len));
887 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
888 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
889 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
890 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
891 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
892 : : uint64_t *) == (uint64_t)&task);
893 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->buf_addr == dst_iov[iov_idx].iov_base + ((
894 : : i % blocks_in_iov) * block_len));
895 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->data_len == block_len);
896 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->next == NULL);
897 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
898 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst);
899 : : }
900 : :
901 : : /* Call accel_dpdk_cryptodev_process_task like it was called by completion poller */
902 : 2 : g_aesni_qp.num_enqueued_ops = 0;
903 : 2 : task.cryop_completed = task.cryop_submitted;
904 : 2 : rc = accel_dpdk_cryptodev_process_task(g_crypto_ch, &task);
905 : :
906 : 2 : CU_ASSERT(rc == 0);
907 : 2 : CU_ASSERT(task.cryop_submitted == ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE * 2);
908 : 2 : CU_ASSERT(task.cryop_total == task.cryop_submitted);
909 : :
910 [ + + ]: 258 : for (i = 0; i < ACCEL_DPDK_CRYPTODEV_MAX_ENQUEUE_ARRAY_SIZE; i++) {
911 [ - + ]: 256 : iov_idx = i / blocks_in_iov + 8;
912 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[iov_idx].iov_base + ((
913 : : i % blocks_in_iov) * block_len));
914 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
915 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
916 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
917 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
918 : 256 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
919 : : uint64_t *) == (uint64_t)&task);
920 [ - + ]: 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->buf_addr == dst_iov[iov_idx].iov_base + ((
921 : : i % blocks_in_iov) * block_len));
922 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->data_len == block_len);
923 : 256 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst->next == NULL);
924 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
925 : 256 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_dst);
926 : : }
927 : 2 : }
928 : :
929 : : static void
930 : 2 : test_dev_full(void)
931 : : {
932 : 2 : struct accel_dpdk_cryptodev_task task = {};
933 : : struct rte_crypto_sym_op *sym_op;
934 : 2 : struct iovec src_iov = {.iov_base = (void *)0xDEADBEEF, .iov_len = 1024 };
935 : 2 : struct iovec dst_iov = src_iov;
936 : : int rc;
937 : :
938 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
939 : 2 : task.base.s.iovcnt = 1;
940 : 2 : task.base.s.iovs = &src_iov;
941 : 2 : task.base.d.iovcnt = 1;
942 : 2 : task.base.d.iovs = &dst_iov;
943 : 2 : task.base.block_size = 512;
944 : 2 : task.base.crypto_key = &g_key;
945 : 2 : task.base.iv = 1;
946 : :
947 : : /* Two element block size decryption, 2nd op was not submitted */
948 : 2 : g_aesni_qp.num_enqueued_ops = 0;
949 : 2 : g_enqueue_mock = g_dequeue_mock = 1;
950 : 2 : ut_rte_crypto_op_bulk_alloc = 2;
951 : 2 : g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
952 : :
953 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
954 : 2 : CU_ASSERT(rc == 0);
955 : 2 : CU_ASSERT(task.cryop_submitted == 1);
956 : 2 : CU_ASSERT(task.cryop_total == 2);
957 : 2 : sym_op = g_test_crypto_ops[0]->sym;
958 : 2 : CU_ASSERT(sym_op->m_src->buf_addr == src_iov.iov_base);
959 : 2 : CU_ASSERT(sym_op->m_src->data_len == 512);
960 : 2 : CU_ASSERT(sym_op->m_src->next == NULL);
961 : 2 : CU_ASSERT(sym_op->cipher.data.length == 512);
962 : 2 : CU_ASSERT(sym_op->cipher.data.offset == 0);
963 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(sym_op->m_src, g_mbuf_offset, uint64_t *) == (uint64_t)&task);
964 : 2 : CU_ASSERT(sym_op->m_dst == NULL);
965 : : /* op which was not submitted is already released */
966 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
967 : 2 : task.cryop_submitted = 0;
968 : :
969 : : /* Two element block size decryption, no ops were submitted, task should be queued */
970 : 2 : g_aesni_qp.num_enqueued_ops = 0;
971 : 2 : g_enqueue_mock = g_dequeue_mock = 0;
972 : 2 : ut_rte_crypto_op_bulk_alloc = 2;
973 : 2 : g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
974 : 2 : g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
975 : :
976 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks) == true);
977 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
978 : 2 : CU_ASSERT(rc == 0);
979 : 2 : CU_ASSERT(task.cryop_submitted == 0);
980 : 2 : CU_ASSERT(!TAILQ_EMPTY(&g_crypto_ch->queued_tasks));
981 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->queued_tasks) == &task);
982 : 2 : TAILQ_INIT(&g_crypto_ch->queued_tasks);
983 : :
984 : : /* Non-busy reason for enqueue failure, all were rejected. */
985 : 2 : g_enqueue_mock = 0;
986 : 2 : g_aesni_qp.num_enqueued_ops = 0;
987 : 2 : g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_ERROR;
988 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
989 : 2 : CU_ASSERT(rc == -EINVAL);
990 : :
991 : : /* QP is full, task should be queued */
992 : 2 : g_aesni_qp.num_enqueued_ops = g_aesni_crypto_dev.qp_desc_nr;
993 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks) == true);
994 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
995 : 2 : CU_ASSERT(rc == 0);
996 : 2 : CU_ASSERT(!TAILQ_EMPTY(&g_crypto_ch->queued_tasks));
997 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->queued_tasks) == &task);
998 : 2 : g_aesni_qp.num_enqueued_ops = 0;
999 : :
1000 : 2 : TAILQ_INIT(&g_crypto_ch->queued_tasks);
1001 : :
1002 : : /* Two element block size decryption, 2nd op was not submitted, but has RTE_CRYPTO_OP_STATUS_SUCCESS status */
1003 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1004 : 2 : g_enqueue_mock = g_dequeue_mock = 1;
1005 : 2 : ut_rte_crypto_op_bulk_alloc = 2;
1006 : 2 : g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
1007 : :
1008 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
1009 : 2 : CU_ASSERT(rc == 0);
1010 : 2 : CU_ASSERT(task.cryop_total == 2);
1011 : 2 : CU_ASSERT(task.cryop_submitted == 2);
1012 : 2 : CU_ASSERT(task.cryop_completed == 1);
1013 : 2 : sym_op = g_test_crypto_ops[0]->sym;
1014 : 2 : CU_ASSERT(sym_op->m_src->buf_addr == src_iov.iov_base);
1015 : 2 : CU_ASSERT(sym_op->m_src->data_len == 512);
1016 : 2 : CU_ASSERT(sym_op->m_src->next == NULL);
1017 : 2 : CU_ASSERT(sym_op->cipher.data.length == 512);
1018 : 2 : CU_ASSERT(sym_op->cipher.data.offset == 0);
1019 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(sym_op->m_src, g_mbuf_offset, uint64_t *) == (uint64_t)&task);
1020 : 2 : CU_ASSERT(sym_op->m_dst == NULL);
1021 : : /* op which was not submitted is already released */
1022 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
1023 : :
1024 : : /* Two element block size decryption, 1st op was not submitted, but has RTE_CRYPTO_OP_STATUS_SUCCESS status */
1025 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1026 : 2 : g_enqueue_mock = g_dequeue_mock = 0;
1027 : 2 : ut_rte_crypto_op_bulk_alloc = 2;
1028 : 2 : g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
1029 : :
1030 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
1031 : 2 : CU_ASSERT(rc == 0);
1032 : 2 : CU_ASSERT(task.cryop_total == 2);
1033 : 2 : CU_ASSERT(task.cryop_submitted == 1);
1034 : 2 : CU_ASSERT(task.cryop_completed == 1);
1035 : 2 : CU_ASSERT(!TAILQ_EMPTY(&g_crypto_ch->queued_tasks));
1036 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->queued_tasks) == &task);
1037 : 2 : TAILQ_INIT(&g_crypto_ch->queued_tasks);
1038 : :
1039 : : /* Single element block size decryption, 1st op was not submitted, but has RTE_CRYPTO_OP_STATUS_SUCCESS status.
1040 : : * Task should be queued in the completed_tasks list */
1041 : 2 : src_iov.iov_len = 512;
1042 : 2 : dst_iov.iov_len = 512;
1043 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1044 : 2 : g_enqueue_mock = g_dequeue_mock = 0;
1045 : 2 : ut_rte_crypto_op_bulk_alloc = 1;
1046 : 2 : g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
1047 : :
1048 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
1049 : 2 : CU_ASSERT(rc == 0);
1050 : 2 : CU_ASSERT(task.cryop_total == 1);
1051 : 2 : CU_ASSERT(task.cryop_submitted == 1);
1052 : 2 : CU_ASSERT(task.cryop_completed == 1);
1053 : 2 : CU_ASSERT(!TAILQ_EMPTY(&g_crypto_ch->completed_tasks));
1054 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->completed_tasks) == &task);
1055 : 2 : TAILQ_INIT(&g_crypto_ch->completed_tasks);
1056 : 2 : }
1057 : :
1058 : : static void
1059 : 2 : test_crazy_rw(void)
1060 : : {
1061 : 2 : struct accel_dpdk_cryptodev_task task = {};
1062 : 2 : struct iovec src_iov[4] = {
1063 : : [0] = {.iov_base = (void *)0xDEADBEEF, .iov_len = 512 },
1064 : : [1] = {.iov_base = (void *)0xDEADBEEF + 512, .iov_len = 1024 },
1065 : : [2] = {.iov_base = (void *)0xDEADBEEF + 512 + 1024, .iov_len = 512 }
1066 : : };
1067 : 2 : struct iovec *dst_iov = src_iov;
1068 : 2 : uint32_t block_len = 512, num_blocks = 4, i;
1069 : : int rc;
1070 : :
1071 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
1072 : 2 : task.base.s.iovcnt = 3;
1073 : 2 : task.base.s.iovs = src_iov;
1074 : 2 : task.base.d.iovcnt = 3;
1075 : 2 : task.base.d.iovs = dst_iov;
1076 : 2 : task.base.block_size = 512;
1077 : 2 : task.base.crypto_key = &g_key;
1078 : 2 : task.base.iv = 1;
1079 : :
1080 : : /* Multi block size read, single element, strange IOV makeup */
1081 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks;
1082 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1083 : :
1084 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
1085 : 2 : CU_ASSERT(rc == 0);
1086 : 2 : CU_ASSERT(task.cryop_submitted == num_blocks);
1087 : :
1088 [ + + ]: 10 : for (i = 0; i < num_blocks; i++) {
1089 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
1090 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
1091 : 8 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
1092 : : uint64_t *) == (uint64_t)&task);
1093 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
1094 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[0].iov_base + (i * block_len));
1095 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
1096 : 8 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
1097 : 8 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
1098 : : }
1099 : :
1100 : : /* Multi block size write, single element strange IOV makeup */
1101 : 2 : num_blocks = 8;
1102 : 2 : task.base.op_code = SPDK_ACCEL_OPC_ENCRYPT;
1103 : 2 : task.cryop_submitted = 0;
1104 : 2 : task.base.s.iovcnt = 4;
1105 : 2 : task.base.d.iovcnt = 4;
1106 : 2 : task.base.s.iovs[0].iov_len = 2048;
1107 : 2 : task.base.s.iovs[0].iov_base = (void *)0xDEADBEEF;
1108 : 2 : task.base.s.iovs[1].iov_len = 512;
1109 : 2 : task.base.s.iovs[1].iov_base = (void *)0xDEADBEEF + 2048;
1110 : 2 : task.base.s.iovs[2].iov_len = 512;
1111 : 2 : task.base.s.iovs[2].iov_base = (void *)0xDEADBEEF + 2048 + 512;
1112 : 2 : task.base.s.iovs[3].iov_len = 1024;
1113 : 2 : task.base.s.iovs[3].iov_base = (void *)0xDEADBEEF + 2048 + 512 + 512;
1114 : :
1115 : 2 : g_enqueue_mock = g_dequeue_mock = ut_rte_crypto_op_bulk_alloc = num_blocks;
1116 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1117 : :
1118 : 2 : rc = accel_dpdk_cryptodev_submit_tasks(g_io_ch, &task.base);
1119 : 2 : CU_ASSERT(rc == 0);
1120 : 2 : CU_ASSERT(task.cryop_submitted == num_blocks);
1121 : :
1122 [ + + ]: 18 : for (i = 0; i < num_blocks; i++) {
1123 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.length == block_len);
1124 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->cipher.data.offset == 0);
1125 : 16 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[i]->sym->m_src, g_mbuf_offset,
1126 : : uint64_t *) == (uint64_t)&task);
1127 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->next == NULL);
1128 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->buf_addr == src_iov[0].iov_base + (i * block_len));
1129 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_src->data_len == block_len);
1130 : 16 : CU_ASSERT(g_test_crypto_ops[i]->sym->m_dst == NULL);
1131 : 16 : rte_pktmbuf_free(g_test_crypto_ops[i]->sym->m_src);
1132 : : }
1133 : 2 : }
1134 : :
1135 : : static void
1136 : 8 : init_cleanup(void)
1137 : : {
1138 : : struct accel_dpdk_cryptodev_device *dev, *tmp;
1139 : :
1140 [ + - ]: 8 : if (g_crypto_op_mp) {
1141 : 8 : rte_mempool_free(g_crypto_op_mp);
1142 : 8 : g_crypto_op_mp = NULL;
1143 : : }
1144 [ + - ]: 8 : if (g_mbuf_mp) {
1145 : 8 : rte_mempool_free(g_mbuf_mp);
1146 : 8 : g_mbuf_mp = NULL;
1147 : : }
1148 [ + - ]: 8 : if (g_session_mp) {
1149 : 8 : rte_mempool_free(g_session_mp);
1150 : 8 : g_session_mp = NULL;
1151 : : }
1152 [ - + ]: 8 : if (g_session_mp_priv != NULL) {
1153 : : /* g_session_mp_priv may or may not be set depending on the DPDK version */
1154 : 0 : rte_mempool_free(g_session_mp_priv);
1155 : 0 : g_session_mp_priv = NULL;
1156 : : }
1157 : :
1158 [ + + ]: 24 : TAILQ_FOREACH_SAFE(dev, &g_crypto_devices, link, tmp) {
1159 [ + + ]: 16 : TAILQ_REMOVE(&g_crypto_devices, dev, link);
1160 : 16 : accel_dpdk_cryptodev_release(dev);
1161 : : }
1162 : :
1163 : 8 : spdk_io_device_unregister(&g_accel_dpdk_cryptodev_module, NULL);
1164 : 8 : }
1165 : :
1166 : : static void
1167 : 2 : test_initdrivers(void)
1168 : : {
1169 : : int rc;
1170 : : static struct rte_mempool *orig_mbuf_mp;
1171 : : static struct rte_mempool *orig_session_mp;
1172 : : static struct rte_mempool *orig_session_mp_priv;
1173 : :
1174 : : /* accel_dpdk_cryptodev_init calls spdk_io_device_register, we need to have a thread */
1175 : 2 : allocate_threads(1);
1176 : 2 : set_thread(0);
1177 : :
1178 : : /* These tests will alloc and free our g_mbuf_mp
1179 : : * so save that off here and restore it after each test is over.
1180 : : */
1181 : 2 : orig_mbuf_mp = g_mbuf_mp;
1182 : 2 : orig_session_mp = g_session_mp;
1183 : 2 : orig_session_mp_priv = g_session_mp_priv;
1184 : :
1185 : 2 : g_session_mp_priv = NULL;
1186 : 2 : g_session_mp = NULL;
1187 : 2 : g_mbuf_mp = NULL;
1188 : :
1189 : : /* No drivers available, not an error though */
1190 : 2 : MOCK_SET(rte_cryptodev_count, 0);
1191 : 2 : rc = accel_dpdk_cryptodev_init();
1192 : 2 : CU_ASSERT(rc == 0);
1193 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1194 : 2 : CU_ASSERT(g_session_mp == NULL);
1195 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1196 : :
1197 : : /* Can't create session pool. */
1198 : 2 : MOCK_SET(rte_cryptodev_count, 2);
1199 : 2 : MOCK_SET(spdk_mempool_create, NULL);
1200 : 2 : rc = accel_dpdk_cryptodev_init();
1201 : 2 : CU_ASSERT(rc == -ENOMEM);
1202 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1203 : 2 : CU_ASSERT(g_session_mp == NULL);
1204 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1205 : 2 : MOCK_CLEAR(spdk_mempool_create);
1206 : :
1207 : : /* Can't create op pool. */
1208 : 2 : MOCK_SET(rte_crypto_op_pool_create, NULL);
1209 : 2 : rc = accel_dpdk_cryptodev_init();
1210 : 2 : CU_ASSERT(rc == -ENOMEM);
1211 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1212 : 2 : CU_ASSERT(g_session_mp == NULL);
1213 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1214 : 2 : MOCK_CLEAR(rte_crypto_op_pool_create);
1215 : :
1216 : : /* Check resources are not sufficient */
1217 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1218 : 2 : rc = accel_dpdk_cryptodev_init();
1219 : 2 : CU_ASSERT(rc == -EINVAL);
1220 : :
1221 : : /* Test crypto dev configure failure. */
1222 : 2 : MOCK_SET(rte_cryptodev_device_count_by_driver, 2);
1223 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_AESNI);
1224 : 2 : MOCK_SET(rte_cryptodev_configure, -1);
1225 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1226 : 2 : rc = accel_dpdk_cryptodev_init();
1227 : 2 : MOCK_SET(rte_cryptodev_configure, 0);
1228 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1229 : 2 : CU_ASSERT(g_session_mp == NULL);
1230 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1231 : 2 : CU_ASSERT(rc == -EINVAL);
1232 : :
1233 : : /* Test failure of qp setup. */
1234 : 2 : MOCK_SET(rte_cryptodev_queue_pair_setup, -1);
1235 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1236 : 2 : rc = accel_dpdk_cryptodev_init();
1237 : 2 : CU_ASSERT(rc == -EINVAL);
1238 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1239 : 2 : CU_ASSERT(g_session_mp == NULL);
1240 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1241 : 2 : MOCK_SET(rte_cryptodev_queue_pair_setup, 0);
1242 : :
1243 : : /* Test failure of dev start. */
1244 : 2 : MOCK_SET(rte_cryptodev_start, -1);
1245 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1246 : 2 : rc = accel_dpdk_cryptodev_init();
1247 : 2 : CU_ASSERT(rc == -EINVAL);
1248 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1249 : 2 : CU_ASSERT(g_session_mp == NULL);
1250 : 2 : CU_ASSERT(g_session_mp_priv == NULL);
1251 : 2 : MOCK_SET(rte_cryptodev_start, 0);
1252 : :
1253 : : /* Test bogus PMD */
1254 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1255 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_BOGUS_PMD);
1256 : 2 : rc = accel_dpdk_cryptodev_init();
1257 : 2 : CU_ASSERT(g_mbuf_mp == NULL);
1258 : 2 : CU_ASSERT(g_session_mp == NULL);
1259 : 2 : CU_ASSERT(rc == -EINVAL);
1260 : :
1261 : : /* Test happy path QAT. */
1262 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1263 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_QAT);
1264 : 2 : rc = accel_dpdk_cryptodev_init();
1265 : 2 : CU_ASSERT(g_mbuf_mp != NULL);
1266 : 2 : CU_ASSERT(g_session_mp != NULL);
1267 : 2 : init_cleanup();
1268 : 2 : CU_ASSERT(rc == 0);
1269 : :
1270 : : /* Test happy path AESNI. */
1271 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1272 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_AESNI);
1273 : 2 : rc = accel_dpdk_cryptodev_init();
1274 : 2 : CU_ASSERT(g_mbuf_offset == DPDK_DYNFIELD_OFFSET);
1275 : 2 : init_cleanup();
1276 : 2 : CU_ASSERT(rc == 0);
1277 : :
1278 : : /* Test happy path MLX5. */
1279 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1280 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_MLX5);
1281 : 2 : rc = accel_dpdk_cryptodev_init();
1282 : 2 : CU_ASSERT(g_mbuf_offset == DPDK_DYNFIELD_OFFSET);
1283 : 2 : init_cleanup();
1284 : 2 : CU_ASSERT(rc == 0);
1285 : :
1286 : : /* Test failure of DPDK dev init. By now it is not longer an error
1287 : : * situation for entire crypto framework. */
1288 : 2 : MOCK_SET(rte_cryptodev_count, 2);
1289 : 2 : MOCK_SET(rte_cryptodev_device_count_by_driver, 2);
1290 : 2 : MOCK_SET(rte_vdev_init, -1);
1291 [ - + - + ]: 2 : MOCK_CLEARED_ASSERT(spdk_mempool_create);
1292 : 2 : MOCK_SET(rte_cryptodev_info_get, MOCK_INFO_GET_1QP_QAT);
1293 : 2 : rc = accel_dpdk_cryptodev_init();
1294 : 2 : CU_ASSERT(rc == 0);
1295 : 2 : CU_ASSERT(g_mbuf_mp != NULL);
1296 : 2 : CU_ASSERT(g_session_mp != NULL);
1297 : : #if RTE_VERSION < RTE_VERSION_NUM(22, 11, 0, 0)
1298 : : CU_ASSERT(g_session_mp_priv != NULL);
1299 : : #endif
1300 : 2 : init_cleanup();
1301 : 2 : MOCK_SET(rte_vdev_init, 0);
1302 : 2 : MOCK_CLEAR(rte_cryptodev_device_count_by_driver);
1303 : :
1304 : : /* restore our initial values. */
1305 : 2 : g_mbuf_mp = orig_mbuf_mp;
1306 : 2 : g_session_mp = orig_session_mp;
1307 : 2 : g_session_mp_priv = orig_session_mp_priv;
1308 : 2 : free_threads();
1309 : 2 : }
1310 : :
1311 : : static void
1312 : 2 : test_supported_opcodes(void)
1313 : : {
1314 : 2 : bool rc = true;
1315 : : enum spdk_accel_opcode opc;
1316 : :
1317 [ + + ]: 30 : for (opc = 0; opc < SPDK_ACCEL_OPC_LAST; opc++) {
1318 : 28 : rc = accel_dpdk_cryptodev_supports_opcode(opc);
1319 [ + + ]: 28 : switch (opc) {
1320 : 4 : case SPDK_ACCEL_OPC_ENCRYPT:
1321 : : case SPDK_ACCEL_OPC_DECRYPT:
1322 : 4 : CU_ASSERT(rc == true);
1323 : 4 : break;
1324 : 24 : default:
1325 : 24 : CU_ASSERT(rc == false);
1326 : : }
1327 : : }
1328 : 2 : }
1329 : :
1330 : : static void
1331 : 2 : test_poller(void)
1332 : : {
1333 : 2 : struct accel_dpdk_cryptodev_task task = {};
1334 : 2 : struct iovec src_iov = {.iov_base = (void *)0xDEADBEEF, .iov_len = 1024 };
1335 : 2 : struct iovec dst_iov = src_iov;
1336 : 1 : struct rte_mbuf *src_mbufs[2];
1337 : : int rc;
1338 : :
1339 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
1340 : 2 : task.base.s.iovcnt = 1;
1341 : 2 : task.base.s.iovs = &src_iov;
1342 : 2 : task.base.d.iovcnt = 1;
1343 : 2 : task.base.d.iovs = &dst_iov;
1344 : 2 : task.base.block_size = 512;
1345 : 2 : task.base.crypto_key = &g_key;
1346 : 2 : task.base.iv = 1;
1347 : 2 : task.inplace = true;
1348 : :
1349 : : /* test regular 1 op to dequeue and complete */
1350 : 2 : g_dequeue_mock = g_enqueue_mock = 1;
1351 : 2 : g_aesni_qp.num_enqueued_ops = 1;
1352 : 2 : rte_pktmbuf_alloc_bulk(g_mbuf_mp, src_mbufs, 1);
1353 : 2 : g_test_crypto_ops[0]->sym->m_src = src_mbufs[0];
1354 : 2 : *RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
1355 : 2 : uint64_t *) = (uintptr_t)&task;
1356 : 2 : g_test_crypto_ops[0]->sym->m_dst = NULL;
1357 : 2 : task.cryop_submitted = 1;
1358 : 2 : task.cryop_total = 1;
1359 : 2 : task.cryop_completed = 0;
1360 : 2 : task.base.op_code = SPDK_ACCEL_OPC_DECRYPT;
1361 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1362 : 2 : CU_ASSERT(rc == 1);
1363 : 2 : CU_ASSERT(task.cryop_completed == task.cryop_submitted);
1364 : 2 : CU_ASSERT(g_aesni_qp.num_enqueued_ops == 0);
1365 : :
1366 : : /* 2 to dequeue but 2nd one failed */
1367 : 2 : g_dequeue_mock = g_enqueue_mock = 2;
1368 : 2 : g_aesni_qp.num_enqueued_ops = 2;
1369 : 2 : task.cryop_submitted = 2;
1370 : 2 : task.cryop_total = 2;
1371 : 2 : task.cryop_completed = 0;
1372 : 2 : rte_pktmbuf_alloc_bulk(g_mbuf_mp, src_mbufs, 2);
1373 : 2 : g_test_crypto_ops[0]->sym->m_src = src_mbufs[0];
1374 : 2 : *RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
1375 : 2 : uint64_t *) = (uint64_t)&task;
1376 : 2 : g_test_crypto_ops[0]->sym->m_dst = NULL;
1377 : 2 : g_test_crypto_ops[0]->status = RTE_CRYPTO_OP_STATUS_SUCCESS;
1378 : 2 : g_test_crypto_ops[1]->sym->m_src = src_mbufs[1];
1379 : 2 : *RTE_MBUF_DYNFIELD(g_test_crypto_ops[1]->sym->m_src, g_mbuf_offset,
1380 : 2 : uint64_t *) = (uint64_t)&task;
1381 : 2 : g_test_crypto_ops[1]->sym->m_dst = NULL;
1382 : 2 : g_test_crypto_ops[1]->status = RTE_CRYPTO_OP_STATUS_NOT_PROCESSED;
1383 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1384 [ - + ]: 2 : CU_ASSERT(task.is_failed == true);
1385 : 2 : CU_ASSERT(rc == 1);
1386 : 2 : CU_ASSERT(g_aesni_qp.num_enqueued_ops == 0);
1387 : :
1388 : : /* Dequeue a task which needs to be submitted again */
1389 : 2 : g_dequeue_mock = g_enqueue_mock = ut_rte_crypto_op_bulk_alloc = 1;
1390 : 2 : task.cryop_submitted = 1;
1391 : 2 : task.cryop_total = 2;
1392 : 2 : task.cryop_completed = 0;
1393 : 2 : g_aesni_qp.num_enqueued_ops = 1;
1394 : 2 : rte_pktmbuf_alloc_bulk(g_mbuf_mp, src_mbufs, 1);
1395 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(src_mbufs[0] != NULL);
1396 : 2 : g_test_crypto_ops[0]->sym->m_src = src_mbufs[0];
1397 : 2 : *RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
1398 : 2 : uint64_t *) = (uintptr_t)&task;
1399 : 2 : g_test_crypto_ops[0]->sym->m_dst = NULL;
1400 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1401 : 2 : CU_ASSERT(rc == 1);
1402 : 2 : CU_ASSERT(task.cryop_submitted == 2);
1403 : 2 : CU_ASSERT(task.cryop_total == 2);
1404 : 2 : CU_ASSERT(task.cryop_completed == 1);
1405 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov.iov_base + task.base.block_size);
1406 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == task.base.block_size);
1407 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
1408 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == task.base.block_size);
1409 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
1410 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
1411 : : uint64_t *) == (uint64_t)&task);
1412 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
1413 : 2 : CU_ASSERT(g_aesni_qp.num_enqueued_ops == 1);
1414 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
1415 : :
1416 : : /* Process queued tasks, qp is full */
1417 : 2 : g_dequeue_mock = g_enqueue_mock = 0;
1418 : 2 : g_aesni_qp.num_enqueued_ops = g_aesni_crypto_dev.qp_desc_nr;
1419 : 2 : task.cryop_submitted = 1;
1420 : 2 : task.cryop_total = 2;
1421 : 2 : task.cryop_completed = 1;
1422 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks));
1423 : 2 : TAILQ_INSERT_TAIL(&g_crypto_ch->queued_tasks, &task, link);
1424 : :
1425 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1426 : 2 : CU_ASSERT(rc == 0);
1427 : 2 : CU_ASSERT(TAILQ_FIRST(&g_crypto_ch->queued_tasks) == &task);
1428 : :
1429 : : /* Try again when queue is empty, task should be submitted */
1430 : 2 : g_enqueue_mock = 1;
1431 : 2 : g_aesni_qp.num_enqueued_ops = 0;
1432 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1433 : 2 : CU_ASSERT(rc == 1);
1434 : 2 : CU_ASSERT(task.cryop_submitted == 2);
1435 : 2 : CU_ASSERT(task.cryop_total == 2);
1436 : 2 : CU_ASSERT(task.cryop_completed == 1);
1437 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->buf_addr == src_iov.iov_base + task.base.block_size);
1438 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->data_len == task.base.block_size);
1439 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_src->next == NULL);
1440 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.length == task.base.block_size);
1441 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->cipher.data.offset == 0);
1442 : 2 : CU_ASSERT(*RTE_MBUF_DYNFIELD(g_test_crypto_ops[0]->sym->m_src, g_mbuf_offset,
1443 : : uint64_t *) == (uint64_t)&task);
1444 : 2 : CU_ASSERT(g_test_crypto_ops[0]->sym->m_dst == NULL);
1445 : 2 : CU_ASSERT(g_aesni_qp.num_enqueued_ops == 1);
1446 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->queued_tasks));
1447 : 2 : rte_pktmbuf_free(g_test_crypto_ops[0]->sym->m_src);
1448 : :
1449 : : /* Complete tasks in the dedicated list */
1450 : 2 : g_dequeue_mock = g_enqueue_mock = 0;
1451 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->completed_tasks));
1452 : 2 : TAILQ_INSERT_TAIL(&g_crypto_ch->completed_tasks, &task, link);
1453 : 2 : rc = accel_dpdk_cryptodev_poller(g_crypto_ch);
1454 : 2 : CU_ASSERT(rc == 1);
1455 : 2 : CU_ASSERT(TAILQ_EMPTY(&g_crypto_ch->completed_tasks));
1456 : 2 : }
1457 : :
1458 : : /* Helper function for accel_dpdk_cryptodev_assign_device_qps() */
1459 : : static void
1460 : 8 : _check_expected_values(struct accel_dpdk_cryptodev_io_channel *crypto_ch,
1461 : : uint8_t expected_qat_index,
1462 : : uint8_t next_qat_index)
1463 : : {
1464 : : uint32_t num_qpairs;
1465 : :
1466 [ - + ]: 8 : memset(crypto_ch->device_qp, 0, sizeof(crypto_ch->device_qp));
1467 : :
1468 : 8 : num_qpairs = accel_dpdk_cryptodev_assign_device_qps(crypto_ch);
1469 : 8 : CU_ASSERT(num_qpairs == 3);
1470 : :
1471 [ - + ]: 8 : SPDK_CU_ASSERT_FATAL(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_QAT] != NULL);
1472 : 8 : CU_ASSERT(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_QAT]->index == expected_qat_index);
1473 [ - + ]: 8 : CU_ASSERT(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_QAT]->in_use == true);
1474 : 8 : CU_ASSERT(g_next_qat_index == next_qat_index);
1475 [ - + ]: 8 : SPDK_CU_ASSERT_FATAL(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB] != NULL);
1476 [ - + ]: 8 : CU_ASSERT(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB]->in_use == true);
1477 [ - + ]: 8 : SPDK_CU_ASSERT_FATAL(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_MLX5_PCI] != NULL);
1478 [ - + ]: 8 : CU_ASSERT(crypto_ch->device_qp[ACCEL_DPDK_CRYPTODEV_DRIVER_MLX5_PCI]->in_use == true);
1479 : 8 : }
1480 : :
1481 : : static void
1482 : 2 : test_assign_device_qp(void)
1483 : : {
1484 : 2 : struct accel_dpdk_cryptodev_device qat_dev = {
1485 : : .type = ACCEL_DPDK_CRYPTODEV_DRIVER_QAT,
1486 : : .qpairs = TAILQ_HEAD_INITIALIZER(qat_dev.qpairs)
1487 : : };
1488 : 2 : struct accel_dpdk_cryptodev_device aesni_dev = {
1489 : : .type = ACCEL_DPDK_CRYPTODEV_DRIVER_AESNI_MB,
1490 : : .qpairs = TAILQ_HEAD_INITIALIZER(aesni_dev.qpairs)
1491 : : };
1492 : 2 : struct accel_dpdk_cryptodev_device mlx5_dev = {
1493 : : .type = ACCEL_DPDK_CRYPTODEV_DRIVER_MLX5_PCI,
1494 : : .qpairs = TAILQ_HEAD_INITIALIZER(mlx5_dev.qpairs)
1495 : : };
1496 : : struct accel_dpdk_cryptodev_qp *qat_qps;
1497 : 2 : struct accel_dpdk_cryptodev_qp aesni_qps[4] = {};
1498 : 2 : struct accel_dpdk_cryptodev_qp mlx5_qps[4] = {};
1499 : 2 : struct accel_dpdk_cryptodev_io_channel io_ch = {};
1500 : 2 : TAILQ_HEAD(, accel_dpdk_cryptodev_device) devs_tmp = TAILQ_HEAD_INITIALIZER(devs_tmp);
1501 : : int i;
1502 : :
1503 : 2 : g_qat_total_qp = 96;
1504 : 2 : qat_qps = calloc(g_qat_total_qp, sizeof(*qat_qps));
1505 [ - + ]: 2 : SPDK_CU_ASSERT_FATAL(qat_qps != NULL);
1506 : :
1507 [ + + ]: 10 : for (i = 0; i < 4; i++) {
1508 : 8 : aesni_qps[i].index = i;
1509 : 8 : aesni_qps[i].device = &aesni_dev;
1510 : 8 : TAILQ_INSERT_TAIL(&aesni_dev.qpairs, &aesni_qps[i], link);
1511 : :
1512 : 8 : mlx5_qps[i].index = i;
1513 : 8 : mlx5_qps[i].device = &mlx5_dev;
1514 : 8 : TAILQ_INSERT_TAIL(&mlx5_dev.qpairs, &mlx5_qps[i], link);
1515 : : }
1516 [ + + ]: 194 : for (i = 0; i < g_qat_total_qp; i++) {
1517 : 192 : qat_qps[i].index = i;
1518 : 192 : qat_qps[i].device = &qat_dev;
1519 : 192 : TAILQ_INSERT_TAIL(&qat_dev.qpairs, &qat_qps[i], link);
1520 : : }
1521 : :
1522 : : /* Swap g_crypto_devices so that other tests are not affected */
1523 [ - + - + ]: 2 : TAILQ_SWAP(&g_crypto_devices, &devs_tmp, accel_dpdk_cryptodev_device, link);
1524 : :
1525 : 2 : TAILQ_INSERT_TAIL(&g_crypto_devices, &qat_dev, link);
1526 : 2 : TAILQ_INSERT_TAIL(&g_crypto_devices, &aesni_dev, link);
1527 : 2 : TAILQ_INSERT_TAIL(&g_crypto_devices, &mlx5_dev, link);
1528 : :
1529 : : /* QAT testing is more complex as the code under test load balances by
1530 : : * assigning each subsequent device/qp to every QAT_VF_SPREAD modulo
1531 : : * g_qat_total_qp. For the current latest QAT we'll have 48 virtual functions
1532 : : * each with 2 qp so the "spread" between assignments is 32. */
1533 : :
1534 : : /* First assignment will assign to 0 and next at 32. */
1535 : 2 : _check_expected_values(&io_ch, 0, ACCEL_DPDK_CRYPTODEV_QAT_VF_SPREAD);
1536 : :
1537 : : /* Second assignment will assign to 32 and next at 64. */
1538 : 2 : _check_expected_values(&io_ch, ACCEL_DPDK_CRYPTODEV_QAT_VF_SPREAD,
1539 : : ACCEL_DPDK_CRYPTODEV_QAT_VF_SPREAD * 2);
1540 : :
1541 : : /* Third assignment will assign to 64 and next at 0. */
1542 : 2 : _check_expected_values(&io_ch, ACCEL_DPDK_CRYPTODEV_QAT_VF_SPREAD * 2, 0);
1543 : :
1544 : : /* Fourth assignment will assign to 1 and next at 33. */
1545 : 2 : _check_expected_values(&io_ch, 1, ACCEL_DPDK_CRYPTODEV_QAT_VF_SPREAD + 1);
1546 : :
1547 [ + - - + ]: 2 : TAILQ_SWAP(&devs_tmp, &g_crypto_devices, accel_dpdk_cryptodev_device, link);
1548 : :
1549 : 2 : free(qat_qps);
1550 : 2 : }
1551 : :
1552 : : int
1553 : 2 : main(int argc, char **argv)
1554 : : {
1555 : 2 : CU_pSuite suite = NULL;
1556 : : unsigned int num_failures;
1557 : :
1558 : 2 : CU_initialize_registry();
1559 : :
1560 : 2 : suite = CU_add_suite("dpdk_cryptodev", test_setup, test_cleanup);
1561 : 2 : CU_ADD_TEST(suite, test_error_paths);
1562 : 2 : CU_ADD_TEST(suite, test_simple_encrypt);
1563 : 2 : CU_ADD_TEST(suite, test_simple_decrypt);
1564 : 2 : CU_ADD_TEST(suite, test_large_enc_dec);
1565 : 2 : CU_ADD_TEST(suite, test_dev_full);
1566 : 2 : CU_ADD_TEST(suite, test_crazy_rw);
1567 : 2 : CU_ADD_TEST(suite, test_initdrivers);
1568 : 2 : CU_ADD_TEST(suite, test_supported_opcodes);
1569 : 2 : CU_ADD_TEST(suite, test_poller);
1570 : 2 : CU_ADD_TEST(suite, test_assign_device_qp);
1571 : :
1572 : 2 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
1573 : 2 : CU_cleanup_registry();
1574 : 2 : return num_failures;
1575 : : }
|