Lines Matching defs:bs
59 static struct spdk_blob *ut_blob_create_and_open(struct spdk_blob_store *bs,
61 static void ut_blob_close_and_delete(struct spdk_blob_store *bs, struct spdk_blob *blob);
137 _get_snapshots_count(struct spdk_blob_store *bs)
142 TAILQ_FOREACH(snapshot, &bs->snapshots, link) {
163 bs_op_with_handle_complete(void *cb_arg, struct spdk_blob_store *bs,
166 g_bs = bs;
214 ut_bs_reload(struct spdk_blob_store **bs, struct spdk_bs_opts *opts)
219 spdk_bs_unload(*bs, bs_op_complete, NULL);
229 *bs = g_bs;
235 ut_bs_dirty_load(struct spdk_blob_store **bs, struct spdk_bs_opts *opts)
240 bs_free(*bs);
248 *bs = g_bs;
256 struct spdk_blob_store *bs;
272 bs = g_bs;
274 spdk_bs_unload(bs, bs_op_complete, NULL);
283 struct spdk_blob_store *bs = g_bs;
288 spdk_bs_get_super(bs, blob_op_with_id_complete, NULL);
295 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
302 spdk_bs_set_super(bs, blobid, blob_op_complete, NULL);
307 spdk_bs_get_super(bs, blob_op_with_id_complete, NULL);
316 struct spdk_blob_store *bs = g_bs;
322 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
328 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
338 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
360 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
376 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete2, NULL);
377 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete2, NULL);
390 ut_blob_close_and_delete(bs, g_blob);
396 struct spdk_blob_store *bs = g_bs;
406 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
412 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
429 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
435 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
449 spdk_bs_create_blob_ext(bs, NULL, blob_op_with_id_complete, NULL);
455 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
470 opts.num_clusters = bs->total_clusters + 1;
472 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
480 struct spdk_blob_store *bs = g_bs;
485 spdk_bs_create_blob_ext(bs, NULL, blob_op_with_id_complete, NULL);
491 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
506 bs_create_blob(bs, NULL, NULL, blob_op_with_id_complete, NULL);
512 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
536 struct spdk_blob_store *bs = g_bs;
540 loop_count = 4 * spdk_max(spdk_bit_array_capacity(bs->used_md_pages),
541 spdk_bit_pool_capacity(bs->used_clusters));
548 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
552 spdk_bs_delete_blob(bs, g_blobid, blob_op_complete, NULL);
561 struct spdk_blob_store *bs = g_bs;
564 uint32_t used_blobids_count = spdk_bit_array_count_set(bs->used_blobids);
565 uint32_t used_md_pages_count = spdk_bit_array_count_set(bs->used_md_pages);
574 blobid = spdk_bit_array_find_first_clear(bs->used_md_pages, 0);
575 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
579 CU_ASSERT(spdk_bit_array_count_set(bs->used_blobids) == used_blobids_count);
580 CU_ASSERT(spdk_bit_array_count_set(bs->used_md_pages) == used_md_pages_count);
582 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
587 ut_bs_reload(&bs, NULL);
588 CU_ASSERT(spdk_bit_array_count_set(bs->used_blobids) == used_blobids_count);
589 CU_ASSERT(spdk_bit_array_count_set(bs->used_md_pages) == used_md_pages_count);
591 spdk_bs_iter_first(bs, blob_op_with_handle_complete, NULL);
600 struct spdk_blob_store *bs = g_bs;
618 bs_create_blob(bs, &opts, &internal_xattrs, blob_op_with_id_complete, NULL);
624 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
663 bs_create_blob(bs, NULL, NULL, blob_op_with_id_complete, NULL);
669 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
686 struct spdk_blob_store *bs;
703 bs = g_bs;
711 blob = ut_blob_create_and_open(bs, &opts);
733 ut_bs_dirty_load(&bs, &bs_opts);
735 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
743 ut_blob_close_and_delete(bs, blob);
745 spdk_bs_unload(bs, bs_op_complete, NULL);
754 struct spdk_blob_store *bs = g_bs;
773 blob = ut_blob_create_and_open(bs, &opts);
778 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 0);
779 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
783 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 1);
786 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
807 spdk_bs_create_snapshot(bs, blobid, &xattrs, blob_op_with_id_complete, NULL);
811 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 2);
814 spdk_bs_open_blob(bs, snapshotid2, blob_op_with_handle_complete, NULL);
854 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid2, ids, &count) == 0);
859 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid, ids, &count) == 0);
864 spdk_bs_create_snapshot(bs, snapshotid, NULL, blob_op_with_id_complete, NULL);
868 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 2);
871 ut_blob_close_and_delete(bs, blob);
873 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid2, ids, &count) == 0);
877 ut_blob_close_and_delete(bs, snapshot2);
878 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 1);
880 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid2, ids, &count) == 0);
883 ut_blob_close_and_delete(bs, snapshot);
884 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 0);
892 struct spdk_blob_store *bs = g_bs;
906 channel = spdk_bs_alloc_io_channel(bs);
914 blob = ut_blob_create_and_open(bs, &opts);
918 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
957 ut_blob_close_and_delete(bs, blob);
963 struct spdk_blob_store *bs = g_bs;
977 blob = ut_blob_create_and_open(bs, &opts);
982 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
988 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
1007 spdk_bs_create_clone(bs, snapshotid, &xattrs, blob_op_with_id_complete, NULL);
1013 spdk_bs_open_blob(bs, cloneid, blob_op_with_handle_complete, NULL);
1047 spdk_bs_create_clone(bs, blobid, NULL, blob_op_with_id_complete, NULL);
1059 spdk_bs_create_clone(bs, blobid, NULL, blob_op_with_id_complete, NULL);
1065 spdk_bs_open_blob(bs, cloneid, blob_op_with_handle_complete, NULL);
1074 ut_blob_close_and_delete(bs, clone);
1075 ut_blob_close_and_delete(bs, blob);
1081 struct spdk_blob_store *bs = g_bs;
1088 channel = spdk_bs_alloc_io_channel(bs);
1097 blob = ut_blob_create_and_open(bs, &opts);
1106 spdk_bs_blob_decouple_parent(bs, channel, blobid, blob_op_complete, NULL);
1111 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
1118 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
1127 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
1140 free_clusters = spdk_bs_free_cluster_count(bs);
1145 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
1149 CU_ASSERT(spdk_bs_free_cluster_count(bs) == free_clusters - 10);
1153 spdk_bs_blob_decouple_parent(bs, channel, blobid, blob_op_complete, NULL);
1157 CU_ASSERT(spdk_bs_free_cluster_count(bs) == free_clusters);
1162 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
1172 ut_blob_close_and_delete(bs, blob);
1185 struct spdk_blob_store *bs = g_bs;
1191 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
1197 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
1202 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
1210 struct spdk_blob_store *bs = g_bs;
1214 free_clusters = spdk_bs_free_cluster_count(bs);
1216 blob = ut_blob_create_and_open(bs, NULL);
1217 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
1231 CU_ASSERT((free_clusters - 5) == spdk_bs_free_cluster_count(bs));
1241 CU_ASSERT((free_clusters - 5) == spdk_bs_free_cluster_count(bs));
1248 CU_ASSERT((free_clusters - 3) == spdk_bs_free_cluster_count(bs));
1254 CU_ASSERT((free_clusters - 10) == spdk_bs_free_cluster_count(bs));
1258 spdk_blob_resize(blob, bs->total_clusters + 1, blob_op_complete, NULL);
1262 ut_blob_close_and_delete(bs, blob);
1268 struct spdk_blob_store *bs = g_bs;
1277 free_clusters = spdk_bs_free_cluster_count(bs);
1279 blob_ch = spdk_bs_alloc_io_channel(bs);
1287 blob = ut_blob_create_and_open(bs, &opts);
1288 CU_ASSERT((free_clusters) == spdk_bs_free_cluster_count(bs));
1296 CU_ASSERT((free_clusters) == spdk_bs_free_cluster_count(bs));
1322 CU_ASSERT((free_clusters - 4) == spdk_bs_free_cluster_count(bs));
1332 CU_ASSERT((free_clusters - 4) == spdk_bs_free_cluster_count(bs));
1339 CU_ASSERT((free_clusters - 1) == spdk_bs_free_cluster_count(bs));
1344 ut_blob_close_and_delete(bs, blob);
1350 struct spdk_blob_store *bs;
1365 bs = g_bs;
1367 blob = ut_blob_create_and_open(bs, NULL);
1387 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
1401 ut_bs_reload(&bs, &opts);
1403 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
1413 ut_blob_close_and_delete(bs, blob);
1415 spdk_bs_unload(bs, bs_op_complete, NULL);
1423 struct spdk_blob_store *bs = g_bs;
1426 channel = spdk_bs_alloc_io_channel(bs);
1436 struct spdk_blob_store *bs = g_bs;
1442 io_units_per_cluster = spdk_bs_get_cluster_size(bs) / spdk_bs_get_io_unit_size(bs);
1444 channel = spdk_bs_alloc_io_channel(bs);
1488 struct spdk_blob_store *bs = g_bs;
1494 io_units_per_cluster = spdk_bs_get_cluster_size(bs) / spdk_bs_get_io_unit_size(bs);
1496 channel = spdk_bs_alloc_io_channel(bs);
1540 struct spdk_blob_store *bs = g_bs;
1546 channel = spdk_bs_alloc_io_channel(bs);
1571 struct spdk_blob_store *bs = g_bs;
1579 uint32_t first_data_cluster = FIRST_DATA_CLUSTER(bs);
1581 channel = spdk_bs_alloc_io_channel(bs);
1584 blob = ut_blob_create_and_open(bs, NULL);
1659 struct spdk_blob_store *bs = g_bs;
1666 channel = spdk_bs_alloc_io_channel(bs);
1698 struct spdk_blob_store *bs = g_bs;
1706 channel = spdk_bs_alloc_io_channel(bs);
1739 uint64_t io_unit_size = spdk_bs_get_io_unit_size(blob->bs);
1763 uint64_t io_unit_size = spdk_bs_get_io_unit_size(blob->bs);
1783 struct spdk_blob_store *bs = g_bs;
1800 cluster_size = spdk_bs_get_cluster_size(bs);
1801 io_unit_size = spdk_bs_get_io_unit_size(bs);
1821 channel = spdk_bs_alloc_io_channel(bs);
1829 blob = ut_blob_create_and_open(bs, &opts);
1918 ut_blob_close_and_delete(bs, blob);
1924 struct spdk_blob_store *bs = g_bs;
1944 cluster_size = spdk_bs_get_cluster_size(bs);
1945 io_unit_size = spdk_bs_get_io_unit_size(bs);
1970 channel = spdk_bs_alloc_io_channel(bs);
1978 blob = ut_blob_create_and_open(bs, &opts);
2081 ut_blob_close_and_delete(bs, blob);
2087 struct spdk_blob_store *bs = g_bs;
2092 uint32_t first_data_cluster = FIRST_DATA_CLUSTER(bs);
2095 channel = spdk_bs_alloc_io_channel(bs);
2101 blob = ut_blob_create_and_open(bs, &opts);
2165 ut_blob_close_and_delete(bs, blob);
2171 struct spdk_blob_store *bs = g_bs;
2176 spdk_bs_iter_first(bs, blob_op_with_handle_complete, NULL);
2182 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
2188 spdk_bs_iter_first(bs, blob_op_with_handle_complete, NULL);
2195 spdk_bs_iter_next(bs, blob, blob_op_with_handle_complete, NULL);
2204 struct spdk_blob_store *bs = g_bs;
2291 ut_bs_reload(&bs, NULL);
2293 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
2316 struct spdk_blob_store *bs = g_bs;
2323 used_pages = spdk_bit_array_count_set(bs->used_md_pages);
2324 blob = ut_blob_create_and_open(bs, NULL);
2339 SPDK_CU_ASSERT_FATAL(used_pages != spdk_bit_array_count_set(bs->used_md_pages));
2340 ut_blob_close_and_delete(bs, blob);
2341 SPDK_CU_ASSERT_FATAL(used_pages == spdk_bit_array_count_set(bs->used_md_pages));
2347 struct spdk_blob_store *bs;
2368 bs = g_bs;
2371 spdk_bs_open_blob(bs, 0, blob_op_with_handle_complete, NULL);
2377 blob = ut_blob_create_and_open(bs, NULL);
2381 spdk_bs_open_blob(bs, blobid & 0xFFFFFFFF, blob_op_with_handle_complete, NULL);
2407 spdk_bs_unload(bs, bs_op_complete, NULL);
2448 bs = g_bs;
2454 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
2484 spdk_bs_unload(bs, bs_op_complete, NULL);
2510 bs = g_bs;
2513 spdk_bs_unload(bs, bs_op_complete, NULL);
2529 bs = g_bs;
2533 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
2542 spdk_bs_unload(bs, bs_op_complete, NULL);
2553 struct spdk_blob_store *bs = g_bs;
2565 blob = ut_blob_create_and_open(bs, &opts);
2569 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
2575 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
2596 ut_bs_reload(&bs, NULL);
2599 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
2615 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
2637 ut_bs_reload(&bs, NULL);
2640 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
2648 struct spdk_blob_store *bs;
2666 bs = g_bs;
2667 cluster_sz = bs->cluster_sz;
2668 total_clusters = bs->total_clusters;
2671 spdk_bs_unload(bs, bs_op_complete, NULL);
2689 bs = g_bs;
2691 CU_ASSERT(cluster_sz == bs->cluster_sz);
2692 CU_ASSERT(total_clusters == bs->total_clusters);
2698 spdk_bs_unload(bs, bs_op_complete, NULL);
2708 struct spdk_blob_store *bs;
2733 bs = g_bs;
2739 blob = ut_blob_create_and_open(bs, &blob_opts);
2743 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
2749 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
2763 total_data_clusters = bs->total_data_clusters;
2764 CU_ASSERT(bs->num_free_clusters + 10 == total_data_clusters);
2767 spdk_bs_unload(bs, bs_op_complete, NULL);
2798 bs = g_bs;
2801 CU_ASSERT(bs->total_data_clusters == total_data_clusters);
2802 CU_ASSERT(bs->num_free_clusters + 10 == total_data_clusters);
2805 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
2815 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
2825 spdk_bs_unload(bs, bs_op_complete, NULL);
2835 struct spdk_blob_store *bs;
2849 bs = g_bs;
2852 spdk_bs_unload(bs, bs_op_complete, NULL);
2881 struct spdk_blob_store *bs;
2894 bs = g_bs;
2897 spdk_bs_unload(bs, bs_op_complete, NULL);
2918 bs = g_bs;
2920 spdk_bs_unload(bs, bs_op_complete, NULL);
2932 bs = g_bs;
2934 spdk_bs_unload(bs, bs_op_complete, NULL);
2953 bs = g_bs;
2955 spdk_bs_unload(bs, bs_op_complete, NULL);
2964 struct spdk_blob_store *bs;
2979 bs = g_bs;
2982 spdk_bs_unload(bs, bs_op_complete, NULL);
3022 bs = g_bs;
3024 spdk_bs_unload(bs, bs_op_complete, NULL);
3033 struct spdk_blob_store *bs;
3069 bs = g_bs;
3070 CU_ASSERT(bs->num_free_clusters == bs->total_clusters - (super_block.md_start +
3073 spdk_bs_unload(bs, bs_op_complete, NULL);
3082 struct spdk_blob_store *bs;
3102 bs = g_bs;
3110 spdk_bs_grow_live(bs, bs_op_complete, NULL);
3113 total_data_clusters = spdk_bs_total_data_cluster_count(bs);
3125 spdk_bs_unload(bs, bs_op_complete, NULL);
3147 bs = g_bs;
3148 CU_ASSERT(total_data_clusters == spdk_bs_total_data_cluster_count(bs));
3151 spdk_bs_grow_live(bs, bs_op_complete, NULL);
3154 CU_ASSERT(total_data_clusters == spdk_bs_total_data_cluster_count(bs));
3159 spdk_bs_unload(bs, bs_op_complete, NULL);
3181 struct spdk_blob_store *bs;
3202 bs = g_bs;
3203 total_data_clusters = spdk_bs_total_data_cluster_count(bs);
3210 spdk_bs_grow_live(bs, bs_op_complete, NULL);
3214 CU_ASSERT(total_data_clusters == spdk_bs_total_data_cluster_count(bs));
3225 max_clusters = (spdk_bs_get_page_size(bs) - sizeof(struct spdk_bs_md_mask)) * 8;
3227 dev->blockcnt = (max_clusters * spdk_bs_get_cluster_size(bs)) / dev->blocklen;
3228 spdk_bs_grow_live(bs, bs_op_complete, NULL);
3231 CU_ASSERT(total_data_clusters == spdk_bs_total_data_cluster_count(bs));
3239 spdk_bs_unload(bs, bs_op_complete, NULL);
3259 bs = g_bs;
3260 CU_ASSERT(total_data_clusters == spdk_bs_total_data_cluster_count(bs));
3262 spdk_bs_unload(bs, bs_op_complete, NULL);
3271 struct spdk_blob_store *bs;
3285 bs = g_bs;
3287 spdk_bs_unload(bs, bs_op_complete, NULL);
3323 bs = g_bs;
3340 spdk_bs_unload(bs, bs_op_complete, NULL);
3352 struct spdk_blob_store *bs = g_bs;
3357 blob = ut_blob_create_and_open(bs, NULL);
3361 spdk_bs_unload(bs, bs_op_complete, NULL);
3376 spdk_bs_unload(bs, bs_op_complete, NULL);
3383 spdk_bs_unload(bs, bs_op_complete, NULL);
3397 struct spdk_blob_store *bs;
3452 bs = g_bs;
3454 CU_ASSERT(spdk_bs_get_cluster_size(bs) == cluster_sz);
3456 ut_bs_reload(&bs, &opts);
3458 CU_ASSERT(spdk_bs_get_cluster_size(bs) == cluster_sz);
3460 spdk_bs_unload(bs, bs_op_complete, NULL);
3473 struct spdk_blob_store *bs = g_bs;
3479 clusters = spdk_bs_total_data_cluster_count(bs);
3481 ut_bs_reload(&bs, NULL);
3483 CU_ASSERT(spdk_bs_total_data_cluster_count(bs) == clusters);
3489 blob = ut_blob_create_and_open(bs, NULL);
3500 CU_ASSERT(spdk_bs_total_data_cluster_count(bs) == clusters);
3504 ut_bs_reload(&bs, NULL);
3506 CU_ASSERT(spdk_bs_total_data_cluster_count(bs) == clusters);
3518 struct spdk_blob_store *bs;
3540 bs = g_bs;
3542 CU_ASSERT(spdk_bs_get_cluster_size(bs) == cluster_sz);
3549 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
3556 ut_bs_reload(&bs, &opts);
3558 CU_ASSERT(spdk_bs_get_cluster_size(bs) == cluster_sz);
3563 spdk_bs_open_blob(bs, blobids[i], blob_op_with_handle_complete, NULL);
3574 spdk_bs_unload(bs, bs_op_complete, NULL);
3583 struct spdk_blob_store *bs;
3593 bs = g_bs;
3599 spdk_bs_destroy(bs, bs_op_complete, NULL);
3606 spdk_bs_destroy(bs, bs_op_complete, NULL);
3628 struct spdk_blob_store *bs;
3644 bs = g_bs;
3648 blob[i] = ut_blob_create_and_open(bs, NULL);
3685 ut_bs_reload(&bs, &opts);
3690 spdk_bs_open_blob(bs, blobid[i], blob_op_with_handle_complete, NULL);
3703 spdk_bs_unload(bs, bs_op_complete, NULL);
3712 struct spdk_blob_store *bs = g_bs;
3719 blob = ut_blob_create_and_open(bs, NULL);
3727 index = g_phys_blocklen * (bs->md_start + page_num);
3731 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
3737 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
3745 struct spdk_blob_store *bs;
3754 bs = g_bs;
3756 spdk_bs_unload(bs, bs_op_complete, NULL);
3791 struct spdk_blob_store *bs = g_bs;
3832 spdk_bs_set_super(bs, blobid1, blob_op_complete, NULL);
3836 free_clusters = spdk_bs_free_cluster_count(bs);
3845 ut_bs_dirty_load(&bs, NULL);
3848 spdk_bs_get_super(bs, blob_op_with_id_complete, NULL);
3853 spdk_bs_open_blob(bs, blobid1, blob_op_with_handle_complete, NULL);
3859 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
3875 free_clusters = spdk_bs_free_cluster_count(bs);
3884 ut_bs_dirty_load(&bs, NULL);
3886 spdk_bs_open_blob(bs, blobid1, blob_op_with_handle_complete, NULL);
3892 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
3902 blob = ut_blob_create_and_open(bs, NULL);
3918 free_clusters = spdk_bs_free_cluster_count(bs);
3927 ut_bs_dirty_load(&bs, NULL);
3929 spdk_bs_open_blob(bs, blobid2, blob_op_with_handle_complete, NULL);
3943 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
3945 ut_blob_close_and_delete(bs, blob);
3947 free_clusters = spdk_bs_free_cluster_count(bs);
3949 ut_bs_dirty_load(&bs, NULL);
3951 spdk_bs_open_blob(bs, blobid2, blob_op_with_handle_complete, NULL);
3956 spdk_bs_open_blob(bs, blobid1, blob_op_with_handle_complete, NULL);
3961 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
3966 ut_bs_reload(&bs, NULL);
3970 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
3977 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
3983 spdk_bs_open_blob(bs, blobid2, blob_op_with_handle_complete, NULL);
4004 spdk_bs_open_blob(bs, blobid3, blob_op_with_handle_complete, NULL);
4028 index = g_phys_blocklen * (bs->md_start + page_num);
4033 free_clusters = spdk_bs_free_cluster_count(bs);
4035 ut_bs_dirty_load(&bs, NULL);
4037 spdk_bs_open_blob(bs, blobid2, blob_op_with_handle_complete, NULL);
4042 spdk_bs_open_blob(bs, blobid3, blob_op_with_handle_complete, NULL);
4048 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4054 struct spdk_blob_store *bs = g_bs;
4061 blob_invalid = ut_blob_create_and_open(bs, NULL);
4064 blob_data_ro = ut_blob_create_and_open(bs, NULL);
4069 blob_md_ro = ut_blob_create_and_open(bs, &blob_opts);
4123 ut_bs_reload(&bs, NULL);
4127 spdk_bs_open_blob(bs, blobid_invalid, blob_op_with_handle_complete, NULL);
4134 spdk_bs_open_blob(bs, blobid_data_ro, blob_op_with_handle_complete, NULL);
4146 spdk_bs_open_blob(bs, blobid_md_ro, blob_op_with_handle_complete, NULL);
4159 ut_blob_close_and_delete(bs, blob_data_ro);
4160 ut_blob_close_and_delete(bs, blob_md_ro);
4167 struct spdk_blob_store *bs = g_bs;
4174 spdk_bs_unload(bs, bs_op_complete, NULL);
4180 * Change the bs version on disk. This will allow us to
4207 bs = g_bs;
4215 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
4222 spdk_bs_unload(bs, bs_op_complete, NULL);
4235 bs = g_bs;
4238 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
4244 ut_blob_close_and_delete(bs, blob);
4254 struct spdk_blob_store *bs = g_bs;
4271 blob = ut_blob_create_and_open(bs, &opts);
4322 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
4334 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
4342 struct spdk_blob_store *bs = g_bs;
4348 free_clusters = spdk_bs_free_cluster_count(bs);
4354 blob = ut_blob_create_and_open(bs, &opts);
4356 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4366 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4375 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4384 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4397 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4406 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4415 ut_bs_reload(&bs, NULL);
4417 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
4424 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4427 ut_blob_close_and_delete(bs, blob);
4433 struct spdk_blob_store *bs = g_bs;
4452 free_clusters = spdk_bs_free_cluster_count(bs);
4459 blob = ut_blob_create_and_open(bs, &opts);
4461 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4470 spdk_spin_lock(&bs->used_lock);
4473 spdk_spin_unlock(&bs->used_lock);
4485 ut_bs_reload(&bs, NULL);
4487 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
4495 ut_blob_close_and_delete(bs, blob);
4502 struct spdk_blob_store *bs = g_bs;
4514 free_clusters = spdk_bs_free_cluster_count(bs);
4515 io_unit_size = spdk_bs_get_io_unit_size(bs);
4517 channel = spdk_bs_alloc_io_channel(bs);
4525 blob_id0 = ut_blob_create_and_open(bs, &opts);
4526 blob = ut_blob_create_and_open(bs, &opts);
4527 ut_blob_close_and_delete(bs, blob_id0);
4528 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4537 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4545 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4561 channel_thread1 = spdk_bs_alloc_io_channel(bs);
4565 CU_ASSERT(free_clusters - 1 == spdk_bs_free_cluster_count(bs));
4571 CU_ASSERT(free_clusters - 2 == spdk_bs_free_cluster_count(bs));
4574 CU_ASSERT(free_clusters - 1 == spdk_bs_free_cluster_count(bs));
4578 expected_bytes = 20 * io_unit_size + spdk_bs_get_page_size(bs);
4581 expected_bytes += spdk_bs_get_page_size(bs);
4591 ut_blob_close_and_delete(bs, blob);
4592 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4606 struct spdk_blob_store *bs;
4636 bs = g_bs;
4638 free_clusters = spdk_bs_free_cluster_count(bs);
4639 io_unit_size = spdk_bs_get_io_unit_size(bs);
4643 ch = spdk_bs_alloc_io_channel(bs);
4649 blob = ut_blob_create_and_open(bs, &opts);
4650 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4664 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4677 CU_ASSERT(free_clusters - (2 * i + 1) == spdk_bs_free_cluster_count(bs));
4684 expected_bytes = io_unit_size + spdk_bs_get_page_size(bs);
4690 expected_bytes = io_unit_size + 2 * spdk_bs_get_page_size(bs);
4704 CU_ASSERT(free_clusters - (2 * i + 1) == spdk_bs_free_cluster_count(bs));
4716 CU_ASSERT(free_clusters - (2 * i + 2) == spdk_bs_free_cluster_count(bs));
4724 expected_bytes = io_unit_size + spdk_bs_get_page_size(bs);
4733 CU_ASSERT(free_clusters - (2 * i + 1) == spdk_bs_free_cluster_count(bs));
4741 CU_ASSERT(free_clusters - (2 * i + 2) == spdk_bs_free_cluster_count(bs));
4744 ut_blob_close_and_delete(bs, blob);
4745 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4752 spdk_bs_unload(bs, bs_op_complete, NULL);
4761 struct spdk_blob_store *bs;
4788 bs = g_bs;
4790 free_clusters = spdk_bs_free_cluster_count(bs);
4791 io_unit_size = spdk_bs_get_io_unit_size(bs);
4794 ch = spdk_bs_alloc_io_channel(bs);
4800 blob = ut_blob_create_and_open(bs, &opts);
4802 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4814 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4824 CU_ASSERT(free_clusters - (i + 1) == spdk_bs_free_cluster_count(bs));
4826 CU_ASSERT(0 == spdk_bs_free_cluster_count(bs));
4833 CU_ASSERT(1 == spdk_bs_free_cluster_count(bs));
4848 CU_ASSERT(0 == spdk_bs_free_cluster_count(bs));
4862 CU_ASSERT(1 == spdk_bs_free_cluster_count(bs));
4880 CU_ASSERT(1 == spdk_bs_free_cluster_count(bs));
4903 CU_ASSERT(0 == spdk_bs_free_cluster_count(bs));
4908 CU_ASSERT(0 == spdk_bs_free_cluster_count(bs));
4913 CU_ASSERT(1 == spdk_bs_free_cluster_count(bs));
4923 CU_ASSERT(0 == spdk_bs_free_cluster_count(bs));
4933 CU_ASSERT(1 == spdk_bs_free_cluster_count(bs));
4942 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4949 CU_ASSERT(free_clusters - 1 == spdk_bs_free_cluster_count(bs));
4952 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 0);
4953 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
4957 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 1);
4959 CU_ASSERT(free_clusters - 1 == spdk_bs_free_cluster_count(bs));
4960 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
4972 CU_ASSERT(free_clusters - 2 == spdk_bs_free_cluster_count(bs));
4979 CU_ASSERT(free_clusters - 2 == spdk_bs_free_cluster_count(bs));
4989 ut_blob_close_and_delete(bs, blob);
4990 ut_blob_close_and_delete(bs, snapshot);
4991 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
4998 spdk_bs_unload(bs, bs_op_complete, NULL);
5008 struct spdk_blob_store *bs = g_bs;
5023 CU_ASSERT(spdk_bs_get_io_unit_size(bs) == BLOCKLEN);
5025 free_clusters = spdk_bs_free_cluster_count(bs);
5026 io_unit_size = spdk_bs_get_io_unit_size(bs);
5032 blob = ut_blob_create_and_open(bs, &opts);
5034 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5036 channel = spdk_bs_alloc_io_channel(bs);
5040 io_unit = bs_cluster_to_io_unit(bs, 1);
5057 CU_ASSERT(free_clusters - 1 == spdk_bs_free_cluster_count(bs));
5060 expected_bytes = 10 * io_unit_size + spdk_bs_get_page_size(bs);
5063 expected_bytes += spdk_bs_get_page_size(bs);
5080 ut_bs_reload(&bs, NULL);
5082 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
5088 channel = spdk_bs_alloc_io_channel(bs);
5100 ut_blob_close_and_delete(bs, blob);
5107 struct spdk_blob_store *bs = g_bs;
5117 free_clusters = spdk_bs_free_cluster_count(bs);
5119 channel = spdk_bs_alloc_io_channel(bs);
5125 blob = ut_blob_create_and_open(bs, &opts);
5126 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5134 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5141 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5184 ut_blob_close_and_delete(bs, blob);
5206 struct spdk_blob_store *bs;
5222 bs = g_bs;
5225 blob = ut_blob_create_and_open(bs, NULL);
5243 spdk_bs_unload(bs, bs_op_complete, NULL);
5258 bs = g_bs;
5261 bs_free(bs);
5275 bs = g_bs;
5277 spdk_bs_unload(bs, bs_op_complete, NULL);
5287 struct spdk_blob_store *bs = g_bs;
5305 free_clusters = spdk_bs_free_cluster_count(bs);
5306 cluster_size = spdk_bs_get_cluster_size(bs);
5307 io_unit_size = spdk_bs_get_io_unit_size(bs);
5309 channel = spdk_bs_alloc_io_channel(bs);
5316 blob = ut_blob_create_and_open(bs, &opts);
5318 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5332 CU_ASSERT(free_clusters != spdk_bs_free_cluster_count(bs));
5335 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5341 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
5359 CU_ASSERT(free_clusters != spdk_bs_free_cluster_count(bs));
5372 expected_bytes = 10 * io_unit_size + cluster_size + spdk_bs_get_page_size(bs);
5375 expected_bytes += spdk_bs_get_page_size(bs);
5392 ut_blob_close_and_delete(bs, blob);
5393 ut_blob_close_and_delete(bs, snapshot);
5405 struct spdk_blob_store *bs = g_bs;
5416 free_clusters = spdk_bs_free_cluster_count(bs);
5418 channel = spdk_bs_alloc_io_channel(bs);
5425 blob = ut_blob_create_and_open(bs, &opts);
5427 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5432 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5438 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
5487 ut_blob_close_and_delete(bs, blob);
5488 ut_blob_close_and_delete(bs, snapshot);
5528 struct spdk_blob_store *bs = g_bs;
5548 free_clusters = spdk_bs_free_cluster_count(bs);
5549 cluster_size = spdk_bs_get_cluster_size(bs);
5550 io_units_per_cluster = cluster_size / spdk_bs_get_io_unit_size(bs);
5564 channel = spdk_bs_alloc_io_channel(bs);
5572 blob = ut_blob_create_and_open(bs, &opts);
5574 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
5593 CU_ASSERT(free_clusters != spdk_bs_free_cluster_count(bs));
5596 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5602 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
5635 CU_ASSERT(free_clusters != spdk_bs_free_cluster_count(bs));
5646 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5652 spdk_bs_open_blob(bs, snapshot2id, blob_op_with_handle_complete, NULL);
5699 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid, ids, &count) == 0);
5704 CU_ASSERT(spdk_blob_get_clones(bs, snapshot2id, ids, &count) == 0);
5708 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshot2id);
5710 free_clusters = spdk_bs_free_cluster_count(bs);
5713 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
5719 CU_ASSERT(spdk_bs_free_cluster_count(bs) == free_clusters - 4);
5723 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid, ids, &count) == 0);
5731 CU_ASSERT(spdk_blob_get_clones(bs, snapshot2id, ids, &count) == 0);
5734 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == SPDK_BLOBID_INVALID);
5737 spdk_bs_blob_decouple_parent(bs, channel, blobid, blob_op_complete, NULL);
5744 CU_ASSERT(spdk_bs_free_cluster_count(bs) == free_clusters - 1);
5748 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid, ids, &count) == 0);
5757 CU_ASSERT(spdk_blob_get_clones(bs, snapshot2id, ids, &count) == 0);
5760 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid);
5764 spdk_bs_delete_blob(bs, snapshot2id, blob_op_complete, NULL);
5769 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
5774 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
5797 ut_blob_close_and_delete(bs, blob);
5821 struct spdk_blob_store *bs;
5839 bs = g_bs;
5846 blob = ut_blob_create_and_open(bs, &opts);
5856 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == SPDK_BLOBID_INVALID);
5858 rc = spdk_blob_get_clones(bs, blobid, ids, &count);
5865 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5871 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
5881 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid) == SPDK_BLOBID_INVALID);
5889 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid);
5892 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
5900 spdk_bs_create_clone(bs, snapshotid, NULL, blob_op_with_id_complete, NULL);
5906 spdk_bs_open_blob(bs, cloneid, blob_op_with_handle_complete, NULL);
5917 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid);
5920 rc = spdk_blob_get_clones(bs, cloneid, ids, &count);
5926 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
5934 spdk_bs_create_snapshot(bs, cloneid, NULL, blob_op_with_id_complete, NULL);
5940 spdk_bs_open_blob(bs, snapshotid2, blob_op_with_handle_complete, NULL);
5950 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid2) == snapshotid);
5959 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid2);
5962 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
5983 spdk_bs_create_clone(bs, blobid, NULL, blob_op_with_id_complete, NULL);
5989 spdk_bs_open_blob(bs, cloneid2, blob_op_with_handle_complete, NULL);
6000 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid2) == blobid);
6003 rc = spdk_blob_get_clones(bs, blobid, ids, &count);
6032 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
6036 ut_bs_reload(&bs, &bs_opts);
6040 rc = spdk_blob_get_clones(bs, snapshotid, NULL, &count);
6046 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
6054 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid) == SPDK_BLOBID_INVALID);
6057 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
6064 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid);
6066 rc = spdk_blob_get_clones(bs, blobid, ids, &count);
6072 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid2);
6074 rc = spdk_blob_get_clones(bs, cloneid, ids, &count);
6079 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid2) == snapshotid);
6081 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
6087 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid2) == blobid);
6089 rc = spdk_blob_get_clones(bs, cloneid2, ids, &count);
6095 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
6101 spdk_bs_delete_blob(bs, cloneid, blob_op_complete, NULL);
6105 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
6109 spdk_bs_delete_blob(bs, cloneid2, blob_op_complete, NULL);
6113 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
6117 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
6121 spdk_bs_unload(bs, bs_op_complete, NULL);
6146 struct spdk_blob_store *bs;
6165 bs = g_bs;
6172 blob = ut_blob_create_and_open(bs, &opts);
6177 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6183 spdk_bs_open_blob(bs, snapshotid1, blob_op_with_handle_complete, NULL);
6190 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid1) == SPDK_BLOBID_INVALID);
6193 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid1);
6197 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid1);
6200 rc = spdk_blob_get_clones(bs, snapshotid1, ids, &count);
6207 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6213 spdk_bs_open_blob(bs, snapshotid2, blob_op_with_handle_complete, NULL);
6221 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid2) == snapshotid1);
6226 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid2);
6229 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
6236 spdk_bs_create_clone(bs, snapshotid2, NULL, blob_op_with_id_complete, NULL);
6242 spdk_bs_open_blob(bs, cloneid, blob_op_with_handle_complete, NULL);
6249 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid2);
6253 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
6261 spdk_bs_create_snapshot(bs, cloneid, NULL, blob_op_with_id_complete, NULL);
6267 spdk_bs_open_blob(bs, snapshotid3, blob_op_with_handle_complete, NULL);
6274 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid3) == snapshotid2);
6279 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid3);
6282 rc = spdk_blob_get_clones(bs, snapshotid3, ids, &count);
6289 spdk_bs_create_snapshot(bs, cloneid, NULL, blob_op_with_id_complete, NULL);
6295 spdk_bs_open_blob(bs, snapshotid4, blob_op_with_handle_complete, NULL);
6302 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid4) == snapshotid3);
6307 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid4);
6310 rc = spdk_blob_get_clones(bs, snapshotid4, ids, &count);
6317 ut_blob_close_and_delete(bs, snapshot4);
6321 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid3);
6324 rc = spdk_blob_get_clones(bs, snapshotid3, ids, &count);
6331 spdk_bs_create_clone(bs, snapshotid3, NULL, blob_op_with_id_complete, NULL);
6337 spdk_bs_delete_blob(bs, snapshotid3, blob_op_complete, NULL);
6343 spdk_bs_open_blob(bs, snapshotid3, blob_op_with_handle_complete, NULL);
6349 spdk_bs_delete_blob(bs, snapshotid3, blob_op_complete, NULL);
6357 spdk_bs_delete_blob(bs, cloneid3, blob_op_complete, NULL);
6367 ut_blob_close_and_delete(bs, snapshot1);
6371 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid2) == SPDK_BLOBID_INVALID);
6377 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
6392 spdk_bs_create_clone(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6398 spdk_bs_open_blob(bs, cloneid2, blob_op_with_handle_complete, NULL);
6404 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid2) == blobid);
6407 rc = spdk_blob_get_clones(bs, blobid, ids, &count);
6434 ut_bs_reload(&bs, &bs_opts);
6439 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid2) == SPDK_BLOBID_INVALID);
6442 rc = spdk_blob_get_clones(bs, snapshotid2, ids, &count);
6449 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid2);
6451 rc = spdk_blob_get_clones(bs, blobid, ids, &count);
6457 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid) == snapshotid3);
6459 rc = spdk_blob_get_clones(bs, cloneid, ids, &count);
6464 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, snapshotid3) == snapshotid2);
6466 rc = spdk_blob_get_clones(bs, snapshotid3, ids, &count);
6472 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, cloneid2) == blobid);
6474 rc = spdk_blob_get_clones(bs, cloneid2, ids, &count);
6480 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
6484 spdk_bs_delete_blob(bs, snapshotid3, blob_op_complete, NULL);
6488 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
6492 spdk_bs_delete_blob(bs, cloneid, blob_op_complete, NULL);
6496 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
6500 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
6504 spdk_bs_delete_blob(bs, cloneid2, blob_op_complete, NULL);
6508 spdk_bs_unload(bs, bs_op_complete, NULL);
6529 struct spdk_blob_store *bs;
6545 bs = g_bs;
6547 channel = spdk_bs_alloc_io_channel(bs);
6554 blob = ut_blob_create_and_open(bs, &opts);
6558 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6565 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6572 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6579 spdk_bs_blob_decouple_parent(bs, channel, blobid, blob_op_complete, NULL);
6584 spdk_bs_blob_decouple_parent(bs, channel, snapshotid2, blob_op_complete, NULL);
6593 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
6599 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
6603 /* Remove remaining blobs and unload bs */
6604 spdk_bs_delete_blob(bs, snapshotid1, blob_op_complete, NULL);
6608 spdk_bs_delete_blob(bs, snapshotid0, blob_op_complete, NULL);
6615 spdk_bs_unload(bs, bs_op_complete, NULL);
6625 struct spdk_blob_store *bs;
6634 /* Create bs and blob */
6638 bs = g_bs;
6645 SPDK_CU_ASSERT_FATAL(bs->clean == 0);
6647 /* Force bs/super block in a clean state.
6650 bs->clean = 1;
6661 /* After successful md sync, both bs and super block
6663 SPDK_CU_ASSERT_FATAL(bs->clean == 0);
6674 /* Delete blob and unload bs */
6685 struct spdk_blob_store *bs;
6707 bs = g_bs;
6709 first_data_cluster = FIRST_DATA_CLUSTER(bs);
6715 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
6722 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6727 SPDK_CU_ASSERT_FATAL(spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster));
6728 SPDK_CU_ASSERT_FATAL(!spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster + 10));
6732 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
6739 ut_bs_dirty_load(&bs, NULL);
6741 SPDK_CU_ASSERT_FATAL(spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster));
6742 SPDK_CU_ASSERT_FATAL(!spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster + 10));
6744 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
6751 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
6757 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid);
6759 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
6773 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == SPDK_BLOBID_INVALID);
6787 spdk_bs_unload(bs, bs_op_complete, NULL);
6798 struct spdk_blob_store *bs = g_bs;
6821 bs = g_bs;
6823 first_data_cluster = FIRST_DATA_CLUSTER(bs);
6829 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
6834 SPDK_CU_ASSERT_FATAL(spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster));
6835 SPDK_CU_ASSERT_FATAL(!spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster + 10));
6840 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
6844 SPDK_CU_ASSERT_FATAL(spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster));
6845 SPDK_CU_ASSERT_FATAL(!spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster + 10));
6850 ut_bs_dirty_load(&bs, NULL);
6852 SPDK_CU_ASSERT_FATAL(spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster));
6853 SPDK_CU_ASSERT_FATAL(!spdk_bit_pool_is_allocated(bs->used_clusters, first_data_cluster + 10));
6855 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
6862 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
6873 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == snapshotid);
6875 rc = spdk_blob_get_clones(bs, snapshotid, ids, &count);
6889 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid) == SPDK_BLOBID_INVALID);
6898 spdk_bs_unload(bs, bs_op_complete, NULL);
7534 struct spdk_blob_store *bs;
7556 bs = g_bs;
7558 CU_ASSERT(spdk_bs_get_io_unit_size(bs) == 512);
7559 channel = spdk_bs_alloc_io_channel(bs);
7566 blob = ut_blob_create_and_open(bs, &opts);
7594 blob = ut_blob_create_and_open(bs, &opts);
7610 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
7616 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
7622 spdk_bs_create_clone(bs, blobid, NULL, blob_op_with_id_complete, NULL);
7628 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
7648 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
7676 spdk_bs_unload(bs, bs_op_complete, NULL);
7688 struct spdk_blob_store *bs;
7708 bs = g_bs;
7710 CU_ASSERT(spdk_bs_get_io_unit_size(bs) == 512);
7713 spdk_bs_unload(bs, bs_op_complete, NULL);
7731 bs = g_bs;
7733 CU_ASSERT(spdk_bs_get_io_unit_size(bs) == SPDK_BS_PAGE_SIZE);
7736 spdk_bs_unload(bs, bs_op_complete, NULL);
7784 struct spdk_blob_store *bs = g_bs;
7791 channel = spdk_bs_alloc_io_channel(bs);
7797 blob = ut_blob_create_and_open(bs, &opts);
7804 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
7806 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
7818 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
7828 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
7830 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
7843 spdk_bs_create_clone(bs, snapshotid, NULL, blob_op_with_id_complete, NULL);
7844 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
7858 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);
7889 ut_blob_close_and_delete(bs, snapshot);
7890 ut_blob_close_and_delete(bs, blob);
7896 struct spdk_blob_store *bs = g_bs;
7908 channel = spdk_bs_alloc_io_channel(bs);
7914 blob = ut_blob_create_and_open(bs, &opts);
7919 page_count_clear = spdk_bit_array_count_set(bs->used_md_pages);
7936 page_count_xattr = spdk_bit_array_count_set(bs->used_md_pages);
7956 SPDK_CU_ASSERT_FATAL(spdk_bit_array_count_set(bs->used_md_pages) == page_count_xattr);
7966 SPDK_CU_ASSERT_FATAL(spdk_bit_array_count_set(bs->used_md_pages) == page_count_clear);
7968 /* Reload bs and re-open blob to verify that xattr was not persisted. */
7973 ut_bs_reload(&bs, NULL);
7975 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
7992 ut_blob_close_and_delete(bs, blob);
8001 struct spdk_blob_store *bs = g_bs;
8009 channel = spdk_bs_alloc_io_channel(bs);
8016 blob = ut_blob_create_and_open(bs, &opts);
8020 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 0);
8021 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
8025 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 1);
8028 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
8035 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 1);
8036 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
8040 CU_ASSERT_EQUAL(_get_snapshots_count(bs), 2);
8043 spdk_bs_open_blob(bs, snapshotid, blob_op_with_handle_complete, NULL);
8048 CU_ASSERT_EQUAL(spdk_blob_get_parent_snapshot(bs, snapshot2->id), snapshot1->id);
8051 spdk_bs_blob_decouple_parent(bs, channel, snapshot2->id, blob_op_complete, NULL);
8056 CU_ASSERT_EQUAL(spdk_blob_get_parent_snapshot(bs, snapshot2->id), SPDK_BLOBID_INVALID);
8066 ut_blob_close_and_delete(bs, snapshot2);
8067 ut_blob_close_and_delete(bs, snapshot1);
8068 ut_blob_close_and_delete(bs, blob);
8070 ut_blob_close_and_delete(bs, blob);
8071 ut_blob_close_and_delete(bs, snapshot2);
8072 ut_blob_close_and_delete(bs, snapshot1);
8081 struct spdk_blob_store *bs = g_bs;
8090 free_clusters = spdk_bs_free_cluster_count(bs);
8092 channel = spdk_bs_alloc_io_channel(bs);
8100 blob = ut_blob_create_and_open(bs, &opts);
8101 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
8109 CU_ASSERT(free_clusters == spdk_bs_free_cluster_count(bs));
8151 ut_blob_close_and_delete(bs, blob);
8157 struct spdk_blob_store *bs = g_bs;
8170 cluster_sz = spdk_bs_get_cluster_size(bs);
8171 block_sz = spdk_bs_get_io_unit_size(bs);
8176 blob = ut_blob_create_and_open(bs, &opts);
8178 ut_blob_close_and_delete(bs, blob);
8186 blob = ut_blob_create_and_open(bs, &opts);
8193 ut_blob_close_and_delete(bs, blob);
8200 blob = ut_blob_create_and_open(bs, &opts);
8228 ut_bs_reload(&bs, &bs_opts);
8229 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8244 ut_bs_reload(&bs, &bs_opts);
8245 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8255 ut_bs_reload(&bs, &bs_opts);
8258 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8276 spdk_bs_open_blob_ext(bs, blobid, &open_opts, blob_op_with_handle_complete, NULL);
8290 struct spdk_blob_store *bs = g_bs;
8295 uint32_t cluster_sz = spdk_bs_get_cluster_size(bs);
8296 uint32_t block_sz = spdk_bs_get_io_unit_size(bs);
8311 eclone1 = ut_blob_create_and_open(bs, &opts);
8317 spdk_bs_create_snapshot(bs, eclone1_id, NULL, blob_op_with_id_complete, NULL);
8322 spdk_bs_open_blob(bs, snap1_id, blob_op_with_handle_complete, NULL);
8329 spdk_bs_create_clone(bs, snap1_id, NULL, blob_op_with_id_complete, NULL);
8334 spdk_bs_open_blob(bs, clone1_id, blob_op_with_handle_complete, NULL);
8355 ut_bs_reload(&bs, &bs_opts);
8358 spdk_bs_open_blob(bs, eclone1_id, blob_op_with_handle_complete, NULL);
8363 spdk_bs_open_blob(bs, snap1_id, blob_op_with_handle_complete, NULL);
8368 spdk_bs_open_blob(bs, clone1_id, blob_op_with_handle_complete, NULL);
8375 bs_ch = spdk_bs_alloc_io_channel(bs);
8398 spdk_bs_unload(bs, blob_op_complete, &bserr4);
8421 const uint32_t bs_blksz = blob->bs->io_unit_size;
8475 struct spdk_blob_store *bs;
8503 bs = g_bs;
8505 bs_ch = spdk_bs_alloc_io_channel(bs);
8514 blob = ut_blob_create_and_open(bs, &opts);
8614 struct spdk_blob_store *bs;
8638 bs = g_bs;
8646 spdk_bs_create_blob_ext(bs, &blob_opts, blob_op_with_id_complete, NULL);
8651 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8657 spdk_bs_unload(bs, bs_op_complete, NULL);
8667 struct spdk_blob_store *bs = g_bs;
8677 const uint32_t blocklen = bs->io_unit_size;
8689 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
8696 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8706 ch0 = spdk_bs_alloc_io_channel(bs);
8721 ch1 = spdk_bs_alloc_io_channel(bs);
8778 struct spdk_blob_store *bs = g_bs;
8787 channel[i] = spdk_bs_alloc_io_channel(bs);
8794 blob = ut_blob_create_and_open(bs, &opts);
8841 ut_blob_close_and_delete(bs, blob);
8851 struct spdk_blob_store *bs;
8873 bs = g_bs;
8875 free_clusters = spdk_bs_free_cluster_count(bs);
8880 blob = ut_blob_create_and_open(bs, &opts);
8884 spdk_bs_unload(bs, bs_op_complete, NULL);
8938 struct spdk_blob_store *bs = g_bs;
8939 const uint32_t blocklen = bs->io_unit_size;
8952 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
8959 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
8969 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
8975 spdk_bs_open_blob(bs, snap_blobid, blob_op_with_handle_complete, NULL);
8987 ut_blob_close_and_delete(bs, snap_blob);
8996 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
9002 spdk_bs_open_blob(bs, snap_blobid, blob_op_with_handle_complete, NULL);
9011 ut_blob_close_and_delete(bs, blob);
9019 spdk_bs_create_clone(bs, snap_blobid, NULL, blob_op_with_id_complete, NULL);
9025 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
9037 ut_blob_close_and_delete(bs, snap_blob);
9045 ut_blob_close_and_delete(bs, blob);
9051 struct spdk_blob_store *bs = g_bs;
9058 const uint32_t blocklen = spdk_bs_get_io_unit_size(bs);
9059 const uint32_t cluster_sz = spdk_bs_get_cluster_size(bs);
9065 channel = spdk_bs_alloc_io_channel(bs);
9074 spdk_bs_create_blob_ext(bs, &opts, blob_op_with_id_complete, NULL);
9081 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
9093 spdk_bs_inflate_blob(bs, channel, blobid, blob_op_complete, NULL);
9095 spdk_bs_blob_decouple_parent(bs, channel, blobid, blob_op_complete, NULL);
9101 ut_blob_close_and_delete(bs, blob);
9128 struct spdk_blob_store *bs = g_bs;
9134 uint32_t cluster_sz = spdk_bs_get_cluster_size(bs);
9135 uint32_t block_sz = spdk_bs_get_io_unit_size(bs);
9149 blob = ut_blob_create_and_open(bs, &opts);
9174 ch0 = spdk_bs_alloc_io_channel(bs);
9178 ch1 = spdk_bs_alloc_io_channel(bs);
9227 /* No back_bs_dev, no bs->dev->is_degraded */
9246 /* back_bs_dev does not define is_degraded, no bs->dev->is_degraded */
9254 /* back_bs_dev is not degraded, no bs->dev->is_degraded */
9262 /* back_bs_dev is degraded, no bs->dev->is_degraded */
9286 struct spdk_blob_store *bs = g_bs;
9291 uint8_t payload_read[bs->dev->blocklen];
9292 uint8_t payload_write[bs->dev->blocklen];
9296 channel = spdk_bs_alloc_io_channel(bs);
9299 pages_per_cluster = spdk_bs_get_cluster_size(bs) / spdk_bs_get_page_size(bs);
9305 blob = ut_blob_create_and_open(bs, &opts);
9310 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
9316 spdk_bs_create_clone(bs, snapid1, NULL, blob_op_with_id_complete, NULL);
9322 spdk_bs_open_blob(bs, cloneid, blob_op_with_handle_complete, NULL);
9336 spdk_bs_create_snapshot(bs, cloneid, NULL, blob_op_with_id_complete, NULL);
9343 spdk_bs_open_blob(bs, snapid1, blob_op_with_handle_complete, NULL);
9351 spdk_bs_open_blob(bs, snapid2, blob_op_with_handle_complete, NULL);
9391 CU_ASSERT(memcmp(payload_write, payload_read, bs->dev->blocklen) == 0);
9394 free_clusters = spdk_bs_free_cluster_count(bs);
9395 spdk_bs_inflate_blob(bs, channel, cloneid, blob_op_complete, NULL);
9400 CU_ASSERT(spdk_bs_free_cluster_count(bs) == free_clusters - 18);
9414 ut_blob_close_and_delete(bs, blob);
9424 struct spdk_blob_store *bs;
9450 bs = g_bs;
9452 bs_ch = spdk_bs_alloc_io_channel(bs);
9461 blob = ut_blob_create_and_open(bs, &opts);
9540 struct spdk_blob_store *bs = g_bs;
9554 blob_ch = spdk_bs_alloc_io_channel(bs);
9563 blob = ut_blob_create_and_open(bs, &blob_opts);
9584 spdk_bs_create_snapshot(bs, blobid, NULL, blob_op_with_id_complete, NULL);
9606 rc = spdk_bs_blob_shallow_copy(bs, blob_ch, blobid, ext_dev,
9622 rc = spdk_bs_blob_shallow_copy(bs, blob_ch, blobid, ext_dev,
9632 rc = spdk_bs_blob_shallow_copy(bs, blob_ch, blobid, ext_dev,
9653 rc = spdk_bs_blob_shallow_copy(bs, blob_ch, blobid, ext_dev,
9699 ut_blob_close_and_delete(bs, blob);
9706 struct spdk_blob_store *bs = g_bs;
9718 cluster_sz = spdk_bs_get_cluster_size(bs);
9719 block_sz = spdk_bs_get_io_unit_size(bs);
9724 blob1 = ut_blob_create_and_open(bs, &opts);
9727 spdk_bs_create_snapshot(bs, blobid1, NULL, blob_op_with_id_complete, NULL);
9732 spdk_bs_create_snapshot(bs, blobid1, NULL, blob_op_with_id_complete, NULL);
9739 spdk_bs_blob_set_parent(bs, blobid1, SPDK_BLOBID_INVALID, blob_op_complete, NULL);
9744 spdk_bs_blob_set_parent(bs, blobid1, blobid1, blob_op_complete, NULL);
9749 spdk_bs_blob_set_parent(bs, blobid1, snapshotid2, blob_op_complete, NULL);
9759 blob2 = ut_blob_create_and_open(bs, &opts);
9765 spdk_bs_blob_set_parent(bs, blobid2, blobid1, blob_op_complete, NULL);
9770 spdk_bs_blob_set_parent(bs, blobid2, snapshotid1, blob_op_complete, NULL);
9775 spdk_bs_blob_set_parent(bs, blobid1, snapshotid1, blob_op_complete, NULL);
9781 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid1) == snapshotid1);
9782 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid1, ids, &clone_count) == 0);
9790 blob3 = ut_blob_create_and_open(bs, &opts);
9793 spdk_bs_create_snapshot(bs, blobid3, NULL, blob_op_with_id_complete, NULL);
9800 spdk_bs_blob_set_parent(bs, blobid2, snapshotid3, blob_op_complete, NULL);
9807 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid2) == snapshotid3);
9808 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid3, ids, &clone_count) == 0);
9815 blob4 = ut_blob_create_and_open(bs, &opts);
9820 spdk_bs_blob_set_parent(bs, blobid4, snapshotid2, blob_op_complete, NULL);
9827 blob5 = ut_blob_create_and_open(bs, &opts);
9832 spdk_bs_blob_set_parent(bs, blobid5, snapshotid2, blob_op_complete, NULL);
9838 CU_ASSERT(spdk_blob_get_parent_snapshot(bs, blobid5) == snapshotid2);
9839 CU_ASSERT(spdk_blob_get_clones(bs, snapshotid2, ids, &clone_count) == 0);
9844 ut_blob_close_and_delete(bs, blob5);
9845 ut_blob_close_and_delete(bs, blob4);
9846 ut_blob_close_and_delete(bs, blob3);
9847 ut_blob_close_and_delete(bs, blob2);
9848 ut_blob_close_and_delete(bs, blob1);
9849 spdk_bs_delete_blob(bs, snapshotid3, blob_op_complete, NULL);
9852 spdk_bs_delete_blob(bs, snapshotid2, blob_op_complete, NULL);
9855 spdk_bs_delete_blob(bs, snapshotid1, blob_op_complete, NULL);
9863 struct spdk_blob_store *bs = g_bs;
9876 cluster_sz = spdk_bs_get_cluster_size(bs);
9877 block_sz = spdk_bs_get_io_unit_size(bs);
9889 blob1 = ut_blob_create_and_open(bs, &opts);
9895 spdk_bs_blob_set_external_parent(bs, blobid1, esnap_dev1, &blobid1, sizeof(blobid1),
9901 spdk_bs_blob_set_external_parent(bs, blobid1, esnap_dev1, opts.esnap_id, opts.esnap_id_len,
9908 spdk_bs_blob_set_external_parent(bs, blobid1, esnap_dev1, opts.esnap_id, opts.esnap_id_len,
9915 blob2 = ut_blob_create_and_open(bs, &opts);
9918 spdk_bs_create_snapshot(bs, blobid2, NULL, blob_op_with_id_complete, NULL);
9928 spdk_bs_blob_set_external_parent(bs, blobid2, esnap_dev2, &esnap_opts2, sizeof(esnap_opts2),
9944 blob3 = ut_blob_create_and_open(bs, &opts);
9949 spdk_bs_blob_set_external_parent(bs, blobid3, esnap_dev1, &esnap_opts, sizeof(esnap_opts),
9957 blob4 = ut_blob_create_and_open(bs, &opts);
9965 spdk_bs_blob_set_external_parent(bs, blobid4, esnap_dev3, &esnap_opts, sizeof(esnap_opts),
9978 ut_blob_close_and_delete(bs, blob4);
9979 ut_blob_close_and_delete(bs, blob3);
9980 ut_blob_close_and_delete(bs, blob2);
9981 ut_blob_close_and_delete(bs, blob1);
9982 spdk_bs_delete_blob(bs, snapshotid, blob_op_complete, NULL);
10031 ut_blob_create_and_open(struct spdk_blob_store *bs, struct spdk_blob_opts *blob_opts)
10042 spdk_bs_create_blob_ext(bs, blob_opts, blob_op_with_id_complete, NULL);
10049 spdk_bs_open_blob(bs, blobid, blob_op_with_handle_complete, NULL);
10062 ut_blob_close_and_delete(struct spdk_blob_store *bs, struct spdk_blob *blob)
10071 spdk_bs_delete_blob(bs, blobid, blob_op_complete, NULL);