Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2019 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2022 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 : : #include "spdk/reduce.h"
15 : :
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_bdev_io *g_bdev_io;
28 : : struct spdk_io_channel *g_io_ch;
29 : : struct vbdev_compress g_comp_bdev;
30 : : struct comp_bdev_io *g_io_ctx;
31 : : struct comp_io_channel *g_comp_ch;
32 : :
33 : : static int ut_spdk_reduce_vol_op_complete_err = 0;
34 : : void
35 : 4 : spdk_reduce_vol_writev(struct spdk_reduce_vol *vol, struct iovec *iov, int iovcnt,
36 : : uint64_t offset, uint64_t length, spdk_reduce_vol_op_complete cb_fn,
37 : : void *cb_arg)
38 : : {
39 : 4 : cb_fn(cb_arg, ut_spdk_reduce_vol_op_complete_err);
40 : 4 : }
41 : :
42 : : void
43 : 4 : spdk_reduce_vol_readv(struct spdk_reduce_vol *vol, struct iovec *iov, int iovcnt,
44 : : uint64_t offset, uint64_t length, spdk_reduce_vol_op_complete cb_fn,
45 : : void *cb_arg)
46 : : {
47 : 4 : cb_fn(cb_arg, ut_spdk_reduce_vol_op_complete_err);
48 : 4 : }
49 : :
50 : : #include "bdev/compress/vbdev_compress.c"
51 : :
52 : : /* SPDK stubs */
53 [ # # ]: 0 : DEFINE_STUB(spdk_accel_get_opc_module_name, int, (enum spdk_accel_opcode opcode,
54 : : const char **module_name), 0);
55 [ # # ]: 0 : DEFINE_STUB(spdk_accel_get_io_channel, struct spdk_io_channel *, (void), (void *)0xfeedbeef);
56 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_get_aliases, const struct spdk_bdev_aliases_list *,
57 : : (const struct spdk_bdev *bdev), NULL);
58 : 2 : DEFINE_STUB_V(spdk_bdev_module_list_add, (struct spdk_bdev_module *bdev_module));
59 : 0 : DEFINE_STUB_V(spdk_bdev_free_io, (struct spdk_bdev_io *g_bdev_io));
60 [ # # # # ]: 0 : DEFINE_STUB(spdk_bdev_io_type_supported, bool, (struct spdk_bdev *bdev,
61 : : enum spdk_bdev_io_type io_type), 0);
62 : 0 : DEFINE_STUB_V(spdk_bdev_module_release_bdev, (struct spdk_bdev *bdev));
63 : 0 : DEFINE_STUB_V(spdk_bdev_close, (struct spdk_bdev_desc *desc));
64 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_get_name, const char *, (const struct spdk_bdev *bdev), 0);
65 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_desc *desc), 0);
66 : 0 : DEFINE_STUB_V(spdk_bdev_unregister, (struct spdk_bdev *bdev, spdk_bdev_unregister_cb cb_fn,
67 : : void *cb_arg));
68 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_open_ext, int, (const char *bdev_name, bool write,
69 : : spdk_bdev_event_cb_t event_cb,
70 : : void *event_ctx, struct spdk_bdev_desc **_desc), 0);
71 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_desc_get_bdev, struct spdk_bdev *, (struct spdk_bdev_desc *desc), NULL);
72 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_module_claim_bdev, int, (struct spdk_bdev *bdev, struct spdk_bdev_desc *desc,
73 : : struct spdk_bdev_module *module), 0);
74 : 0 : DEFINE_STUB_V(spdk_bdev_module_examine_done, (struct spdk_bdev_module *module));
75 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_register, int, (struct spdk_bdev *bdev), 0);
76 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_get_by_name, struct spdk_bdev *, (const char *bdev_name), NULL);
77 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_io_get_io_channel, struct spdk_io_channel *, (struct spdk_bdev_io *bdev_io),
78 : : 0);
79 [ # # ]: 0 : DEFINE_STUB(spdk_bdev_queue_io_wait, int, (struct spdk_bdev *bdev, struct spdk_io_channel *ch,
80 : : struct spdk_bdev_io_wait_entry *entry), 0);
81 : 0 : DEFINE_STUB_V(spdk_reduce_vol_unload, (struct spdk_reduce_vol *vol,
82 : : spdk_reduce_vol_op_complete cb_fn, void *cb_arg));
83 : 0 : DEFINE_STUB_V(spdk_reduce_vol_load, (struct spdk_reduce_backing_dev *backing_dev,
84 : : spdk_reduce_vol_op_with_handle_complete cb_fn, void *cb_arg));
85 [ # # ]: 0 : DEFINE_STUB(spdk_reduce_vol_get_params, const struct spdk_reduce_vol_params *,
86 : : (struct spdk_reduce_vol *vol), NULL);
87 [ # # ]: 0 : DEFINE_STUB(spdk_reduce_vol_get_pm_path, const char *,
88 : : (const struct spdk_reduce_vol *vol), NULL);
89 : 0 : DEFINE_STUB_V(spdk_reduce_vol_init, (struct spdk_reduce_vol_params *params,
90 : : struct spdk_reduce_backing_dev *backing_dev,
91 : : const char *pm_file_dir,
92 : : spdk_reduce_vol_op_with_handle_complete cb_fn, void *cb_arg));
93 : 0 : DEFINE_STUB_V(spdk_reduce_vol_destroy, (struct spdk_reduce_backing_dev *backing_dev,
94 : : spdk_reduce_vol_op_complete cb_fn, void *cb_arg));
95 : :
96 : : int g_small_size_counter = 0;
97 : : int g_small_size_modify = 0;
98 : : uint64_t g_small_size = 0;
99 : : uint64_t
100 : 0 : spdk_vtophys(const void *buf, uint64_t *size)
101 : : {
102 : 0 : g_small_size_counter++;
103 [ # # ]: 0 : if (g_small_size_counter == g_small_size_modify) {
104 : 0 : *size = g_small_size;
105 : 0 : g_small_size_counter = 0;
106 : 0 : g_small_size_modify = 0;
107 : : }
108 : 0 : return (uint64_t)buf;
109 : : }
110 : :
111 : : void
112 : 4 : spdk_bdev_io_get_buf(struct spdk_bdev_io *bdev_io, spdk_bdev_io_get_buf_cb cb, uint64_t len)
113 : : {
114 : 4 : cb(g_io_ch, g_bdev_io, true);
115 : 4 : }
116 : :
117 : : /* Mock these functions to call the callback and then return the value we require */
118 : : int ut_spdk_bdev_readv_blocks = 0;
119 : : int
120 : 0 : spdk_bdev_readv_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
121 : : struct iovec *iov, int iovcnt,
122 : : uint64_t offset_blocks, uint64_t num_blocks,
123 : : spdk_bdev_io_completion_cb cb, void *cb_arg)
124 : : {
125 : 0 : cb(g_bdev_io, !ut_spdk_bdev_readv_blocks, cb_arg);
126 : 0 : return ut_spdk_bdev_readv_blocks;
127 : : }
128 : :
129 : : int ut_spdk_bdev_writev_blocks = 0;
130 : : bool ut_spdk_bdev_writev_blocks_mocked = false;
131 : : int
132 : 0 : spdk_bdev_writev_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
133 : : struct iovec *iov, int iovcnt,
134 : : uint64_t offset_blocks, uint64_t num_blocks,
135 : : spdk_bdev_io_completion_cb cb, void *cb_arg)
136 : : {
137 : 0 : cb(g_bdev_io, !ut_spdk_bdev_writev_blocks, cb_arg);
138 : 0 : return ut_spdk_bdev_writev_blocks;
139 : : }
140 : :
141 : : int ut_spdk_bdev_unmap_blocks = 0;
142 : : bool ut_spdk_bdev_unmap_blocks_mocked = false;
143 : : int
144 : 0 : spdk_bdev_unmap_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
145 : : uint64_t offset_blocks, uint64_t num_blocks,
146 : : spdk_bdev_io_completion_cb cb, void *cb_arg)
147 : : {
148 : 0 : cb(g_bdev_io, !ut_spdk_bdev_unmap_blocks, cb_arg);
149 : 0 : return ut_spdk_bdev_unmap_blocks;
150 : : }
151 : :
152 : : int ut_spdk_bdev_flush_blocks = 0;
153 : : bool ut_spdk_bdev_flush_blocks_mocked = false;
154 : : int
155 : 0 : spdk_bdev_flush_blocks(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
156 : : uint64_t offset_blocks, uint64_t num_blocks, spdk_bdev_io_completion_cb cb,
157 : : void *cb_arg)
158 : : {
159 : 0 : cb(g_bdev_io, !ut_spdk_bdev_flush_blocks, cb_arg);
160 : 0 : return ut_spdk_bdev_flush_blocks;
161 : : }
162 : :
163 : : int ut_spdk_bdev_reset = 0;
164 : : bool ut_spdk_bdev_reset_mocked = false;
165 : : int
166 : 0 : spdk_bdev_reset(struct spdk_bdev_desc *desc, struct spdk_io_channel *ch,
167 : : spdk_bdev_io_completion_cb cb, void *cb_arg)
168 : : {
169 : 0 : cb(g_bdev_io, !ut_spdk_bdev_reset, cb_arg);
170 : 0 : return ut_spdk_bdev_reset;
171 : : }
172 : :
173 : : bool g_completion_called = false;
174 : : void
175 : 8 : spdk_bdev_io_complete(struct spdk_bdev_io *bdev_io, enum spdk_bdev_io_status status)
176 : : {
177 : 8 : bdev_io->internal.status = status;
178 : 8 : g_completion_called = true;
179 : 8 : }
180 : :
181 : : int
182 : 0 : spdk_accel_submit_compress(struct spdk_io_channel *ch, void *dst, uint64_t nbytes,
183 : : struct iovec *src_iovs, size_t src_iovcnt, uint32_t *output_size,
184 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
185 : : {
186 : :
187 : 0 : return 0;
188 : : }
189 : :
190 : : int
191 : 0 : spdk_accel_submit_decompress(struct spdk_io_channel *ch, struct iovec *dst_iovs, size_t dst_iovcnt,
192 : : struct iovec *src_iovs, size_t src_iovcnt, uint32_t *output_size,
193 : : spdk_accel_completion_cb cb_fn, void *cb_arg)
194 : : {
195 : :
196 : 0 : return 0;
197 : : }
198 : :
199 : : /* Global setup for all tests that share a bunch of preparation... */
200 : : static int
201 : 2 : test_setup(void)
202 : : {
203 : : struct spdk_thread *thread;
204 : :
205 : 2 : spdk_thread_lib_init(NULL, 0);
206 : :
207 : 2 : thread = spdk_thread_create(NULL, NULL);
208 : 2 : spdk_set_thread(thread);
209 : :
210 : 2 : g_comp_bdev.reduce_thread = thread;
211 : 2 : g_comp_bdev.backing_dev.unmap = _comp_reduce_unmap;
212 : 2 : g_comp_bdev.backing_dev.readv = _comp_reduce_readv;
213 : 2 : g_comp_bdev.backing_dev.writev = _comp_reduce_writev;
214 : 2 : g_comp_bdev.backing_dev.compress = _comp_reduce_compress;
215 : 2 : g_comp_bdev.backing_dev.decompress = _comp_reduce_decompress;
216 : 2 : g_comp_bdev.backing_dev.blocklen = 512;
217 : 2 : g_comp_bdev.backing_dev.blockcnt = 1024 * 16;
218 : 2 : g_comp_bdev.backing_dev.sgl_in = true;
219 : 2 : g_comp_bdev.backing_dev.sgl_out = true;
220 : :
221 : 2 : TAILQ_INIT(&g_comp_bdev.queued_comp_ops);
222 : :
223 : 2 : g_bdev_io = calloc(1, sizeof(struct spdk_bdev_io) + sizeof(struct comp_bdev_io));
224 : 2 : g_bdev_io->u.bdev.iovs = calloc(128, sizeof(struct iovec));
225 : 2 : g_bdev_io->bdev = &g_comp_bdev.comp_bdev;
226 : 2 : g_io_ch = calloc(1, sizeof(struct spdk_io_channel) + sizeof(struct comp_io_channel));
227 : 2 : g_io_ch->thread = thread;
228 : 2 : g_comp_ch = (struct comp_io_channel *)spdk_io_channel_get_ctx(g_io_ch);
229 : 2 : g_io_ctx = (struct comp_bdev_io *)g_bdev_io->driver_ctx;
230 : :
231 : 2 : g_io_ctx->comp_ch = g_comp_ch;
232 : 2 : g_io_ctx->comp_bdev = &g_comp_bdev;
233 : :
234 : 2 : return 0;
235 : : }
236 : :
237 : : /* Global teardown for all tests */
238 : : static int
239 : 2 : test_cleanup(void)
240 : : {
241 : : struct spdk_thread *thread;
242 : :
243 : 2 : free(g_bdev_io->u.bdev.iovs);
244 : 2 : free(g_bdev_io);
245 : 2 : free(g_io_ch);
246 : :
247 : 2 : thread = spdk_get_thread();
248 : 2 : spdk_thread_exit(thread);
249 [ + + ]: 4 : while (!spdk_thread_is_exited(thread)) {
250 : 2 : spdk_thread_poll(thread, 0, 0);
251 : : }
252 : 2 : spdk_thread_destroy(thread);
253 : :
254 : 2 : spdk_thread_lib_fini();
255 : :
256 : 2 : return 0;
257 : : }
258 : :
259 : : static void
260 : 2 : test_compress_operation(void)
261 : : {
262 : 2 : }
263 : :
264 : : static void
265 : 2 : test_compress_operation_cross_boundary(void)
266 : : {
267 : 2 : }
268 : :
269 : : static void
270 : 2 : test_vbdev_compress_submit_request(void)
271 : : {
272 : : /* Single element block size write */
273 : 2 : g_bdev_io->internal.status = SPDK_BDEV_IO_STATUS_FAILED;
274 : 2 : g_bdev_io->type = SPDK_BDEV_IO_TYPE_WRITE;
275 : 2 : g_completion_called = false;
276 : 2 : vbdev_compress_submit_request(g_io_ch, g_bdev_io);
277 : 2 : CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
278 [ - + ]: 2 : CU_ASSERT(g_completion_called == true);
279 : 2 : CU_ASSERT(g_io_ctx->orig_io == g_bdev_io);
280 : 2 : CU_ASSERT(g_io_ctx->comp_bdev == &g_comp_bdev);
281 : 2 : CU_ASSERT(g_io_ctx->comp_ch == g_comp_ch);
282 : :
283 : : /* same write but now fail it */
284 : 2 : ut_spdk_reduce_vol_op_complete_err = 1;
285 : 2 : g_completion_called = false;
286 : 2 : vbdev_compress_submit_request(g_io_ch, g_bdev_io);
287 : 2 : CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED);
288 [ - + ]: 2 : CU_ASSERT(g_completion_called == true);
289 : :
290 : : /* test a read success */
291 : 2 : g_bdev_io->type = SPDK_BDEV_IO_TYPE_READ;
292 : 2 : ut_spdk_reduce_vol_op_complete_err = 0;
293 : 2 : g_completion_called = false;
294 : 2 : vbdev_compress_submit_request(g_io_ch, g_bdev_io);
295 : 2 : CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_SUCCESS);
296 [ - + ]: 2 : CU_ASSERT(g_completion_called == true);
297 : :
298 : : /* test a read failure */
299 : 2 : ut_spdk_reduce_vol_op_complete_err = 1;
300 : 2 : g_completion_called = false;
301 : 2 : vbdev_compress_submit_request(g_io_ch, g_bdev_io);
302 : 2 : CU_ASSERT(g_bdev_io->internal.status == SPDK_BDEV_IO_STATUS_FAILED);
303 [ - + ]: 2 : CU_ASSERT(g_completion_called == true);
304 : 2 : }
305 : :
306 : : static void
307 : 2 : test_passthru(void)
308 : : {
309 : :
310 : 2 : }
311 : :
312 : : static void
313 : 2 : test_reset(void)
314 : : {
315 : : /* TODO: There are a few different ways to do this given that
316 : : * the code uses spdk_for_each_channel() to implement reset
317 : : * handling. SUbmitting w/o UT for this function for now and
318 : : * will follow up with something shortly.
319 : : */
320 : 2 : }
321 : :
322 : : static void
323 : 2 : test_supported_io(void)
324 : : {
325 : :
326 : 2 : }
327 : :
328 : : int
329 : 2 : main(int argc, char **argv)
330 : : {
331 : 2 : CU_pSuite suite = NULL;
332 : : unsigned int num_failures;
333 : :
334 : 2 : CU_initialize_registry();
335 : :
336 : 2 : suite = CU_add_suite("compress", test_setup, test_cleanup);
337 : 2 : CU_ADD_TEST(suite, test_compress_operation);
338 : 2 : CU_ADD_TEST(suite, test_compress_operation_cross_boundary);
339 : 2 : CU_ADD_TEST(suite, test_vbdev_compress_submit_request);
340 : 2 : CU_ADD_TEST(suite, test_passthru);
341 : 2 : CU_ADD_TEST(suite, test_supported_io);
342 : 2 : CU_ADD_TEST(suite, test_reset);
343 : :
344 : 2 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
345 : 2 : CU_cleanup_registry();
346 : 2 : return num_failures;
347 : : }
|