4 * Copyright (c) Intel Corporation.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of Intel Corporation nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 #include "spdk_cunit.h"
35 /* We have our own mock for this */
36 #define UNIT_TEST_NO_VTOPHYS
37 #include "common/lib/test_env.c"
38 #include "spdk_internal/mock.h"
39 #include "unit/lib/json_mock.c"
40 #include "spdk/reduce.h"
42 #include <rte_compressdev.h>
44 /* There will be one if the data perfectly matches the chunk size,
45 * or there could be an offset into the data and a remainder after
46 * the data or both for a max of 3.
48 #define UT_MBUFS_PER_OP 3
49 /* For testing the crossing of a huge page boundary on address translation,
50 * we'll have an extra one but we only test on the source side.
52 #define UT_MBUFS_PER_OP_BOUND_TEST 4
54 struct spdk_bdev_io
*g_bdev_io
;
55 struct spdk_io_channel
*g_io_ch
;
56 struct rte_comp_op g_comp_op
[2];
57 struct vbdev_compress g_comp_bdev
;
58 struct comp_device_qp g_device_qp
;
59 struct compress_dev g_device
;
60 struct rte_compressdev_capabilities g_cdev_cap
;
61 static struct rte_mbuf
*g_src_mbufs
[UT_MBUFS_PER_OP_BOUND_TEST
];
62 static struct rte_mbuf
*g_dst_mbufs
[UT_MBUFS_PER_OP
];
63 static struct rte_mbuf g_expected_src_mbufs
[UT_MBUFS_PER_OP_BOUND_TEST
];
64 static struct rte_mbuf g_expected_dst_mbufs
[UT_MBUFS_PER_OP
];
65 struct comp_bdev_io
*g_io_ctx
;
66 struct comp_io_channel
*g_comp_ch
;
68 /* Those functions are defined as static inline in DPDK, so we can't
69 * mock them straight away. We use defines to redirect them into
70 * our custom functions.
73 static void mock_rte_pktmbuf_attach_extbuf(struct rte_mbuf
*m
, void *buf_addr
, rte_iova_t buf_iova
,
74 uint16_t buf_len
, struct rte_mbuf_ext_shared_info
*shinfo
);
75 #define rte_pktmbuf_attach_extbuf mock_rte_pktmbuf_attach_extbuf
76 static void mock_rte_pktmbuf_attach_extbuf(struct rte_mbuf
*m
, void *buf_addr
, rte_iova_t buf_iova
,
77 uint16_t buf_len
, struct rte_mbuf_ext_shared_info
*shinfo
)
80 m
->buf_addr
= buf_addr
;
81 m
->buf_iova
= buf_iova
;
83 m
->data_len
= m
->pkt_len
= 0;
86 static char *mock_rte_pktmbuf_append(struct rte_mbuf
*m
, uint16_t len
);
87 #define rte_pktmbuf_append mock_rte_pktmbuf_append
88 static char *mock_rte_pktmbuf_append(struct rte_mbuf
*m
, uint16_t len
)
90 m
->pkt_len
= m
->pkt_len
+ len
;
94 static inline int mock_rte_pktmbuf_chain(struct rte_mbuf
*head
, struct rte_mbuf
*tail
);
95 #define rte_pktmbuf_chain mock_rte_pktmbuf_chain
96 static inline int mock_rte_pktmbuf_chain(struct rte_mbuf
*head
, struct rte_mbuf
*tail
)
98 struct rte_mbuf
*cur_tail
;
100 cur_tail
= rte_pktmbuf_lastseg(head
);
101 cur_tail
->next
= tail
;
106 uint16_t ut_max_nb_queue_pairs
= 0;
107 void __rte_experimental
mock_rte_compressdev_info_get(uint8_t dev_id
,
108 struct rte_compressdev_info
*dev_info
);
109 #define rte_compressdev_info_get mock_rte_compressdev_info_get
110 void __rte_experimental
111 mock_rte_compressdev_info_get(uint8_t dev_id
, struct rte_compressdev_info
*dev_info
)
113 dev_info
->max_nb_queue_pairs
= ut_max_nb_queue_pairs
;
114 dev_info
->capabilities
= &g_cdev_cap
;
115 dev_info
->driver_name
= "compress_isal";
118 int ut_rte_compressdev_configure
= 0;
119 int __rte_experimental
mock_rte_compressdev_configure(uint8_t dev_id
,
120 struct rte_compressdev_config
*config
);
121 #define rte_compressdev_configure mock_rte_compressdev_configure
122 int __rte_experimental
123 mock_rte_compressdev_configure(uint8_t dev_id
, struct rte_compressdev_config
*config
)
125 return ut_rte_compressdev_configure
;
128 int ut_rte_compressdev_queue_pair_setup
= 0;
129 int __rte_experimental
mock_rte_compressdev_queue_pair_setup(uint8_t dev_id
, uint16_t queue_pair_id
,
130 uint32_t max_inflight_ops
, int socket_id
);
131 #define rte_compressdev_queue_pair_setup mock_rte_compressdev_queue_pair_setup
132 int __rte_experimental
133 mock_rte_compressdev_queue_pair_setup(uint8_t dev_id
, uint16_t queue_pair_id
,
134 uint32_t max_inflight_ops
, int socket_id
)
136 return ut_rte_compressdev_queue_pair_setup
;
139 int ut_rte_compressdev_start
= 0;
140 int __rte_experimental
mock_rte_compressdev_start(uint8_t dev_id
);
141 #define rte_compressdev_start mock_rte_compressdev_start
142 int __rte_experimental
143 mock_rte_compressdev_start(uint8_t dev_id
)
145 return ut_rte_compressdev_start
;
148 int ut_rte_compressdev_private_xform_create
= 0;
149 int __rte_experimental
mock_rte_compressdev_private_xform_create(uint8_t dev_id
,
150 const struct rte_comp_xform
*xform
, void **private_xform
);
151 #define rte_compressdev_private_xform_create mock_rte_compressdev_private_xform_create
152 int __rte_experimental
153 mock_rte_compressdev_private_xform_create(uint8_t dev_id
,
154 const struct rte_comp_xform
*xform
, void **private_xform
)
156 return ut_rte_compressdev_private_xform_create
;
159 uint8_t ut_rte_compressdev_count
= 0;
160 uint8_t __rte_experimental
mock_rte_compressdev_count(void);
161 #define rte_compressdev_count mock_rte_compressdev_count
162 uint8_t __rte_experimental
163 mock_rte_compressdev_count(void)
165 return ut_rte_compressdev_count
;
168 struct rte_mempool
*ut_rte_comp_op_pool_create
= NULL
;
169 struct rte_mempool
*__rte_experimental
mock_rte_comp_op_pool_create(const char *name
,
170 unsigned int nb_elts
, unsigned int cache_size
, uint16_t user_size
,
172 #define rte_comp_op_pool_create mock_rte_comp_op_pool_create
173 struct rte_mempool
*__rte_experimental
174 mock_rte_comp_op_pool_create(const char *name
, unsigned int nb_elts
,
175 unsigned int cache_size
, uint16_t user_size
, int socket_id
)
177 return ut_rte_comp_op_pool_create
;
180 void mock_rte_pktmbuf_free(struct rte_mbuf
*m
);
181 #define rte_pktmbuf_free mock_rte_pktmbuf_free
182 void mock_rte_pktmbuf_free(struct rte_mbuf
*m
)
186 static bool ut_boundary_alloc
= false;
187 static int ut_rte_pktmbuf_alloc_bulk
= 0;
188 int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool
*pool
, struct rte_mbuf
**mbufs
,
190 #define rte_pktmbuf_alloc_bulk mock_rte_pktmbuf_alloc_bulk
191 int mock_rte_pktmbuf_alloc_bulk(struct rte_mempool
*pool
, struct rte_mbuf
**mbufs
,
196 /* This mocked function only supports the alloc of up to 3 src and 3 dst. */
197 ut_rte_pktmbuf_alloc_bulk
+= count
;
199 if (ut_rte_pktmbuf_alloc_bulk
== 1) {
200 /* allocation of an extra mbuf for boundary cross test */
201 ut_boundary_alloc
= true;
202 g_src_mbufs
[UT_MBUFS_PER_OP_BOUND_TEST
- 1]->next
= NULL
;
203 *mbufs
= g_src_mbufs
[UT_MBUFS_PER_OP_BOUND_TEST
- 1];
204 ut_rte_pktmbuf_alloc_bulk
= 0;
205 } else if (ut_rte_pktmbuf_alloc_bulk
== UT_MBUFS_PER_OP
) {
206 /* first test allocation, src mbufs */
207 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
208 g_src_mbufs
[i
]->next
= NULL
;
209 *mbufs
++ = g_src_mbufs
[i
];
211 } else if (ut_rte_pktmbuf_alloc_bulk
== UT_MBUFS_PER_OP
* 2) {
212 /* second test allocation, dst mbufs */
213 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
214 g_dst_mbufs
[i
]->next
= NULL
;
215 *mbufs
++ = g_dst_mbufs
[i
];
217 ut_rte_pktmbuf_alloc_bulk
= 0;
225 rte_pktmbuf_pool_create(const char *name
, unsigned n
, unsigned cache_size
,
226 uint16_t priv_size
, uint16_t data_room_size
, int socket_id
)
228 struct spdk_mempool
*tmp
;
230 tmp
= spdk_mempool_create("mbuf_mp", 1024, sizeof(struct rte_mbuf
),
231 SPDK_MEMPOOL_DEFAULT_CACHE_SIZE
,
232 SPDK_ENV_SOCKET_ID_ANY
);
234 return (struct rte_mempool
*)tmp
;
238 rte_mempool_free(struct rte_mempool
*mp
)
241 spdk_mempool_free((struct spdk_mempool
*)mp
);
245 static int ut_spdk_reduce_vol_op_complete_err
= 0;
247 spdk_reduce_vol_writev(struct spdk_reduce_vol
*vol
, struct iovec
*iov
, int iovcnt
,
248 uint64_t offset
, uint64_t length
, spdk_reduce_vol_op_complete cb_fn
,
251 cb_fn(cb_arg
, ut_spdk_reduce_vol_op_complete_err
);
255 spdk_reduce_vol_readv(struct spdk_reduce_vol
*vol
, struct iovec
*iov
, int iovcnt
,
256 uint64_t offset
, uint64_t length
, spdk_reduce_vol_op_complete cb_fn
,
259 cb_fn(cb_arg
, ut_spdk_reduce_vol_op_complete_err
);
262 #include "bdev/compress/vbdev_compress.c"
265 DEFINE_STUB(spdk_bdev_get_aliases
, const struct spdk_bdev_aliases_list
*,
266 (const struct spdk_bdev
*bdev
), NULL
);
267 DEFINE_STUB_V(spdk_bdev_module_list_add
, (struct spdk_bdev_module
*bdev_module
));
268 DEFINE_STUB_V(spdk_bdev_free_io
, (struct spdk_bdev_io
*g_bdev_io
));
269 DEFINE_STUB(spdk_bdev_io_type_supported
, bool, (struct spdk_bdev
*bdev
,
270 enum spdk_bdev_io_type io_type
), 0);
271 DEFINE_STUB_V(spdk_bdev_module_release_bdev
, (struct spdk_bdev
*bdev
));
272 DEFINE_STUB_V(spdk_bdev_close
, (struct spdk_bdev_desc
*desc
));
273 DEFINE_STUB(spdk_bdev_get_name
, const char *, (const struct spdk_bdev
*bdev
), 0);
274 DEFINE_STUB(spdk_bdev_get_io_channel
, struct spdk_io_channel
*, (struct spdk_bdev_desc
*desc
), 0);
275 DEFINE_STUB_V(spdk_bdev_unregister
, (struct spdk_bdev
*bdev
, spdk_bdev_unregister_cb cb_fn
,
277 DEFINE_STUB(spdk_bdev_open
, int, (struct spdk_bdev
*bdev
, bool write
,
278 spdk_bdev_remove_cb_t remove_cb
,
279 void *remove_ctx
, struct spdk_bdev_desc
**_desc
), 0);
280 DEFINE_STUB(spdk_bdev_module_claim_bdev
, int, (struct spdk_bdev
*bdev
, struct spdk_bdev_desc
*desc
,
281 struct spdk_bdev_module
*module
), 0);
282 DEFINE_STUB_V(spdk_bdev_module_examine_done
, (struct spdk_bdev_module
*module
));
283 DEFINE_STUB(spdk_bdev_register
, int, (struct spdk_bdev
*bdev
), 0);
284 DEFINE_STUB(spdk_bdev_get_by_name
, struct spdk_bdev
*, (const char *bdev_name
), NULL
);
285 DEFINE_STUB(spdk_bdev_io_get_io_channel
, struct spdk_io_channel
*, (struct spdk_bdev_io
*bdev_io
),
287 DEFINE_STUB(spdk_bdev_queue_io_wait
, int, (struct spdk_bdev
*bdev
, struct spdk_io_channel
*ch
,
288 struct spdk_bdev_io_wait_entry
*entry
), 0);
289 DEFINE_STUB_V(spdk_reduce_vol_unload
, (struct spdk_reduce_vol
*vol
,
290 spdk_reduce_vol_op_complete cb_fn
, void *cb_arg
));
291 DEFINE_STUB_V(spdk_reduce_vol_load
, (struct spdk_reduce_backing_dev
*backing_dev
,
292 spdk_reduce_vol_op_with_handle_complete cb_fn
, void *cb_arg
));
293 DEFINE_STUB(spdk_reduce_vol_get_params
, const struct spdk_reduce_vol_params
*,
294 (struct spdk_reduce_vol
*vol
), NULL
);
297 DEFINE_STUB(rte_socket_id
, unsigned, (void), 0);
298 DEFINE_STUB(rte_vdev_init
, int, (const char *name
, const char *args
), 0);
299 DEFINE_STUB_V(rte_comp_op_free
, (struct rte_comp_op
*op
));
300 DEFINE_STUB(rte_comp_op_alloc
, struct rte_comp_op
*, (struct rte_mempool
*mempool
), NULL
);
302 int g_small_size_counter
= 0;
303 int g_small_size_modify
= 0;
304 uint64_t g_small_size
= 0;
306 spdk_vtophys(void *buf
, uint64_t *size
)
308 g_small_size_counter
++;
309 if (g_small_size_counter
== g_small_size_modify
) {
310 *size
= g_small_size
;
311 g_small_size_counter
= 0;
312 g_small_size_modify
= 0;
314 return (uint64_t)buf
;
318 spdk_bdev_io_get_buf(struct spdk_bdev_io
*bdev_io
, spdk_bdev_io_get_buf_cb cb
, uint64_t len
)
320 cb(g_io_ch
, g_bdev_io
, true);
323 /* Mock these functions to call the callback and then return the value we require */
324 int ut_spdk_bdev_readv_blocks
= 0;
326 spdk_bdev_readv_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
327 struct iovec
*iov
, int iovcnt
,
328 uint64_t offset_blocks
, uint64_t num_blocks
,
329 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
331 cb(g_bdev_io
, !ut_spdk_bdev_readv_blocks
, cb_arg
);
332 return ut_spdk_bdev_readv_blocks
;
335 int ut_spdk_bdev_writev_blocks
= 0;
336 bool ut_spdk_bdev_writev_blocks_mocked
= false;
338 spdk_bdev_writev_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
339 struct iovec
*iov
, int iovcnt
,
340 uint64_t offset_blocks
, uint64_t num_blocks
,
341 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
343 cb(g_bdev_io
, !ut_spdk_bdev_writev_blocks
, cb_arg
);
344 return ut_spdk_bdev_writev_blocks
;
347 int ut_spdk_bdev_unmap_blocks
= 0;
348 bool ut_spdk_bdev_unmap_blocks_mocked
= false;
350 spdk_bdev_unmap_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
351 uint64_t offset_blocks
, uint64_t num_blocks
,
352 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
354 cb(g_bdev_io
, !ut_spdk_bdev_unmap_blocks
, cb_arg
);
355 return ut_spdk_bdev_unmap_blocks
;
358 int ut_spdk_bdev_flush_blocks
= 0;
359 bool ut_spdk_bdev_flush_blocks_mocked
= false;
361 spdk_bdev_flush_blocks(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
362 uint64_t offset_blocks
, uint64_t num_blocks
, spdk_bdev_io_completion_cb cb
,
365 cb(g_bdev_io
, !ut_spdk_bdev_flush_blocks
, cb_arg
);
366 return ut_spdk_bdev_flush_blocks
;
369 int ut_spdk_bdev_reset
= 0;
370 bool ut_spdk_bdev_reset_mocked
= false;
372 spdk_bdev_reset(struct spdk_bdev_desc
*desc
, struct spdk_io_channel
*ch
,
373 spdk_bdev_io_completion_cb cb
, void *cb_arg
)
375 cb(g_bdev_io
, !ut_spdk_bdev_reset
, cb_arg
);
376 return ut_spdk_bdev_reset
;
379 bool g_completion_called
= false;
381 spdk_bdev_io_complete(struct spdk_bdev_io
*bdev_io
, enum spdk_bdev_io_status status
)
383 bdev_io
->internal
.status
= status
;
384 g_completion_called
= true;
387 static uint16_t ut_rte_compressdev_dequeue_burst
= 0;
389 rte_compressdev_dequeue_burst(uint8_t dev_id
, uint16_t qp_id
, struct rte_comp_op
**ops
,
392 if (ut_rte_compressdev_dequeue_burst
== 0) {
396 ops
[0] = &g_comp_op
[0];
397 ops
[1] = &g_comp_op
[1];
399 return ut_rte_compressdev_dequeue_burst
;
402 static int ut_compress_done
[2];
403 /* done_count and done_idx together control which expected assertion
404 * value to use when dequeuing 2 operations.
406 static uint16_t done_count
= 1;
407 static uint16_t done_idx
= 0;
409 _compress_done(void *_req
, int reduce_errno
)
411 if (done_count
== 1) {
412 CU_ASSERT(reduce_errno
== ut_compress_done
[0]);
413 } else if (done_count
== 2) {
414 CU_ASSERT(reduce_errno
== ut_compress_done
[done_idx
++]);
419 _get_mbuf_array(struct rte_mbuf
*mbuf_array
[UT_MBUFS_PER_OP_BOUND_TEST
],
420 struct rte_mbuf
*mbuf_head
, int mbuf_count
, bool null_final
)
424 for (i
= 0; i
< mbuf_count
; i
++) {
425 mbuf_array
[i
] = mbuf_head
;
427 mbuf_head
= mbuf_head
->next
;
431 mbuf_array
[i
- 1] = NULL
;
435 #define FAKE_ENQUEUE_SUCCESS 255
436 #define FAKE_ENQUEUE_ERROR 128
437 #define FAKE_ENQUEUE_BUSY 64
438 static uint16_t ut_enqueue_value
= FAKE_ENQUEUE_SUCCESS
;
439 static struct rte_comp_op ut_expected_op
;
441 rte_compressdev_enqueue_burst(uint8_t dev_id
, uint16_t qp_id
, struct rte_comp_op
**ops
,
444 struct rte_comp_op
*op
= *ops
;
445 struct rte_mbuf
*op_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
];
446 struct rte_mbuf
*exp_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
];
447 int i
, num_src_mbufs
= UT_MBUFS_PER_OP
;
449 switch (ut_enqueue_value
) {
450 case FAKE_ENQUEUE_BUSY
:
451 op
->status
= RTE_COMP_OP_STATUS_NOT_PROCESSED
;
454 case FAKE_ENQUEUE_SUCCESS
:
455 op
->status
= RTE_COMP_OP_STATUS_SUCCESS
;
458 case FAKE_ENQUEUE_ERROR
:
459 op
->status
= RTE_COMP_OP_STATUS_ERROR
;
466 /* by design the compress module will never send more than 1 op at a time */
467 CU_ASSERT(op
->private_xform
== ut_expected_op
.private_xform
);
469 /* setup our local pointers to the chained mbufs, those pointed to in the
470 * operation struct and the expected values.
472 _get_mbuf_array(op_mbuf
, op
->m_src
, SPDK_COUNTOF(op_mbuf
), true);
473 _get_mbuf_array(exp_mbuf
, ut_expected_op
.m_src
, SPDK_COUNTOF(exp_mbuf
), true);
475 if (ut_boundary_alloc
== true) {
476 /* if we crossed a boundary, we need to check the 4th src mbuf and
477 * reset the global that is used to identify whether we crossed
480 num_src_mbufs
= UT_MBUFS_PER_OP_BOUND_TEST
;
481 exp_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
- 1] = ut_expected_op
.m_src
->next
->next
->next
;
482 op_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
- 1] = op
->m_src
->next
->next
->next
;
483 ut_boundary_alloc
= false;
487 for (i
= 0; i
< num_src_mbufs
; i
++) {
488 CU_ASSERT(op_mbuf
[i
]->buf_addr
== exp_mbuf
[i
]->buf_addr
);
489 CU_ASSERT(op_mbuf
[i
]->buf_iova
== exp_mbuf
[i
]->buf_iova
);
490 CU_ASSERT(op_mbuf
[i
]->buf_len
== exp_mbuf
[i
]->buf_len
);
491 CU_ASSERT(op_mbuf
[i
]->pkt_len
== exp_mbuf
[i
]->pkt_len
);
494 /* if only 3 mbufs were used in the test, the 4th should be zeroed */
495 if (num_src_mbufs
== UT_MBUFS_PER_OP
) {
496 CU_ASSERT(op_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
- 1] == NULL
);
497 CU_ASSERT(exp_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
- 1] == NULL
);
500 CU_ASSERT(op
->m_src
->userdata
== ut_expected_op
.m_src
->userdata
);
501 CU_ASSERT(op
->src
.offset
== ut_expected_op
.src
.offset
);
502 CU_ASSERT(op
->src
.length
== ut_expected_op
.src
.length
);
504 /* check dst mbuf values */
505 _get_mbuf_array(op_mbuf
, op
->m_dst
, SPDK_COUNTOF(op_mbuf
), true);
506 _get_mbuf_array(exp_mbuf
, ut_expected_op
.m_dst
, SPDK_COUNTOF(exp_mbuf
), true);
508 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
509 CU_ASSERT(op_mbuf
[i
]->buf_addr
== exp_mbuf
[i
]->buf_addr
);
510 CU_ASSERT(op_mbuf
[i
]->buf_iova
== exp_mbuf
[i
]->buf_iova
);
511 CU_ASSERT(op_mbuf
[i
]->buf_len
== exp_mbuf
[i
]->buf_len
);
512 CU_ASSERT(op_mbuf
[i
]->pkt_len
== exp_mbuf
[i
]->pkt_len
);
514 CU_ASSERT(op
->dst
.offset
== ut_expected_op
.dst
.offset
);
516 return ut_enqueue_value
;
519 /* Global setup for all tests that share a bunch of preparation... */
523 struct spdk_thread
*thread
;
526 spdk_thread_lib_init(NULL
, 0);
528 thread
= spdk_thread_create(NULL
, NULL
);
529 spdk_set_thread(thread
);
531 g_comp_bdev
.reduce_thread
= thread
;
532 g_comp_bdev
.backing_dev
.unmap
= _comp_reduce_unmap
;
533 g_comp_bdev
.backing_dev
.readv
= _comp_reduce_readv
;
534 g_comp_bdev
.backing_dev
.writev
= _comp_reduce_writev
;
535 g_comp_bdev
.backing_dev
.compress
= _comp_reduce_compress
;
536 g_comp_bdev
.backing_dev
.decompress
= _comp_reduce_decompress
;
537 g_comp_bdev
.backing_dev
.blocklen
= 512;
538 g_comp_bdev
.backing_dev
.blockcnt
= 1024 * 16;
540 g_comp_bdev
.device_qp
= &g_device_qp
;
541 g_comp_bdev
.device_qp
->device
= &g_device
;
543 TAILQ_INIT(&g_comp_bdev
.queued_comp_ops
);
545 g_comp_xform
= (struct rte_comp_xform
) {
546 .type
= RTE_COMP_COMPRESS
,
548 .algo
= RTE_COMP_ALGO_DEFLATE
,
549 .deflate
.huffman
= RTE_COMP_HUFFMAN_DEFAULT
,
550 .level
= RTE_COMP_LEVEL_MAX
,
551 .window_size
= DEFAULT_WINDOW_SIZE
,
552 .chksum
= RTE_COMP_CHECKSUM_NONE
,
553 .hash_algo
= RTE_COMP_HASH_ALGO_NONE
557 g_decomp_xform
= (struct rte_comp_xform
) {
558 .type
= RTE_COMP_DECOMPRESS
,
560 .algo
= RTE_COMP_ALGO_DEFLATE
,
561 .chksum
= RTE_COMP_CHECKSUM_NONE
,
562 .window_size
= DEFAULT_WINDOW_SIZE
,
563 .hash_algo
= RTE_COMP_HASH_ALGO_NONE
566 g_device
.comp_xform
= &g_comp_xform
;
567 g_device
.decomp_xform
= &g_decomp_xform
;
568 g_cdev_cap
.comp_feature_flags
= RTE_COMP_FF_SHAREABLE_PRIV_XFORM
;
569 g_device
.cdev_info
.driver_name
= "compress_isal";
570 g_device
.cdev_info
.capabilities
= &g_cdev_cap
;
571 for (i
= 0; i
< UT_MBUFS_PER_OP_BOUND_TEST
; i
++) {
572 g_src_mbufs
[i
] = calloc(1, sizeof(struct rte_mbuf
));
574 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
575 g_dst_mbufs
[i
] = calloc(1, sizeof(struct rte_mbuf
));
578 g_bdev_io
= calloc(1, sizeof(struct spdk_bdev_io
) + sizeof(struct comp_bdev_io
));
579 g_bdev_io
->u
.bdev
.iovs
= calloc(128, sizeof(struct iovec
));
580 g_bdev_io
->bdev
= &g_comp_bdev
.comp_bdev
;
581 g_io_ch
= calloc(1, sizeof(struct spdk_io_channel
) + sizeof(struct comp_io_channel
));
582 g_io_ch
->thread
= thread
;
583 g_comp_ch
= (struct comp_io_channel
*)((uint8_t *)g_io_ch
+ sizeof(struct spdk_io_channel
));
584 g_io_ctx
= (struct comp_bdev_io
*)g_bdev_io
->driver_ctx
;
586 g_io_ctx
->comp_ch
= g_comp_ch
;
587 g_io_ctx
->comp_bdev
= &g_comp_bdev
;
588 g_comp_bdev
.device_qp
= &g_device_qp
;
590 for (i
= 0; i
< UT_MBUFS_PER_OP_BOUND_TEST
- 1; i
++) {
591 g_expected_src_mbufs
[i
].next
= &g_expected_src_mbufs
[i
+ 1];
593 g_expected_src_mbufs
[UT_MBUFS_PER_OP_BOUND_TEST
- 1].next
= NULL
;
595 /* we only test w/4 mbufs on src side */
596 for (i
= 0; i
< UT_MBUFS_PER_OP
- 1; i
++) {
597 g_expected_dst_mbufs
[i
].next
= &g_expected_dst_mbufs
[i
+ 1];
599 g_expected_dst_mbufs
[UT_MBUFS_PER_OP
- 1].next
= NULL
;
604 /* Global teardown for all tests */
608 struct spdk_thread
*thread
;
611 for (i
= 0; i
< UT_MBUFS_PER_OP_BOUND_TEST
; i
++) {
612 free(g_src_mbufs
[i
]);
614 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
615 free(g_dst_mbufs
[i
]);
617 free(g_bdev_io
->u
.bdev
.iovs
);
621 thread
= spdk_get_thread();
622 spdk_thread_exit(thread
);
623 while (!spdk_thread_is_exited(thread
)) {
624 spdk_thread_poll(thread
, 0, 0);
626 spdk_thread_destroy(thread
);
628 spdk_thread_lib_fini();
634 test_compress_operation(void)
636 struct iovec src_iovs
[3] = {};
638 struct iovec dst_iovs
[3] = {};
640 struct spdk_reduce_vol_cb_args cb_arg
;
642 struct vbdev_comp_op
*op
;
643 struct rte_mbuf
*exp_src_mbuf
[UT_MBUFS_PER_OP
];
644 struct rte_mbuf
*exp_dst_mbuf
[UT_MBUFS_PER_OP
];
646 src_iovcnt
= dst_iovcnt
= 3;
647 for (i
= 0; i
< dst_iovcnt
; i
++) {
648 src_iovs
[i
].iov_len
= 0x1000;
649 dst_iovs
[i
].iov_len
= 0x1000;
650 src_iovs
[i
].iov_base
= (void *)0x10000000 + 0x1000 * i
;
651 dst_iovs
[i
].iov_base
= (void *)0x20000000 + 0x1000 * i
;
654 /* test rte_comp_op_alloc failure */
655 MOCK_SET(rte_comp_op_alloc
, NULL
);
656 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
657 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
658 &dst_iovs
[0], dst_iovcnt
, true, &cb_arg
);
659 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == false);
660 while (!TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
)) {
661 op
= TAILQ_FIRST(&g_comp_bdev
.queued_comp_ops
);
662 TAILQ_REMOVE(&g_comp_bdev
.queued_comp_ops
, op
, link
);
665 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
667 MOCK_SET(rte_comp_op_alloc
, &g_comp_op
[0]);
669 /* test mempool get failure */
670 ut_rte_pktmbuf_alloc_bulk
= -1;
671 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
672 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
673 &dst_iovs
[0], dst_iovcnt
, true, &cb_arg
);
674 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == false);
675 while (!TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
)) {
676 op
= TAILQ_FIRST(&g_comp_bdev
.queued_comp_ops
);
677 TAILQ_REMOVE(&g_comp_bdev
.queued_comp_ops
, op
, link
);
680 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
682 ut_rte_pktmbuf_alloc_bulk
= 0;
684 /* test enqueue failure busy */
685 ut_enqueue_value
= FAKE_ENQUEUE_BUSY
;
686 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
687 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
688 &dst_iovs
[0], dst_iovcnt
, true, &cb_arg
);
689 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == false);
690 while (!TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
)) {
691 op
= TAILQ_FIRST(&g_comp_bdev
.queued_comp_ops
);
692 TAILQ_REMOVE(&g_comp_bdev
.queued_comp_ops
, op
, link
);
695 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
697 ut_enqueue_value
= 1;
699 /* test enqueue failure error */
700 ut_enqueue_value
= FAKE_ENQUEUE_ERROR
;
701 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
702 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
703 &dst_iovs
[0], dst_iovcnt
, true, &cb_arg
);
704 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
705 CU_ASSERT(rc
== -EINVAL
);
706 ut_enqueue_value
= FAKE_ENQUEUE_SUCCESS
;
708 /* test success with 3 vector iovec */
709 ut_expected_op
.private_xform
= &g_decomp_xform
;
710 ut_expected_op
.src
.offset
= 0;
711 ut_expected_op
.src
.length
= src_iovs
[0].iov_len
+ src_iovs
[1].iov_len
+ src_iovs
[2].iov_len
;
713 /* setup the src expected values */
714 _get_mbuf_array(exp_src_mbuf
, &g_expected_src_mbufs
[0], SPDK_COUNTOF(exp_src_mbuf
), false);
715 ut_expected_op
.m_src
= exp_src_mbuf
[0];
717 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
718 exp_src_mbuf
[i
]->userdata
= &cb_arg
;
719 exp_src_mbuf
[i
]->buf_addr
= src_iovs
[i
].iov_base
;
720 exp_src_mbuf
[i
]->buf_iova
= spdk_vtophys(src_iovs
[i
].iov_base
, &src_iovs
[i
].iov_len
);
721 exp_src_mbuf
[i
]->buf_len
= src_iovs
[i
].iov_len
;
722 exp_src_mbuf
[i
]->pkt_len
= src_iovs
[i
].iov_len
;
725 /* setup the dst expected values */
726 _get_mbuf_array(exp_dst_mbuf
, &g_expected_dst_mbufs
[0], SPDK_COUNTOF(exp_dst_mbuf
), false);
727 ut_expected_op
.dst
.offset
= 0;
728 ut_expected_op
.m_dst
= exp_dst_mbuf
[0];
730 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
731 exp_dst_mbuf
[i
]->buf_addr
= dst_iovs
[i
].iov_base
;
732 exp_dst_mbuf
[i
]->buf_iova
= spdk_vtophys(dst_iovs
[i
].iov_base
, &dst_iovs
[i
].iov_len
);
733 exp_dst_mbuf
[i
]->buf_len
= dst_iovs
[i
].iov_len
;
734 exp_dst_mbuf
[i
]->pkt_len
= dst_iovs
[i
].iov_len
;
737 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
738 &dst_iovs
[0], dst_iovcnt
, false, &cb_arg
);
739 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
745 test_compress_operation_cross_boundary(void)
747 struct iovec src_iovs
[3] = {};
749 struct iovec dst_iovs
[3] = {};
751 struct spdk_reduce_vol_cb_args cb_arg
;
753 struct rte_mbuf
*exp_src_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
];
754 struct rte_mbuf
*exp_dst_mbuf
[UT_MBUFS_PER_OP_BOUND_TEST
];
756 /* Setup the same basic 3 IOV test as used in the simple success case
757 * but then we'll start testing a vtophy boundary crossing at each
760 src_iovcnt
= dst_iovcnt
= 3;
761 for (i
= 0; i
< dst_iovcnt
; i
++) {
762 src_iovs
[i
].iov_len
= 0x1000;
763 dst_iovs
[i
].iov_len
= 0x1000;
764 src_iovs
[i
].iov_base
= (void *)0x10000000 + 0x1000 * i
;
765 dst_iovs
[i
].iov_base
= (void *)0x20000000 + 0x1000 * i
;
768 ut_expected_op
.private_xform
= &g_decomp_xform
;
769 ut_expected_op
.src
.offset
= 0;
770 ut_expected_op
.src
.length
= src_iovs
[0].iov_len
+ src_iovs
[1].iov_len
+ src_iovs
[2].iov_len
;
772 /* setup the src expected values */
773 _get_mbuf_array(exp_src_mbuf
, &g_expected_src_mbufs
[0], SPDK_COUNTOF(exp_src_mbuf
), false);
774 ut_expected_op
.m_src
= exp_src_mbuf
[0];
776 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
777 exp_src_mbuf
[i
]->userdata
= &cb_arg
;
778 exp_src_mbuf
[i
]->buf_addr
= src_iovs
[i
].iov_base
;
779 exp_src_mbuf
[i
]->buf_iova
= spdk_vtophys(src_iovs
[i
].iov_base
, &src_iovs
[i
].iov_len
);
780 exp_src_mbuf
[i
]->buf_len
= src_iovs
[i
].iov_len
;
781 exp_src_mbuf
[i
]->pkt_len
= src_iovs
[i
].iov_len
;
784 /* setup the dst expected values, we don't test needing a 4th dst mbuf */
785 _get_mbuf_array(exp_dst_mbuf
, &g_expected_dst_mbufs
[0], SPDK_COUNTOF(exp_dst_mbuf
), false);
786 ut_expected_op
.dst
.offset
= 0;
787 ut_expected_op
.m_dst
= exp_dst_mbuf
[0];
789 for (i
= 0; i
< UT_MBUFS_PER_OP
; i
++) {
790 exp_dst_mbuf
[i
]->buf_addr
= dst_iovs
[i
].iov_base
;
791 exp_dst_mbuf
[i
]->buf_iova
= spdk_vtophys(dst_iovs
[i
].iov_base
, &dst_iovs
[i
].iov_len
);
792 exp_dst_mbuf
[i
]->buf_len
= dst_iovs
[i
].iov_len
;
793 exp_dst_mbuf
[i
]->pkt_len
= dst_iovs
[i
].iov_len
;
796 /* force the 1st IOV to get partial length from spdk_vtophys */
797 g_small_size_counter
= 0;
798 g_small_size_modify
= 1;
799 g_small_size
= 0x800;
800 exp_src_mbuf
[3]->userdata
= &cb_arg
;
802 /* first only has shorter length */
803 exp_src_mbuf
[0]->pkt_len
= exp_src_mbuf
[0]->buf_len
= 0x800;
805 /* 2nd was inserted by the boundary crossing condition and finishes off
806 * the length from the first */
807 exp_src_mbuf
[1]->buf_addr
= (void *)0x10000800;
808 exp_src_mbuf
[1]->buf_iova
= 0x10000800;
809 exp_src_mbuf
[1]->pkt_len
= exp_src_mbuf
[1]->buf_len
= 0x800;
811 /* 3rd looks like that the 2nd would have */
812 exp_src_mbuf
[2]->buf_addr
= (void *)0x10001000;
813 exp_src_mbuf
[2]->buf_iova
= 0x10001000;
814 exp_src_mbuf
[2]->pkt_len
= exp_src_mbuf
[2]->buf_len
= 0x1000;
816 /* a new 4th looks like what the 3rd would have */
817 exp_src_mbuf
[3]->buf_addr
= (void *)0x10002000;
818 exp_src_mbuf
[3]->buf_iova
= 0x10002000;
819 exp_src_mbuf
[3]->pkt_len
= exp_src_mbuf
[3]->buf_len
= 0x1000;
821 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
822 &dst_iovs
[0], dst_iovcnt
, false, &cb_arg
);
823 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
826 /* Now force the 2nd IOV to get partial length from spdk_vtophys */
827 g_small_size_counter
= 0;
828 g_small_size_modify
= 2;
829 g_small_size
= 0x800;
831 /* first is normal */
832 exp_src_mbuf
[0]->buf_addr
= (void *)0x10000000;
833 exp_src_mbuf
[0]->buf_iova
= 0x10000000;
834 exp_src_mbuf
[0]->pkt_len
= exp_src_mbuf
[0]->buf_len
= 0x1000;
836 /* second only has shorter length */
837 exp_src_mbuf
[1]->buf_addr
= (void *)0x10001000;
838 exp_src_mbuf
[1]->buf_iova
= 0x10001000;
839 exp_src_mbuf
[1]->pkt_len
= exp_src_mbuf
[1]->buf_len
= 0x800;
841 /* 3rd was inserted by the boundary crossing condition and finishes off
842 * the length from the first */
843 exp_src_mbuf
[2]->buf_addr
= (void *)0x10001800;
844 exp_src_mbuf
[2]->buf_iova
= 0x10001800;
845 exp_src_mbuf
[2]->pkt_len
= exp_src_mbuf
[2]->buf_len
= 0x800;
847 /* a new 4th looks like what the 3rd would have */
848 exp_src_mbuf
[3]->buf_addr
= (void *)0x10002000;
849 exp_src_mbuf
[3]->buf_iova
= 0x10002000;
850 exp_src_mbuf
[3]->pkt_len
= exp_src_mbuf
[3]->buf_len
= 0x1000;
852 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
853 &dst_iovs
[0], dst_iovcnt
, false, &cb_arg
);
854 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
857 /* Finally force the 3rd IOV to get partial length from spdk_vtophys */
858 g_small_size_counter
= 0;
859 g_small_size_modify
= 3;
860 g_small_size
= 0x800;
862 /* first is normal */
863 exp_src_mbuf
[0]->buf_addr
= (void *)0x10000000;
864 exp_src_mbuf
[0]->buf_iova
= 0x10000000;
865 exp_src_mbuf
[0]->pkt_len
= exp_src_mbuf
[0]->buf_len
= 0x1000;
867 /* second is normal */
868 exp_src_mbuf
[1]->buf_addr
= (void *)0x10001000;
869 exp_src_mbuf
[1]->buf_iova
= 0x10001000;
870 exp_src_mbuf
[1]->pkt_len
= exp_src_mbuf
[1]->buf_len
= 0x1000;
872 /* 3rd has shorter length */
873 exp_src_mbuf
[2]->buf_addr
= (void *)0x10002000;
874 exp_src_mbuf
[2]->buf_iova
= 0x10002000;
875 exp_src_mbuf
[2]->pkt_len
= exp_src_mbuf
[2]->buf_len
= 0x800;
877 /* a new 4th handles the remainder from the 3rd */
878 exp_src_mbuf
[3]->buf_addr
= (void *)0x10002800;
879 exp_src_mbuf
[3]->buf_iova
= 0x10002800;
880 exp_src_mbuf
[3]->pkt_len
= exp_src_mbuf
[3]->buf_len
= 0x800;
882 rc
= _compress_operation(&g_comp_bdev
.backing_dev
, &src_iovs
[0], src_iovcnt
,
883 &dst_iovs
[0], dst_iovcnt
, false, &cb_arg
);
884 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
892 struct spdk_reduce_vol_cb_args
*cb_args
;
893 struct rte_mbuf mbuf
[4]; /* one src, one dst, 2 ops */
894 struct vbdev_comp_op
*op_to_queue
;
895 struct iovec src_iovs
[3] = {};
896 struct iovec dst_iovs
[3] = {};
899 cb_args
= calloc(1, sizeof(*cb_args
));
900 SPDK_CU_ASSERT_FATAL(cb_args
!= NULL
);
901 cb_args
->cb_fn
= _compress_done
;
902 memset(&g_comp_op
[0], 0, sizeof(struct rte_comp_op
));
903 g_comp_op
[0].m_src
= &mbuf
[0];
904 g_comp_op
[1].m_src
= &mbuf
[1];
905 g_comp_op
[0].m_dst
= &mbuf
[2];
906 g_comp_op
[1].m_dst
= &mbuf
[3];
907 for (i
= 0; i
< 3; i
++) {
908 src_iovs
[i
].iov_len
= 0x1000;
909 dst_iovs
[i
].iov_len
= 0x1000;
910 src_iovs
[i
].iov_base
= (void *)0x10000000 + 0x1000 * i
;
911 dst_iovs
[i
].iov_base
= (void *)0x20000000 + 0x1000 * i
;
914 /* Error from dequeue, nothing needing to be resubmitted.
916 ut_rte_compressdev_dequeue_burst
= 1;
917 /* setup what we want dequeue to return for the op */
918 g_comp_op
[0].m_src
->userdata
= (void *)cb_args
;
919 g_comp_op
[0].produced
= 1;
920 g_comp_op
[0].status
= 1;
921 /* value asserted in the reduce callback */
922 ut_compress_done
[0] = -EINVAL
;
923 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
924 rc
= comp_dev_poller((void *)&g_comp_bdev
);
925 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
926 CU_ASSERT(rc
== SPDK_POLLER_BUSY
);
928 /* Success from dequeue, 2 ops. nothing needing to be resubmitted.
930 ut_rte_compressdev_dequeue_burst
= 2;
931 /* setup what we want dequeue to return for the op */
932 g_comp_op
[0].m_src
->userdata
= (void *)cb_args
;
933 g_comp_op
[0].produced
= 16;
934 g_comp_op
[0].status
= 0;
935 g_comp_op
[1].m_src
->userdata
= (void *)cb_args
;
936 g_comp_op
[1].produced
= 32;
937 g_comp_op
[1].status
= 0;
938 /* value asserted in the reduce callback */
939 ut_compress_done
[0] = 16;
940 ut_compress_done
[1] = 32;
942 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
943 rc
= comp_dev_poller((void *)&g_comp_bdev
);
944 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
945 CU_ASSERT(rc
== SPDK_POLLER_BUSY
);
947 /* Success from dequeue, one op to be resubmitted.
949 ut_rte_compressdev_dequeue_burst
= 1;
950 /* setup what we want dequeue to return for the op */
951 g_comp_op
[0].m_src
->userdata
= (void *)cb_args
;
952 g_comp_op
[0].produced
= 16;
953 g_comp_op
[0].status
= 0;
954 /* value asserted in the reduce callback */
955 ut_compress_done
[0] = 16;
957 op_to_queue
= calloc(1, sizeof(struct vbdev_comp_op
));
958 SPDK_CU_ASSERT_FATAL(op_to_queue
!= NULL
);
959 op_to_queue
->backing_dev
= &g_comp_bdev
.backing_dev
;
960 op_to_queue
->src_iovs
= &src_iovs
[0];
961 op_to_queue
->src_iovcnt
= 3;
962 op_to_queue
->dst_iovs
= &dst_iovs
[0];
963 op_to_queue
->dst_iovcnt
= 3;
964 op_to_queue
->compress
= true;
965 op_to_queue
->cb_arg
= cb_args
;
966 ut_enqueue_value
= FAKE_ENQUEUE_SUCCESS
;
967 TAILQ_INSERT_TAIL(&g_comp_bdev
.queued_comp_ops
,
970 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == false);
971 rc
= comp_dev_poller((void *)&g_comp_bdev
);
972 CU_ASSERT(TAILQ_EMPTY(&g_comp_bdev
.queued_comp_ops
) == true);
973 CU_ASSERT(rc
== SPDK_POLLER_BUSY
);
975 /* op_to_queue is freed in code under test */
980 test_vbdev_compress_submit_request(void)
982 /* Single element block size write */
983 g_bdev_io
->internal
.status
= SPDK_BDEV_IO_STATUS_FAILED
;
984 g_bdev_io
->type
= SPDK_BDEV_IO_TYPE_WRITE
;
985 g_completion_called
= false;
986 vbdev_compress_submit_request(g_io_ch
, g_bdev_io
);
987 CU_ASSERT(g_bdev_io
->internal
.status
== SPDK_BDEV_IO_STATUS_SUCCESS
);
988 CU_ASSERT(g_completion_called
== true);
989 CU_ASSERT(g_io_ctx
->orig_io
== g_bdev_io
);
990 CU_ASSERT(g_io_ctx
->comp_bdev
== &g_comp_bdev
);
991 CU_ASSERT(g_io_ctx
->comp_ch
== g_comp_ch
);
993 /* same write but now fail it */
994 ut_spdk_reduce_vol_op_complete_err
= 1;
995 g_completion_called
= false;
996 vbdev_compress_submit_request(g_io_ch
, g_bdev_io
);
997 CU_ASSERT(g_bdev_io
->internal
.status
== SPDK_BDEV_IO_STATUS_FAILED
);
998 CU_ASSERT(g_completion_called
== true);
1000 /* test a read success */
1001 g_bdev_io
->type
= SPDK_BDEV_IO_TYPE_READ
;
1002 ut_spdk_reduce_vol_op_complete_err
= 0;
1003 g_completion_called
= false;
1004 vbdev_compress_submit_request(g_io_ch
, g_bdev_io
);
1005 CU_ASSERT(g_bdev_io
->internal
.status
== SPDK_BDEV_IO_STATUS_SUCCESS
);
1006 CU_ASSERT(g_completion_called
== true);
1008 /* test a read failure */
1009 ut_spdk_reduce_vol_op_complete_err
= 1;
1010 g_completion_called
= false;
1011 vbdev_compress_submit_request(g_io_ch
, g_bdev_io
);
1012 CU_ASSERT(g_bdev_io
->internal
.status
== SPDK_BDEV_IO_STATUS_FAILED
);
1013 CU_ASSERT(g_completion_called
== true);
1025 /* TODO: There are a few different ways to do this given that
1026 * the code uses spdk_for_each_channel() to implement reset
1027 * handling. SUbmitting w/o UT for this function for now and
1028 * will follow up with something shortly.
1033 test_initdrivers(void)
1037 /* test return values from rte_vdev_init() */
1038 MOCK_SET(rte_vdev_init
, -EEXIST
);
1039 rc
= vbdev_init_compress_drivers();
1040 /* This is not an error condition, we already have one */
1044 MOCK_SET(rte_vdev_init
, -2);
1045 rc
= vbdev_init_compress_drivers();
1046 CU_ASSERT(rc
== -EINVAL
);
1047 CU_ASSERT(g_mbuf_mp
== NULL
);
1048 CU_ASSERT(g_comp_op_mp
== NULL
);
1050 /* compressdev count 0 */
1051 ut_rte_compressdev_count
= 0;
1052 MOCK_SET(rte_vdev_init
, 0);
1053 rc
= vbdev_init_compress_drivers();
1057 ut_rte_compressdev_count
= RTE_COMPRESS_MAX_DEVS
+ 1;
1058 rc
= vbdev_init_compress_drivers();
1059 CU_ASSERT(rc
== -EINVAL
);
1061 /* can't get mbuf pool */
1062 ut_rte_compressdev_count
= 1;
1063 MOCK_SET(spdk_mempool_create
, NULL
);
1064 rc
= vbdev_init_compress_drivers();
1065 CU_ASSERT(rc
== -ENOMEM
);
1066 MOCK_CLEAR(spdk_mempool_create
);
1068 /* can't get comp op pool */
1069 ut_rte_comp_op_pool_create
= NULL
;
1070 rc
= vbdev_init_compress_drivers();
1071 CU_ASSERT(rc
== -ENOMEM
);
1073 /* error on create_compress_dev() */
1074 ut_rte_comp_op_pool_create
= (struct rte_mempool
*)&test_initdrivers
;
1075 ut_rte_compressdev_configure
= -1;
1076 rc
= vbdev_init_compress_drivers();
1077 CU_ASSERT(rc
== -1);
1079 /* error on create_compress_dev() but coverage for large num queues */
1080 ut_max_nb_queue_pairs
= 99;
1081 rc
= vbdev_init_compress_drivers();
1082 CU_ASSERT(rc
== -1);
1084 /* qpair setup fails */
1085 ut_rte_compressdev_configure
= 0;
1086 ut_max_nb_queue_pairs
= 0;
1087 ut_rte_compressdev_queue_pair_setup
= -1;
1088 rc
= vbdev_init_compress_drivers();
1089 CU_ASSERT(rc
== -EINVAL
);
1091 /* rte_compressdev_start fails */
1092 ut_rte_compressdev_queue_pair_setup
= 0;
1093 ut_rte_compressdev_start
= -1;
1094 rc
= vbdev_init_compress_drivers();
1095 CU_ASSERT(rc
== -1);
1097 /* rte_compressdev_private_xform_create() fails */
1098 ut_rte_compressdev_start
= 0;
1099 ut_rte_compressdev_private_xform_create
= -2;
1100 rc
= vbdev_init_compress_drivers();
1101 CU_ASSERT(rc
== -2);
1104 ut_rte_compressdev_private_xform_create
= 0;
1105 rc
= vbdev_init_compress_drivers();
1107 spdk_mempool_free((struct spdk_mempool
*)g_mbuf_mp
);
1111 test_supported_io(void)
1117 main(int argc
, char **argv
)
1119 CU_pSuite suite
= NULL
;
1120 unsigned int num_failures
;
1122 CU_set_error_action(CUEA_ABORT
);
1123 CU_initialize_registry();
1125 suite
= CU_add_suite("compress", test_setup
, test_cleanup
);
1126 CU_ADD_TEST(suite
, test_compress_operation
);
1127 CU_ADD_TEST(suite
, test_compress_operation_cross_boundary
);
1128 CU_ADD_TEST(suite
, test_vbdev_compress_submit_request
);
1129 CU_ADD_TEST(suite
, test_passthru
);
1130 CU_ADD_TEST(suite
, test_initdrivers
);
1131 CU_ADD_TEST(suite
, test_supported_io
);
1132 CU_ADD_TEST(suite
, test_poller
);
1133 CU_ADD_TEST(suite
, test_reset
);
1135 CU_basic_set_mode(CU_BRM_VERBOSE
);
1136 CU_basic_run_tests();
1137 num_failures
= CU_get_number_of_failures();
1138 CU_cleanup_registry();
1139 return num_failures
;