Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
3 : : */
4 : :
5 : : #include "spdk_internal/cunit.h"
6 : :
7 : : #include "common/lib/ut_multithread.c"
8 : : #include "unit/lib/json_mock.c"
9 : :
10 : : #include "spdk/config.h"
11 : :
12 : : #include "spdk/log.h"
13 : : #include "spdk/fsdev.h"
14 : : #include "spdk/fsdev_module.h"
15 : :
16 : : #define UT_UNIQUE 0xBEADBEAD
17 : : #define UT_FOBJECT ((struct spdk_fsdev_file_object *)0xDEADDEAD)
18 : : #define UT_FHANDLE ((struct spdk_fsdev_file_handle *)0xBEABBEAB)
19 : : #define UT_FNAME "ut_test.file"
20 : : #define UT_LNAME "ut_test.file.link"
21 : : #define UT_ANAME "xattr1.name"
22 : : #define UT_AVALUE "xattr1.val"
23 : : #define UT_NUM_LOOKUPS 11
24 : : #define UT_DATA_SIZE 22
25 : :
26 : :
27 : : #define UT_CALL_REC_MAX_CALLS 5
28 : : #define UT_CALL_REC_MAX_PARAMS 15
29 : : #define UT_CALL_REC_MAX_STR_SIZE 255
30 : :
31 : : #define UT_SUBMIT_IO_NUM_COMMON_PARAMS 4
32 : :
33 : : static uint64_t
34 : 310 : ut_hash(const void *buf, size_t size)
35 : : {
36 : 310 : uint64_t hash = 5381;
37 : 310 : const char *p = buf;
38 : : size_t i;
39 : :
40 [ + + ]: 27110 : for (i = 0; i < size; i++) {
41 : 26800 : hash = ((hash << 5) + hash) + (*p); /* hash * 33 + c */
42 : 26800 : p++;
43 : : }
44 : :
45 : 310 : return hash;
46 : : }
47 : :
48 : : struct ut_call_record {
49 : : struct {
50 : : void *func;
51 : : union {
52 : : uint64_t integer;
53 : : void *ptr;
54 : : char str[UT_CALL_REC_MAX_STR_SIZE + 1];
55 : : uint64_t hash;
56 : : } params[UT_CALL_REC_MAX_PARAMS];
57 : : size_t param_count;
58 : : } call[UT_CALL_REC_MAX_CALLS];
59 : : size_t count;
60 : : };
61 : :
62 : : static struct ut_call_record g_call_list;
63 : :
64 : : static inline void
65 : 555 : ut_calls_reset(void)
66 : : {
67 [ - + ]: 555 : memset(&g_call_list, 0, sizeof(g_call_list));
68 : 555 : }
69 : :
70 : : static inline void
71 : 1085 : ut_call_record_begin(void *pfunc)
72 : : {
73 [ - + ]: 1085 : SPDK_CU_ASSERT_FATAL(g_call_list.count < UT_CALL_REC_MAX_CALLS);
74 : 1085 : g_call_list.call[g_call_list.count].func = pfunc;
75 : 1085 : g_call_list.call[g_call_list.count].param_count = 0;
76 : 1085 : }
77 : :
78 : : static inline void
79 : 560 : ut_call_record_param_int(uint64_t val)
80 : : {
81 [ - + ]: 560 : SPDK_CU_ASSERT_FATAL(g_call_list.call[g_call_list.count].param_count < UT_CALL_REC_MAX_PARAMS);
82 : 560 : g_call_list.call[g_call_list.count].params[g_call_list.call[g_call_list.count].param_count].integer
83 : 560 : = val;
84 : 560 : g_call_list.call[g_call_list.count].param_count++;
85 : 560 : }
86 : :
87 : : static inline void
88 : 1545 : ut_call_record_param_ptr(void *ptr)
89 : : {
90 [ - + ]: 1545 : SPDK_CU_ASSERT_FATAL(g_call_list.call[g_call_list.count].param_count < UT_CALL_REC_MAX_PARAMS);
91 : 1545 : g_call_list.call[g_call_list.count].params[g_call_list.call[g_call_list.count].param_count].ptr =
92 : : ptr;
93 : 1545 : g_call_list.call[g_call_list.count].param_count++;
94 : 1545 : }
95 : :
96 : : static inline void
97 : 80 : ut_call_record_param_str(const char *str)
98 : : {
99 [ - + ]: 80 : SPDK_CU_ASSERT_FATAL(g_call_list.call[g_call_list.count].param_count < UT_CALL_REC_MAX_PARAMS);
100 : 80 : spdk_strcpy_pad(
101 : 80 : g_call_list.call[g_call_list.count].params[g_call_list.call[g_call_list.count].param_count].str,
102 : : str, UT_CALL_REC_MAX_STR_SIZE, 0);
103 : 80 : g_call_list.call[g_call_list.count].params[g_call_list.call[g_call_list.count].param_count].str[UT_CALL_REC_MAX_STR_SIZE]
104 : 80 : = 0;
105 : 80 : g_call_list.call[g_call_list.count].param_count++;
106 : 80 : }
107 : :
108 : : static inline void
109 : 15 : ut_call_record_param_hash(const void *buf, size_t size)
110 : : {
111 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(g_call_list.call[g_call_list.count].param_count < UT_CALL_REC_MAX_PARAMS);
112 : 30 : g_call_list.call[g_call_list.count].params[g_call_list.call[g_call_list.count].param_count].hash =
113 : 15 : ut_hash(buf, size);
114 : 15 : g_call_list.call[g_call_list.count].param_count++;
115 : 15 : }
116 : :
117 : : static inline size_t
118 : 170 : ut_call_record_get_current_param_count(void)
119 : : {
120 : 170 : return g_call_list.call[g_call_list.count].param_count;
121 : : }
122 : : static inline void
123 : 1085 : ut_call_record_end(void)
124 : : {
125 : 1085 : g_call_list.count++;
126 : 1085 : }
127 : :
128 : : static inline void
129 : 905 : ut_call_record_simple_param_ptr(void *pfunc, void *ptr)
130 : : {
131 : 905 : ut_call_record_begin(pfunc);
132 : 905 : ut_call_record_param_ptr(ptr);
133 : 905 : ut_call_record_end();
134 : 905 : }
135 : :
136 : : static inline size_t
137 : 370 : ut_calls_get_call_count(void)
138 : : {
139 : 370 : return g_call_list.count;
140 : : }
141 : :
142 : : static inline size_t
143 : 575 : ut_calls_get_param_count(size_t call_idx)
144 : : {
145 [ - + ]: 575 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
146 : 575 : return g_call_list.call[call_idx].param_count;
147 : : }
148 : :
149 : : static inline void *
150 : 575 : ut_calls_get_func(size_t call_idx)
151 : : {
152 [ - + ]: 575 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
153 : 575 : return g_call_list.call[call_idx].func;
154 : : }
155 : :
156 : : static inline uint64_t
157 : 570 : ut_calls_param_get_int(size_t call_idx, size_t param_idx)
158 : : {
159 [ - + ]: 570 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
160 [ - + ]: 570 : SPDK_CU_ASSERT_FATAL(param_idx < g_call_list.call[call_idx].param_count);
161 : 570 : return g_call_list.call[call_idx].params[param_idx].integer;
162 : : }
163 : :
164 : : static inline void *
165 : 1025 : ut_calls_param_get_ptr(size_t call_idx, size_t param_idx)
166 : : {
167 [ - + ]: 1025 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
168 [ - + ]: 1025 : SPDK_CU_ASSERT_FATAL(param_idx < g_call_list.call[call_idx].param_count);
169 : 1025 : return g_call_list.call[call_idx].params[param_idx].ptr;
170 : : }
171 : :
172 : : static inline const char *
173 : 80 : ut_calls_param_get_str(size_t call_idx, size_t param_idx)
174 : : {
175 [ - + ]: 80 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
176 [ - + ]: 80 : SPDK_CU_ASSERT_FATAL(param_idx < g_call_list.call[call_idx].param_count);
177 : 80 : return g_call_list.call[call_idx].params[param_idx].str;
178 : : }
179 : :
180 : : static inline uint64_t
181 : 15 : ut_calls_param_get_hash(size_t call_idx, size_t param_idx)
182 : : {
183 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(call_idx < g_call_list.count);
184 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(param_idx < g_call_list.call[call_idx].param_count);
185 : 15 : return g_call_list.call[call_idx].params[param_idx].hash;
186 : : }
187 : :
188 : : struct ut_fsdev {
189 : : struct spdk_fsdev fsdev;
190 : : int desired_io_status;
191 : : };
192 : :
193 : : struct ut_io_channel {
194 : : int reserved;
195 : : };
196 : :
197 : : struct spdk_fsdev_file_object {
198 : : int reserved;
199 : : };
200 : :
201 : : struct spdk_fsdev_file_handle {
202 : : int reserved;
203 : : };
204 : :
205 : : static inline struct ut_fsdev *
206 : 170 : fsdev_to_ut_fsdev(struct spdk_fsdev *fsdev)
207 : : {
208 : 170 : return SPDK_CONTAINEROF(fsdev, struct ut_fsdev, fsdev);
209 : : }
210 : :
211 : : static struct ut_io_channel *g_ut_io_channel = NULL;
212 : :
213 : : static int
214 : 175 : ut_fsdev_io_channel_create_cb(void *io_device, void *ctx_buf)
215 : : {
216 : 175 : struct ut_io_channel *ch = ctx_buf;
217 : :
218 : 175 : g_ut_io_channel = ch;
219 : :
220 : 175 : ut_call_record_simple_param_ptr(ut_fsdev_io_channel_create_cb, ctx_buf);
221 : :
222 : 175 : return 0;
223 : : }
224 : :
225 : : static void
226 : 175 : ut_fsdev_io_channel_destroy_cb(void *io_device, void *ctx_buf)
227 : : {
228 : 175 : g_ut_io_channel = NULL;
229 : :
230 : 175 : ut_call_record_simple_param_ptr(ut_fsdev_io_channel_destroy_cb, ctx_buf);
231 : 175 : }
232 : :
233 : : static int
234 : 5 : ut_fsdev_initialize(void)
235 : : {
236 : 5 : spdk_io_device_register(&g_call_list,
237 : : ut_fsdev_io_channel_create_cb, ut_fsdev_io_channel_destroy_cb,
238 : : sizeof(struct ut_io_channel), "ut_fsdev");
239 : :
240 : 5 : return 0;
241 : : }
242 : :
243 : : static void
244 : 5 : ut_fsdev_io_device_unregister_done(void *io_device)
245 : : {
246 : 5 : SPDK_NOTICELOG("ut_fsdev_io_device unregistred\n");
247 : 5 : }
248 : :
249 : : static void
250 : 5 : ut_fsdev_finish(void)
251 : : {
252 : 5 : spdk_io_device_unregister(&g_call_list, ut_fsdev_io_device_unregister_done);
253 : 5 : }
254 : :
255 : : static int
256 : 5 : ut_fsdev_get_ctx_size(void)
257 : : {
258 : 5 : return 0;
259 : : }
260 : :
261 : : static struct spdk_fsdev_module ut_fsdev_module = {
262 : : .name = "ut_fsdev",
263 : : .module_init = ut_fsdev_initialize,
264 : : .module_fini = ut_fsdev_finish,
265 : : .get_ctx_size = ut_fsdev_get_ctx_size,
266 : : };
267 : :
268 : 5 : SPDK_FSDEV_MODULE_REGISTER(ut_fsdev, &ut_fsdev_module);
269 : :
270 : : static int
271 : 190 : ut_fsdev_destruct(void *ctx)
272 : : {
273 : 190 : ut_call_record_simple_param_ptr(ut_fsdev_destruct, ctx);
274 : :
275 : 190 : return 0;
276 : : }
277 : :
278 : : static int ut_negotiate_opts_desired_err;
279 : : static struct spdk_fsdev_file_attr ut_fsdev_attr;
280 : : static struct spdk_fsdev_file_object ut_fsdev_fobject;
281 : : static struct iovec ut_iov[5];
282 : : static struct spdk_fsdev_file_statfs ut_statfs;
283 : : static char ut_buff[1024];
284 : : static bool ut_listxattr_size_only;
285 : : static uint64_t ut_readdir_offset;
286 : : static uint64_t ut_readdir_num_entries;
287 : : static uint64_t ut_readdir_num_entry_cb_calls;
288 : :
289 : : static void
290 : 170 : ut_fsdev_submit_request(struct spdk_io_channel *_ch, struct spdk_fsdev_io *fsdev_io)
291 : : {
292 : 170 : enum spdk_fsdev_io_type type = spdk_fsdev_io_get_type(fsdev_io);
293 : 170 : struct ut_fsdev *utfsdev = fsdev_to_ut_fsdev(fsdev_io->fsdev);
294 : 170 : struct ut_io_channel *ch = spdk_io_channel_get_ctx(_ch);
295 : 170 : uint64_t unique = spdk_fsdev_io_get_unique(fsdev_io);
296 : 170 : int res, i = 0;
297 : :
298 : 170 : CU_ASSERT(type >= 0 && type < __SPDK_FSDEV_IO_LAST);
299 : :
300 : 170 : ut_call_record_begin(ut_fsdev_submit_request);
301 : :
302 : : /* Common params */
303 : 170 : ut_call_record_param_int(type);
304 : : /* There's no unique for abort so we just add UT_UNIQUE to pass the test */
305 [ + + ]: 170 : ut_call_record_param_int((type != SPDK_FSDEV_IO_ABORT) ? unique : UT_UNIQUE);
306 : 170 : ut_call_record_param_ptr(ch);
307 : 170 : ut_call_record_param_ptr(utfsdev);
308 : :
309 : 170 : CU_ASSERT(ut_call_record_get_current_param_count() == UT_SUBMIT_IO_NUM_COMMON_PARAMS);
310 : :
311 [ + + + + : 170 : switch (type) {
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + - ]
312 : 10 : case SPDK_FSDEV_IO_LOOKUP:
313 : 10 : ut_call_record_param_str(fsdev_io->u_in.lookup.name);
314 : 10 : ut_call_record_param_ptr(fsdev_io->u_in.lookup.parent_fobject);
315 : 10 : fsdev_io->u_out.lookup.fobject = &ut_fsdev_fobject;
316 : 10 : fsdev_io->u_out.lookup.attr = ut_fsdev_attr;
317 : 10 : break;
318 : 5 : case SPDK_FSDEV_IO_FORGET:
319 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.forget.fobject);
320 : 5 : ut_call_record_param_int(fsdev_io->u_in.forget.nlookup);
321 : 5 : break;
322 : 5 : case SPDK_FSDEV_IO_GETATTR:
323 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.getattr.fobject);
324 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.getattr.fhandle);
325 : 5 : fsdev_io->u_out.getattr.attr = ut_fsdev_attr;
326 : 5 : break;
327 : 5 : case SPDK_FSDEV_IO_SETATTR:
328 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.setattr.fobject);
329 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.setattr.fhandle);
330 : 5 : ut_call_record_param_hash(&fsdev_io->u_in.setattr.attr, sizeof(fsdev_io->u_in.setattr.attr));
331 : 5 : ut_call_record_param_int(fsdev_io->u_in.setattr.to_set);
332 : 5 : fsdev_io->u_out.getattr.attr = ut_fsdev_attr;
333 : 5 : break;
334 : 5 : case SPDK_FSDEV_IO_READLINK:
335 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.readlink.fobject);
336 [ - + ]: 5 : fsdev_io->u_out.readlink.linkname = strdup(UT_FNAME);
337 [ - + ]: 5 : SPDK_CU_ASSERT_FATAL(fsdev_io->u_out.readlink.linkname != NULL);
338 : 5 : break;
339 : 5 : case SPDK_FSDEV_IO_SYMLINK:
340 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.symlink.parent_fobject);
341 : 5 : ut_call_record_param_str(fsdev_io->u_in.symlink.target);
342 : 5 : ut_call_record_param_str(fsdev_io->u_in.symlink.linkpath);
343 : 5 : ut_call_record_param_int(fsdev_io->u_in.symlink.euid);
344 : 5 : ut_call_record_param_int(fsdev_io->u_in.symlink.egid);
345 : 5 : fsdev_io->u_out.symlink.fobject = UT_FOBJECT + 1;
346 : 5 : fsdev_io->u_out.symlink.attr = ut_fsdev_attr;
347 : 5 : break;
348 : 5 : case SPDK_FSDEV_IO_MKNOD:
349 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.mknod.parent_fobject);
350 : 5 : ut_call_record_param_str(fsdev_io->u_in.mknod.name);
351 : 5 : ut_call_record_param_int(fsdev_io->u_in.mknod.mode);
352 : 5 : ut_call_record_param_int(fsdev_io->u_in.mknod.rdev);
353 : 5 : ut_call_record_param_int(fsdev_io->u_in.mknod.euid);
354 : 5 : ut_call_record_param_int(fsdev_io->u_in.mknod.egid);
355 : 5 : fsdev_io->u_out.mknod.fobject = UT_FOBJECT + 1;
356 : 5 : fsdev_io->u_out.mknod.attr = ut_fsdev_attr;
357 : 5 : break;
358 : 5 : case SPDK_FSDEV_IO_MKDIR:
359 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.mkdir.parent_fobject);
360 : 5 : ut_call_record_param_str(fsdev_io->u_in.mkdir.name);
361 : 5 : ut_call_record_param_int(fsdev_io->u_in.mkdir.mode);
362 : 5 : ut_call_record_param_int(fsdev_io->u_in.mkdir.euid);
363 : 5 : ut_call_record_param_int(fsdev_io->u_in.mkdir.egid);
364 : 5 : fsdev_io->u_out.mkdir.fobject = UT_FOBJECT + 1;
365 : 5 : fsdev_io->u_out.mkdir.attr = ut_fsdev_attr;
366 : 5 : break;
367 : 5 : case SPDK_FSDEV_IO_UNLINK:
368 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.unlink.parent_fobject);
369 : 5 : ut_call_record_param_str(fsdev_io->u_in.unlink.name);
370 : 5 : break;
371 : 5 : case SPDK_FSDEV_IO_RMDIR:
372 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.rmdir.parent_fobject);
373 : 5 : ut_call_record_param_str(fsdev_io->u_in.rmdir.name);
374 : 5 : break;
375 : 5 : case SPDK_FSDEV_IO_RENAME:
376 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.rename.parent_fobject);
377 : 5 : ut_call_record_param_str(fsdev_io->u_in.rename.name);
378 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.rename.new_parent_fobject);
379 : 5 : ut_call_record_param_str(fsdev_io->u_in.rename.new_name);
380 : 5 : ut_call_record_param_int(fsdev_io->u_in.rename.flags);
381 : 5 : break;
382 : 5 : case SPDK_FSDEV_IO_LINK:
383 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.link.fobject);
384 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.link.new_parent_fobject);
385 : 5 : ut_call_record_param_str(fsdev_io->u_in.link.name);
386 : 5 : fsdev_io->u_out.link.fobject = UT_FOBJECT + 1;
387 : 5 : fsdev_io->u_out.link.attr = ut_fsdev_attr;
388 : 5 : break;
389 : 5 : case SPDK_FSDEV_IO_OPEN:
390 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.open.fobject);
391 : 5 : ut_call_record_param_int(fsdev_io->u_in.open.flags);
392 : 5 : fsdev_io->u_out.open.fhandle = UT_FHANDLE;
393 : 5 : break;
394 : 5 : case SPDK_FSDEV_IO_READ:
395 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.read.fobject);
396 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.read.fhandle);
397 : 5 : ut_call_record_param_int(fsdev_io->u_in.read.size);
398 : 5 : ut_call_record_param_int(fsdev_io->u_in.read.offs);
399 : 5 : ut_call_record_param_int(fsdev_io->u_in.read.flags);
400 : 5 : ut_call_record_param_hash(fsdev_io->u_in.read.iov,
401 : 5 : fsdev_io->u_in.read.iovcnt * sizeof(fsdev_io->u_in.read.iov[0]));
402 : 5 : ut_call_record_param_int(fsdev_io->u_in.read.iovcnt);
403 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.read.opts);
404 : 5 : fsdev_io->u_out.read.data_size = UT_DATA_SIZE;
405 : 5 : break;
406 : 5 : case SPDK_FSDEV_IO_WRITE:
407 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.write.fobject);
408 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.write.fhandle);
409 : 5 : ut_call_record_param_int(fsdev_io->u_in.write.size);
410 : 5 : ut_call_record_param_int(fsdev_io->u_in.write.offs);
411 : 5 : ut_call_record_param_int(fsdev_io->u_in.write.flags);
412 : 5 : ut_call_record_param_hash(fsdev_io->u_in.write.iov,
413 : 5 : fsdev_io->u_in.write.iovcnt * sizeof(fsdev_io->u_in.write.iov[0]));
414 : 5 : ut_call_record_param_int(fsdev_io->u_in.write.iovcnt);
415 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.write.opts);
416 : 5 : fsdev_io->u_out.write.data_size = UT_DATA_SIZE;
417 : 5 : break;
418 : 5 : case SPDK_FSDEV_IO_STATFS:
419 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.statfs.fobject);
420 : 5 : fsdev_io->u_out.statfs.statfs = ut_statfs;
421 : 5 : break;
422 : 5 : case SPDK_FSDEV_IO_RELEASE:
423 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.release.fobject);
424 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.release.fhandle);
425 : 5 : break;
426 : 5 : case SPDK_FSDEV_IO_FSYNC:
427 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fsync.fobject);
428 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fsync.fhandle);
429 [ - + ]: 5 : ut_call_record_param_int(fsdev_io->u_in.fsync.datasync);
430 : 5 : break;
431 : 5 : case SPDK_FSDEV_IO_SETXATTR:
432 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.setxattr.fobject);
433 : 5 : ut_call_record_param_str(fsdev_io->u_in.setxattr.name);
434 : 5 : ut_call_record_param_str(fsdev_io->u_in.setxattr.value);
435 : 5 : ut_call_record_param_int(fsdev_io->u_in.setxattr.size);
436 : 5 : ut_call_record_param_int(fsdev_io->u_in.setxattr.flags);
437 : 5 : break;
438 : 5 : case SPDK_FSDEV_IO_GETXATTR:
439 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.getxattr.fobject);
440 : 5 : ut_call_record_param_str(fsdev_io->u_in.getxattr.name);
441 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.getxattr.buffer);
442 : 5 : ut_call_record_param_int(fsdev_io->u_in.getxattr.size);
443 : 5 : spdk_strcpy_pad(fsdev_io->u_in.getxattr.buffer, UT_AVALUE,
444 : 5 : fsdev_io->u_in.getxattr.size - 1, 0);
445 : 5 : fsdev_io->u_out.getxattr.value_size = sizeof(UT_AVALUE);
446 : 5 : break;
447 : 10 : case SPDK_FSDEV_IO_LISTXATTR:
448 : 10 : ut_call_record_param_ptr(fsdev_io->u_in.listxattr.fobject);
449 : 10 : ut_call_record_param_ptr(fsdev_io->u_in.listxattr.buffer);
450 : 10 : ut_call_record_param_int(fsdev_io->u_in.listxattr.size);
451 : :
452 : 10 : fsdev_io->u_out.listxattr.size_only = fsdev_io->u_in.listxattr.buffer == NULL;
453 : 10 : fsdev_io->u_out.listxattr.data_size = (sizeof(ut_buff) / sizeof(UT_ANAME)) * sizeof(UT_ANAME);
454 : :
455 [ + + + + ]: 10 : if (!fsdev_io->u_out.listxattr.size_only) {
456 : 5 : size_t size = fsdev_io->u_in.listxattr.size;
457 : 5 : char *p = fsdev_io->u_in.listxattr.buffer;
458 : :
459 [ + + ]: 430 : while (size >= sizeof(UT_ANAME)) {
460 [ - + - + ]: 425 : memcpy(p, UT_ANAME, sizeof(UT_ANAME));
461 : 425 : p += sizeof(UT_ANAME);
462 : 425 : size -= sizeof(UT_ANAME);
463 : : }
464 : : }
465 : 10 : break;
466 : 5 : case SPDK_FSDEV_IO_REMOVEXATTR:
467 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.removexattr.fobject);
468 : 5 : ut_call_record_param_str(fsdev_io->u_in.removexattr.name);
469 : 5 : break;
470 : 5 : case SPDK_FSDEV_IO_FLUSH:
471 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.flush.fobject);
472 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.flush.fhandle);
473 : 5 : break;
474 : 5 : case SPDK_FSDEV_IO_OPENDIR:
475 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.opendir.fobject);
476 : 5 : ut_call_record_param_int(fsdev_io->u_in.opendir.flags);
477 : 5 : fsdev_io->u_out.opendir.fhandle = UT_FHANDLE;
478 : 5 : break;
479 : 5 : case SPDK_FSDEV_IO_READDIR:
480 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.readdir.fobject);
481 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.readdir.fhandle);
482 : 5 : ut_call_record_param_int(fsdev_io->u_in.readdir.offset);
483 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.readdir.usr_entry_cb_fn);
484 : :
485 : : do {
486 : 100 : fsdev_io->u_out.readdir.fobject = UT_FOBJECT + i;
487 : 100 : fsdev_io->u_out.readdir.attr = ut_fsdev_attr;
488 : 100 : fsdev_io->u_out.readdir.name = UT_FNAME;
489 : 100 : fsdev_io->u_out.readdir.offset = ut_readdir_offset + i;
490 : 100 : res = fsdev_io->u_in.readdir.entry_cb_fn(fsdev_io, fsdev_io->internal.cb_arg);
491 : 100 : i++;
492 [ + + ]: 100 : } while (!res);
493 : :
494 : 5 : break;
495 : 5 : case SPDK_FSDEV_IO_RELEASEDIR:
496 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.releasedir.fobject);
497 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.releasedir.fhandle);
498 : 5 : break;
499 : 5 : case SPDK_FSDEV_IO_FSYNCDIR:
500 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fsyncdir.fobject);
501 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fsyncdir.fhandle);
502 [ - + ]: 5 : ut_call_record_param_int(fsdev_io->u_in.fsyncdir.datasync);
503 : 5 : break;
504 : 5 : case SPDK_FSDEV_IO_FLOCK:
505 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.flock.fobject);
506 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.flock.fhandle);
507 : 5 : ut_call_record_param_int(fsdev_io->u_in.flock.operation);
508 : 5 : break;
509 : 5 : case SPDK_FSDEV_IO_CREATE:
510 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.create.parent_fobject);
511 : 5 : ut_call_record_param_str(fsdev_io->u_in.create.name);
512 : 5 : ut_call_record_param_int(fsdev_io->u_in.create.mode);
513 : 5 : ut_call_record_param_int(fsdev_io->u_in.create.flags);
514 : 5 : ut_call_record_param_int(fsdev_io->u_in.create.umask);
515 : 5 : ut_call_record_param_int(fsdev_io->u_in.create.euid);
516 : 5 : ut_call_record_param_int(fsdev_io->u_in.create.egid);
517 : 5 : fsdev_io->u_out.create.fobject = UT_FOBJECT + 1;
518 : 5 : fsdev_io->u_out.create.fhandle = UT_FHANDLE;
519 : 5 : fsdev_io->u_out.create.attr = ut_fsdev_attr;
520 : 5 : break;
521 : 5 : case SPDK_FSDEV_IO_ABORT:
522 : 5 : ut_call_record_param_int(fsdev_io->u_in.abort.unique_to_abort);
523 : 5 : break;
524 : 5 : case SPDK_FSDEV_IO_FALLOCATE:
525 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fallocate.fobject);
526 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.fallocate.fhandle);
527 : 5 : ut_call_record_param_int(fsdev_io->u_in.fallocate.mode);
528 : 5 : ut_call_record_param_int(fsdev_io->u_in.fallocate.offset);
529 : 5 : ut_call_record_param_int(fsdev_io->u_in.fallocate.length);
530 : 5 : break;
531 : 5 : case SPDK_FSDEV_IO_COPY_FILE_RANGE:
532 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.copy_file_range.fobject_in);
533 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.copy_file_range.fhandle_in);
534 : 5 : ut_call_record_param_int(fsdev_io->u_in.copy_file_range.off_in);
535 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.copy_file_range.fobject_out);
536 : 5 : ut_call_record_param_ptr(fsdev_io->u_in.copy_file_range.fhandle_out);
537 : 5 : ut_call_record_param_int(fsdev_io->u_in.copy_file_range.off_out);
538 : 5 : ut_call_record_param_int(fsdev_io->u_in.copy_file_range.len);
539 : 5 : ut_call_record_param_int(fsdev_io->u_in.copy_file_range.flags);
540 : 5 : fsdev_io->u_out.copy_file_range.data_size = UT_DATA_SIZE;
541 : 5 : break;
542 : 0 : case __SPDK_FSDEV_IO_LAST:
543 : : default:
544 : 0 : break;
545 : : }
546 : :
547 : 170 : ut_call_record_end();
548 : :
549 : 170 : spdk_fsdev_io_complete(fsdev_io, utfsdev->desired_io_status);
550 : 170 : }
551 : :
552 : : static struct spdk_io_channel *
553 : 175 : ut_fsdev_get_io_channel(void *ctx)
554 : : {
555 : 175 : ut_call_record_simple_param_ptr(ut_fsdev_get_io_channel, ctx);
556 : :
557 : 175 : return spdk_get_io_channel(&g_call_list);
558 : : }
559 : :
560 : : static int
561 : 10 : ut_fsdev_negotiate_opts(void *ctx, struct spdk_fsdev_open_opts *opts)
562 : : {
563 : 10 : ut_call_record_begin(ut_fsdev_negotiate_opts);
564 : 10 : ut_call_record_param_ptr(ctx);
565 : 10 : ut_call_record_param_ptr(opts);
566 : 10 : ut_call_record_end();
567 : :
568 [ + + ]: 10 : if (!ut_negotiate_opts_desired_err) {
569 : 5 : opts->max_write = opts->max_write / 2;
570 : 5 : opts->writeback_cache_enabled = !opts->writeback_cache_enabled;
571 : : }
572 : :
573 : 10 : return ut_negotiate_opts_desired_err;
574 : : }
575 : :
576 : : static void
577 : 0 : ut_fsdev_write_config_json(struct spdk_fsdev *fsdev, struct spdk_json_write_ctx *w)
578 : : {
579 : :
580 : 0 : }
581 : :
582 : : static int
583 : 0 : ut_fsdev_get_memory_domains(void *ctx, struct spdk_memory_domain **domains,
584 : : int array_size)
585 : : {
586 : 0 : return 0;
587 : : }
588 : :
589 : : static const struct spdk_fsdev_fn_table ut_fdev_fn_table = {
590 : : .destruct = ut_fsdev_destruct,
591 : : .submit_request = ut_fsdev_submit_request,
592 : : .get_io_channel = ut_fsdev_get_io_channel,
593 : : .negotiate_opts = ut_fsdev_negotiate_opts,
594 : : .write_config_json = ut_fsdev_write_config_json,
595 : : .get_memory_domains = ut_fsdev_get_memory_domains,
596 : : };
597 : :
598 : : static void
599 : 190 : ut_fsdev_free(struct ut_fsdev *ufsdev)
600 : : {
601 : 190 : free(ufsdev->fsdev.name);
602 : 190 : free(ufsdev);
603 : 190 : }
604 : :
605 : : static void
606 : 190 : ut_fsdev_unregister_done(void *cb_arg, int rc)
607 : : {
608 : 190 : struct ut_fsdev *ufsdev = cb_arg;
609 : :
610 : 190 : ut_call_record_simple_param_ptr(ut_fsdev_unregister_done, cb_arg);
611 : :
612 : 190 : ut_fsdev_free(ufsdev);
613 : 190 : }
614 : :
615 : : static void
616 : 190 : ut_fsdev_destroy(struct ut_fsdev *utfsdev)
617 : : {
618 : 190 : ut_calls_reset();
619 : 190 : spdk_fsdev_unregister(&utfsdev->fsdev, ut_fsdev_unregister_done, utfsdev);
620 : 190 : poll_thread(0);
621 : :
622 : 190 : CU_ASSERT(ut_calls_get_call_count() == 2);
623 : :
624 : 190 : CU_ASSERT(ut_calls_get_func(0) == ut_fsdev_destruct);
625 : 190 : CU_ASSERT(ut_calls_get_param_count(0) == 1);
626 : 190 : CU_ASSERT(ut_calls_param_get_ptr(0, 0) == utfsdev);
627 : :
628 : 190 : CU_ASSERT(ut_calls_get_func(1) == ut_fsdev_unregister_done);
629 : 190 : CU_ASSERT(ut_calls_get_param_count(1) == 1);
630 : 190 : CU_ASSERT(ut_calls_param_get_ptr(1, 0) == utfsdev);
631 : 190 : }
632 : :
633 : : static struct ut_fsdev *
634 : 190 : ut_fsdev_create(const char *name)
635 : : {
636 : : struct ut_fsdev *ufsdev;
637 : : int rc;
638 : :
639 : 190 : ufsdev = calloc(1, sizeof(*ufsdev));
640 [ - + ]: 190 : if (!ufsdev) {
641 : 0 : SPDK_ERRLOG("Could not allocate ut_fsdev\n");
642 : 0 : return NULL;
643 : : }
644 : :
645 [ - + ]: 190 : ufsdev->fsdev.name = strdup(name);
646 [ - + ]: 190 : if (!ufsdev->fsdev.name) {
647 : 0 : SPDK_ERRLOG("Could not strdup name %s\n", name);
648 : 0 : free(ufsdev);
649 : 0 : return NULL;
650 : : }
651 : :
652 : 190 : ufsdev->fsdev.ctxt = ufsdev;
653 : 190 : ufsdev->fsdev.fn_table = &ut_fdev_fn_table;
654 : 190 : ufsdev->fsdev.module = &ut_fsdev_module;
655 : :
656 : 190 : rc = spdk_fsdev_register(&ufsdev->fsdev);
657 [ - + ]: 190 : if (rc) {
658 : 0 : ut_fsdev_free(ufsdev);
659 : 0 : return NULL;
660 : : }
661 : :
662 : 190 : return ufsdev;
663 : : }
664 : :
665 : : static void
666 : 5 : ut_fsdev_initialize_complete(void *cb_arg, int rc)
667 : : {
668 : 5 : bool *completed = cb_arg;
669 : :
670 : 5 : *completed = true;
671 : 5 : }
672 : :
673 : : static int
674 : 5 : ut_fsdev_setup(void)
675 : : {
676 : 5 : bool completed = false;
677 : :
678 : 5 : spdk_fsdev_initialize(ut_fsdev_initialize_complete, &completed);
679 : :
680 : 5 : poll_thread(0);
681 : :
682 [ - + - + ]: 5 : if (!completed) {
683 : 0 : SPDK_ERRLOG("No spdk_fsdev_initialize callback arrived\n");
684 : 0 : return EINVAL;
685 : : }
686 : :
687 : 5 : return 0;
688 : : }
689 : :
690 : : static void
691 : 5 : ut_fsdev_teardown_complete(void *cb_arg)
692 : : {
693 : 5 : bool *completed = cb_arg;
694 : :
695 : 5 : *completed = true;
696 : 5 : }
697 : :
698 : : static int
699 : 5 : ut_fsdev_teardown(void)
700 : : {
701 : 5 : bool completed = false;
702 : 5 : spdk_fsdev_finish(ut_fsdev_teardown_complete, &completed);
703 : :
704 : 5 : poll_thread(0);
705 : :
706 [ - + - + ]: 5 : if (!completed) {
707 : 0 : SPDK_ERRLOG("No spdk_fsdev_finish callback arrived\n");
708 : 0 : return EINVAL;
709 : : }
710 : :
711 : 5 : return 0;
712 : : }
713 : :
714 : : static void
715 : 0 : fsdev_event_cb(enum spdk_fsdev_event_type type, struct spdk_fsdev *fsdev,
716 : : void *event_ctx)
717 : : {
718 : 0 : SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type);
719 : 0 : }
720 : :
721 : : static void
722 : 15 : ut_fsdev_test_open_close(bool with_opts, bool opts_negotiation_fails)
723 : : {
724 : : struct ut_fsdev *utfsdev;
725 : 12 : struct spdk_fsdev_desc *fsdev_desc;
726 : 15 : struct spdk_fsdev_open_opts opts, *popts = NULL;
727 : : int rc;
728 : :
729 : 15 : utfsdev = ut_fsdev_create("utfsdev0");
730 : 15 : CU_ASSERT(utfsdev != NULL);
731 : :
732 [ - + - + ]: 15 : CU_ASSERT(!strcmp(spdk_fsdev_get_module_name(&utfsdev->fsdev), ut_fsdev_module.name));
733 [ - + ]: 15 : CU_ASSERT(!strcmp(spdk_fsdev_get_name(&utfsdev->fsdev), "utfsdev0"));
734 : :
735 [ + + ]: 15 : if (with_opts) {
736 : 10 : memset(&opts, 0, sizeof(opts));
737 : 10 : opts.opts_size = sizeof(opts);
738 : 10 : opts.max_write = UINT32_MAX;
739 : 10 : opts.writeback_cache_enabled = true;
740 : 10 : popts = &opts;
741 [ + + ]: 10 : ut_negotiate_opts_desired_err = opts_negotiation_fails ? EINVAL : 0;
742 : : } else {
743 : 5 : ut_negotiate_opts_desired_err = 0;
744 : : }
745 : :
746 : 15 : ut_calls_reset();
747 : 15 : rc = spdk_fsdev_open("utfsdev0", fsdev_event_cb, NULL, popts, &fsdev_desc);
748 [ + + + + ]: 15 : if (!with_opts || !opts_negotiation_fails) {
749 : 10 : CU_ASSERT(rc == 0);
750 : 10 : CU_ASSERT(fsdev_desc != NULL);
751 : 10 : CU_ASSERT(spdk_fsdev_desc_get_fsdev(fsdev_desc) == &utfsdev->fsdev);
752 : : } else {
753 : 5 : CU_ASSERT(rc == ut_negotiate_opts_desired_err);
754 : 5 : CU_ASSERT(fsdev_desc == NULL);
755 : : }
756 : :
757 [ + + ]: 15 : if (with_opts) {
758 : 10 : CU_ASSERT(ut_calls_get_func(0) == ut_fsdev_negotiate_opts);
759 : 10 : CU_ASSERT(ut_calls_get_param_count(0) == 2);
760 : 10 : CU_ASSERT(ut_calls_param_get_ptr(0, 0) == utfsdev);
761 : 10 : CU_ASSERT(ut_calls_param_get_ptr(0, 1) == popts);
762 : :
763 [ + + ]: 10 : if (!opts_negotiation_fails) {
764 : 5 : CU_ASSERT(opts.max_write == UINT32_MAX / 2);
765 : 5 : CU_ASSERT(opts.writeback_cache_enabled == false);
766 : : }
767 : : }
768 : :
769 [ + + ]: 15 : if (fsdev_desc) {
770 : 10 : spdk_fsdev_close(fsdev_desc);
771 : : }
772 : :
773 : 15 : ut_fsdev_destroy(utfsdev);
774 : 15 : }
775 : :
776 : : static void
777 : 5 : ut_fsdev_test_open_close_no_opts(void)
778 : : {
779 : 5 : ut_fsdev_test_open_close(false, false);
780 : 5 : }
781 : :
782 : : static void
783 : 5 : ut_fsdev_test_open_close_good_opts(void)
784 : : {
785 : 5 : ut_fsdev_test_open_close(true, false);
786 : 5 : }
787 : :
788 : : static void
789 : 5 : ut_fsdev_test_open_close_bad_opts(void)
790 : : {
791 : 5 : ut_fsdev_test_open_close(true, true);
792 : 5 : }
793 : :
794 : : static void
795 : 5 : ut_fsdev_test_set_opts(void)
796 : : {
797 : 4 : struct spdk_fsdev_opts old_opts;
798 : 4 : struct spdk_fsdev_opts new_opts;
799 : : int rc;
800 : :
801 : 5 : rc = spdk_fsdev_set_opts(NULL);
802 : 5 : CU_ASSERT(rc == -EINVAL);
803 : :
804 : 5 : new_opts.opts_size = 0;
805 : 5 : rc = spdk_fsdev_set_opts(&new_opts);
806 : 5 : CU_ASSERT(rc == -EINVAL);
807 : :
808 : 5 : old_opts.opts_size = sizeof(old_opts);
809 : 5 : rc = spdk_fsdev_get_opts(&old_opts, sizeof(old_opts));
810 : 5 : CU_ASSERT(rc == 0);
811 : :
812 : 5 : new_opts.opts_size = sizeof(new_opts);
813 : 5 : new_opts.fsdev_io_pool_size = old_opts.fsdev_io_pool_size * 2;
814 : 5 : new_opts.fsdev_io_cache_size = old_opts.fsdev_io_cache_size * 2;
815 : 5 : rc = spdk_fsdev_set_opts(&new_opts);
816 : 5 : CU_ASSERT(rc == 0);
817 : :
818 : 5 : rc = spdk_fsdev_get_opts(&new_opts, sizeof(new_opts));
819 : 5 : CU_ASSERT(rc == 0);
820 : 5 : CU_ASSERT(old_opts.fsdev_io_pool_size * 2 == new_opts.fsdev_io_pool_size);
821 : 5 : CU_ASSERT(old_opts.fsdev_io_cache_size * 2 == new_opts.fsdev_io_cache_size);
822 : 5 : }
823 : :
824 : : static void
825 : 5 : ut_fsdev_test_get_io_channel(void)
826 : : {
827 : : struct ut_fsdev *utfsdev;
828 : : struct spdk_io_channel *ch;
829 : 4 : struct spdk_fsdev_desc *fsdev_desc;
830 : : struct ut_io_channel *ut_ch;
831 : : int rc;
832 : :
833 : 5 : utfsdev = ut_fsdev_create("utfsdev0");
834 : 5 : CU_ASSERT(utfsdev != NULL);
835 : :
836 : 5 : rc = spdk_fsdev_open("utfsdev0", fsdev_event_cb, NULL, NULL, &fsdev_desc);
837 : 5 : CU_ASSERT(rc == 0);
838 : 5 : CU_ASSERT(fsdev_desc != NULL);
839 : 5 : CU_ASSERT(spdk_fsdev_desc_get_fsdev(fsdev_desc) == &utfsdev->fsdev);
840 : :
841 : 5 : ut_calls_reset();
842 : 5 : ch = spdk_fsdev_get_io_channel(fsdev_desc);
843 : 5 : CU_ASSERT(ch != NULL);
844 : 5 : CU_ASSERT(ut_calls_get_call_count() == 2);
845 : :
846 : 5 : CU_ASSERT(ut_calls_get_func(0) == ut_fsdev_get_io_channel);
847 : 5 : CU_ASSERT(ut_calls_get_param_count(0) == 1);
848 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, 0) == utfsdev);
849 : :
850 : 5 : CU_ASSERT(ut_calls_get_func(1) == ut_fsdev_io_channel_create_cb);
851 : 5 : CU_ASSERT(ut_calls_get_param_count(1) == 1);
852 : 5 : ut_ch = (struct ut_io_channel *)ut_calls_param_get_ptr(1, 0);
853 : :
854 : 5 : ut_calls_reset();
855 : 5 : spdk_put_io_channel(ch);
856 : 5 : poll_thread(0);
857 : 5 : CU_ASSERT(ut_calls_get_call_count() == 1);
858 : :
859 : 5 : CU_ASSERT(ut_calls_get_func(0) == ut_fsdev_io_channel_destroy_cb);
860 : 5 : CU_ASSERT(ut_calls_get_param_count(0) == 1);
861 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, 0) == ut_ch);
862 : :
863 : 5 : spdk_fsdev_close(fsdev_desc);
864 : :
865 : 5 : ut_fsdev_destroy(utfsdev);
866 : 5 : }
867 : :
868 : : typedef int (*execute_clb)(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
869 : : struct spdk_fsdev_desc *fsdev_desc, int *status);
870 : : typedef void (*check_clb)(void);
871 : :
872 : : static void
873 : 170 : ut_fsdev_test_io(enum spdk_fsdev_io_type type, int desired_io_status, size_t num_priv_params,
874 : : execute_clb execute_cb, check_clb check_cb)
875 : : {
876 : : struct ut_fsdev *utfsdev;
877 : : struct spdk_io_channel *ch;
878 : 136 : struct spdk_fsdev_desc *fsdev_desc;
879 : : int rc;
880 : 170 : int status = -1;
881 : :
882 : 170 : utfsdev = ut_fsdev_create("utfsdev0");
883 : 170 : CU_ASSERT(utfsdev != NULL);
884 : :
885 : 170 : rc = spdk_fsdev_open("utfsdev0", fsdev_event_cb, NULL, NULL, &fsdev_desc);
886 : 170 : CU_ASSERT(rc == 0);
887 : 170 : CU_ASSERT(fsdev_desc != NULL);
888 : :
889 : 170 : ch = spdk_fsdev_get_io_channel(fsdev_desc);
890 : 170 : CU_ASSERT(ch != NULL);
891 : :
892 : 170 : ut_calls_reset();
893 : 170 : utfsdev->desired_io_status = desired_io_status;
894 : 170 : rc = execute_cb(utfsdev, ch, fsdev_desc, &status);
895 : 170 : CU_ASSERT(rc == 0);
896 : :
897 : 170 : poll_thread(0);
898 : 170 : CU_ASSERT(status == desired_io_status);
899 : 170 : CU_ASSERT(ut_calls_get_call_count() == 1);
900 : 170 : CU_ASSERT(ut_calls_get_func(0) == ut_fsdev_submit_request);
901 : 170 : CU_ASSERT(ut_calls_get_param_count(0) == UT_SUBMIT_IO_NUM_COMMON_PARAMS + num_priv_params);
902 : :
903 : : /* Common params */
904 : 170 : CU_ASSERT(ut_calls_param_get_int(0, 0) == type);
905 : 170 : CU_ASSERT(ut_calls_param_get_int(0, 1) == UT_UNIQUE);
906 : 170 : CU_ASSERT(ut_calls_param_get_ptr(0, 2) == g_ut_io_channel);
907 : 170 : CU_ASSERT(ut_calls_param_get_ptr(0, 3) == utfsdev);
908 : :
909 [ - + ]: 170 : SPDK_CU_ASSERT_FATAL(UT_SUBMIT_IO_NUM_COMMON_PARAMS == 4);
910 : :
911 : : /* Op-specific params */
912 : 170 : check_cb();
913 : :
914 : 170 : ut_calls_reset();
915 : 170 : spdk_put_io_channel(ch);
916 : 170 : poll_thread(0);
917 : :
918 : 170 : spdk_fsdev_close(fsdev_desc);
919 : :
920 : 170 : ut_fsdev_destroy(utfsdev);
921 : 170 : }
922 : :
923 : : static void
924 : 10 : ut_fsdev_lookup_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
925 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr)
926 : : {
927 : 10 : int *clb_status = cb_arg;
928 : 10 : *clb_status = status;
929 [ + + ]: 10 : if (!status) {
930 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
931 : 5 : CU_ASSERT(&ut_fsdev_fobject == fobject);
932 : : }
933 : 10 : }
934 : :
935 : : static int
936 : 10 : ut_fsdev_lookup_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
937 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
938 : : {
939 : 10 : return spdk_fsdev_lookup(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME,
940 : : ut_fsdev_lookup_cpl_cb,
941 : : status);
942 : : }
943 : :
944 : : static void
945 : 10 : ut_fsdev_lookup_check_clb(void)
946 : : {
947 [ - + ]: 10 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS), UT_FNAME,
948 : : UT_CALL_REC_MAX_STR_SIZE));
949 : 10 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FOBJECT);
950 : 10 : }
951 : :
952 : : static void
953 : 5 : ut_fsdev_test_lookup_ok(void)
954 : : {
955 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_LOOKUP, 0, 2, ut_fsdev_lookup_execute_clb,
956 : : ut_fsdev_lookup_check_clb);
957 : 5 : }
958 : :
959 : : static void
960 : 5 : ut_fsdev_test_lookup_err(void)
961 : : {
962 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_LOOKUP, -EBUSY, 2, ut_fsdev_lookup_execute_clb,
963 : : ut_fsdev_lookup_check_clb);
964 : 5 : }
965 : :
966 : : static void
967 : 5 : ut_fsdev_forget_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
968 : : {
969 : 5 : int *clb_status = cb_arg;
970 : 5 : *clb_status = status;
971 : 5 : }
972 : :
973 : : static int
974 : 5 : ut_fsdev_forget_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
975 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
976 : : {
977 : 5 : return spdk_fsdev_forget(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_NUM_LOOKUPS,
978 : : ut_fsdev_forget_cpl_cb, status);
979 : : }
980 : :
981 : : static void
982 : 5 : ut_fsdev_forget_check_clb(void)
983 : : {
984 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
985 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_NUM_LOOKUPS);
986 : 5 : }
987 : :
988 : : static void
989 : 5 : ut_fsdev_test_forget(void)
990 : : {
991 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FORGET, 0, 2, ut_fsdev_forget_execute_clb,
992 : : ut_fsdev_forget_check_clb);
993 : 5 : }
994 : :
995 : : static void
996 : 5 : ut_fsdev_getattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
997 : : const struct spdk_fsdev_file_attr *attr)
998 : : {
999 : 5 : int *clb_status = cb_arg;
1000 : 5 : *clb_status = status;
1001 : 5 : }
1002 : :
1003 : : static int
1004 : 5 : ut_fsdev_getattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1005 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1006 : : {
1007 : 5 : return spdk_fsdev_getattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE,
1008 : : ut_fsdev_getattr_cpl_cb, status);
1009 : : }
1010 : :
1011 : : static void
1012 : 5 : ut_fsdev_getattr_check_clb(void)
1013 : : {
1014 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1015 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1016 : 5 : }
1017 : :
1018 : : static void
1019 : 5 : ut_fsdev_test_getattr(void)
1020 : : {
1021 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_GETATTR, 0, 2, ut_fsdev_getattr_execute_clb,
1022 : : ut_fsdev_getattr_check_clb);
1023 : 5 : }
1024 : :
1025 : : static void
1026 : 5 : ut_fsdev_setattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1027 : : const struct spdk_fsdev_file_attr *attr)
1028 : : {
1029 : 5 : int *clb_status = cb_arg;
1030 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1031 : 5 : *clb_status = status;
1032 : 5 : }
1033 : :
1034 : : static int
1035 : 5 : ut_fsdev_setattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1036 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1037 : : {
1038 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1039 : 5 : return spdk_fsdev_setattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE,
1040 : : &ut_fsdev_attr, 0x11111111, ut_fsdev_setattr_cpl_cb, status);
1041 : : }
1042 : :
1043 : : static void
1044 : 5 : ut_fsdev_setattr_check_clb(void)
1045 : : {
1046 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1047 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1048 : 5 : CU_ASSERT(ut_calls_param_get_hash(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) ==
1049 : : ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)));
1050 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 0x11111111);
1051 : 5 : }
1052 : :
1053 : : static void
1054 : 5 : ut_fsdev_test_setattr(void)
1055 : : {
1056 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_SETATTR, 0, 4, ut_fsdev_setattr_execute_clb,
1057 : : ut_fsdev_setattr_check_clb);
1058 : 5 : }
1059 : :
1060 : : static void
1061 : 5 : ut_fsdev_readlink_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1062 : : const char *linkname)
1063 : : {
1064 : 5 : int *clb_status = cb_arg;
1065 [ - + ]: 5 : CU_ASSERT(!strcmp(linkname, UT_FNAME));
1066 : 5 : *clb_status = status;
1067 : 5 : }
1068 : :
1069 : : static int
1070 : 5 : ut_fsdev_readlink_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1071 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1072 : : {
1073 : 5 : return spdk_fsdev_readlink(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, ut_fsdev_readlink_cpl_cb,
1074 : : status);
1075 : : }
1076 : :
1077 : : static void
1078 : 5 : ut_fsdev_readlink_check_clb(void)
1079 : : {
1080 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1081 : 5 : }
1082 : :
1083 : : static void
1084 : 5 : ut_fsdev_test_readlink(void)
1085 : : {
1086 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_READLINK, 0, 1, ut_fsdev_readlink_execute_clb,
1087 : : ut_fsdev_readlink_check_clb);
1088 : 5 : }
1089 : :
1090 : : static void
1091 : 5 : ut_fsdev_symlink_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1092 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr)
1093 : : {
1094 : 5 : int *clb_status = cb_arg;
1095 : 5 : CU_ASSERT(fobject == UT_FOBJECT + 1);
1096 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1097 : 5 : *clb_status = status;
1098 : 5 : }
1099 : :
1100 : : static int
1101 : 5 : ut_fsdev_symlink_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1102 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1103 : : {
1104 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1105 : 5 : return spdk_fsdev_symlink(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME, UT_LNAME, 100, 200,
1106 : : ut_fsdev_symlink_cpl_cb, status);
1107 : : }
1108 : :
1109 : : static void
1110 : 5 : ut_fsdev_symlink_check_clb(void)
1111 : : {
1112 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1113 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1114 : : UT_CALL_REC_MAX_STR_SIZE));
1115 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2), UT_LNAME,
1116 : : UT_CALL_REC_MAX_STR_SIZE));
1117 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 100);
1118 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 200);
1119 : 5 : }
1120 : :
1121 : : static void
1122 : 5 : ut_fsdev_test_symlink(void)
1123 : : {
1124 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_SYMLINK, 0, 5, ut_fsdev_symlink_execute_clb,
1125 : : ut_fsdev_symlink_check_clb);
1126 : 5 : }
1127 : :
1128 : : static void
1129 : 5 : ut_fsdev_mknod_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1130 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr)
1131 : : {
1132 : 5 : int *clb_status = cb_arg;
1133 : 5 : CU_ASSERT(fobject == UT_FOBJECT + 1);
1134 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1135 : 5 : *clb_status = status;
1136 : 5 : }
1137 : :
1138 : : static int
1139 : 5 : ut_fsdev_mknod_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1140 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1141 : : {
1142 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1143 : 5 : return spdk_fsdev_mknod(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME, 0x1111, 50, 100, 200,
1144 : : ut_fsdev_mknod_cpl_cb, status);
1145 : : }
1146 : :
1147 : : static void
1148 : 5 : ut_fsdev_mknod_check_clb(void)
1149 : : {
1150 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1151 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1152 : : UT_CALL_REC_MAX_STR_SIZE));
1153 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 0x1111);
1154 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 50);
1155 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 100);
1156 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 5) == 200);
1157 : 5 : }
1158 : :
1159 : : static void
1160 : 5 : ut_fsdev_test_mknod(void)
1161 : : {
1162 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_MKNOD, 0, 6, ut_fsdev_mknod_execute_clb,
1163 : : ut_fsdev_mknod_check_clb);
1164 : 5 : }
1165 : :
1166 : : static void
1167 : 5 : ut_fsdev_mkdir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1168 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr)
1169 : : {
1170 : 5 : int *clb_status = cb_arg;
1171 : 5 : CU_ASSERT(fobject == UT_FOBJECT + 1);
1172 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1173 : 5 : *clb_status = status;
1174 : 5 : }
1175 : :
1176 : : static int
1177 : 5 : ut_fsdev_mkdir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1178 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1179 : : {
1180 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1181 : 5 : return spdk_fsdev_mkdir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME, 0x1111, 100, 200,
1182 : : ut_fsdev_mkdir_cpl_cb, status);
1183 : : }
1184 : :
1185 : : static void
1186 : 5 : ut_fsdev_mkdir_check_clb(void)
1187 : : {
1188 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1189 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1190 : : UT_CALL_REC_MAX_STR_SIZE));
1191 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 0x1111);
1192 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 100);
1193 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 200);
1194 : 5 : }
1195 : :
1196 : : static void
1197 : 5 : ut_fsdev_test_mkdir(void)
1198 : : {
1199 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_MKDIR, 0, 5, ut_fsdev_mkdir_execute_clb,
1200 : : ut_fsdev_mkdir_check_clb);
1201 : 5 : }
1202 : :
1203 : : static void
1204 : 5 : ut_fsdev_unlink_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1205 : : {
1206 : 5 : int *clb_status = cb_arg;
1207 : 5 : *clb_status = status;
1208 : 5 : }
1209 : :
1210 : : static int
1211 : 5 : ut_fsdev_unlink_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1212 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1213 : : {
1214 : 5 : return spdk_fsdev_unlink(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME,
1215 : : ut_fsdev_unlink_cpl_cb, status);
1216 : : }
1217 : :
1218 : : static void
1219 : 5 : ut_fsdev_unlink_check_clb(void)
1220 : : {
1221 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1222 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1223 : : UT_CALL_REC_MAX_STR_SIZE));
1224 : 5 : }
1225 : :
1226 : : static void
1227 : 5 : ut_fsdev_test_unlink(void)
1228 : : {
1229 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_UNLINK, 0, 2, ut_fsdev_unlink_execute_clb,
1230 : : ut_fsdev_unlink_check_clb);
1231 : 5 : }
1232 : :
1233 : : static void
1234 : 5 : ut_fsdev_rmdir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1235 : : {
1236 : 5 : int *clb_status = cb_arg;
1237 : 5 : *clb_status = status;
1238 : 5 : }
1239 : :
1240 : : static int
1241 : 5 : ut_fsdev_rmdir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1242 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1243 : : {
1244 : 5 : return spdk_fsdev_rmdir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME,
1245 : : ut_fsdev_rmdir_cpl_cb, status);
1246 : : }
1247 : :
1248 : : static void
1249 : 5 : ut_fsdev_rmdir_check_clb(void)
1250 : : {
1251 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1252 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1253 : : UT_CALL_REC_MAX_STR_SIZE));
1254 : 5 : }
1255 : :
1256 : : static void
1257 : 5 : ut_fsdev_test_rmdir(void)
1258 : : {
1259 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_RMDIR, 0, 2, ut_fsdev_rmdir_execute_clb,
1260 : : ut_fsdev_rmdir_check_clb);
1261 : 5 : }
1262 : :
1263 : : static void
1264 : 5 : ut_fsdev_rename_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1265 : : {
1266 : 5 : int *clb_status = cb_arg;
1267 : 5 : *clb_status = status;
1268 : 5 : }
1269 : :
1270 : : static int
1271 : 5 : ut_fsdev_rename_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1272 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1273 : : {
1274 : 5 : return spdk_fsdev_rename(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FNAME, UT_FOBJECT + 2,
1275 : : UT_LNAME, 0xFFFF, ut_fsdev_rename_cpl_cb, status);
1276 : : }
1277 : :
1278 : : static void
1279 : 5 : ut_fsdev_rename_check_clb(void)
1280 : : {
1281 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1282 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_FNAME,
1283 : : UT_CALL_REC_MAX_STR_SIZE));
1284 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == UT_FOBJECT + 2);
1285 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3), UT_LNAME,
1286 : : UT_CALL_REC_MAX_STR_SIZE));
1287 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 0xFFFF);
1288 : 5 : }
1289 : :
1290 : : static void
1291 : 5 : ut_fsdev_test_rename(void)
1292 : : {
1293 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_RENAME, 0, 5, ut_fsdev_rename_execute_clb,
1294 : : ut_fsdev_rename_check_clb);
1295 : 5 : }
1296 : :
1297 : : static void
1298 : 5 : ut_fsdev_link_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1299 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr)
1300 : : {
1301 : 5 : int *clb_status = cb_arg;
1302 : 5 : CU_ASSERT(fobject == UT_FOBJECT + 1);
1303 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1304 : 5 : *clb_status = status;
1305 : 5 : }
1306 : :
1307 : : static int
1308 : 5 : ut_fsdev_link_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1309 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1310 : : {
1311 : 5 : return spdk_fsdev_link(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FOBJECT + 2, UT_LNAME,
1312 : : ut_fsdev_link_cpl_cb, status);
1313 : : }
1314 : :
1315 : : static void
1316 : 5 : ut_fsdev_link_check_clb(void)
1317 : : {
1318 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1319 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FOBJECT + 2);
1320 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2), UT_LNAME,
1321 : : UT_CALL_REC_MAX_STR_SIZE));
1322 : 5 : }
1323 : :
1324 : : static void
1325 : 5 : ut_fsdev_test_link(void)
1326 : : {
1327 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_LINK, 0, 3, ut_fsdev_link_execute_clb,
1328 : : ut_fsdev_link_check_clb);
1329 : 5 : }
1330 : :
1331 : : static void
1332 : 5 : ut_fsdev_fopen_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1333 : : struct spdk_fsdev_file_handle *fhandle)
1334 : : {
1335 : 5 : int *clb_status = cb_arg;
1336 : 5 : CU_ASSERT(fhandle == UT_FHANDLE);
1337 : 5 : *clb_status = status;
1338 : 5 : }
1339 : :
1340 : : static int
1341 : 5 : ut_fsdev_fopen_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1342 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1343 : : {
1344 : 5 : return spdk_fsdev_fopen(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, 0xFEAD,
1345 : : ut_fsdev_fopen_cpl_cb, status);
1346 : : }
1347 : :
1348 : : static void
1349 : 5 : ut_fsdev_fopen_check_clb(void)
1350 : : {
1351 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1352 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == 0xFEAD);
1353 : 5 : }
1354 : :
1355 : : static void
1356 : 5 : ut_fsdev_test_fopen(void)
1357 : : {
1358 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_OPEN, 0, 2, ut_fsdev_fopen_execute_clb,
1359 : : ut_fsdev_fopen_check_clb);
1360 : 5 : }
1361 : :
1362 : : static void
1363 : 5 : ut_fsdev_read_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1364 : : uint32_t data_size)
1365 : : {
1366 : 5 : int *clb_status = cb_arg;
1367 : 5 : CU_ASSERT(data_size == UT_DATA_SIZE);
1368 : 5 : *clb_status = status;
1369 : 5 : }
1370 : :
1371 : : static int
1372 : 5 : ut_fsdev_read_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1373 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1374 : : {
1375 [ - + ]: 5 : memset(&ut_iov, rand(), sizeof(ut_iov));
1376 : 5 : return spdk_fsdev_read(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 100, 200, 0x1111,
1377 : : ut_iov, SPDK_COUNTOF(ut_iov), (struct spdk_fsdev_io_opts *)0xAAAAAAAA,
1378 : : ut_fsdev_read_cpl_cb, status);
1379 : : }
1380 : :
1381 : : static void
1382 : 5 : ut_fsdev_read_check_clb(void)
1383 : : {
1384 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1385 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1386 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 100);
1387 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 200);
1388 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 0x1111);
1389 : 5 : CU_ASSERT(ut_calls_param_get_hash(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 5) == ut_hash(ut_iov,
1390 : : sizeof(ut_iov)));
1391 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 6) == SPDK_COUNTOF(ut_iov));
1392 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 7) == 0xAAAAAAAA);
1393 : 5 : }
1394 : :
1395 : : static void
1396 : 5 : ut_fsdev_test_read(void)
1397 : : {
1398 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_READ, 0, 8, ut_fsdev_read_execute_clb,
1399 : : ut_fsdev_read_check_clb);
1400 : 5 : }
1401 : :
1402 : : static void
1403 : 5 : ut_fsdev_write_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1404 : : uint32_t data_size)
1405 : : {
1406 : 5 : int *clb_status = cb_arg;
1407 : 5 : CU_ASSERT(data_size == UT_DATA_SIZE);
1408 : 5 : *clb_status = status;
1409 : 5 : }
1410 : :
1411 : : static int
1412 : 5 : ut_fsdev_write_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1413 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1414 : : {
1415 [ - + ]: 5 : memset(&ut_iov, rand(), sizeof(ut_iov));
1416 : 5 : return spdk_fsdev_write(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 100, 200, 0x1111,
1417 : : ut_iov, SPDK_COUNTOF(ut_iov), (struct spdk_fsdev_io_opts *)0xAAAAAAAA,
1418 : : ut_fsdev_write_cpl_cb, status);
1419 : : }
1420 : :
1421 : : static void
1422 : 5 : ut_fsdev_write_check_clb(void)
1423 : : {
1424 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1425 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1426 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 100);
1427 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 200);
1428 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 0x1111);
1429 : 5 : CU_ASSERT(ut_calls_param_get_hash(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 5) ==
1430 : : ut_hash(ut_iov, sizeof(ut_iov)));
1431 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 6) == SPDK_COUNTOF(ut_iov));
1432 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 7) == 0xAAAAAAAA);
1433 : 5 : }
1434 : :
1435 : : static void
1436 : 5 : ut_fsdev_test_write(void)
1437 : : {
1438 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_WRITE, 0, 8, ut_fsdev_write_execute_clb,
1439 : : ut_fsdev_write_check_clb);
1440 : 5 : }
1441 : :
1442 : : static void
1443 : 5 : ut_fsdev_statfs_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1444 : : const struct spdk_fsdev_file_statfs *statfs)
1445 : : {
1446 : 5 : int *clb_status = cb_arg;
1447 : 5 : CU_ASSERT(ut_hash(&ut_statfs, sizeof(ut_statfs)) == ut_hash(statfs, sizeof(*statfs)));
1448 : 5 : *clb_status = status;
1449 : 5 : }
1450 : :
1451 : : static int
1452 : 5 : ut_fsdev_statfs_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1453 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1454 : : {
1455 [ - + ]: 5 : memset(&ut_statfs, rand(), sizeof(ut_statfs));
1456 : 5 : return spdk_fsdev_statfs(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT,
1457 : : ut_fsdev_statfs_cpl_cb, status);
1458 : : }
1459 : :
1460 : : static void
1461 : 5 : ut_fsdev_statfs_check_clb(void)
1462 : : {
1463 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1464 : 5 : }
1465 : :
1466 : : static void
1467 : 5 : ut_fsdev_test_statfs(void)
1468 : : {
1469 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_STATFS, 0, 1, ut_fsdev_statfs_execute_clb,
1470 : : ut_fsdev_statfs_check_clb);
1471 : 5 : }
1472 : :
1473 : : static void
1474 : 5 : ut_fsdev_release_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1475 : : {
1476 : 5 : int *clb_status = cb_arg;
1477 : 5 : *clb_status = status;
1478 : 5 : }
1479 : :
1480 : : static int
1481 : 5 : ut_fsdev_release_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1482 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1483 : : {
1484 : 5 : return spdk_fsdev_release(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE,
1485 : : ut_fsdev_release_cpl_cb, status);
1486 : : }
1487 : :
1488 : : static void
1489 : 5 : ut_fsdev_release_check_clb(void)
1490 : : {
1491 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1492 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1493 : 5 : }
1494 : :
1495 : : static void
1496 : 5 : ut_fsdev_test_release(void)
1497 : : {
1498 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_RELEASE, 0, 2, ut_fsdev_release_execute_clb,
1499 : : ut_fsdev_release_check_clb);
1500 : 5 : }
1501 : :
1502 : : static void
1503 : 5 : ut_fsdev_fsync_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1504 : : {
1505 : 5 : int *clb_status = cb_arg;
1506 : 5 : *clb_status = status;
1507 : 5 : }
1508 : :
1509 : : static int
1510 : 5 : ut_fsdev_fsync_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1511 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1512 : : {
1513 : 5 : return spdk_fsdev_fsync(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, false,
1514 : : ut_fsdev_fsync_cpl_cb, status);
1515 : : }
1516 : :
1517 : : static void
1518 : 5 : ut_fsdev_fsync_check_clb(void)
1519 : : {
1520 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1521 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1522 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == false);
1523 : 5 : }
1524 : :
1525 : : static void
1526 : 5 : ut_fsdev_test_fsync(void)
1527 : : {
1528 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FSYNC, 0, 3, ut_fsdev_fsync_execute_clb,
1529 : : ut_fsdev_fsync_check_clb);
1530 : 5 : }
1531 : :
1532 : : static void
1533 : 5 : ut_fsdev_getxattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1534 : : size_t value_size)
1535 : : {
1536 : 5 : int *clb_status = cb_arg;
1537 : 5 : CU_ASSERT(value_size == sizeof(UT_AVALUE));
1538 : 5 : CU_ASSERT(!strcmp(ut_buff, UT_AVALUE));
1539 : 5 : *clb_status = status;
1540 : 5 : }
1541 : :
1542 : : static int
1543 : 5 : ut_fsdev_getxattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1544 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1545 : : {
1546 [ - + ]: 5 : memset(ut_buff, 0, sizeof(ut_buff));
1547 : 5 : return spdk_fsdev_getxattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_ANAME, ut_buff,
1548 : : sizeof(ut_buff), ut_fsdev_getxattr_cpl_cb, status);
1549 : : }
1550 : :
1551 : : static void
1552 : 5 : ut_fsdev_getxattr_check_clb(void)
1553 : : {
1554 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1555 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_ANAME,
1556 : : UT_CALL_REC_MAX_STR_SIZE));
1557 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == ut_buff);
1558 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == sizeof(ut_buff));
1559 : 5 : }
1560 : :
1561 : : static void
1562 : 5 : ut_fsdev_test_getxattr(void)
1563 : : {
1564 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_GETXATTR, 0, 4, ut_fsdev_getxattr_execute_clb,
1565 : : ut_fsdev_getxattr_check_clb);
1566 : 5 : }
1567 : :
1568 : : static void
1569 : 5 : ut_fsdev_setxattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1570 : : {
1571 : 5 : int *clb_status = cb_arg;
1572 : 5 : *clb_status = status;
1573 : 5 : }
1574 : :
1575 : : static int
1576 : 5 : ut_fsdev_setxattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1577 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1578 : : {
1579 : 5 : return spdk_fsdev_setxattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_ANAME, UT_AVALUE,
1580 : : sizeof(UT_AVALUE), 0xFF, ut_fsdev_setxattr_cpl_cb, status);
1581 : : }
1582 : :
1583 : : static void
1584 : 5 : ut_fsdev_setxattr_check_clb(void)
1585 : : {
1586 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1587 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_ANAME,
1588 : : UT_CALL_REC_MAX_STR_SIZE));
1589 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2), UT_AVALUE,
1590 : : UT_CALL_REC_MAX_STR_SIZE));
1591 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == sizeof(UT_AVALUE));
1592 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 0xFF);
1593 : 5 : }
1594 : :
1595 : : static void
1596 : 5 : ut_fsdev_test_setxattr(void)
1597 : : {
1598 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_SETXATTR, 0, 5, ut_fsdev_setxattr_execute_clb,
1599 : : ut_fsdev_setxattr_check_clb);
1600 : 5 : }
1601 : :
1602 : : static void
1603 : 10 : ut_fsdev_listxattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status, size_t size,
1604 : : bool size_only)
1605 : : {
1606 : 10 : int *clb_status = cb_arg;
1607 [ + + + + ]: 10 : if (ut_listxattr_size_only) {
1608 : 5 : CU_ASSERT(size_only);
1609 : 5 : CU_ASSERT(size == (sizeof(ut_buff) / sizeof(UT_ANAME)) * sizeof(UT_ANAME));
1610 : : } else {
1611 : 5 : char *p = ut_buff;
1612 : :
1613 : 5 : CU_ASSERT(!size_only);
1614 : 5 : CU_ASSERT(size != 0);
1615 : :
1616 [ + + ]: 430 : for (; p + sizeof(UT_ANAME) <= ut_buff + size; p += sizeof(UT_ANAME)) {
1617 [ - + ]: 425 : CU_ASSERT(!strcmp(p, UT_ANAME));
1618 : : }
1619 : :
1620 : 5 : CU_ASSERT(size + sizeof(UT_ANAME) > sizeof(ut_buff));
1621 : : }
1622 : 10 : *clb_status = status;
1623 : 10 : }
1624 : :
1625 : : static int
1626 : 10 : ut_fsdev_listxattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1627 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1628 : : {
1629 [ + + + + ]: 10 : return spdk_fsdev_listxattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT,
1630 [ + + + + ]: 10 : ut_listxattr_size_only ? NULL : ut_buff, ut_listxattr_size_only ? 0 : sizeof(ut_buff),
1631 : : ut_fsdev_listxattr_cpl_cb, status);
1632 : : }
1633 : :
1634 : : static void
1635 : 10 : ut_fsdev_listxattr_check_clb(void)
1636 : : {
1637 : 10 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1638 [ + + + + ]: 10 : if (ut_listxattr_size_only) {
1639 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == NULL);
1640 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 0);
1641 : : } else {
1642 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == ut_buff);
1643 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == sizeof(ut_buff));
1644 : : }
1645 : 10 : }
1646 : :
1647 : : static void
1648 : 5 : ut_fsdev_test_listxattr(void)
1649 : : {
1650 : 5 : ut_listxattr_size_only = false;
1651 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_LISTXATTR, 0, 3, ut_fsdev_listxattr_execute_clb,
1652 : : ut_fsdev_listxattr_check_clb);
1653 : 5 : }
1654 : :
1655 : : static void
1656 : 5 : ut_fsdev_test_listxattr_get_size(void)
1657 : : {
1658 : 5 : ut_listxattr_size_only = true;
1659 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_LISTXATTR, 0, 3, ut_fsdev_listxattr_execute_clb,
1660 : : ut_fsdev_listxattr_check_clb);
1661 : 5 : }
1662 : :
1663 : : static void
1664 : 5 : ut_fsdev_removexattr_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1665 : : {
1666 : 5 : int *clb_status = cb_arg;
1667 : 5 : *clb_status = status;
1668 : 5 : }
1669 : :
1670 : : static int
1671 : 5 : ut_fsdev_removexattr_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1672 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1673 : : {
1674 : 5 : return spdk_fsdev_removexattr(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_ANAME,
1675 : : ut_fsdev_removexattr_cpl_cb, status);
1676 : : }
1677 : :
1678 : : static void
1679 : 5 : ut_fsdev_removexattr_check_clb(void)
1680 : : {
1681 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1682 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_ANAME,
1683 : : UT_CALL_REC_MAX_STR_SIZE));
1684 : 5 : }
1685 : :
1686 : : static void
1687 : 5 : ut_fsdev_test_removexattr(void)
1688 : : {
1689 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_REMOVEXATTR, 0, 2, ut_fsdev_removexattr_execute_clb,
1690 : : ut_fsdev_removexattr_check_clb);
1691 : 5 : }
1692 : :
1693 : : static void
1694 : 5 : ut_fsdev_flush_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1695 : : {
1696 : 5 : int *clb_status = cb_arg;
1697 : 5 : *clb_status = status;
1698 : 5 : }
1699 : :
1700 : : static int
1701 : 5 : ut_fsdev_flush_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1702 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1703 : : {
1704 : 5 : return spdk_fsdev_flush(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE,
1705 : : ut_fsdev_flush_cpl_cb, status);
1706 : : }
1707 : :
1708 : : static void
1709 : 5 : ut_fsdev_flush_check_clb(void)
1710 : : {
1711 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1712 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1713 : 5 : }
1714 : :
1715 : : static void
1716 : 5 : ut_fsdev_test_flush(void)
1717 : : {
1718 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FLUSH, 0, 2, ut_fsdev_flush_execute_clb,
1719 : : ut_fsdev_flush_check_clb);
1720 : 5 : }
1721 : :
1722 : : static void
1723 : 5 : ut_fsdev_opendir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1724 : : struct spdk_fsdev_file_handle *fhandle)
1725 : : {
1726 : 5 : int *clb_status = cb_arg;
1727 : 5 : CU_ASSERT(fhandle == UT_FHANDLE);
1728 : 5 : *clb_status = status;
1729 : 5 : }
1730 : :
1731 : : static int
1732 : 5 : ut_fsdev_opendir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1733 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1734 : : {
1735 : 5 : return spdk_fsdev_opendir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, 0x1111,
1736 : : ut_fsdev_opendir_cpl_cb, status);
1737 : : }
1738 : :
1739 : : static void
1740 : 5 : ut_fsdev_opendir_check_clb(void)
1741 : : {
1742 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1743 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == 0x1111);
1744 : 5 : }
1745 : :
1746 : : static void
1747 : 5 : ut_fsdev_test_opendir(void)
1748 : : {
1749 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_OPENDIR, 0, 2, ut_fsdev_opendir_execute_clb,
1750 : : ut_fsdev_opendir_check_clb);
1751 : 5 : }
1752 : :
1753 : : static int
1754 : 100 : ut_fsdev_readdir_entry_cb(void *cb_arg, struct spdk_io_channel *ch, const char *name,
1755 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr,
1756 : : off_t offset)
1757 : : {
1758 [ - + ]: 100 : CU_ASSERT(!strcmp(name, UT_FNAME));
1759 : 100 : CU_ASSERT(fobject == UT_FOBJECT + ut_readdir_num_entry_cb_calls);
1760 : 100 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1761 : 100 : CU_ASSERT(offset == (off_t)(ut_readdir_offset + ut_readdir_num_entry_cb_calls));
1762 : :
1763 : 100 : ut_readdir_num_entry_cb_calls++;
1764 [ + + ]: 100 : return (ut_readdir_num_entry_cb_calls == ut_readdir_num_entries) ? -1 : 0;
1765 : : }
1766 : :
1767 : : static void
1768 : 5 : ut_fsdev_readdir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1769 : : {
1770 : 5 : int *clb_status = cb_arg;
1771 : 5 : *clb_status = status;
1772 : 5 : }
1773 : :
1774 : : static int
1775 : 5 : ut_fsdev_readdir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1776 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1777 : : {
1778 : 5 : ut_readdir_num_entries = 20;
1779 : 5 : ut_readdir_num_entry_cb_calls = 0;
1780 : 5 : ut_readdir_offset = (uint64_t)rand();
1781 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1782 : 5 : return spdk_fsdev_readdir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 10000,
1783 : : ut_fsdev_readdir_entry_cb, ut_fsdev_readdir_cpl_cb, status);
1784 : : }
1785 : :
1786 : : static void
1787 : 5 : ut_fsdev_readdir_check_clb(void)
1788 : : {
1789 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1790 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1791 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 10000);
1792 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0,
1793 : : UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == ut_fsdev_readdir_entry_cb);
1794 : 5 : CU_ASSERT(ut_readdir_num_entry_cb_calls == ut_readdir_num_entries);
1795 : 5 : }
1796 : :
1797 : : static void
1798 : 5 : ut_fsdev_test_readdir(void)
1799 : : {
1800 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_READDIR, 0, 4, ut_fsdev_readdir_execute_clb,
1801 : : ut_fsdev_readdir_check_clb);
1802 : 5 : }
1803 : :
1804 : : static void
1805 : 5 : ut_fsdev_releasedir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1806 : : {
1807 : 5 : int *clb_status = cb_arg;
1808 : 5 : *clb_status = status;
1809 : 5 : }
1810 : :
1811 : : static int
1812 : 5 : ut_fsdev_releasedir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1813 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1814 : : {
1815 : 5 : return spdk_fsdev_releasedir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE,
1816 : : ut_fsdev_releasedir_cpl_cb, status);
1817 : : }
1818 : :
1819 : : static void
1820 : 5 : ut_fsdev_releasedir_check_clb(void)
1821 : : {
1822 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1823 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1824 : 5 : }
1825 : :
1826 : : static void
1827 : 5 : ut_fsdev_test_releasedir(void)
1828 : : {
1829 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_RELEASEDIR, 0, 2, ut_fsdev_releasedir_execute_clb,
1830 : : ut_fsdev_releasedir_check_clb);
1831 : 5 : }
1832 : :
1833 : : static void
1834 : 5 : ut_fsdev_fsyncdir_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1835 : : {
1836 : 5 : int *clb_status = cb_arg;
1837 : 5 : *clb_status = status;
1838 : 5 : }
1839 : :
1840 : : static int
1841 : 5 : ut_fsdev_fsyncdir_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1842 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1843 : : {
1844 : 5 : return spdk_fsdev_fsyncdir(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, true,
1845 : : ut_fsdev_fsyncdir_cpl_cb, status);
1846 : : }
1847 : :
1848 : : static void
1849 : 5 : ut_fsdev_fsyncdir_check_clb(void)
1850 : : {
1851 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1852 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1853 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == true);
1854 : 5 : }
1855 : :
1856 : : static void
1857 : 5 : ut_fsdev_test_fsyncdir(void)
1858 : : {
1859 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FSYNCDIR, 0, 3, ut_fsdev_fsyncdir_execute_clb,
1860 : : ut_fsdev_fsyncdir_check_clb);
1861 : 5 : }
1862 : :
1863 : : static void
1864 : 5 : ut_fsdev_flock_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1865 : : {
1866 : 5 : int *clb_status = cb_arg;
1867 : 5 : *clb_status = status;
1868 : 5 : }
1869 : :
1870 : : static int
1871 : 5 : ut_fsdev_flock_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1872 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1873 : : {
1874 : 5 : return spdk_fsdev_flock(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 111,
1875 : : ut_fsdev_flock_cpl_cb, status);
1876 : : }
1877 : :
1878 : : static void
1879 : 5 : ut_fsdev_flock_check_clb(void)
1880 : : {
1881 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1882 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1883 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 111);
1884 : 5 : }
1885 : :
1886 : : static void
1887 : 5 : ut_fsdev_test_flock(void)
1888 : : {
1889 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FLOCK, 0, 3, ut_fsdev_flock_execute_clb,
1890 : : ut_fsdev_flock_check_clb);
1891 : 5 : }
1892 : :
1893 : : static void
1894 : 5 : ut_fsdev_create_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1895 : : struct spdk_fsdev_file_object *fobject, const struct spdk_fsdev_file_attr *attr,
1896 : : struct spdk_fsdev_file_handle *fhandle)
1897 : : {
1898 : 5 : int *clb_status = cb_arg;
1899 : 5 : CU_ASSERT(fobject == UT_FOBJECT + 1);
1900 : 5 : CU_ASSERT(fhandle == UT_FHANDLE);
1901 : 5 : CU_ASSERT(ut_hash(&ut_fsdev_attr, sizeof(ut_fsdev_attr)) == ut_hash(attr, sizeof(*attr)));
1902 : 5 : *clb_status = status;
1903 : 5 : }
1904 : :
1905 : : static int
1906 : 5 : ut_fsdev_create_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1907 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1908 : : {
1909 [ - + ]: 5 : memset(&ut_fsdev_attr, rand(), sizeof(ut_fsdev_attr));
1910 : 5 : return spdk_fsdev_create(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_LNAME, 100, 0x2222, 0x666,
1911 : : 200, 300, ut_fsdev_create_cpl_cb, status);
1912 : : }
1913 : :
1914 : : static void
1915 : 5 : ut_fsdev_create_check_clb(void)
1916 : : {
1917 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1918 [ - + ]: 5 : CU_ASSERT(!strncmp(ut_calls_param_get_str(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1), UT_LNAME,
1919 : : UT_CALL_REC_MAX_STR_SIZE));
1920 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 100);
1921 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 0x2222);
1922 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 0x666);
1923 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 5) == 200);
1924 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 6) == 300);
1925 : 5 : }
1926 : :
1927 : : static void
1928 : 5 : ut_fsdev_test_create(void)
1929 : : {
1930 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_CREATE, 0, 7, ut_fsdev_create_execute_clb,
1931 : : ut_fsdev_create_check_clb);
1932 : 5 : }
1933 : :
1934 : : static void
1935 : 5 : ut_fsdev_abort_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1936 : : {
1937 : 5 : int *clb_status = cb_arg;
1938 : 5 : *clb_status = status;
1939 : 5 : }
1940 : :
1941 : : static int
1942 : 5 : ut_fsdev_abort_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1943 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1944 : : {
1945 : 5 : return spdk_fsdev_abort(fsdev_desc, ch, UT_UNIQUE,
1946 : : ut_fsdev_abort_cpl_cb, status);
1947 : : }
1948 : :
1949 : : static void
1950 : 5 : ut_fsdev_abort_check_clb(void)
1951 : : {
1952 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_UNIQUE);
1953 : 5 : }
1954 : :
1955 : : static void
1956 : 5 : ut_fsdev_test_abort(void)
1957 : : {
1958 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_ABORT, 0, 1, ut_fsdev_abort_execute_clb,
1959 : : ut_fsdev_abort_check_clb);
1960 : 5 : }
1961 : :
1962 : : static void
1963 : 5 : ut_fsdev_fallocate_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status)
1964 : : {
1965 : 5 : int *clb_status = cb_arg;
1966 : 5 : *clb_status = status;
1967 : 5 : }
1968 : :
1969 : : static int
1970 : 5 : ut_fsdev_fallocate_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
1971 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
1972 : : {
1973 : 5 : return spdk_fsdev_fallocate(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 0x1111, 2000,
1974 : : 1002, ut_fsdev_fallocate_cpl_cb, status);
1975 : : }
1976 : :
1977 : : static void
1978 : 5 : ut_fsdev_fallocate_check_clb(void)
1979 : : {
1980 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
1981 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
1982 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 0x1111);
1983 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == 2000);
1984 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == 1002);
1985 : 5 : }
1986 : :
1987 : : static void
1988 : 5 : ut_fsdev_test_fallocate(void)
1989 : : {
1990 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_FALLOCATE, 0, 5, ut_fsdev_fallocate_execute_clb,
1991 : : ut_fsdev_fallocate_check_clb);
1992 : 5 : }
1993 : :
1994 : : static void
1995 : 5 : ut_fsdev_copy_file_range_cpl_cb(void *cb_arg, struct spdk_io_channel *ch, int status,
1996 : : uint32_t data_size)
1997 : : {
1998 : 5 : int *clb_status = cb_arg;
1999 : 5 : CU_ASSERT(data_size == UT_DATA_SIZE);
2000 : 5 : *clb_status = status;
2001 : 5 : }
2002 : :
2003 : : static int
2004 : 5 : ut_fsdev_copy_file_range_execute_clb(struct ut_fsdev *utfsdev, struct spdk_io_channel *ch,
2005 : : struct spdk_fsdev_desc *fsdev_desc, int *status)
2006 : : {
2007 : 5 : return spdk_fsdev_copy_file_range(fsdev_desc, ch, UT_UNIQUE, UT_FOBJECT, UT_FHANDLE, 1000,
2008 : : UT_FOBJECT + 2, UT_FHANDLE + 2, 3000, 50000, 0x77777777,
2009 : : ut_fsdev_copy_file_range_cpl_cb, status);
2010 : : }
2011 : :
2012 : : static void
2013 : 5 : ut_fsdev_copy_file_range_check_clb(void)
2014 : : {
2015 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS) == UT_FOBJECT);
2016 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 1) == UT_FHANDLE);
2017 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 2) == 1000);
2018 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 3) == UT_FOBJECT + 2);
2019 : 5 : CU_ASSERT(ut_calls_param_get_ptr(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 4) == UT_FHANDLE + 2);
2020 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 5) == 3000);
2021 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 6) == 50000);
2022 : 5 : CU_ASSERT(ut_calls_param_get_int(0, UT_SUBMIT_IO_NUM_COMMON_PARAMS + 7) == 0x77777777);
2023 : 5 : }
2024 : :
2025 : : static void
2026 : 5 : ut_fsdev_test_copy_file_range(void)
2027 : : {
2028 : 5 : ut_fsdev_test_io(SPDK_FSDEV_IO_COPY_FILE_RANGE, 0, 8, ut_fsdev_copy_file_range_execute_clb,
2029 : : ut_fsdev_copy_file_range_check_clb);
2030 : 5 : }
2031 : :
2032 : : int
2033 : 5 : main(int argc, char **argv)
2034 : : {
2035 : 5 : CU_pSuite suite = NULL;
2036 : : unsigned int num_failures;
2037 : :
2038 : 5 : CU_initialize_registry();
2039 : :
2040 : 5 : suite = CU_add_suite("fsdev", ut_fsdev_setup, ut_fsdev_teardown);
2041 : :
2042 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_open_close_no_opts);
2043 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_open_close_good_opts);
2044 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_open_close_bad_opts);
2045 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_set_opts);
2046 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_get_io_channel);
2047 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_lookup_ok);
2048 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_lookup_err);
2049 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_forget);
2050 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_getattr);
2051 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_setattr);
2052 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_readlink);
2053 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_symlink);
2054 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_mknod);
2055 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_mkdir);
2056 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_unlink);
2057 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_rmdir);
2058 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_rename);
2059 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_link);
2060 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_fopen);
2061 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_read);
2062 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_write);
2063 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_statfs);
2064 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_release);
2065 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_fsync);
2066 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_getxattr);
2067 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_setxattr);
2068 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_listxattr);
2069 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_listxattr_get_size);
2070 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_removexattr);
2071 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_flush);
2072 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_opendir);
2073 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_readdir);
2074 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_releasedir);
2075 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_fsyncdir);
2076 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_flock);
2077 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_create);
2078 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_abort);
2079 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_fallocate);
2080 : 5 : CU_ADD_TEST(suite, ut_fsdev_test_copy_file_range);
2081 : :
2082 : 5 : allocate_cores(1);
2083 : 5 : allocate_threads(1);
2084 : 5 : set_thread(0);
2085 : :
2086 : 5 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
2087 : 5 : CU_cleanup_registry();
2088 : :
2089 : 5 : poll_thread(0);
2090 : :
2091 : 5 : free_threads();
2092 : 5 : free_cores();
2093 : :
2094 : 5 : return num_failures;
2095 : : }
|