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