Lines Matching defs:bdev
16 #include "bdev/bdev.c"
18 #include "common/lib/bdev/common_stubs.h"
198 uint32_t len = bdev_io->u.bdev.iovs[0].iov_len;
200 CU_ASSERT(bdev_io->u.bdev.iovcnt == 1);
202 memcpy(bdev_io->u.bdev.iovs[0].iov_base, g_compare_read_buf, len);
203 if (bdev_io->bdev->md_len && bdev_io->u.bdev.md_buf && g_compare_md_buf) {
204 memcpy(bdev_io->u.bdev.md_buf, g_compare_md_buf,
205 bdev_io->bdev->md_len * bdev_io->u.bdev.num_blocks);
210 uint32_t len = bdev_io->u.bdev.iovs[0].iov_len;
212 CU_ASSERT(bdev_io->u.bdev.iovcnt == 1);
214 memcpy(g_compare_write_buf, bdev_io->u.bdev.iovs[0].iov_base, len);
218 uint32_t len = bdev_io->u.bdev.iovs[0].iov_len;
220 CU_ASSERT(bdev_io->u.bdev.iovcnt == 1);
222 if (memcmp(bdev_io->u.bdev.iovs[0].iov_base, g_compare_read_buf, len)) {
225 if (bdev_io->u.bdev.md_buf &&
226 memcmp(bdev_io->u.bdev.md_buf, g_compare_md_buf,
227 bdev_io->bdev->md_len * bdev_io->u.bdev.num_blocks)) {
247 if (bdev_io->u.bdev.zcopy.start) {
249 if (bdev_io->u.bdev.zcopy.populate) {
253 bdev_io->u.bdev.iovs[0].iov_base = g_zcopy_read_buf;
254 bdev_io->u.bdev.iovs[0].iov_len = g_zcopy_read_buf_len;
255 bdev_io->u.bdev.iovcnt = 1;
260 bdev_io->u.bdev.iovs[0].iov_base = g_zcopy_write_buf;
261 bdev_io->u.bdev.iovs[0].iov_len = g_zcopy_write_buf_len;
262 bdev_io->u.bdev.iovcnt = 1;
265 if (bdev_io->u.bdev.zcopy.commit) {
267 CU_ASSERT(bdev_io->u.bdev.iovs[0].iov_base == g_zcopy_write_buf);
268 CU_ASSERT(bdev_io->u.bdev.iovs[0].iov_len == g_zcopy_write_buf_len);
269 CU_ASSERT(bdev_io->u.bdev.iovcnt == 1);
274 CU_ASSERT(bdev_io->u.bdev.iovs[0].iov_base == g_zcopy_read_buf);
275 CU_ASSERT(bdev_io->u.bdev.iovs[0].iov_len == g_zcopy_read_buf_len);
276 CU_ASSERT(bdev_io->u.bdev.iovcnt == 1);
284 bdev_io->u.bdev.seek.offset = g_seek_data_offset;
288 bdev_io->u.bdev.seek.offset = g_seek_hole_offset;
305 CU_ASSERT(expected_io->md_buf == bdev_io->u.bdev.md_buf);
313 CU_ASSERT(expected_io->offset == bdev_io->u.bdev.offset_blocks);
314 CU_ASSERT(expected_io->length == bdev_io->u.bdev.num_blocks);
316 CU_ASSERT(expected_io->src_offset == bdev_io->u.bdev.copy.src_offset_blocks);
325 CU_ASSERT(expected_io->iovcnt == bdev_io->u.bdev.iovcnt);
329 iov = &bdev_io->u.bdev.iovs[i];
353 bdev_io->u.bdev.num_blocks * bdev_io->bdev->blocklen);
470 static void vbdev_ut_examine_config(struct spdk_bdev *bdev);
471 static void vbdev_ut_examine_disk(struct spdk_bdev *bdev);
503 void (*examine_config)(struct spdk_bdev *bdev);
504 void (*examine_disk)(struct spdk_bdev *bdev);
510 vbdev_ut_examine_config(struct spdk_bdev *bdev)
512 struct ut_examine_ctx *ctx = bdev->ctxt;
517 ctx->examine_config(bdev);
525 vbdev_ut_examine_disk(struct spdk_bdev *bdev)
527 struct ut_examine_ctx *ctx = bdev->ctxt;
532 ctx->examine_disk(bdev);
576 struct spdk_bdev *bdev;
579 bdev = calloc(1, sizeof(*bdev));
580 SPDK_CU_ASSERT_FATAL(bdev != NULL);
582 bdev->ctxt = ctx;
583 bdev->name = name;
584 bdev->fn_table = &fn_table;
585 bdev->module = &bdev_ut_if;
586 bdev->blockcnt = 1024;
587 bdev->blocklen = 512;
589 spdk_uuid_generate(&bdev->uuid);
591 rc = spdk_bdev_register(bdev);
595 return bdev;
607 struct spdk_bdev *bdev;
610 bdev = calloc(1, sizeof(*bdev));
611 SPDK_CU_ASSERT_FATAL(bdev != NULL);
613 bdev->name = name;
614 bdev->fn_table = &fn_table;
615 bdev->module = &vbdev_ut_if;
616 bdev->blockcnt = 1024;
617 bdev->blocklen = 512;
619 rc = spdk_bdev_register(bdev);
623 return bdev;
627 free_bdev(struct spdk_bdev *bdev)
629 spdk_bdev_unregister(bdev, NULL, NULL);
631 memset(bdev, 0xFF, sizeof(*bdev));
632 free(bdev);
636 free_vbdev(struct spdk_bdev *bdev)
638 spdk_bdev_unregister(bdev, NULL, NULL);
640 memset(bdev, 0xFF, sizeof(*bdev));
641 free(bdev);
645 get_device_stat_cb(struct spdk_bdev *bdev, struct spdk_bdev_io_stat *stat, void *cb_arg, int rc)
649 CU_ASSERT(bdev != NULL);
651 bdev_name = spdk_bdev_get_name(bdev);
667 bdev_ut_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
672 bdev_open_cb1(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
683 bdev_open_cb2(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
694 bdev_open_cb3(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
700 bdev_open_cb4(enum spdk_bdev_event_type type, struct spdk_bdev *bdev, void *event_ctx)
715 struct spdk_bdev *bdev;
719 bdev = allocate_bdev("bdev0");
722 free_bdev(bdev);
727 spdk_bdev_get_device_stat(bdev, stat, SPDK_BDEV_RESET_STAT_NONE, get_device_stat_cb, &done);
730 free_bdev(bdev);
736 struct spdk_bdev *bdev[9];
748 * bdev4 is a virtual bdev with multiple base bdevs. This models
752 * bdev (except bdev7). This models partitioning or logical volume
755 * bdev7 is a virtual bdev with multiple base bdevs. One of base bdevs
759 * bdev8 is a virtual bdev with multiple base bdevs, but these
773 bdev[0] = allocate_bdev("bdev0");
774 rc = spdk_bdev_module_claim_bdev(bdev[0], NULL, &bdev_ut_if);
777 bdev[1] = allocate_bdev("bdev1");
778 rc = spdk_bdev_module_claim_bdev(bdev[1], NULL, &bdev_ut_if);
781 bdev[2] = allocate_bdev("bdev2");
782 rc = spdk_bdev_module_claim_bdev(bdev[2], NULL, &bdev_ut_if);
785 bdev[3] = allocate_bdev("bdev3");
786 rc = spdk_bdev_module_claim_bdev(bdev[3], NULL, &bdev_ut_if);
789 bdev[4] = allocate_vbdev("bdev4");
790 rc = spdk_bdev_module_claim_bdev(bdev[4], NULL, &bdev_ut_if);
793 bdev[5] = allocate_vbdev("bdev5");
794 rc = spdk_bdev_module_claim_bdev(bdev[5], NULL, &bdev_ut_if);
797 bdev[6] = allocate_vbdev("bdev6");
799 bdev[7] = allocate_vbdev("bdev7");
801 bdev[8] = allocate_vbdev("bdev8");
807 CU_ASSERT(bdev[0] == spdk_bdev_desc_get_bdev(desc[0]));
828 CU_ASSERT(bdev[4] == spdk_bdev_desc_get_bdev(desc[4]));
833 * bdev.
838 CU_ASSERT(bdev[8] == spdk_bdev_desc_get_bdev(desc[8]));
852 CU_ASSERT(bdev[5] == spdk_bdev_desc_get_bdev(desc[5]));
855 free_vbdev(bdev[8]);
857 free_vbdev(bdev[5]);
858 free_vbdev(bdev[6]);
859 free_vbdev(bdev[7]);
861 free_vbdev(bdev[4]);
863 free_bdev(bdev[0]);
864 free_bdev(bdev[1]);
865 free_bdev(bdev[2]);
866 free_bdev(bdev[3]);
874 struct spdk_bdev *bdev;
882 * A vbdev that uses a read-only bdev may need it to remain read-only.
883 * To do so, it opens the bdev read-only, then claims it without
886 bdev = allocate_bdev("bdev0");
891 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
893 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE);
894 CU_ASSERT(bdev->internal.claim.v1.module == &bdev_ut_if);
898 TAILQ_FOREACH(open_desc, &bdev->internal.open_descs, link) {
905 /* A read-only bdev is upgraded to read-write if desc is passed. */
906 spdk_bdev_module_release_bdev(bdev);
907 rc = spdk_bdev_module_claim_bdev(bdev, desc, &bdev_ut_if);
909 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE);
910 CU_ASSERT(bdev->internal.claim.v1.module == &bdev_ut_if);
914 TAILQ_FOREACH(open_desc, &bdev->internal.open_descs, link) {
922 free_bdev(bdev);
930 struct spdk_bdev bdev = {0};
934 desc.bdev = &bdev;
935 memset(&bdev, 0, sizeof(bdev));
937 bdev.blocklen = 512;
953 bdev.blocklen = 100;
968 struct spdk_bdev *bdev;
973 bdev = allocate_bdev("num_blocks");
975 spdk_bdev_notify_blockcnt_change(bdev, 50);
978 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 70) == 0);
980 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 30) == 0);
985 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
988 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 80) == 0);
990 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 20) != 0);
994 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 90) == 0);
1001 CU_ASSERT(spdk_bdev_notify_blockcnt_change(bdev, 100) == 0);
1004 free_bdev(bdev);
1016 struct spdk_bdev bdev;
1018 memset(&bdev, 0, sizeof(bdev));
1020 bdev.blocklen = 512;
1021 spdk_spin_init(&bdev.internal.spinlock);
1023 spdk_bdev_notify_blockcnt_change(&bdev, 100);
1026 CU_ASSERT(bdev_io_valid_blocks(&bdev, 1, 2) == true);
1029 CU_ASSERT(bdev_io_valid_blocks(&bdev, 99, 1) == true);
1031 /* Offset past end of bdev */
1032 CU_ASSERT(bdev_io_valid_blocks(&bdev, 100, 1) == false);
1034 /* Offset + length past end of bdev */
1035 CU_ASSERT(bdev_io_valid_blocks(&bdev, 99, 2) == false);
1038 CU_ASSERT(bdev_io_valid_blocks(&bdev, 18446744073709551615ULL, 1) == false);
1040 spdk_spin_destroy(&bdev.internal.spinlock);
1046 struct spdk_bdev *bdev[3];
1052 bdev[0] = allocate_bdev("bdev0");
1053 SPDK_CU_ASSERT_FATAL(bdev[0] != 0);
1055 bdev[1] = allocate_bdev("bdev1");
1056 SPDK_CU_ASSERT_FATAL(bdev[1] != 0);
1058 bdev[2] = allocate_bdev("bdev2");
1059 SPDK_CU_ASSERT_FATAL(bdev[2] != 0);
1067 rc = spdk_bdev_alias_add(bdev[0], bdev[0]->name);
1074 rc = spdk_bdev_alias_add(bdev[0], NULL);
1080 rc = spdk_bdev_alias_add(bdev[0], "proper alias 0");
1083 /* Alias was added to another bdev, so this one should fail */
1084 rc = spdk_bdev_alias_add(bdev[1], "proper alias 0");
1088 rc = spdk_bdev_alias_add(bdev[1], "proper alias 1");
1093 /* Alias is not on a bdev aliases list, so this one should fail */
1094 rc = spdk_bdev_alias_del(bdev[0], "not existing");
1097 /* Alias is present on a bdev aliases list, so this one should pass */
1098 rc = spdk_bdev_alias_del(bdev[0], "proper alias 0");
1101 /* Alias is present on a bdev aliases list, so this one should pass */
1102 rc = spdk_bdev_alias_del(bdev[1], "proper alias 1");
1106 rc = spdk_bdev_alias_del(bdev[0], bdev[0]->name);
1110 spdk_bdev_alias_del_all(bdev[2]);
1111 SPDK_CU_ASSERT_FATAL(TAILQ_EMPTY(&bdev[2]->aliases));
1114 rc = spdk_bdev_alias_add(bdev[2], "alias0");
1116 rc = spdk_bdev_alias_add(bdev[2], "alias1");
1118 spdk_bdev_alias_del_all(bdev[2]);
1119 CU_ASSERT(TAILQ_EMPTY(&bdev[2]->aliases));
1122 spdk_bdev_unregister(bdev[0], NULL, NULL);
1123 spdk_bdev_unregister(bdev[1], NULL, NULL);
1124 spdk_bdev_unregister(bdev[2], NULL, NULL);
1128 free(bdev[0]);
1129 free(bdev[1]);
1130 free(bdev[2]);
1141 (bdev_io->u.bdev.zcopy.start)) {
1170 struct spdk_bdev *bdev;
1181 bdev = allocate_bdev("bdev0");
1187 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
1215 free_bdev(bdev);
1222 struct spdk_bdev *bdev;
1235 bdev = allocate_bdev("bdev0");
1241 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
1258 io_wait_entry.entry.bdev = bdev;
1269 rc = spdk_bdev_queue_io_wait(bdev, io_ch, &io_wait_entry.entry);
1272 rc = spdk_bdev_queue_io_wait(bdev, io_ch, &io_wait_entry2.entry);
1290 free_bdev(bdev);
1297 struct spdk_bdev bdev;
1301 memset(&bdev, 0, sizeof(bdev));
1302 bdev_io.u.bdev.iovs = iov;
1305 bdev.optimal_io_boundary = 0;
1306 bdev.max_segment_size = 0;
1307 bdev.max_num_segments = 0;
1308 bdev_io.bdev = &bdev;
1310 /* bdev has no optimal_io_boundary and max_size set - so this should return false. */
1313 bdev.split_on_optimal_io_boundary = true;
1314 bdev.optimal_io_boundary = 32;
1321 bdev_io.u.bdev.offset_blocks = 0;
1322 bdev_io.u.bdev.num_blocks = 32;
1327 bdev_io.u.bdev.num_blocks = 33;
1332 bdev_io.u.bdev.num_blocks = 32;
1333 bdev.max_segment_size = 512 * 32;
1334 bdev.max_num_segments = 1;
1335 bdev_io.u.bdev.iovcnt = 1;
1341 bdev.split_on_optimal_io_boundary = false;
1342 bdev.max_segment_size = 512;
1343 bdev.max_num_segments = 1;
1344 bdev_io.u.bdev.iovcnt = 2;
1349 bdev.max_num_segments = 2;
1356 bdev.max_segment_size = 0;
1357 bdev.write_unit_size = 32;
1358 bdev.split_on_write_unit = true;
1364 bdev_io.u.bdev.num_blocks = 32 * 2;
1369 bdev_io.u.bdev.offset_blocks = 1;
1370 bdev_io.u.bdev.num_blocks = 32;
1379 struct spdk_bdev *bdev;
1394 bdev = allocate_bdev("bdev0");
1399 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
1403 bdev->optimal_io_boundary = 16;
1404 bdev->split_on_optimal_io_boundary = false;
1422 bdev->split_on_optimal_io_boundary = true;
1423 bdev->md_interleave = false;
1424 bdev->md_len = 8;
1500 bdev->optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
1556 bdev->optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
1616 bdev->optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
1668 bdev->optimal_io_boundary = 128;
1848 bdev->optimal_io_boundary = 15;
1861 bdev->optimal_io_boundary = 16;
1874 bdev->optimal_io_boundary = 16;
1887 bdev->optimal_io_boundary = 15;
1902 bdev->optimal_io_boundary = 16;
1937 bdev->optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
1967 bdev->optimal_io_boundary = 32;
1968 bdev->split_on_optimal_io_boundary = true;
2022 free_bdev(bdev);
2029 struct spdk_bdev *bdev;
2044 bdev = allocate_bdev("bdev0");
2046 rc = spdk_bdev_open_ext(bdev->name, true, bdev_ut_event_cb, NULL, &desc);
2052 bdev->split_on_optimal_io_boundary = false;
2053 bdev->optimal_io_boundary = 0;
2058 bdev->max_segment_size = 512;
2059 bdev->max_num_segments = 0;
2079 bdev->max_segment_size = 0;
2080 bdev->max_num_segments = 1;
2108 bdev->max_segment_size = 512;
2109 bdev->max_num_segments = 1;
2135 bdev->max_segment_size = 2 * 512;
2136 bdev->max_num_segments = 1;
2184 bdev->max_segment_size = 512;
2185 bdev->max_num_segments = 1;
2235 bdev->max_segment_size = 512;
2236 bdev->max_num_segments = 1;
2275 bdev->max_segment_size = 512;
2276 bdev->max_num_segments = SPDK_BDEV_IO_NUM_CHILD_IOV;
2324 bdev->max_segment_size = 512;
2325 bdev->max_num_segments = SPDK_BDEV_IO_NUM_CHILD_IOV;
2378 bdev->max_segment_size = 512 + 128;
2379 bdev->max_num_segments = 3;
2524 bdev->max_segment_size = 512;
2525 bdev->max_num_segments = 1;
2578 bdev->max_rw_size = 2;
2579 bdev->max_segment_size = 0;
2580 bdev->max_num_segments = 0;
2610 bdev->max_rw_size = 2;
2611 bdev->max_num_segments = 2;
2612 bdev->max_segment_size = 0;
2655 bdev->max_rw_size = 2;
2656 bdev->max_segment_size = 512;
2657 bdev->max_num_segments = 0;
2682 bdev->max_rw_size = 1;
2683 bdev->max_segment_size = 0;
2684 bdev->max_num_segments = 0;
2712 free_bdev(bdev);
2719 struct spdk_bdev *bdev;
2733 bdev = allocate_bdev("bdev0");
2735 rc = spdk_bdev_open_ext(bdev->name, true, bdev_ut_event_cb, NULL, &desc);
2742 bdev->split_on_optimal_io_boundary = true;
2743 bdev->optimal_io_boundary = 16;
2745 bdev->max_segment_size = 512;
2746 bdev->max_num_segments = 16;
2775 bdev->max_segment_size = 15 * 512;
2776 bdev->max_num_segments = 1;
2813 bdev->max_segment_size = 17 * 512;
2814 bdev->max_num_segments = 1;
2843 bdev->max_segment_size = 3 * 512;
2844 bdev->max_num_segments = 6;
2896 bdev->max_segment_size = 3 * 512;
2897 bdev->max_num_segments = SPDK_BDEV_IO_NUM_CHILD_IOV;
2977 free_bdev(bdev);
2984 struct spdk_bdev *bdev;
2999 bdev = allocate_bdev("bdev0");
3004 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3010 bdev->optimal_io_boundary = 16;
3011 bdev->split_on_optimal_io_boundary = true;
3110 free_bdev(bdev);
3117 struct spdk_bdev *bdev;
3131 bdev = allocate_bdev("bdev0");
3133 rc = spdk_bdev_open_ext(bdev->name, true, bdev_ut_event_cb, NULL, &desc);
3140 bdev->write_unit_size = 32;
3141 bdev->split_on_write_unit = true;
3164 bdev->split_on_optimal_io_boundary = true;
3165 bdev->optimal_io_boundary = 16;
3206 bdev->write_unit_size = SPDK_COUNTOF(iov) / 2;
3227 free_bdev(bdev);
3234 struct spdk_bdev *bdev;
3250 bdev = allocate_bdev("bdev0");
3255 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3265 bdev->required_alignment = spdk_u32log2(alignment);
3270 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3276 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3281 bdev->required_alignment = spdk_u32log2(alignment);
3286 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == buf + 4);
3292 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == buf + 4);
3297 bdev->required_alignment = spdk_u32log2(alignment);
3302 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3303 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3311 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3312 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3319 bdev->required_alignment = spdk_u32log2(alignment);
3324 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3325 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3333 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3334 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3341 bdev->required_alignment = spdk_u32log2(alignment);
3351 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == iovs[0].iov_base);
3357 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == iovs[0].iov_base);
3361 bdev->required_alignment = spdk_u32log2(alignment);
3373 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == iovs[0].iov_base);
3379 CU_ASSERT(g_bdev_io->u.bdev.iovs[0].iov_base == iovs[0].iov_base);
3383 bdev->required_alignment = spdk_u32log2(alignment);
3394 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3395 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3403 CU_ASSERT(g_bdev_io->u.bdev.iovs == &g_bdev_io->internal.bounce_buf.iov);
3404 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3411 bdev->required_alignment = spdk_u32log2(alignment);
3420 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3426 bdev->required_alignment = spdk_u32log2(alignment);
3435 CU_ASSERT(_are_iovs_aligned(g_bdev_io->u.bdev.iovs, g_bdev_io->u.bdev.iovcnt,
3441 free_bdev(bdev);
3451 struct spdk_bdev *bdev;
3468 bdev = allocate_bdev("bdev0");
3473 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3483 /* 512 * 3 with 2 IO boundary, allocate small data buffer from bdev layer */
3485 bdev->required_alignment = spdk_u32log2(alignment);
3486 bdev->optimal_io_boundary = 2;
3487 bdev->split_on_optimal_io_boundary = true;
3498 /* 8KiB with 16 IO boundary, allocate large data buffer from bdev layer */
3500 bdev->required_alignment = spdk_u32log2(alignment);
3501 bdev->optimal_io_boundary = 16;
3502 bdev->split_on_optimal_io_boundary = true;
3515 bdev->required_alignment = spdk_u32log2(alignment);
3516 bdev->optimal_io_boundary = 128;
3517 bdev->split_on_optimal_io_boundary = true;
3531 bdev->required_alignment = spdk_u32log2(alignment);
3532 bdev->optimal_io_boundary = 2;
3533 bdev->split_on_optimal_io_boundary = true;
3552 bdev->optimal_io_boundary = 32;
3581 free_bdev(bdev);
3623 struct spdk_bdev *bdev;
3632 bdev = allocate_bdev("bdev");
3634 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
3637 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3644 spdk_bdev_histogram_enable(bdev, histogram_status_cb, NULL, true);
3647 CU_ASSERT(bdev->internal.histogram_enabled == true);
3654 spdk_bdev_histogram_get(bdev, histogram, histogram_data_cb, NULL);
3680 spdk_bdev_histogram_get(bdev, histogram, histogram_data_cb, NULL);
3683 CU_ASSERT(bdev->internal.histogram_enabled == true);
3696 spdk_bdev_histogram_enable(bdev, histogram_status_cb, NULL, false);
3699 CU_ASSERT(bdev->internal.histogram_enabled == false);
3701 /* Try to run histogram commands on disabled bdev */
3702 spdk_bdev_histogram_get(bdev, histogram, histogram_data_cb, NULL);
3712 free_bdev(bdev);
3719 struct spdk_bdev *bdev;
3744 bdev = allocate_bdev("bdev");
3746 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
3749 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3820 free_bdev(bdev);
3832 struct spdk_bdev *bdev;
3865 bdev = allocate_bdev("bdev");
3867 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
3870 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
3881 bdev->md_interleave = true;
3882 bdev->md_len = 8;
3883 bdev->blocklen = 512 + 8;
3916 bdev->md_interleave = false;
3917 bdev->blocklen = 512;
3970 bdev->md_len = 0;
3975 free_bdev(bdev);
4001 struct spdk_bdev *bdev;
4023 bdev = allocate_bdev("bdev");
4025 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
4028 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4095 free_bdev(bdev);
4108 struct spdk_bdev *bdev;
4117 bdev = allocate_bdev("bdev");
4119 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
4122 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4129 /* First test that if the bdev supports write_zeroes, the request won't be split */
4130 bdev->md_len = 0;
4131 bdev->blocklen = 4096;
4132 num_blocks = (ZERO_BUFFER_SIZE / bdev->blocklen) * 2;
4143 bdev->max_write_zeroes = bdev_get_max_write(bdev, ZERO_BUFFER_SIZE);
4144 num_io_blocks = ZERO_BUFFER_SIZE / bdev->blocklen;
4146 num_blocks = (ZERO_BUFFER_SIZE / bdev->blocklen) * num_requests;
4159 /* Check that the splitting is correct if bdev has interleaved metadata */
4160 bdev->md_interleave = true;
4161 bdev->md_len = 64;
4162 bdev->blocklen = 4096 + 64;
4163 bdev->max_write_zeroes = bdev_get_max_write(bdev, ZERO_BUFFER_SIZE);
4164 num_blocks = (ZERO_BUFFER_SIZE / bdev->blocklen) * 2;
4168 num_io_blocks = spdk_min(ZERO_BUFFER_SIZE / bdev->blocklen, num_blocks - offset);
4184 bdev->md_interleave = false;
4185 bdev->md_len = 64;
4186 bdev->blocklen = 4096;
4187 bdev->max_write_zeroes = bdev_get_max_write(bdev, ZERO_BUFFER_SIZE);
4191 num_io_blocks = spdk_min(ZERO_BUFFER_SIZE / (bdev->blocklen + bdev->md_len), num_blocks);
4194 expected_io->md_buf = (char *)g_bdev_mgr.zero_buffer + num_io_blocks * bdev->blocklen;
4208 free_bdev(bdev);
4215 struct spdk_bdev *bdev;
4230 bdev = allocate_bdev("bdev");
4232 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
4235 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4290 free_bdev(bdev);
4297 struct spdk_bdev *bdev;
4312 bdev = allocate_bdev("bdev");
4314 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
4317 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4374 free_bdev(bdev);
4381 struct spdk_bdev *bdev;
4385 bdev = allocate_bdev("bdev");
4387 rc = spdk_bdev_open_ext("bdev", false, bdev_ut_event_cb, NULL, &desc[0]);
4390 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc[0]));
4392 spdk_bdev_unregister(bdev, NULL, NULL);
4396 rc = spdk_bdev_open_ext("bdev", false, bdev_ut_event_cb, NULL, &desc[1]);
4401 free_bdev(bdev);
4407 struct spdk_bdev *bdev;
4411 bdev = allocate_bdev("bdev");
4413 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb1, &desc, &desc);
4416 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4418 /* Simulate hot-unplug by unregistering bdev */
4422 spdk_bdev_unregister(bdev, bdev_unregister_cb, (void *)0x12345678);
4438 free_bdev(bdev);
4444 struct spdk_bdev *bdev;
4449 bdev = allocate_bdev("bdev");
4451 rc = spdk_bdev_open_ext("bdev", true, NULL, NULL, &desc1);
4454 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb1, &desc1, &desc1);
4457 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb2, &desc2, &desc2);
4463 /* Simulate hot-unplug by unregistering bdev */
4464 spdk_bdev_unregister(bdev, NULL, NULL);
4471 free_bdev(bdev);
4478 struct spdk_bdev *bdev;
4485 bdev = allocate_bdev("bdev");
4487 rc = spdk_bdev_open_ext("bdev", true, NULL, NULL, &desc1);
4490 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb1, &desc1, &desc1);
4493 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb2, &desc2, &desc2);
4496 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb3, &desc3, &desc3);
4499 rc = spdk_bdev_open_ext("bdev", true, bdev_open_cb4, &desc4, &desc4);
4510 /* Simulate hot-unplug by unregistering bdev */
4511 spdk_bdev_unregister(bdev, bdev_unregister_cb, (void *)0x12345678);
4517 * close the desc3 and desc4 so that the bdev is not closed.
4540 * Explicitly close desc4 to trigger the ongoing bdev unregister
4552 free_bdev(bdev);
4591 struct spdk_bdev *bdev;
4598 bdev = allocate_bdev("bdev");
4600 CU_ASSERT(spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc) == 0);
4602 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4624 bdev->optimal_io_boundary = 16;
4625 bdev->split_on_optimal_io_boundary = true;
4692 CU_ASSERT(cb_arg.iov.iov_len == 1 * bdev->blocklen);
4712 CU_ASSERT(cb_arg.iov.iov_len == 8 * bdev->blocklen);
4726 free_bdev(bdev);
4733 struct spdk_bdev *bdev;
4740 bdev = allocate_bdev("bdev");
4742 CU_ASSERT(spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc) == 0);
4744 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4766 * Test the bdev's qd poller register
4769 spdk_bdev_set_qd_sampling_period(bdev, 10);
4770 CU_ASSERT(bdev->internal.new_period == 10);
4771 CU_ASSERT(bdev->internal.period == 10);
4772 CU_ASSERT(bdev->internal.qd_desc != NULL);
4774 CU_ASSERT(bdev->internal.qd_poller != NULL);
4777 spdk_bdev_set_qd_sampling_period(bdev, 20);
4778 CU_ASSERT(bdev->internal.new_period == 20);
4779 CU_ASSERT(bdev->internal.period == 10);
4780 CU_ASSERT(bdev->internal.qd_desc != NULL);
4782 CU_ASSERT(bdev->internal.qd_poller != NULL);
4783 CU_ASSERT(bdev->internal.period == bdev->internal.new_period);
4788 CU_ASSERT(bdev->internal.qd_poll_in_progress == true);
4789 spdk_bdev_set_qd_sampling_period(bdev, 30);
4790 CU_ASSERT(bdev->internal.new_period == 30);
4791 CU_ASSERT(bdev->internal.period == 20);
4793 CU_ASSERT(bdev->internal.qd_poll_in_progress == false);
4794 CU_ASSERT(bdev->internal.period == bdev->internal.new_period);
4797 spdk_bdev_set_qd_sampling_period(bdev, 0);
4798 CU_ASSERT(bdev->internal.new_period == 0);
4799 CU_ASSERT(bdev->internal.period == 30);
4801 CU_ASSERT(bdev->internal.qd_poller == NULL);
4802 CU_ASSERT(bdev->internal.period == bdev->internal.new_period);
4803 CU_ASSERT(bdev->internal.qd_desc == NULL);
4810 spdk_bdev_set_qd_sampling_period(bdev, 1);
4829 free_bdev(bdev);
4896 struct spdk_bdev *bdev;
4905 bdev = allocate_bdev("bdev0");
4910 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
4943 free_bdev(bdev);
4950 struct spdk_bdev *bdev;
4960 bdev = allocate_bdev("bdev0");
4965 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5037 free_bdev(bdev);
5044 struct spdk_bdev *bdev;
5053 bdev = allocate_bdev("bdev0");
5058 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5084 range = TAILQ_FIRST(&bdev->internal.pending_locked_ranges);
5098 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.pending_locked_ranges));
5113 range = TAILQ_FIRST(&bdev->internal.locked_ranges);
5127 range = TAILQ_FIRST(&bdev->internal.pending_locked_ranges);
5142 range = TAILQ_FIRST(&bdev->internal.pending_locked_ranges);
5157 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.pending_locked_ranges));
5158 range = TAILQ_FIRST(&bdev->internal.locked_ranges);
5170 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.locked_ranges));
5174 free_bdev(bdev);
5193 struct spdk_bdev *bdev = ctx;
5198 rc = spdk_bdev_unquiesce(bdev, &bdev_ut_if, bdev_unquiesce_done, NULL);
5205 struct spdk_bdev *bdev;
5215 bdev = allocate_bdev("bdev0");
5220 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5226 rc = spdk_bdev_quiesce(bdev, &bdev_ut_if, bdev_quiesce_done, &ctx1);
5234 CU_ASSERT(range->length == bdev->blockcnt);
5239 CU_ASSERT(range->length == bdev->blockcnt);
5243 rc = spdk_bdev_unquiesce(bdev, &bdev_ut_if, bdev_unquiesce_done, &ctx1);
5253 rc = spdk_bdev_quiesce_range(bdev, &bdev_ut_if, 20, 10, bdev_quiesce_done, &ctx1);
5271 rc = spdk_bdev_unquiesce_range(bdev, &bdev_ut_if, 20, 1, bdev_unquiesce_done, &ctx1);
5275 rc = spdk_bdev_unquiesce_range(bdev, &bdev_ut_if, 20, 10, bdev_unquiesce_done, &ctx1);
5287 rc = spdk_bdev_quiesce(bdev, &bdev_ut_if, bdev_quiesce_done_unquiesce, bdev);
5301 rc = spdk_bdev_quiesce(bdev, &bdev_ut_if, bdev_quiesce_done, &ctx1);
5323 CU_ASSERT(bdev_io->u.bdev.offset_blocks == 20);
5324 CU_ASSERT(bdev_io->u.bdev.num_blocks == 1);
5326 rc = spdk_bdev_unquiesce(bdev, &bdev_ut_if, bdev_unquiesce_done, &ctx1);
5342 free_bdev(bdev);
5357 struct spdk_bdev *bdev;
5372 bdev = allocate_bdev("bdev0");
5377 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5443 bdev->optimal_io_boundary = 16;
5444 bdev->split_on_optimal_io_boundary = true;
5479 bdev->optimal_io_boundary = SPDK_BDEV_IO_NUM_CHILD_IOV;
5502 bdev->optimal_io_boundary = 16;
5534 bdev->split_on_optimal_io_boundary = false;
5535 bdev->split_on_write_unit = true;
5536 bdev->write_unit_size = 16;
5543 * Use bdev->split_on_write_unit as a split condition.
5567 bdev->split_on_write_unit = false;
5568 bdev->max_rw_size = 16;
5571 * Use bdev->max_rw_size as a split condition.
5595 bdev->max_rw_size = 0;
5596 bdev->max_segment_size = 512 * 16;
5597 bdev->max_num_segments = 1;
5600 * Use bdev->max_segment_size and bdev->max_num_segments together as split conditions.
5603 * bdev->max_num_segments is 1 and it is split into two single-vector commands.
5629 free_bdev(bdev);
5636 struct spdk_bdev *bdev;
5651 bdev = allocate_bdev("bdev");
5653 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
5656 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5680 bdev->max_unmap = 8;
5681 bdev->max_unmap_segments = 2;
5682 max_unmap_blocks = bdev->max_unmap * bdev->max_unmap_segments;
5726 free_bdev(bdev);
5733 struct spdk_bdev *bdev;
5748 bdev = allocate_bdev("bdev");
5750 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
5753 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5778 bdev->max_write_zeroes = max_write_zeroes_blocks;
5824 free_bdev(bdev);
5858 struct spdk_bdev bdev = { .fn_table = &fn_table };
5862 /* bdev is NULL */
5867 rc = spdk_bdev_get_memory_domains(&bdev, NULL, 2);
5871 rc = spdk_bdev_get_memory_domains(&bdev, domains, 0);
5875 rc = spdk_bdev_get_memory_domains(&bdev, domains, 2);
5881 rc = spdk_bdev_get_memory_domains(&bdev, domains, 2);
5888 struct spdk_bdev *bdev;
5898 bdev = allocate_bdev("bdev0");
5899 bdev->md_interleave = false;
5900 bdev->md_len = 8;
5905 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
5945 free_bdev(bdev);
5971 struct spdk_bdev *bdev;
5985 bdev = allocate_bdev("bdev0");
5986 bdev->md_interleave = false;
5987 bdev->md_len = 8;
5992 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6018 free_bdev(bdev);
6025 struct spdk_bdev *bdev;
6040 bdev = allocate_bdev("bdev0");
6041 bdev->md_interleave = false;
6042 bdev->md_len = 8;
6047 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6056 bdev->optimal_io_boundary = 16;
6057 bdev->split_on_optimal_io_boundary = true;
6058 bdev->md_interleave = false;
6059 bdev->md_len = 8;
6111 free_bdev(bdev);
6118 struct spdk_bdev *bdev;
6133 bdev = allocate_bdev("bdev0");
6134 bdev->md_interleave = false;
6135 bdev->md_len = 8;
6140 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6145 * bdev doesn't support memory domains, so buffers from bdev memory pool will be used */
6243 free_bdev(bdev);
6250 struct spdk_bdev *bdev, *second;
6255 bdev = allocate_bdev("bdev0");
6258 CU_ASSERT_FALSE(spdk_uuid_is_null(&bdev->uuid));
6261 spdk_uuid_fmt_lower(uuid, sizeof(uuid), &bdev->uuid);
6262 CU_ASSERT_EQUAL(spdk_bdev_get_by_name(uuid), bdev);
6264 /* Unregister the bdev */
6265 spdk_bdev_unregister(bdev, NULL, NULL);
6269 /* Check the same, but this time register the bdev with non-zero UUID */
6270 rc = spdk_bdev_register(bdev);
6272 CU_ASSERT_EQUAL(spdk_bdev_get_by_name(uuid), bdev);
6274 /* Unregister the bdev */
6275 spdk_bdev_unregister(bdev, NULL, NULL);
6279 /* Register the bdev using UUID as the name */
6280 bdev->name = uuid;
6281 rc = spdk_bdev_register(bdev);
6283 CU_ASSERT_EQUAL(spdk_bdev_get_by_name(uuid), bdev);
6285 /* Unregister the bdev */
6286 spdk_bdev_unregister(bdev, NULL, NULL);
6291 bdev->name = "bdev0";
6293 spdk_uuid_copy(&bdev->uuid, &second->uuid);
6294 rc = spdk_bdev_register(bdev);
6298 spdk_uuid_generate(&bdev->uuid);
6299 rc = spdk_bdev_register(bdev);
6303 spdk_uuid_fmt_lower(uuid, sizeof(uuid), &bdev->uuid);
6304 CU_ASSERT_EQUAL(spdk_bdev_get_by_name(uuid), bdev);
6309 free_bdev(bdev);
6316 struct spdk_bdev *bdev;
6319 bdev = allocate_bdev("bdev");
6328 rc = spdk_bdev_unregister_by_name("bdev", &vbdev_ut_if, bdev_unregister_cb, (void *)0x12345678);
6331 rc = spdk_bdev_unregister_by_name("bdev", &bdev_ut_if, bdev_unregister_cb, (void *)0x12345678);
6346 free_bdev(bdev);
6350 count_bdevs(void *ctx, struct spdk_bdev *bdev)
6362 struct spdk_bdev *bdev[8];
6365 bdev[0] = allocate_bdev("bdev0");
6366 bdev[0]->internal.status = SPDK_BDEV_STATUS_REMOVING;
6368 bdev[1] = allocate_bdev("bdev1");
6369 rc = spdk_bdev_module_claim_bdev(bdev[1], NULL, &bdev_ut_if);
6372 bdev[2] = allocate_bdev("bdev2");
6374 bdev[3] = allocate_bdev("bdev3");
6375 rc = spdk_bdev_module_claim_bdev(bdev[3], NULL, &bdev_ut_if);
6378 bdev[4] = allocate_bdev("bdev4");
6380 bdev[5] = allocate_bdev("bdev5");
6381 rc = spdk_bdev_module_claim_bdev(bdev[5], NULL, &bdev_ut_if);
6384 bdev[6] = allocate_bdev("bdev6");
6386 bdev[7] = allocate_bdev("bdev7");
6398 bdev[0]->internal.status = SPDK_BDEV_STATUS_READY;
6399 free_bdev(bdev[0]);
6400 free_bdev(bdev[1]);
6401 free_bdev(bdev[2]);
6402 free_bdev(bdev[3]);
6403 free_bdev(bdev[4]);
6404 free_bdev(bdev[5]);
6405 free_bdev(bdev[6]);
6406 free_bdev(bdev[7]);
6412 struct spdk_bdev *bdev;
6420 bdev = allocate_bdev("bdev0");
6426 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6468 free_bdev(bdev);
6475 struct spdk_bdev *bdev;
6484 bdev = allocate_bdev("bdev");
6486 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
6489 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6496 /* First test that if the bdev supports copy, the request won't be split */
6497 bdev->md_len = 0;
6498 bdev->blocklen = 512;
6500 src_offset = bdev->blockcnt - num_blocks;
6528 free_bdev(bdev);
6535 struct spdk_bdev *bdev;
6552 bdev = allocate_bdev("bdev");
6554 rc = spdk_bdev_open_ext("bdev", true, bdev_ut_event_cb, NULL, &desc);
6557 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
6568 src_offset = bdev->blockcnt - num_blocks;
6583 bdev->max_copy = max_copy_blocks;
6587 src_offset = bdev->blockcnt - num_blocks;
6609 src_offset = bdev->blockcnt - num_blocks;
6637 max_copy_blocks = spdk_bdev_get_max_copy(bdev);
6639 src_offset = bdev->blockcnt - num_blocks;
6656 src_offset = bdev->blockcnt - num_blocks;
6680 free_bdev(bdev);
6685 examine_claim_v1(struct spdk_bdev *bdev)
6689 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &vbdev_ut_if);
6694 examine_no_lock_held(struct spdk_bdev *bdev)
6697 CU_ASSERT(!spdk_spin_held(&bdev->internal.spinlock));
6707 examine_claim_v2(struct spdk_bdev *bdev)
6709 struct examine_claim_v2_ctx *ctx = bdev->ctxt;
6712 rc = spdk_bdev_open_ext(bdev->name, false, bdev_ut_event_cb, NULL, &ctx->desc);
6722 struct spdk_bdev *bdev;
6729 bdev = allocate_bdev_ctx("bdev0", &ctx);
6732 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6733 CU_ASSERT(bdev->internal.claim.v1.module == NULL);
6734 free_bdev(bdev);
6740 bdev = allocate_bdev_ctx("bdev0", &ctx);
6743 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE);
6744 CU_ASSERT(bdev->internal.claim.v1.module == &vbdev_ut_if);
6745 spdk_bdev_module_release_bdev(bdev);
6746 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6747 CU_ASSERT(bdev->internal.claim.v1.module == NULL);
6748 free_bdev(bdev);
6755 bdev = allocate_bdev_ctx("bdev0", &v2_ctx);
6758 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE);
6760 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6761 free_bdev(bdev);
6764 #define UT_ASSERT_CLAIM_V2_COUNT(bdev, expect) \
6768 TAILQ_FOREACH(claim, &bdev->internal.claim.v2.claims, link) { \
6777 struct spdk_bdev *bdev;
6783 bdev = allocate_bdev("bdev0");
6793 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE);
6797 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6798 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6802 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6803 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
6804 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
6816 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE);
6822 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6823 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6859 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
6863 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6864 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6868 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6869 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
6876 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE);
6877 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc2->claim);
6878 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6880 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6881 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
6893 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6894 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
6898 free_bdev(bdev);
6904 struct spdk_bdev *bdev;
6910 bdev = allocate_bdev("bdev0");
6920 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE);
6924 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6925 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6929 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6930 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
6931 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
6932 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
6944 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE);
6950 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6951 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6980 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
6984 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6985 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
6993 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
6995 UT_ASSERT_CLAIM_V2_COUNT(bdev, 2);
6999 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE);
7000 CU_ASSERT(!TAILQ_EMPTY(&bdev->internal.open_descs));
7001 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc2->claim);
7002 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
7006 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7007 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
7008 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
7020 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7021 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
7032 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7033 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
7035 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
7038 free_bdev(bdev);
7044 struct spdk_bdev *bdev;
7051 bdev = allocate_bdev("bdev0");
7061 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7062 UT_ASSERT_CLAIM_V2_COUNT(bdev, 0);
7072 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED);
7078 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
7079 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
7107 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
7119 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc->claim);
7120 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
7131 UT_ASSERT_CLAIM_V2_COUNT(bdev, 2);
7135 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED);
7136 CU_ASSERT(!TAILQ_EMPTY(&bdev->internal.open_descs));
7137 CU_ASSERT(TAILQ_FIRST(&bdev->internal.claim.v2.claims) == desc2->claim);
7138 UT_ASSERT_CLAIM_V2_COUNT(bdev, 1);
7142 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7143 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
7155 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7156 CU_ASSERT(TAILQ_EMPTY(&bdev->internal.open_descs));
7159 free_bdev(bdev);
7165 struct spdk_bdev *bdev;
7178 bdev = allocate_bdev("bdev0");
7201 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7208 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE);
7215 free_bdev(bdev);
7221 struct spdk_bdev *bdev;
7233 bdev = allocate_bdev("bdev0");
7235 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
7237 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE);
7252 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_EXCL_WRITE);
7255 spdk_bdev_module_release_bdev(bdev);
7259 free_bdev(bdev);
7265 struct spdk_bdev *bdev;
7277 bdev = allocate_bdev("bdev0");
7296 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
7302 rc = spdk_bdev_module_claim_bdev(bdev, NULL, &bdev_ut_if);
7304 spdk_bdev_module_release_bdev(bdev);
7308 free_bdev(bdev);
7313 static void ut_examine_claimed_config0(struct spdk_bdev *bdev);
7314 static void ut_examine_claimed_disk0(struct spdk_bdev *bdev);
7315 static void ut_examine_claimed_config1(struct spdk_bdev *bdev);
7316 static void ut_examine_claimed_disk1(struct spdk_bdev *bdev);
7367 /* Only do this for the first initialization of the bdev framework */
7405 examine_claimed_config(struct spdk_bdev *bdev, uint32_t modnum)
7420 rc = spdk_bdev_open_ext(bdev->name, false, bdev_ut_event_cb, &ctx->claim_opts,
7431 ut_examine_claimed_config0(struct spdk_bdev *bdev)
7433 examine_claimed_config(bdev, g_ut_examine_claimed_order[0]);
7437 ut_examine_claimed_config1(struct spdk_bdev *bdev)
7439 examine_claimed_config(bdev, g_ut_examine_claimed_order[1]);
7443 examine_claimed_disk(struct spdk_bdev *bdev, uint32_t modnum)
7460 ut_examine_claimed_disk0(struct spdk_bdev *bdev)
7462 examine_claimed_disk(bdev, 0);
7466 ut_examine_claimed_disk1(struct spdk_bdev *bdev)
7468 examine_claimed_disk(bdev, 1);
7482 struct spdk_bdev *bdev;
7501 bdev = allocate_bdev("bdev0");
7521 free_bdev(bdev);
7530 bdev = allocate_bdev("bdev0");
7551 free_bdev(bdev);
7562 bdev = allocate_bdev("bdev0");
7580 CU_ASSERT(bdev->internal.claim_type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE);
7582 free_bdev(bdev);
7604 struct spdk_bdev bdev = {};
7606 bdev.numa.id = 0;
7607 bdev.numa.id_valid = 0;
7608 CU_ASSERT(spdk_bdev_get_numa_id(&bdev) == SPDK_ENV_NUMA_ID_ANY);
7610 bdev.numa.id_valid = 1;
7611 CU_ASSERT(spdk_bdev_get_numa_id(&bdev) == 0);
7613 bdev.numa.id = SPDK_ENV_NUMA_ID_ANY;
7614 CU_ASSERT(spdk_bdev_get_numa_id(&bdev) == SPDK_ENV_NUMA_ID_ANY);
7618 get_device_stat_with_reset_cb(struct spdk_bdev *bdev, struct spdk_bdev_io_stat *stat, void *cb_arg,
7625 get_device_stat_with_given_reset(struct spdk_bdev *bdev, struct spdk_bdev_io_stat *stat,
7630 spdk_bdev_get_device_stat(bdev, stat, mode, get_device_stat_with_reset_cb, &done);
7637 struct spdk_bdev *bdev;
7647 bdev = allocate_bdev("bdev0");
7651 CU_ASSERT(bdev == spdk_bdev_desc_get_bdev(desc));
7665 get_device_stat_with_given_reset(bdev, stat, SPDK_BDEV_RESET_STAT_NONE);
7673 get_device_stat_with_given_reset(bdev, stat, SPDK_BDEV_RESET_STAT_MAXMIN);
7681 get_device_stat_with_given_reset(bdev, stat, SPDK_BDEV_RESET_STAT_ALL);
7686 get_device_stat_with_given_reset(bdev, stat, SPDK_BDEV_RESET_STAT_NONE);
7693 free_bdev(bdev);
7701 struct spdk_bdev *bdev;
7705 bdev = allocate_bdev("bdev0");
7725 free_bdev(bdev);
7731 struct spdk_bdev *bdev;
7735 bdev = allocate_bdev("bdev0");
7738 bdev->dif_pi_format = SPDK_DIF_PI_FORMAT_32;
7739 bdev->blocklen = 4096 + 8;
7740 bdev->md_len = 8;
7741 bdev->md_interleave = true;
7743 bdev_io.bdev = bdev;
7750 bdev->blocklen = 4096 + 16;
7751 bdev->md_len = 16;
7756 free_bdev(bdev);
7767 suite = CU_add_suite("bdev", ut_bdev_setup, ut_bdev_teardown);