Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : :
8 : : #include "CUnit/Basic.h"
9 : :
10 : : #include "common/lib/ut_multithread.c"
11 : :
12 : : #include "spdk_internal/cunit.h"
13 : : #include "blobfs/blobfs.c"
14 : : #include "blobfs/tree.c"
15 : : #include "blob/blobstore.h"
16 : :
17 : : #include "unit/lib/blob/bs_dev_common.c"
18 : :
19 : : struct spdk_filesystem *g_fs;
20 : : struct spdk_file *g_file;
21 : : int g_fserrno;
22 : :
23 [ # # ]: 0 : DEFINE_STUB(spdk_memory_domain_memzero, int, (struct spdk_memory_domain *src_domain,
24 : : void *src_domain_ctx, struct iovec *iov, uint32_t iovcnt, void (*cpl_cb)(void *, int),
25 : : void *cpl_cb_arg), 0);
26 [ # # ]: 0 : DEFINE_STUB(spdk_mempool_lookup, struct spdk_mempool *, (const char *name), NULL);
27 : :
28 : : static void
29 : 150 : fs_op_complete(void *ctx, int fserrno)
30 : : {
31 : 150 : g_fserrno = fserrno;
32 : 150 : }
33 : :
34 : : static void
35 : 54 : fs_op_with_handle_complete(void *ctx, struct spdk_filesystem *fs, int fserrno)
36 : : {
37 : 54 : g_fs = fs;
38 : 54 : g_fserrno = fserrno;
39 : 54 : }
40 : :
41 : : static void
42 : 306 : fs_poll_threads(void)
43 : : {
44 : 306 : poll_threads();
45 [ + + ]: 414 : while (spdk_thread_poll(g_cache_pool_thread, 0, 0) > 0) {}
46 : 306 : }
47 : :
48 : : static void
49 : 6 : fs_init(void)
50 : : {
51 : : struct spdk_filesystem *fs;
52 : : struct spdk_bs_dev *dev;
53 : :
54 : 6 : dev = init_dev();
55 : :
56 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
57 : 6 : fs_poll_threads();
58 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
59 : 6 : CU_ASSERT(g_fserrno == 0);
60 : 6 : fs = g_fs;
61 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
62 : :
63 : 6 : g_fserrno = 1;
64 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
65 : 6 : fs_poll_threads();
66 : 6 : CU_ASSERT(g_fserrno == 0);
67 : 6 : }
68 : :
69 : : static void
70 : 24 : create_cb(void *ctx, int fserrno)
71 : : {
72 : 24 : g_fserrno = fserrno;
73 : 24 : }
74 : :
75 : : static void
76 : 48 : open_cb(void *ctx, struct spdk_file *f, int fserrno)
77 : : {
78 : 48 : g_fserrno = fserrno;
79 : 48 : g_file = f;
80 : 48 : }
81 : :
82 : : static void
83 : 30 : delete_cb(void *ctx, int fserrno)
84 : : {
85 : 30 : g_fserrno = fserrno;
86 : 30 : }
87 : :
88 : : static void
89 : 6 : fs_open(void)
90 : : {
91 : : struct spdk_filesystem *fs;
92 : : spdk_fs_iter iter;
93 : : struct spdk_bs_dev *dev;
94 : : struct spdk_file *file;
95 : 6 : char name[257] = {'\0'};
96 : :
97 : 6 : dev = init_dev();
98 : 6 : memset(name, 'a', sizeof(name) - 1);
99 : :
100 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
101 : 6 : fs_poll_threads();
102 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
103 : 6 : CU_ASSERT(g_fserrno == 0);
104 : 6 : fs = g_fs;
105 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
106 : :
107 : 6 : g_fserrno = 0;
108 : : /* Open should fail, because the file name is too long. */
109 : 6 : spdk_fs_open_file_async(fs, name, SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
110 : 6 : fs_poll_threads();
111 : 6 : CU_ASSERT(g_fserrno == -ENAMETOOLONG);
112 : :
113 : 6 : g_fserrno = 0;
114 : 6 : spdk_fs_open_file_async(fs, "file1", 0, open_cb, NULL);
115 : 6 : fs_poll_threads();
116 : 6 : CU_ASSERT(g_fserrno == -ENOENT);
117 : :
118 : 6 : g_file = NULL;
119 : 6 : g_fserrno = 1;
120 : 6 : spdk_fs_open_file_async(fs, "file1", SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
121 : 6 : fs_poll_threads();
122 : 6 : CU_ASSERT(g_fserrno == 0);
123 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
124 [ - + ]: 6 : CU_ASSERT(!strcmp("file1", g_file->name));
125 : 6 : CU_ASSERT(g_file->ref_count == 1);
126 : :
127 : 6 : iter = spdk_fs_iter_first(fs);
128 : 6 : CU_ASSERT(iter != NULL);
129 : 6 : file = spdk_fs_iter_get_file(iter);
130 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(file != NULL);
131 [ - + ]: 6 : CU_ASSERT(!strcmp("file1", file->name));
132 : 6 : iter = spdk_fs_iter_next(iter);
133 : 6 : CU_ASSERT(iter == NULL);
134 : :
135 : 6 : g_fserrno = 0;
136 : : /* Delete should successful, we will mark the file as deleted. */
137 : 6 : spdk_fs_delete_file_async(fs, "file1", delete_cb, NULL);
138 : 6 : fs_poll_threads();
139 : 6 : CU_ASSERT(g_fserrno == 0);
140 : 6 : CU_ASSERT(!TAILQ_EMPTY(&fs->files));
141 : :
142 : 6 : g_fserrno = 1;
143 : 6 : spdk_file_close_async(g_file, fs_op_complete, NULL);
144 : 6 : fs_poll_threads();
145 : 6 : CU_ASSERT(g_fserrno == 0);
146 : 6 : CU_ASSERT(TAILQ_EMPTY(&fs->files));
147 : :
148 : 6 : g_fserrno = 1;
149 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
150 : 6 : fs_poll_threads();
151 : 6 : CU_ASSERT(g_fserrno == 0);
152 : 6 : }
153 : :
154 : : static void
155 : 6 : fs_create(void)
156 : : {
157 : : struct spdk_filesystem *fs;
158 : : struct spdk_bs_dev *dev;
159 : 6 : char name[257] = {'\0'};
160 : :
161 : 6 : dev = init_dev();
162 [ - + ]: 6 : memset(name, 'a', sizeof(name) - 1);
163 : :
164 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
165 : 6 : fs_poll_threads();
166 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
167 : 6 : CU_ASSERT(g_fserrno == 0);
168 : 6 : fs = g_fs;
169 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
170 : :
171 : 6 : g_fserrno = 0;
172 : : /* Create should fail, because the file name is too long. */
173 : 6 : spdk_fs_create_file_async(fs, name, create_cb, NULL);
174 : 6 : fs_poll_threads();
175 : 6 : CU_ASSERT(g_fserrno == -ENAMETOOLONG);
176 : :
177 : 6 : g_fserrno = 1;
178 : 6 : spdk_fs_create_file_async(fs, "file1", create_cb, NULL);
179 : 6 : fs_poll_threads();
180 : 6 : CU_ASSERT(g_fserrno == 0);
181 : :
182 : 6 : g_fserrno = 1;
183 : 6 : spdk_fs_create_file_async(fs, "file1", create_cb, NULL);
184 : 6 : fs_poll_threads();
185 : 6 : CU_ASSERT(g_fserrno == -EEXIST);
186 : :
187 : 6 : g_fserrno = 1;
188 : 6 : spdk_fs_delete_file_async(fs, "file1", delete_cb, NULL);
189 : 6 : fs_poll_threads();
190 : 6 : CU_ASSERT(g_fserrno == 0);
191 : 6 : CU_ASSERT(TAILQ_EMPTY(&fs->files));
192 : :
193 : 6 : g_fserrno = 1;
194 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
195 : 6 : fs_poll_threads();
196 : 6 : CU_ASSERT(g_fserrno == 0);
197 : 6 : }
198 : :
199 : : static void
200 : 6 : fs_truncate(void)
201 : : {
202 : : struct spdk_filesystem *fs;
203 : : struct spdk_bs_dev *dev;
204 : :
205 : 6 : dev = init_dev();
206 : :
207 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
208 : 6 : fs_poll_threads();
209 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
210 : 6 : CU_ASSERT(g_fserrno == 0);
211 : 6 : fs = g_fs;
212 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
213 : :
214 : 6 : g_file = NULL;
215 : 6 : g_fserrno = 1;
216 : 6 : spdk_fs_open_file_async(fs, "file1", SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
217 : 6 : fs_poll_threads();
218 : 6 : CU_ASSERT(g_fserrno == 0);
219 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
220 : :
221 : 6 : g_fserrno = 1;
222 : 6 : spdk_file_truncate_async(g_file, 18 * 1024 * 1024 + 1, fs_op_complete, NULL);
223 : 6 : fs_poll_threads();
224 : 6 : CU_ASSERT(g_fserrno == 0);
225 : 6 : CU_ASSERT(g_file->length == 18 * 1024 * 1024 + 1);
226 : :
227 : 6 : g_fserrno = 1;
228 : 6 : spdk_file_truncate_async(g_file, 1, fs_op_complete, NULL);
229 : 6 : fs_poll_threads();
230 : 6 : CU_ASSERT(g_fserrno == 0);
231 : 6 : CU_ASSERT(g_file->length == 1);
232 : :
233 : 6 : g_fserrno = 1;
234 : 6 : spdk_file_truncate_async(g_file, 18 * 1024 * 1024 + 1, fs_op_complete, NULL);
235 : 6 : fs_poll_threads();
236 : 6 : CU_ASSERT(g_fserrno == 0);
237 : 6 : CU_ASSERT(g_file->length == 18 * 1024 * 1024 + 1);
238 : :
239 : 6 : g_fserrno = 1;
240 : 6 : spdk_file_close_async(g_file, fs_op_complete, NULL);
241 : 6 : fs_poll_threads();
242 : 6 : CU_ASSERT(g_fserrno == 0);
243 : 6 : CU_ASSERT(g_file->ref_count == 0);
244 : :
245 : 6 : g_fserrno = 1;
246 : 6 : spdk_fs_delete_file_async(fs, "file1", delete_cb, NULL);
247 : 6 : fs_poll_threads();
248 : 6 : CU_ASSERT(g_fserrno == 0);
249 : 6 : CU_ASSERT(TAILQ_EMPTY(&fs->files));
250 : :
251 : 6 : g_fserrno = 1;
252 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
253 : 6 : fs_poll_threads();
254 : 6 : CU_ASSERT(g_fserrno == 0);
255 : 6 : }
256 : :
257 : : static void
258 : 6 : fs_rename(void)
259 : : {
260 : : struct spdk_filesystem *fs;
261 : : struct spdk_file *file, *file2, *file_iter;
262 : : struct spdk_bs_dev *dev;
263 : :
264 : 6 : dev = init_dev();
265 : :
266 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
267 : 6 : fs_poll_threads();
268 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
269 : 6 : CU_ASSERT(g_fserrno == 0);
270 : 6 : fs = g_fs;
271 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
272 : :
273 : 6 : g_fserrno = 1;
274 : 6 : spdk_fs_create_file_async(fs, "file1", create_cb, NULL);
275 : 6 : fs_poll_threads();
276 : 6 : CU_ASSERT(g_fserrno == 0);
277 : :
278 : 6 : g_file = NULL;
279 : 6 : g_fserrno = 1;
280 : 6 : spdk_fs_open_file_async(fs, "file1", 0, open_cb, NULL);
281 : 6 : fs_poll_threads();
282 : 6 : CU_ASSERT(g_fserrno == 0);
283 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
284 : 6 : CU_ASSERT(g_file->ref_count == 1);
285 : :
286 : 6 : file = g_file;
287 : 6 : g_file = NULL;
288 : 6 : g_fserrno = 1;
289 : 6 : spdk_file_close_async(file, fs_op_complete, NULL);
290 : 6 : fs_poll_threads();
291 : 6 : CU_ASSERT(g_fserrno == 0);
292 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(file->ref_count == 0);
293 : :
294 : 6 : g_file = NULL;
295 : 6 : g_fserrno = 1;
296 : 6 : spdk_fs_open_file_async(fs, "file2", SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
297 : 6 : fs_poll_threads();
298 : 6 : CU_ASSERT(g_fserrno == 0);
299 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
300 : 6 : CU_ASSERT(g_file->ref_count == 1);
301 : :
302 : 6 : file2 = g_file;
303 : 6 : g_file = NULL;
304 : 6 : g_fserrno = 1;
305 : 6 : spdk_file_close_async(file2, fs_op_complete, NULL);
306 : 6 : fs_poll_threads();
307 : 6 : CU_ASSERT(g_fserrno == 0);
308 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(file2->ref_count == 0);
309 : :
310 : : /*
311 : : * Do a 3-way rename. This should delete the old "file2", then rename
312 : : * "file1" to "file2".
313 : : */
314 : 6 : g_fserrno = 1;
315 : 6 : spdk_fs_rename_file_async(fs, "file1", "file2", fs_op_complete, NULL);
316 : 6 : fs_poll_threads();
317 : 6 : CU_ASSERT(g_fserrno == 0);
318 : 6 : CU_ASSERT(file->ref_count == 0);
319 [ - + ]: 6 : CU_ASSERT(!strcmp(file->name, "file2"));
320 : 6 : CU_ASSERT(TAILQ_FIRST(&fs->files) == file);
321 : 6 : CU_ASSERT(TAILQ_NEXT(file, tailq) == NULL);
322 : :
323 : 6 : g_fserrno = 0;
324 : 6 : spdk_fs_delete_file_async(fs, "file1", delete_cb, NULL);
325 : 6 : fs_poll_threads();
326 : 6 : CU_ASSERT(g_fserrno == -ENOENT);
327 : 6 : CU_ASSERT(!TAILQ_EMPTY(&fs->files));
328 [ + + ]: 12 : TAILQ_FOREACH(file_iter, &fs->files, tailq) {
329 [ - + ]: 6 : if (file_iter == NULL) {
330 [ # # ]: 0 : SPDK_CU_ASSERT_FATAL(false);
331 : : }
332 : : }
333 : :
334 : 6 : g_fserrno = 1;
335 : 6 : spdk_fs_delete_file_async(fs, "file2", delete_cb, NULL);
336 : 6 : fs_poll_threads();
337 : 6 : CU_ASSERT(g_fserrno == 0);
338 : 6 : CU_ASSERT(TAILQ_EMPTY(&fs->files));
339 : :
340 : 6 : g_fserrno = 1;
341 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
342 : 6 : fs_poll_threads();
343 : 6 : CU_ASSERT(g_fserrno == 0);
344 : 6 : }
345 : :
346 : : static void
347 : 6 : fs_rw_async(void)
348 : : {
349 : : struct spdk_filesystem *fs;
350 : : struct spdk_bs_dev *dev;
351 : 5 : uint8_t w_buf[4096];
352 : 5 : uint8_t r_buf[4096];
353 : :
354 : 6 : dev = init_dev();
355 : :
356 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
357 : 6 : fs_poll_threads();
358 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
359 : 6 : CU_ASSERT(g_fserrno == 0);
360 : 6 : fs = g_fs;
361 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
362 : :
363 : 6 : g_file = NULL;
364 : 6 : g_fserrno = 1;
365 : 6 : spdk_fs_open_file_async(fs, "file1", SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
366 : 6 : fs_poll_threads();
367 : 6 : CU_ASSERT(g_fserrno == 0);
368 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
369 : :
370 : : /* Write file */
371 : 6 : CU_ASSERT(g_file->length == 0);
372 : 6 : g_fserrno = 1;
373 : 6 : memset(w_buf, 0x5a, sizeof(w_buf));
374 : 6 : spdk_file_write_async(g_file, fs->sync_target.sync_io_channel, w_buf, 0, 4096,
375 : : fs_op_complete, NULL);
376 : 6 : fs_poll_threads();
377 : 6 : CU_ASSERT(g_fserrno == 0);
378 : 6 : CU_ASSERT(g_file->length == 4096);
379 : :
380 : : /* Read file */
381 : 6 : g_fserrno = 1;
382 : 6 : memset(r_buf, 0x0, sizeof(r_buf));
383 : 6 : spdk_file_read_async(g_file, fs->sync_target.sync_io_channel, r_buf, 0, 4096,
384 : : fs_op_complete, NULL);
385 : 6 : fs_poll_threads();
386 : 6 : CU_ASSERT(g_fserrno == 0);
387 : 6 : CU_ASSERT(memcmp(r_buf, w_buf, sizeof(r_buf)) == 0);
388 : :
389 : 6 : g_fserrno = 1;
390 : 6 : spdk_file_close_async(g_file, fs_op_complete, NULL);
391 : 6 : fs_poll_threads();
392 : 6 : CU_ASSERT(g_fserrno == 0);
393 : :
394 : 6 : g_fserrno = 1;
395 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
396 : 6 : fs_poll_threads();
397 : 6 : CU_ASSERT(g_fserrno == 0);
398 : 6 : }
399 : :
400 : : static void
401 : 6 : fs_writev_readv_async(void)
402 : : {
403 : : struct spdk_filesystem *fs;
404 : : struct spdk_bs_dev *dev;
405 : 5 : struct iovec w_iov[2];
406 : 5 : struct iovec r_iov[2];
407 : 5 : uint8_t w_buf[4096];
408 : 5 : uint8_t r_buf[4096];
409 : :
410 : 6 : dev = init_dev();
411 : :
412 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
413 : 6 : fs_poll_threads();
414 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
415 : 6 : CU_ASSERT(g_fserrno == 0);
416 : 6 : fs = g_fs;
417 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
418 : :
419 : 6 : g_file = NULL;
420 : 6 : g_fserrno = 1;
421 : 6 : spdk_fs_open_file_async(fs, "file1", SPDK_BLOBFS_OPEN_CREATE, open_cb, NULL);
422 : 6 : fs_poll_threads();
423 : 6 : CU_ASSERT(g_fserrno == 0);
424 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_file != NULL);
425 : :
426 : : /* Write file */
427 : 6 : CU_ASSERT(g_file->length == 0);
428 : 6 : g_fserrno = 1;
429 : 6 : memset(w_buf, 0x5a, sizeof(w_buf));
430 : 6 : w_iov[0].iov_base = w_buf;
431 : 6 : w_iov[0].iov_len = 2048;
432 : 6 : w_iov[1].iov_base = w_buf + 2048;
433 : 6 : w_iov[1].iov_len = 2048;
434 : 6 : spdk_file_writev_async(g_file, fs->sync_target.sync_io_channel,
435 : : w_iov, 2, 0, 4096, fs_op_complete, NULL);
436 : 6 : fs_poll_threads();
437 : 6 : CU_ASSERT(g_fserrno == 0);
438 : 6 : CU_ASSERT(g_file->length == 4096);
439 : :
440 : : /* Read file */
441 : 6 : g_fserrno = 1;
442 : 6 : memset(r_buf, 0x0, sizeof(r_buf));
443 : 6 : r_iov[0].iov_base = r_buf;
444 : 6 : r_iov[0].iov_len = 2048;
445 : 6 : r_iov[1].iov_base = r_buf + 2048;
446 : 6 : r_iov[1].iov_len = 2048;
447 : 6 : spdk_file_readv_async(g_file, fs->sync_target.sync_io_channel,
448 : : r_iov, 2, 0, 4096, fs_op_complete, NULL);
449 : 6 : fs_poll_threads();
450 : 6 : CU_ASSERT(g_fserrno == 0);
451 : 6 : CU_ASSERT(memcmp(r_buf, w_buf, sizeof(r_buf)) == 0);
452 : :
453 : : /* Overwrite file with block aligned */
454 : 6 : g_fserrno = 1;
455 : 6 : memset(w_buf, 0x6a, sizeof(w_buf));
456 : 6 : w_iov[0].iov_base = w_buf;
457 : 6 : w_iov[0].iov_len = 2048;
458 : 6 : w_iov[1].iov_base = w_buf + 2048;
459 : 6 : w_iov[1].iov_len = 2048;
460 : 6 : spdk_file_writev_async(g_file, fs->sync_target.sync_io_channel,
461 : : w_iov, 2, 0, 4096, fs_op_complete, NULL);
462 : 6 : fs_poll_threads();
463 : 6 : CU_ASSERT(g_fserrno == 0);
464 : 6 : CU_ASSERT(g_file->length == 4096);
465 : :
466 : : /* Read file to verify the overwritten data */
467 : 6 : g_fserrno = 1;
468 : 6 : memset(r_buf, 0x0, sizeof(r_buf));
469 : 6 : r_iov[0].iov_base = r_buf;
470 : 6 : r_iov[0].iov_len = 2048;
471 : 6 : r_iov[1].iov_base = r_buf + 2048;
472 : 6 : r_iov[1].iov_len = 2048;
473 : 6 : spdk_file_readv_async(g_file, fs->sync_target.sync_io_channel,
474 : : r_iov, 2, 0, 4096, fs_op_complete, NULL);
475 : 6 : fs_poll_threads();
476 : 6 : CU_ASSERT(g_fserrno == 0);
477 : 6 : CU_ASSERT(memcmp(r_buf, w_buf, sizeof(r_buf)) == 0);
478 : :
479 : 6 : g_fserrno = 1;
480 : 6 : spdk_file_close_async(g_file, fs_op_complete, NULL);
481 : 6 : fs_poll_threads();
482 : 6 : CU_ASSERT(g_fserrno == 0);
483 : :
484 : 6 : g_fserrno = 1;
485 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
486 : 6 : fs_poll_threads();
487 : 6 : CU_ASSERT(g_fserrno == 0);
488 : 6 : }
489 : :
490 : : static void
491 : 6 : tree_find_buffer_ut(void)
492 : : {
493 : : struct cache_tree *root;
494 : : struct cache_tree *level1_0;
495 : : struct cache_tree *level0_0_0;
496 : : struct cache_tree *level0_0_12;
497 : : struct cache_buffer *leaf_0_0_4;
498 : : struct cache_buffer *leaf_0_12_8;
499 : : struct cache_buffer *leaf_9_23_15;
500 : : struct cache_buffer *buffer;
501 : :
502 : 6 : level1_0 = calloc(1, sizeof(struct cache_tree));
503 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(level1_0 != NULL);
504 : 6 : level0_0_0 = calloc(1, sizeof(struct cache_tree));
505 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(level0_0_0 != NULL);
506 : 6 : level0_0_12 = calloc(1, sizeof(struct cache_tree));
507 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(level0_0_12 != NULL);
508 : 6 : leaf_0_0_4 = calloc(1, sizeof(struct cache_buffer));
509 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(leaf_0_0_4 != NULL);
510 : 6 : leaf_0_12_8 = calloc(1, sizeof(struct cache_buffer));
511 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(leaf_0_12_8 != NULL);
512 : 6 : leaf_9_23_15 = calloc(1, sizeof(struct cache_buffer));
513 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(leaf_9_23_15 != NULL);
514 : :
515 : 6 : level1_0->level = 1;
516 : 6 : level0_0_0->level = 0;
517 : 6 : level0_0_12->level = 0;
518 : :
519 : 6 : leaf_0_0_4->offset = CACHE_BUFFER_SIZE * 4;
520 : 6 : level0_0_0->u.buffer[4] = leaf_0_0_4;
521 : 6 : level0_0_0->present_mask |= (1ULL << 4);
522 : :
523 : 6 : leaf_0_12_8->offset = CACHE_TREE_LEVEL_SIZE(1) * 12 + CACHE_BUFFER_SIZE * 8;
524 : 6 : level0_0_12->u.buffer[8] = leaf_0_12_8;
525 : 6 : level0_0_12->present_mask |= (1ULL << 8);
526 : :
527 : 6 : level1_0->u.tree[0] = level0_0_0;
528 : 6 : level1_0->present_mask |= (1ULL << 0);
529 : 6 : level1_0->u.tree[12] = level0_0_12;
530 : 6 : level1_0->present_mask |= (1ULL << 12);
531 : :
532 : 6 : buffer = tree_find_buffer(NULL, 0);
533 : 6 : CU_ASSERT(buffer == NULL);
534 : :
535 : 6 : buffer = tree_find_buffer(level0_0_0, 0);
536 : 6 : CU_ASSERT(buffer == NULL);
537 : :
538 : 6 : buffer = tree_find_buffer(level0_0_0, CACHE_TREE_LEVEL_SIZE(0) + 1);
539 : 6 : CU_ASSERT(buffer == NULL);
540 : :
541 : 6 : buffer = tree_find_buffer(level0_0_0, leaf_0_0_4->offset);
542 : 6 : CU_ASSERT(buffer == leaf_0_0_4);
543 : :
544 : 6 : buffer = tree_find_buffer(level1_0, leaf_0_0_4->offset);
545 : 6 : CU_ASSERT(buffer == leaf_0_0_4);
546 : :
547 : 6 : buffer = tree_find_buffer(level1_0, leaf_0_12_8->offset);
548 : 6 : CU_ASSERT(buffer == leaf_0_12_8);
549 : :
550 : 6 : buffer = tree_find_buffer(level1_0, leaf_0_12_8->offset + CACHE_BUFFER_SIZE - 1);
551 : 6 : CU_ASSERT(buffer == leaf_0_12_8);
552 : :
553 : 6 : buffer = tree_find_buffer(level1_0, leaf_0_12_8->offset - 1);
554 : 6 : CU_ASSERT(buffer == NULL);
555 : :
556 : 6 : leaf_9_23_15->offset = CACHE_TREE_LEVEL_SIZE(2) * 9 +
557 : : CACHE_TREE_LEVEL_SIZE(1) * 23 +
558 : : CACHE_BUFFER_SIZE * 15;
559 : 6 : root = tree_insert_buffer(level1_0, leaf_9_23_15);
560 : 6 : CU_ASSERT(root != level1_0);
561 : 6 : buffer = tree_find_buffer(root, leaf_9_23_15->offset);
562 : 6 : CU_ASSERT(buffer == leaf_9_23_15);
563 : 6 : tree_free_buffers(root);
564 : 6 : free(root);
565 : 6 : }
566 : :
567 : : static void
568 : 6 : channel_ops(void)
569 : : {
570 : : struct spdk_filesystem *fs;
571 : : struct spdk_bs_dev *dev;
572 : : struct spdk_io_channel *channel;
573 : :
574 : 6 : dev = init_dev();
575 : :
576 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
577 : 6 : fs_poll_threads();
578 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
579 : 6 : CU_ASSERT(g_fserrno == 0);
580 : 6 : fs = g_fs;
581 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
582 : :
583 : 6 : channel = spdk_fs_alloc_io_channel(fs);
584 : 6 : CU_ASSERT(channel != NULL);
585 : :
586 : 6 : spdk_fs_free_io_channel(channel);
587 : :
588 : 6 : g_fserrno = 1;
589 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
590 : 6 : fs_poll_threads();
591 : 6 : CU_ASSERT(g_fserrno == 0);
592 : 6 : g_fs = NULL;
593 : 6 : }
594 : :
595 : : static void
596 : 6 : channel_ops_sync(void)
597 : : {
598 : : struct spdk_filesystem *fs;
599 : : struct spdk_bs_dev *dev;
600 : : struct spdk_fs_thread_ctx *channel;
601 : :
602 : 6 : dev = init_dev();
603 : :
604 : 6 : spdk_fs_init(dev, NULL, NULL, fs_op_with_handle_complete, NULL);
605 : 6 : fs_poll_threads();
606 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(g_fs != NULL);
607 : 6 : CU_ASSERT(g_fserrno == 0);
608 : 6 : fs = g_fs;
609 [ - + ]: 6 : SPDK_CU_ASSERT_FATAL(fs->bs->dev == dev);
610 : :
611 : 6 : channel = spdk_fs_alloc_thread_ctx(fs);
612 : 6 : CU_ASSERT(channel != NULL);
613 : :
614 : 6 : spdk_fs_free_thread_ctx(channel);
615 : :
616 : 6 : g_fserrno = 1;
617 : 6 : spdk_fs_unload(fs, fs_op_complete, NULL);
618 : 6 : fs_poll_threads();
619 : 6 : CU_ASSERT(g_fserrno == 0);
620 : 6 : g_fs = NULL;
621 : 6 : }
622 : :
623 : : int
624 : 6 : main(int argc, char **argv)
625 : : {
626 : 6 : CU_pSuite suite = NULL;
627 : : unsigned int num_failures;
628 : :
629 : 6 : CU_initialize_registry();
630 : :
631 : 6 : suite = CU_add_suite("blobfs_async_ut", NULL, NULL);
632 : :
633 : 6 : CU_ADD_TEST(suite, fs_init);
634 : 6 : CU_ADD_TEST(suite, fs_open);
635 : 6 : CU_ADD_TEST(suite, fs_create);
636 : 6 : CU_ADD_TEST(suite, fs_truncate);
637 : 6 : CU_ADD_TEST(suite, fs_rename);
638 : 6 : CU_ADD_TEST(suite, fs_rw_async);
639 : 6 : CU_ADD_TEST(suite, fs_writev_readv_async);
640 : 6 : CU_ADD_TEST(suite, tree_find_buffer_ut);
641 : 6 : CU_ADD_TEST(suite, channel_ops);
642 : 6 : CU_ADD_TEST(suite, channel_ops_sync);
643 : :
644 : 6 : allocate_threads(1);
645 : 6 : set_thread(0);
646 : :
647 : 6 : g_dev_buffer = calloc(1, DEV_BUFFER_SIZE);
648 : 6 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
649 : 6 : CU_cleanup_registry();
650 : 6 : free(g_dev_buffer);
651 : :
652 : 6 : free_threads();
653 : :
654 : 6 : return num_failures;
655 : : }
|