Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2017 Intel Corporation.
3 : : * All rights reserved.
4 : : * Copyright (c) 2021-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : : */
6 : :
7 : : #include "spdk/stdinc.h"
8 : :
9 : : #include "spdk/blob.h"
10 : : #include "spdk/crc32.h"
11 : : #include "spdk/env.h"
12 : : #include "spdk/queue.h"
13 : : #include "spdk/thread.h"
14 : : #include "spdk/bit_array.h"
15 : : #include "spdk/bit_pool.h"
16 : : #include "spdk/likely.h"
17 : : #include "spdk/util.h"
18 : : #include "spdk/string.h"
19 : : #include "spdk/trace.h"
20 : :
21 : : #include "spdk_internal/assert.h"
22 : : #include "spdk_internal/trace_defs.h"
23 : : #include "spdk/log.h"
24 : :
25 : : #include "blobstore.h"
26 : :
27 : : #define BLOB_CRC32C_INITIAL 0xffffffffUL
28 : :
29 : : static int bs_register_md_thread(struct spdk_blob_store *bs);
30 : : static int bs_unregister_md_thread(struct spdk_blob_store *bs);
31 : : static void blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno);
32 : : static void blob_insert_cluster_on_md_thread(struct spdk_blob *blob, uint32_t cluster_num,
33 : : uint64_t cluster, uint32_t extent, struct spdk_blob_md_page *page,
34 : : spdk_blob_op_complete cb_fn, void *cb_arg);
35 : : static void blob_free_cluster_on_md_thread(struct spdk_blob *blob, uint32_t cluster_num,
36 : : uint32_t extent_page, struct spdk_blob_md_page *page, spdk_blob_op_complete cb_fn, void *cb_arg);
37 : :
38 : : static int blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value,
39 : : uint16_t value_len, bool internal);
40 : : static int blob_get_xattr_value(struct spdk_blob *blob, const char *name,
41 : : const void **value, size_t *value_len, bool internal);
42 : : static int blob_remove_xattr(struct spdk_blob *blob, const char *name, bool internal);
43 : :
44 : : static void blob_write_extent_page(struct spdk_blob *blob, uint32_t extent, uint64_t cluster_num,
45 : : struct spdk_blob_md_page *page, spdk_blob_op_complete cb_fn, void *cb_arg);
46 : : static void blob_freeze_io(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg);
47 : :
48 : : static void bs_shallow_copy_cluster_find_next(void *cb_arg);
49 : :
50 : : /*
51 : : * External snapshots require a channel per thread per esnap bdev. The tree
52 : : * is populated lazily as blob IOs are handled by the back_bs_dev. When this
53 : : * channel is destroyed, all the channels in the tree are destroyed.
54 : : */
55 : :
56 : : struct blob_esnap_channel {
57 : : RB_ENTRY(blob_esnap_channel) node;
58 : : spdk_blob_id blob_id;
59 : : struct spdk_io_channel *channel;
60 : : };
61 : :
62 : : static int blob_esnap_channel_compare(struct blob_esnap_channel *c1, struct blob_esnap_channel *c2);
63 : : static void blob_esnap_destroy_bs_dev_channels(struct spdk_blob *blob, bool abort_io,
64 : : spdk_blob_op_with_handle_complete cb_fn, void *cb_arg);
65 : : static void blob_esnap_destroy_bs_channel(struct spdk_bs_channel *ch);
66 : : static void blob_set_back_bs_dev_frozen(void *_ctx, int bserrno);
67 [ + + + + : 97162 : RB_GENERATE_STATIC(blob_esnap_channel_tree, blob_esnap_channel, node, blob_esnap_channel_compare)
+ + + + +
+ + - - +
- + - + +
- - - - -
- - - - -
- - - - -
- - - - -
- - - - -
- - - + #
# # # # #
# # # # #
# # # # #
# # - + #
# # # # #
- + # # -
+ - + - +
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # + + -
+ - + # #
- + # # +
- - + # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # +
- + - + -
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
68 : :
69 : : static inline bool
70 : 23427844 : blob_is_esnap_clone(const struct spdk_blob *blob)
71 : : {
72 [ + + # # ]: 23427844 : assert(blob != NULL);
73 [ # # # # : 23427844 : return !!(blob->invalid_flags & SPDK_BLOB_EXTERNAL_SNAPSHOT);
# # ]
74 : : }
75 : :
76 : : static int
77 : 98071 : blob_id_cmp(struct spdk_blob *blob1, struct spdk_blob *blob2)
78 : : {
79 [ + - + - ]: 98071 : assert(blob1 != NULL && blob2 != NULL);
80 [ + + # # : 98071 : return (blob1->id < blob2->id ? -1 : blob1->id > blob2->id);
# # # # #
# # # # #
# # # # ]
81 : : }
82 : :
83 [ + + + + : 267145 : RB_GENERATE_STATIC(spdk_blob_tree, spdk_blob, link, blob_id_cmp);
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + +
+ + + + -
- + # # +
+ + + + +
+ + + - #
# # # # #
# # # # +
+ - + # #
- + + + +
+ + + + +
+ + + - +
+ + + - +
+ + + + +
+ + + - +
+ - + - +
- - + + -
+ - + + +
+ + + + +
+ + + - +
- + - - +
+ - + + +
+ + - # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
84 : :
85 : : static void
86 : 3706610 : blob_verify_md_op(struct spdk_blob *blob)
87 : : {
88 [ + + # # ]: 3706610 : assert(blob != NULL);
89 [ + + # # : 3706610 : assert(spdk_get_thread() == blob->bs->md_thread);
# # # # #
# # # ]
90 [ + + # # : 3706610 : assert(blob->state != SPDK_BLOB_STATE_LOADING);
# # # # ]
91 : 3706610 : }
92 : :
93 : : static struct spdk_blob_list *
94 : 24964 : bs_get_snapshot_entry(struct spdk_blob_store *bs, spdk_blob_id blobid)
95 : : {
96 : 24964 : struct spdk_blob_list *snapshot_entry = NULL;
97 : :
98 [ + + # # : 30283 : TAILQ_FOREACH(snapshot_entry, &bs->snapshots, link) {
# # # # #
# # # #
# ]
99 [ + + # # : 9582 : if (snapshot_entry->id == blobid) {
# # ]
100 : 4263 : break;
101 : : }
102 : 1249 : }
103 : :
104 : 24964 : return snapshot_entry;
105 : : }
106 : :
107 : : static void
108 : 26796 : bs_claim_md_page(struct spdk_blob_store *bs, uint32_t page)
109 : : {
110 [ + + # # : 26796 : assert(spdk_spin_held(&bs->used_lock));
# # ]
111 [ + + # # : 26796 : assert(page < spdk_bit_array_capacity(bs->used_md_pages));
# # # # ]
112 [ + + # # : 26796 : assert(spdk_bit_array_get(bs->used_md_pages, page) == false);
# # # # ]
113 : :
114 [ # # # # ]: 26796 : spdk_bit_array_set(bs->used_md_pages, page);
115 : 26796 : }
116 : :
117 : : static void
118 : 19857 : bs_release_md_page(struct spdk_blob_store *bs, uint32_t page)
119 : : {
120 [ + + # # : 19857 : assert(spdk_spin_held(&bs->used_lock));
# # ]
121 [ + + # # : 19857 : assert(page < spdk_bit_array_capacity(bs->used_md_pages));
# # # # ]
122 [ + + # # : 19857 : assert(spdk_bit_array_get(bs->used_md_pages, page) == true);
# # # # ]
123 : :
124 [ # # # # ]: 19857 : spdk_bit_array_clear(bs->used_md_pages, page);
125 : 19857 : }
126 : :
127 : : static uint32_t
128 : 2675193 : bs_claim_cluster(struct spdk_blob_store *bs)
129 : : {
130 : : uint32_t cluster_num;
131 : :
132 [ + + # # : 2675193 : assert(spdk_spin_held(&bs->used_lock));
# # ]
133 : :
134 [ # # # # ]: 2675193 : cluster_num = spdk_bit_pool_allocate_bit(bs->used_clusters);
135 [ + + ]: 2675193 : if (cluster_num == UINT32_MAX) {
136 : 1 : return UINT32_MAX;
137 : : }
138 : :
139 [ + + - + : 2675192 : SPDK_DEBUGLOG(blob, "Claiming cluster %u\n", cluster_num);
# # ]
140 [ # # ]: 2675192 : bs->num_free_clusters--;
141 : :
142 : 2675192 : return cluster_num;
143 : 10315 : }
144 : :
145 : : static void
146 : 2518906 : bs_release_cluster(struct spdk_blob_store *bs, uint32_t cluster_num)
147 : : {
148 [ + + # # : 2518906 : assert(spdk_spin_held(&bs->used_lock));
# # ]
149 [ + + # # : 2518906 : assert(cluster_num < spdk_bit_pool_capacity(bs->used_clusters));
# # # # ]
150 [ + + # # : 2518906 : assert(spdk_bit_pool_is_allocated(bs->used_clusters, cluster_num) == true);
# # # # ]
151 [ - + # # : 2518906 : assert(bs->num_free_clusters < bs->total_clusters);
# # # # #
# # # ]
152 : :
153 [ + + - + : 2518906 : SPDK_DEBUGLOG(blob, "Releasing cluster %u\n", cluster_num);
# # ]
154 : :
155 [ # # # # ]: 2518906 : spdk_bit_pool_free_bit(bs->used_clusters, cluster_num);
156 [ # # ]: 2518906 : bs->num_free_clusters++;
157 : 2518906 : }
158 : :
159 : : static int
160 : 2675192 : blob_insert_cluster(struct spdk_blob *blob, uint32_t cluster_num, uint64_t cluster)
161 : : {
162 [ # # # # : 2675192 : uint64_t *cluster_lba = &blob->active.clusters[cluster_num];
# # # # ]
163 : :
164 : 2675192 : blob_verify_md_op(blob);
165 : :
166 [ + + # # ]: 2675192 : if (*cluster_lba != 0) {
167 : 36 : return -EEXIST;
168 : : }
169 : :
170 [ # # # # : 2675156 : *cluster_lba = bs_cluster_to_lba(blob->bs, cluster);
# # ]
171 [ # # # # ]: 2675156 : blob->active.num_allocated_clusters++;
172 : :
173 : 2675156 : return 0;
174 : 10315 : }
175 : :
176 : : static int
177 : 2675193 : bs_allocate_cluster(struct spdk_blob *blob, uint32_t cluster_num,
178 : : uint64_t *cluster, uint32_t *lowest_free_md_page, bool update_map)
179 : : {
180 : 2675193 : uint32_t *extent_page = 0;
181 : :
182 [ + + # # : 2675193 : assert(spdk_spin_held(&blob->bs->used_lock));
# # # # #
# ]
183 : :
184 [ # # # # : 2675193 : *cluster = bs_claim_cluster(blob->bs);
# # ]
185 [ + + # # ]: 2675193 : if (*cluster == UINT32_MAX) {
186 : : /* No more free clusters. Cannot satisfy the request */
187 : 1 : return -ENOSPC;
188 : : }
189 : :
190 [ + + + + : 2675192 : if (blob->use_extent_table) {
# # # # ]
191 : 2658968 : extent_page = bs_cluster_to_extent_page(blob, cluster_num);
192 [ + + # # ]: 2658968 : if (*extent_page == 0) {
193 : : /* Extent page shall never occupy md_page so start the search from 1 */
194 [ + + # # ]: 12453 : if (*lowest_free_md_page == 0) {
195 [ # # ]: 7820 : *lowest_free_md_page = 1;
196 : 1085 : }
197 : : /* No extent_page is allocated for the cluster */
198 [ # # # # : 13541 : *lowest_free_md_page = spdk_bit_array_find_first_clear(blob->bs->used_md_pages,
# # # # #
# ]
199 [ # # ]: 1088 : *lowest_free_md_page);
200 [ + + # # ]: 12453 : if (*lowest_free_md_page == UINT32_MAX) {
201 : : /* No more free md pages. Cannot satisfy the request */
202 [ # # # # : 0 : bs_release_cluster(blob->bs, *cluster);
# # ]
203 : 0 : return -ENOSPC;
204 : : }
205 [ # # # # : 12453 : bs_claim_md_page(blob->bs, *lowest_free_md_page);
# # ]
206 : 1088 : }
207 : 6259 : }
208 : :
209 [ + + - + : 2675192 : SPDK_DEBUGLOG(blob, "Claiming cluster %" PRIu64 " for blob 0x%" PRIx64 "\n", *cluster,
# # # # #
# # # ]
210 : : blob->id);
211 : :
212 [ + + # # ]: 2675192 : if (update_map) {
213 [ # # ]: 2638761 : blob_insert_cluster(blob, cluster_num, *cluster);
214 [ + + + + : 2638761 : if (blob->use_extent_table && *extent_page == 0) {
+ + # # #
# # # ]
215 [ # # # # ]: 10950 : *extent_page = *lowest_free_md_page;
216 : 959 : }
217 : 9285 : }
218 : :
219 : 2675192 : return 0;
220 : 10315 : }
221 : :
222 : : static void
223 : 34154 : blob_xattrs_init(struct spdk_blob_xattr_opts *xattrs)
224 : : {
225 [ # # # # ]: 34154 : xattrs->count = 0;
226 [ # # # # ]: 34154 : xattrs->names = NULL;
227 [ # # # # ]: 34154 : xattrs->ctx = NULL;
228 [ # # # # ]: 34154 : xattrs->get_value = NULL;
229 : 34154 : }
230 : :
231 : : void
232 : 21848 : spdk_blob_opts_init(struct spdk_blob_opts *opts, size_t opts_size)
233 : : {
234 [ + + ]: 21848 : if (!opts) {
235 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
236 : 0 : return;
237 : : }
238 : :
239 [ + + ]: 21848 : if (!opts_size) {
240 : 0 : SPDK_ERRLOG("opts_size should not be zero value\n");
241 : 0 : return;
242 : : }
243 : :
244 [ - + ]: 21848 : memset(opts, 0, opts_size);
245 [ # # # # ]: 21848 : opts->opts_size = opts_size;
246 : :
247 : : #define FIELD_OK(field) \
248 : : offsetof(struct spdk_blob_opts, field) + sizeof(opts->field) <= opts_size
249 : :
250 : : #define SET_FIELD(field, value) \
251 : : if (FIELD_OK(field)) { \
252 : : opts->field = value; \
253 : : } \
254 : :
255 [ + - # # : 21848 : SET_FIELD(num_clusters, 0);
# # ]
256 [ + - # # : 21848 : SET_FIELD(thin_provision, false);
# # ]
257 [ + - # # : 21848 : SET_FIELD(clear_method, BLOB_CLEAR_WITH_DEFAULT);
# # ]
258 : :
259 [ + - ]: 21848 : if (FIELD_OK(xattrs)) {
260 [ # # ]: 21848 : blob_xattrs_init(&opts->xattrs);
261 : 4620 : }
262 : :
263 [ + - # # : 21848 : SET_FIELD(use_extent_table, true);
# # ]
264 : :
265 : : #undef FIELD_OK
266 : : #undef SET_FIELD
267 : 4620 : }
268 : :
269 : : void
270 : 36691 : spdk_blob_open_opts_init(struct spdk_blob_open_opts *opts, size_t opts_size)
271 : : {
272 [ + + ]: 36691 : if (!opts) {
273 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
274 : 0 : return;
275 : : }
276 : :
277 [ + + ]: 36691 : if (!opts_size) {
278 : 0 : SPDK_ERRLOG("opts_size should not be zero value\n");
279 : 0 : return;
280 : : }
281 : :
282 [ - + ]: 36691 : memset(opts, 0, opts_size);
283 [ # # # # ]: 36691 : opts->opts_size = opts_size;
284 : :
285 : : #define FIELD_OK(field) \
286 : : offsetof(struct spdk_blob_open_opts, field) + sizeof(opts->field) <= opts_size
287 : :
288 : : #define SET_FIELD(field, value) \
289 : : if (FIELD_OK(field)) { \
290 : : opts->field = value; \
291 : : } \
292 : :
293 [ + - # # : 36691 : SET_FIELD(clear_method, BLOB_CLEAR_WITH_DEFAULT);
# # ]
294 : :
295 : : #undef FIELD_OK
296 : : #undef SET_FILED
297 : 4386 : }
298 : :
299 : : static struct spdk_blob *
300 : 48311 : blob_alloc(struct spdk_blob_store *bs, spdk_blob_id id)
301 : : {
302 : : struct spdk_blob *blob;
303 : :
304 : 48311 : blob = calloc(1, sizeof(*blob));
305 [ + + ]: 48311 : if (!blob) {
306 : 0 : return NULL;
307 : : }
308 : :
309 [ # # # # ]: 48311 : blob->id = id;
310 [ # # # # ]: 48311 : blob->bs = bs;
311 : :
312 [ # # # # ]: 48311 : blob->parent_id = SPDK_BLOBID_INVALID;
313 : :
314 [ # # # # ]: 48311 : blob->state = SPDK_BLOB_STATE_DIRTY;
315 [ # # # # ]: 48311 : blob->extent_rle_found = false;
316 [ # # # # ]: 48311 : blob->extent_table_found = false;
317 [ # # # # : 48311 : blob->active.num_pages = 1;
# # ]
318 [ # # # # : 48311 : blob->active.pages = calloc(1, sizeof(*blob->active.pages));
# # ]
319 [ - + # # : 48311 : if (!blob->active.pages) {
# # # # ]
320 : 0 : free(blob);
321 : 0 : return NULL;
322 : : }
323 : :
324 [ # # # # : 48311 : blob->active.pages[0] = bs_blobid_to_page(id);
# # # # #
# ]
325 : :
326 [ # # # # : 48311 : TAILQ_INIT(&blob->xattrs);
# # # # #
# # # # #
# # ]
327 [ # # # # : 48311 : TAILQ_INIT(&blob->xattrs_internal);
# # # # #
# # # # #
# # ]
328 [ # # # # : 48311 : TAILQ_INIT(&blob->pending_persists);
# # # # #
# # # # #
# # ]
329 [ # # # # : 48311 : TAILQ_INIT(&blob->persists_to_complete);
# # # # #
# # # # #
# # ]
330 : :
331 : 48311 : return blob;
332 : 6744 : }
333 : :
334 : : static void
335 : 96622 : xattrs_free(struct spdk_xattr_tailq *xattrs)
336 : : {
337 : : struct spdk_xattr *xattr, *xattr_tmp;
338 : :
339 [ + + + + : 144084 : TAILQ_FOREACH_SAFE(xattr, xattrs, link, xattr_tmp) {
# # # # #
# # # #
# ]
340 [ + + # # : 47462 : TAILQ_REMOVE(xattrs, xattr, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
341 [ # # # # ]: 47462 : free(xattr->name);
342 [ # # # # ]: 47462 : free(xattr->value);
343 : 47462 : free(xattr);
344 : 2272 : }
345 : 96622 : }
346 : :
347 : : static void
348 : 6047 : blob_unref_back_bs_dev(struct spdk_blob *blob)
349 : : {
350 [ # # # # : 6047 : blob->back_bs_dev->destroy(blob->back_bs_dev);
# # # # #
# # # # #
# # ]
351 [ # # # # ]: 6047 : blob->back_bs_dev = NULL;
352 : 6047 : }
353 : :
354 : : static void
355 : 48311 : blob_free(struct spdk_blob *blob)
356 : : {
357 [ + + # # ]: 48311 : assert(blob != NULL);
358 [ + + # # : 48311 : assert(TAILQ_EMPTY(&blob->pending_persists));
# # # # #
# ]
359 [ - + # # : 48311 : assert(TAILQ_EMPTY(&blob->persists_to_complete));
# # # # #
# ]
360 : :
361 [ # # # # : 48311 : free(blob->active.extent_pages);
# # ]
362 [ # # # # : 48311 : free(blob->clean.extent_pages);
# # ]
363 [ # # # # : 48311 : free(blob->active.clusters);
# # ]
364 [ # # # # : 48311 : free(blob->clean.clusters);
# # ]
365 [ # # # # : 48311 : free(blob->active.pages);
# # ]
366 [ # # # # : 48311 : free(blob->clean.pages);
# # ]
367 : :
368 [ # # ]: 48311 : xattrs_free(&blob->xattrs);
369 [ # # ]: 48311 : xattrs_free(&blob->xattrs_internal);
370 : :
371 [ + + # # : 48311 : if (blob->back_bs_dev) {
# # ]
372 : 5898 : blob_unref_back_bs_dev(blob);
373 : 1379 : }
374 : :
375 : 48311 : free(blob);
376 : 48311 : }
377 : :
378 : : static void
379 : 1682 : blob_back_bs_destroy_esnap_done(void *ctx, struct spdk_blob *blob, int bserrno)
380 : : {
381 : 1682 : struct spdk_bs_dev *bs_dev = ctx;
382 : :
383 [ + + ]: 1682 : if (bserrno != 0) {
384 : : /*
385 : : * This is probably due to a memory allocation failure when creating the
386 : : * blob_esnap_destroy_ctx before iterating threads.
387 : : */
388 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": Unable to destroy bs dev channels: error %d\n",
389 : : blob->id, bserrno);
390 [ # # ]: 0 : assert(false);
391 : : }
392 : :
393 [ - + ]: 1682 : if (bs_dev == NULL) {
394 : : /*
395 : : * This check exists to make scanbuild happy.
396 : : *
397 : : * blob->back_bs_dev for an esnap is NULL during the first iteration of blobs while
398 : : * the blobstore is being loaded. It could also be NULL if there was an error
399 : : * opening the esnap device. In each of these cases, no channels could have been
400 : : * created because back_bs_dev->create_channel() would have led to a NULL pointer
401 : : * deref.
402 : : */
403 [ # # ]: 0 : assert(false);
404 : : return;
405 : : }
406 : :
407 [ + + - + : 1682 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": calling destroy on back_bs_dev\n", blob->id);
# # # # #
# ]
408 [ # # # # : 1682 : bs_dev->destroy(bs_dev);
# # # # ]
409 : 407 : }
410 : :
411 : : static void
412 : 1682 : blob_back_bs_destroy(struct spdk_blob *blob)
413 : : {
414 [ + + - + : 1682 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": preparing to destroy back_bs_dev\n",
# # # # #
# ]
415 : : blob->id);
416 : :
417 : 2089 : blob_esnap_destroy_bs_dev_channels(blob, false, blob_back_bs_destroy_esnap_done,
418 [ # # # # ]: 1682 : blob->back_bs_dev);
419 [ # # # # ]: 1682 : blob->back_bs_dev = NULL;
420 : 1682 : }
421 : :
422 : : struct blob_parent {
423 : : union {
424 : : struct {
425 : : spdk_blob_id id;
426 : : struct spdk_blob *blob;
427 : : } snapshot;
428 : :
429 : : struct {
430 : : void *id;
431 : : uint32_t id_len;
432 : : struct spdk_bs_dev *back_bs_dev;
433 : : } esnap;
434 : : } u;
435 : : };
436 : :
437 : : typedef int (*set_parent_refs_cb)(struct spdk_blob *blob, struct blob_parent *parent);
438 : :
439 : : struct set_bs_dev_ctx {
440 : : struct spdk_blob *blob;
441 : : struct spdk_bs_dev *back_bs_dev;
442 : :
443 : : /*
444 : : * This callback is used during a set parent operation to change the references
445 : : * to the parent of the blob.
446 : : */
447 : : set_parent_refs_cb parent_refs_cb_fn;
448 : : struct blob_parent *parent_refs_cb_arg;
449 : :
450 : : spdk_blob_op_complete cb_fn;
451 : : void *cb_arg;
452 : : int bserrno;
453 : : };
454 : :
455 : : static void
456 : 149 : blob_set_back_bs_dev(struct spdk_blob *blob, struct spdk_bs_dev *back_bs_dev,
457 : : set_parent_refs_cb parent_refs_cb_fn, struct blob_parent *parent_refs_cb_arg,
458 : : spdk_blob_op_complete cb_fn, void *cb_arg)
459 : : {
460 : : struct set_bs_dev_ctx *ctx;
461 : :
462 : 149 : ctx = calloc(1, sizeof(*ctx));
463 [ - + ]: 149 : if (ctx == NULL) {
464 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": out of memory while setting back_bs_dev\n",
465 : : blob->id);
466 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
467 : 0 : return;
468 : : }
469 : :
470 [ # # # # ]: 149 : ctx->parent_refs_cb_fn = parent_refs_cb_fn;
471 [ # # # # ]: 149 : ctx->parent_refs_cb_arg = parent_refs_cb_arg;
472 [ # # # # ]: 149 : ctx->cb_fn = cb_fn;
473 [ # # # # ]: 149 : ctx->cb_arg = cb_arg;
474 [ # # # # ]: 149 : ctx->back_bs_dev = back_bs_dev;
475 [ # # # # ]: 149 : ctx->blob = blob;
476 : :
477 : 149 : blob_freeze_io(blob, blob_set_back_bs_dev_frozen, ctx);
478 : 35 : }
479 : :
480 : : struct freeze_io_ctx {
481 : : struct spdk_bs_cpl cpl;
482 : : struct spdk_blob *blob;
483 : : };
484 : :
485 : : static void
486 : 114209 : blob_io_sync(struct spdk_io_channel_iter *i)
487 : : {
488 : 114209 : spdk_for_each_channel_continue(i, 0);
489 : 114209 : }
490 : :
491 : : static void
492 : 114149 : blob_execute_queued_io(struct spdk_io_channel_iter *i)
493 : : {
494 : 114149 : struct spdk_io_channel *_ch = spdk_io_channel_iter_get_channel(i);
495 : 114149 : struct spdk_bs_channel *ch = spdk_io_channel_get_ctx(_ch);
496 : 114149 : struct freeze_io_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
497 : : struct spdk_bs_request_set *set;
498 : : struct spdk_bs_user_op_args *args;
499 : : spdk_bs_user_op_t *op, *tmp;
500 : :
501 [ + + + + : 116935 : TAILQ_FOREACH_SAFE(op, &ch->queued_io, link, tmp) {
# # # # #
# # # # #
# # ]
502 : 2786 : set = (struct spdk_bs_request_set *)op;
503 [ # # # # ]: 2786 : args = &set->u.user_op;
504 : :
505 [ + + # # : 2786 : if (args->blob == ctx->blob) {
# # # # #
# ]
506 [ + + # # : 2783 : TAILQ_REMOVE(&ch->queued_io, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
507 : 2783 : bs_user_op_execute(op);
508 : 5 : }
509 : 5 : }
510 : :
511 : 114149 : spdk_for_each_channel_continue(i, 0);
512 : 114149 : }
513 : :
514 : : static void
515 : 228114 : blob_io_cpl(struct spdk_io_channel_iter *i, int status)
516 : : {
517 : 228114 : struct freeze_io_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
518 : :
519 [ # # # # : 228114 : ctx->cpl.u.blob_basic.cb_fn(ctx->cpl.u.blob_basic.cb_arg, 0);
# # # # #
# # # # #
# # # # #
# # # #
# ]
520 : :
521 : 228114 : free(ctx);
522 : 228114 : }
523 : :
524 : : static void
525 : 114087 : blob_freeze_io(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
526 : : {
527 : : struct freeze_io_ctx *ctx;
528 : :
529 : 114087 : blob_verify_md_op(blob);
530 : :
531 : 114087 : ctx = calloc(1, sizeof(*ctx));
532 [ - + ]: 114087 : if (!ctx) {
533 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
534 : 0 : return;
535 : : }
536 : :
537 [ # # # # : 114087 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
# # ]
538 [ # # # # : 114087 : ctx->cpl.u.blob_basic.cb_fn = cb_fn;
# # # # #
# ]
539 [ # # # # : 114087 : ctx->cpl.u.blob_basic.cb_arg = cb_arg;
# # # # #
# ]
540 [ # # # # ]: 114087 : ctx->blob = blob;
541 : :
542 : : /* Freeze I/O on blob */
543 [ # # ]: 114087 : blob->frozen_refcnt++;
544 : :
545 [ # # # # ]: 114087 : spdk_for_each_channel(blob->bs, blob_io_sync, ctx, blob_io_cpl);
546 : 644 : }
547 : :
548 : : static void
549 : 114027 : blob_unfreeze_io(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
550 : : {
551 : : struct freeze_io_ctx *ctx;
552 : :
553 : 114027 : blob_verify_md_op(blob);
554 : :
555 : 114027 : ctx = calloc(1, sizeof(*ctx));
556 [ + + ]: 114027 : if (!ctx) {
557 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
558 : 0 : return;
559 : : }
560 : :
561 [ # # # # : 114027 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
# # ]
562 [ # # # # : 114027 : ctx->cpl.u.blob_basic.cb_fn = cb_fn;
# # # # #
# ]
563 [ # # # # : 114027 : ctx->cpl.u.blob_basic.cb_arg = cb_arg;
# # # # #
# ]
564 [ # # # # ]: 114027 : ctx->blob = blob;
565 : :
566 [ - + # # : 114027 : assert(blob->frozen_refcnt > 0);
# # # # ]
567 : :
568 [ # # ]: 114027 : blob->frozen_refcnt--;
569 : :
570 [ # # # # ]: 114027 : spdk_for_each_channel(blob->bs, blob_execute_queued_io, ctx, blob_io_cpl);
571 : 629 : }
572 : :
573 : : static int
574 : 220760 : blob_mark_clean(struct spdk_blob *blob)
575 : : {
576 : 220760 : uint32_t *extent_pages = NULL;
577 : 220760 : uint64_t *clusters = NULL;
578 : 220760 : uint32_t *pages = NULL;
579 : :
580 [ + + # # ]: 220760 : assert(blob != NULL);
581 : :
582 [ + + # # : 220760 : if (blob->active.num_extent_pages) {
# # # # ]
583 [ + + # # : 189493 : assert(blob->active.extent_pages);
# # # # #
# ]
584 [ # # # # : 189493 : extent_pages = calloc(blob->active.num_extent_pages, sizeof(*blob->active.extent_pages));
# # ]
585 [ + + ]: 189493 : if (!extent_pages) {
586 : 0 : return -ENOMEM;
587 : : }
588 [ - + - + : 193785 : memcpy(extent_pages, blob->active.extent_pages,
# # # # #
# ]
589 [ # # # # : 189493 : blob->active.num_extent_pages * sizeof(*extent_pages));
# # ]
590 : 4292 : }
591 : :
592 [ + + # # : 220760 : if (blob->active.num_clusters) {
# # # # ]
593 [ + + # # : 201857 : assert(blob->active.clusters);
# # # # #
# ]
594 [ # # # # : 201857 : clusters = calloc(blob->active.num_clusters, sizeof(*blob->active.clusters));
# # ]
595 [ + + ]: 201857 : if (!clusters) {
596 : 0 : free(extent_pages);
597 : 0 : return -ENOMEM;
598 : : }
599 [ - + - + : 201857 : memcpy(clusters, blob->active.clusters, blob->active.num_clusters * sizeof(*blob->active.clusters));
# # # # #
# # # # #
# # ]
600 : 7383 : }
601 : :
602 [ + + # # : 220760 : if (blob->active.num_pages) {
# # # # ]
603 [ - + # # : 212178 : assert(blob->active.pages);
# # # # #
# ]
604 [ # # # # : 212178 : pages = calloc(blob->active.num_pages, sizeof(*blob->active.pages));
# # ]
605 [ + + ]: 212178 : if (!pages) {
606 : 0 : free(extent_pages);
607 : 0 : free(clusters);
608 : 0 : return -ENOMEM;
609 : : }
610 [ - + - + : 212178 : memcpy(pages, blob->active.pages, blob->active.num_pages * sizeof(*blob->active.pages));
# # # # #
# # # # #
# # ]
611 : 8682 : }
612 : :
613 [ # # # # : 220760 : free(blob->clean.extent_pages);
# # ]
614 [ # # # # : 220760 : free(blob->clean.clusters);
# # ]
615 [ # # # # : 220760 : free(blob->clean.pages);
# # ]
616 : :
617 [ # # # # : 220760 : blob->clean.num_extent_pages = blob->active.num_extent_pages;
# # # # #
# # # ]
618 [ # # # # : 220760 : blob->clean.extent_pages = blob->active.extent_pages;
# # # # #
# # # ]
619 [ # # # # : 220760 : blob->clean.num_clusters = blob->active.num_clusters;
# # # # #
# # # ]
620 [ # # # # : 220760 : blob->clean.clusters = blob->active.clusters;
# # # # #
# # # ]
621 [ # # # # : 220760 : blob->clean.num_allocated_clusters = blob->active.num_allocated_clusters;
# # # # #
# # # ]
622 [ # # # # : 220760 : blob->clean.num_pages = blob->active.num_pages;
# # # # #
# # # ]
623 [ # # # # : 220760 : blob->clean.pages = blob->active.pages;
# # # # #
# # # ]
624 : :
625 [ # # # # : 220760 : blob->active.extent_pages = extent_pages;
# # ]
626 [ # # # # : 220760 : blob->active.clusters = clusters;
# # ]
627 [ # # # # : 220760 : blob->active.pages = pages;
# # ]
628 : :
629 : : /* If the metadata was dirtied again while the metadata was being written to disk,
630 : : * we do not want to revert the DIRTY state back to CLEAN here.
631 : : */
632 [ + + # # : 220760 : if (blob->state == SPDK_BLOB_STATE_LOADING) {
# # ]
633 [ # # # # ]: 35677 : blob->state = SPDK_BLOB_STATE_CLEAN;
634 : 4291 : }
635 : :
636 : 220760 : return 0;
637 : 10544 : }
638 : :
639 : : static int
640 : 39327 : blob_deserialize_xattr(struct spdk_blob *blob,
641 : : struct spdk_blob_md_descriptor_xattr *desc_xattr, bool internal)
642 : : {
643 : : struct spdk_xattr *xattr;
644 : :
645 [ - + - + : 40992 : if (desc_xattr->length != sizeof(desc_xattr->name_length) +
# # ]
646 : 1665 : sizeof(desc_xattr->value_length) +
647 [ - + # # : 40992 : desc_xattr->name_length + desc_xattr->value_length) {
# # # # #
# ]
648 : 0 : return -EINVAL;
649 : : }
650 : :
651 : 39327 : xattr = calloc(1, sizeof(*xattr));
652 [ + + ]: 39327 : if (xattr == NULL) {
653 : 0 : return -ENOMEM;
654 : : }
655 : :
656 [ # # # # : 39327 : xattr->name = malloc(desc_xattr->name_length + 1);
# # # # #
# ]
657 [ + + # # : 39327 : if (xattr->name == NULL) {
# # ]
658 : 0 : free(xattr);
659 : 0 : return -ENOMEM;
660 : : }
661 : :
662 [ # # # # : 39327 : xattr->value = malloc(desc_xattr->value_length);
# # # # ]
663 [ + + # # : 39327 : if (xattr->value == NULL) {
# # ]
664 [ # # # # ]: 0 : free(xattr->name);
665 : 0 : free(xattr);
666 : 0 : return -ENOMEM;
667 : : }
668 : :
669 [ - + - + : 39327 : memcpy(xattr->name, desc_xattr->name, desc_xattr->name_length);
# # # # #
# # # #
# ]
670 [ # # # # : 39327 : xattr->name[desc_xattr->name_length] = '\0';
# # # # #
# # # ]
671 [ # # # # : 39327 : xattr->value_len = desc_xattr->value_length;
# # # # ]
672 [ - + - + : 40992 : memcpy(xattr->value,
# # # # ]
673 [ # # # # : 39327 : (void *)((uintptr_t)desc_xattr->name + desc_xattr->name_length),
# # ]
674 [ # # # # ]: 39327 : desc_xattr->value_length);
675 : :
676 [ + + + + : 39327 : TAILQ_INSERT_TAIL(internal ? &blob->xattrs_internal : &blob->xattrs, xattr, link);
+ + # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ]
677 : :
678 : 39327 : return 0;
679 : 1665 : }
680 : :
681 : :
682 : : static int
683 : 68442 : blob_parse_page(const struct spdk_blob_md_page *page, struct spdk_blob *blob)
684 : : {
685 : : struct spdk_blob_md_descriptor *desc;
686 : 68442 : size_t cur_desc = 0;
687 : : void *tmp;
688 : :
689 [ # # ]: 68442 : desc = (struct spdk_blob_md_descriptor *)page->descriptors;
690 [ + + ]: 210200 : while (cur_desc < sizeof(page->descriptors)) {
691 [ + + # # : 210200 : if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_PADDING) {
# # ]
692 [ + + # # : 68202 : if (desc->length == 0) {
# # ]
693 : : /* If padding and length are 0, this terminates the page */
694 : 68202 : break;
695 : : }
696 [ + + # # : 141998 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_FLAGS) {
# # ]
697 : : struct spdk_blob_md_descriptor_flags *desc_flags;
698 : :
699 : 35845 : desc_flags = (struct spdk_blob_md_descriptor_flags *)desc;
700 : :
701 [ + + # # : 35845 : if (desc_flags->length != sizeof(*desc_flags) - sizeof(*desc)) {
# # ]
702 : 0 : return -EINVAL;
703 : : }
704 : :
705 [ + + # # : 35845 : if ((desc_flags->invalid_flags | SPDK_BLOB_INVALID_FLAGS_MASK) !=
# # # # #
# # # #
# ]
706 [ # # # # : 0 : SPDK_BLOB_INVALID_FLAGS_MASK) {
# # # # ]
707 : 40 : return -EINVAL;
708 : : }
709 : :
710 [ + + # # : 35805 : if ((desc_flags->data_ro_flags | SPDK_BLOB_DATA_RO_FLAGS_MASK) !=
# # # # ]
711 [ # # ]: 0 : SPDK_BLOB_DATA_RO_FLAGS_MASK) {
712 [ # # # # ]: 60 : blob->data_ro = true;
713 [ # # # # ]: 60 : blob->md_ro = true;
714 : 15 : }
715 : :
716 [ + + # # : 35805 : if ((desc_flags->md_ro_flags | SPDK_BLOB_MD_RO_FLAGS_MASK) !=
# # # # ]
717 [ # # ]: 0 : SPDK_BLOB_MD_RO_FLAGS_MASK) {
718 [ # # # # ]: 60 : blob->md_ro = true;
719 : 15 : }
720 : :
721 [ + + # # : 35805 : if ((desc_flags->data_ro_flags & SPDK_BLOB_READ_ONLY)) {
# # # # ]
722 [ # # # # ]: 2976 : blob->data_ro = true;
723 [ # # # # ]: 2976 : blob->md_ro = true;
724 : 722 : }
725 : :
726 [ # # # # : 35805 : blob->invalid_flags = desc_flags->invalid_flags;
# # # # ]
727 [ # # # # : 35805 : blob->data_ro_flags = desc_flags->data_ro_flags;
# # # # ]
728 [ # # # # : 35805 : blob->md_ro_flags = desc_flags->md_ro_flags;
# # # # ]
729 : :
730 [ + + # # : 110476 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE) {
# # ]
731 : : struct spdk_blob_md_descriptor_extent_rle *desc_extent_rle;
732 : : unsigned int i, j;
733 [ # # # # : 5584 : unsigned int cluster_count = blob->active.num_clusters;
# # ]
734 : :
735 [ + + - + : 5584 : if (blob->extent_table_found) {
# # # # ]
736 : : /* Extent Table already present in the md,
737 : : * both descriptors should never be at the same time. */
738 : 0 : return -EINVAL;
739 : : }
740 [ # # # # ]: 5584 : blob->extent_rle_found = true;
741 : :
742 : 5584 : desc_extent_rle = (struct spdk_blob_md_descriptor_extent_rle *)desc;
743 : :
744 [ + - - + : 5584 : if (desc_extent_rle->length == 0 ||
# # # # ]
745 [ - + # # : 5584 : (desc_extent_rle->length % sizeof(desc_extent_rle->extents[0]) != 0)) {
# # ]
746 : 0 : return -EINVAL;
747 : : }
748 : :
749 [ + + # # : 11872 : for (i = 0; i < desc_extent_rle->length / sizeof(desc_extent_rle->extents[0]); i++) {
# # # # ]
750 [ + + # # : 84960 : for (j = 0; j < desc_extent_rle->extents[i].length; j++) {
# # # # #
# ]
751 [ + + # # : 78672 : if (desc_extent_rle->extents[i].cluster_idx != 0) {
# # # # ]
752 [ + + + - : 33460 : if (!spdk_bit_pool_is_allocated(blob->bs->used_clusters,
# # # # #
# ]
753 [ # # # # : 26768 : desc_extent_rle->extents[i].cluster_idx + j)) {
# # # # ]
754 : 0 : return -EINVAL;
755 : : }
756 : 6692 : }
757 : 78672 : cluster_count++;
758 : 19668 : }
759 : 1572 : }
760 : :
761 [ + + ]: 5584 : if (cluster_count == 0) {
762 : 0 : return -EINVAL;
763 : : }
764 [ # # # # : 5584 : tmp = realloc(blob->active.clusters, cluster_count * sizeof(*blob->active.clusters));
# # ]
765 [ + + ]: 5584 : if (tmp == NULL) {
766 : 0 : return -ENOMEM;
767 : : }
768 [ # # # # : 5584 : blob->active.clusters = tmp;
# # ]
769 [ # # # # : 5584 : blob->active.cluster_array_size = cluster_count;
# # ]
770 : :
771 [ + + # # : 11872 : for (i = 0; i < desc_extent_rle->length / sizeof(desc_extent_rle->extents[0]); i++) {
# # # # ]
772 [ + + # # : 84960 : for (j = 0; j < desc_extent_rle->extents[i].length; j++) {
# # # # #
# ]
773 [ + + # # : 78672 : if (desc_extent_rle->extents[i].cluster_idx != 0) {
# # # # #
# ]
774 [ # # # # : 33460 : blob->active.clusters[blob->active.num_clusters++] = bs_cluster_to_lba(blob->bs,
# # # # #
# # # # #
# # # # ]
775 [ # # # # : 26768 : desc_extent_rle->extents[i].cluster_idx + j);
# # # # ]
776 [ # # # # ]: 26768 : blob->active.num_allocated_clusters++;
777 [ + - ]: 58596 : } else if (spdk_blob_is_thin_provisioned(blob)) {
778 [ # # # # : 51904 : blob->active.clusters[blob->active.num_clusters++] = 0;
# # # # #
# # # #
# ]
779 : 12976 : } else {
780 : 0 : return -EINVAL;
781 : : }
782 : 19668 : }
783 : 1572 : }
784 [ + + # # : 101965 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_TABLE) {
# # ]
785 : : struct spdk_blob_md_descriptor_extent_table *desc_extent_table;
786 [ # # # # : 29142 : uint32_t num_extent_pages = blob->active.num_extent_pages;
# # ]
787 : : uint32_t i, j;
788 : : size_t extent_pages_length;
789 : :
790 : 29142 : desc_extent_table = (struct spdk_blob_md_descriptor_extent_table *)desc;
791 [ # # # # ]: 29142 : extent_pages_length = desc_extent_table->length - sizeof(desc_extent_table->num_clusters);
792 : :
793 [ + + - + : 29142 : if (blob->extent_rle_found) {
# # # # ]
794 : : /* This means that Extent RLE is present in MD,
795 : : * both should never be at the same time. */
796 : 0 : return -EINVAL;
797 [ - + + + : 29142 : } else if (blob->extent_table_found &&
# # # # #
# ]
798 [ - + # # : 5 : desc_extent_table->num_clusters != blob->remaining_clusters_in_et) {
# # # # ]
799 : : /* Number of clusters in this ET does not match number
800 : : * from previously read EXTENT_TABLE. */
801 : 0 : return -EINVAL;
802 : : }
803 : :
804 [ + - - + : 29142 : if (desc_extent_table->length == 0 ||
# # # # ]
805 [ - + ]: 29142 : (extent_pages_length % sizeof(desc_extent_table->extent_page[0]) != 0)) {
806 : 0 : return -EINVAL;
807 : : }
808 : :
809 [ # # # # ]: 29142 : blob->extent_table_found = true;
810 : :
811 [ + + # # ]: 64255 : for (i = 0; i < extent_pages_length / sizeof(desc_extent_table->extent_page[0]); i++) {
812 [ # # # # : 35113 : num_extent_pages += desc_extent_table->extent_page[i].num_pages;
# # # # ]
813 : 2228 : }
814 : :
815 [ + + ]: 29142 : if (num_extent_pages > 0) {
816 [ # # # # : 24694 : tmp = realloc(blob->active.extent_pages, num_extent_pages * sizeof(uint32_t));
# # ]
817 [ + + ]: 24694 : if (tmp == NULL) {
818 : 0 : return -ENOMEM;
819 : : }
820 [ # # # # : 24694 : blob->active.extent_pages = tmp;
# # ]
821 : 2204 : }
822 [ # # # # : 29142 : blob->active.extent_pages_array_size = num_extent_pages;
# # ]
823 : :
824 [ # # # # : 29142 : blob->remaining_clusters_in_et = desc_extent_table->num_clusters;
# # # # ]
825 : :
826 : : /* Extent table entries contain md page numbers for extent pages.
827 : : * Zeroes represent unallocated extent pages, those are run-length-encoded.
828 : : */
829 [ + + # # ]: 64255 : for (i = 0; i < extent_pages_length / sizeof(desc_extent_table->extent_page[0]); i++) {
830 [ + + # # : 35113 : if (desc_extent_table->extent_page[i].page_idx != 0) {
# # # # #
# ]
831 [ + + # # : 32136 : assert(desc_extent_table->extent_page[i].num_pages == 1);
# # # # #
# # # ]
832 [ # # # # : 62696 : blob->active.extent_pages[blob->active.num_extent_pages++] =
# # # # #
# # # #
# ]
833 [ # # # # : 32136 : desc_extent_table->extent_page[i].page_idx;
# # # # ]
834 [ + - ]: 4553 : } else if (spdk_blob_is_thin_provisioned(blob)) {
835 [ + + # # : 11000 : for (j = 0; j < desc_extent_table->extent_page[i].num_pages; j++) {
# # # # #
# ]
836 [ # # # # : 8023 : blob->active.extent_pages[blob->active.num_extent_pages++] = 0;
# # # # #
# # # #
# ]
837 : 652 : }
838 : 652 : } else {
839 : 0 : return -EINVAL;
840 : : }
841 : 2228 : }
842 [ + + # # : 74083 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE) {
# # ]
843 : : struct spdk_blob_md_descriptor_extent_page *desc_extent;
844 : : unsigned int i;
845 : 32100 : unsigned int cluster_count = 0;
846 : : size_t cluster_idx_length;
847 : :
848 [ + + - + : 32100 : if (blob->extent_rle_found) {
# # # # ]
849 : : /* This means that Extent RLE is present in MD,
850 : : * both should never be at the same time. */
851 : 0 : return -EINVAL;
852 : : }
853 : :
854 : 32100 : desc_extent = (struct spdk_blob_md_descriptor_extent_page *)desc;
855 [ # # # # ]: 32100 : cluster_idx_length = desc_extent->length - sizeof(desc_extent->start_cluster_idx);
856 : :
857 [ + - - + : 32100 : if (desc_extent->length <= sizeof(desc_extent->start_cluster_idx) ||
# # # # ]
858 [ - + ]: 32100 : (cluster_idx_length % sizeof(desc_extent->cluster_idx[0]) != 0)) {
859 : 0 : return -EINVAL;
860 : : }
861 : :
862 [ + + # # ]: 6623885 : for (i = 0; i < cluster_idx_length / sizeof(desc_extent->cluster_idx[0]); i++) {
863 [ + + # # : 6591785 : if (desc_extent->cluster_idx[i] != 0) {
# # # # ]
864 [ + + # # : 6050917 : if (!spdk_bit_pool_is_allocated(blob->bs->used_clusters, desc_extent->cluster_idx[i])) {
# # # # #
# # # # #
# # ]
865 : 0 : return -EINVAL;
866 : : }
867 : 10767 : }
868 : 6591785 : cluster_count++;
869 : 23268 : }
870 : :
871 [ + + ]: 32100 : if (cluster_count == 0) {
872 : 0 : return -EINVAL;
873 : : }
874 : :
875 : : /* When reading extent pages sequentially starting cluster idx should match
876 : : * current size of a blob.
877 : : * If changed to batch reading, this check shall be removed. */
878 [ + + # # : 32100 : if (desc_extent->start_cluster_idx != blob->active.num_clusters) {
# # # # #
# # # ]
879 : 0 : return -EINVAL;
880 : : }
881 : :
882 [ # # # # : 33667 : tmp = realloc(blob->active.clusters,
# # ]
883 [ # # # # : 32100 : (cluster_count + blob->active.num_clusters) * sizeof(*blob->active.clusters));
# # ]
884 [ + + ]: 32100 : if (tmp == NULL) {
885 : 0 : return -ENOMEM;
886 : : }
887 [ # # # # : 32100 : blob->active.clusters = tmp;
# # ]
888 [ # # # # : 32100 : blob->active.cluster_array_size = (cluster_count + blob->active.num_clusters);
# # # # #
# # # ]
889 : :
890 [ + + # # ]: 6623885 : for (i = 0; i < cluster_idx_length / sizeof(desc_extent->cluster_idx[0]); i++) {
891 [ + + # # : 6591785 : if (desc_extent->cluster_idx[i] != 0) {
# # # # ]
892 [ # # # # : 6061684 : blob->active.clusters[blob->active.num_clusters++] = bs_cluster_to_lba(blob->bs,
# # # # #
# # # # #
# # # # ]
893 [ # # # # : 10767 : desc_extent->cluster_idx[i]);
# # ]
894 [ # # # # ]: 6050917 : blob->active.num_allocated_clusters++;
895 [ + + ]: 551635 : } else if (spdk_blob_is_thin_provisioned(blob)) {
896 [ # # # # : 540868 : blob->active.clusters[blob->active.num_clusters++] = 0;
# # # # #
# # # #
# ]
897 : 12501 : } else {
898 : 0 : return -EINVAL;
899 : : }
900 : 23268 : }
901 [ - + # # : 32100 : assert(desc_extent->start_cluster_idx + cluster_count == blob->active.num_clusters);
# # # # #
# # # #
# ]
902 [ - + # # : 32100 : assert(blob->remaining_clusters_in_et >= cluster_count);
# # # # ]
903 [ # # # # ]: 32100 : blob->remaining_clusters_in_et -= cluster_count;
904 [ + + # # : 40894 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR) {
# # ]
905 : : int rc;
906 : :
907 : 35123 : rc = blob_deserialize_xattr(blob,
908 : 538 : (struct spdk_blob_md_descriptor_xattr *) desc, false);
909 [ + + ]: 34585 : if (rc != 0) {
910 : 0 : return rc;
911 : : }
912 [ + - # # : 5280 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL) {
# # ]
913 : : int rc;
914 : :
915 : 5869 : rc = blob_deserialize_xattr(blob,
916 : 1127 : (struct spdk_blob_md_descriptor_xattr *) desc, true);
917 [ + + ]: 4742 : if (rc != 0) {
918 : 0 : return rc;
919 : : }
920 : 1127 : } else {
921 : : /* Unrecognized descriptor type. Do not fail - just continue to the
922 : : * next descriptor. If this descriptor is associated with some feature
923 : : * defined in a newer version of blobstore, that version of blobstore
924 : : * should create and set an associated feature flag to specify if this
925 : : * blob can be loaded or not.
926 : : */
927 : : }
928 : :
929 : : /* Advance to the next descriptor */
930 [ # # # # ]: 141958 : cur_desc += sizeof(*desc) + desc->length;
931 [ + + ]: 141958 : if (cur_desc + sizeof(*desc) > sizeof(page->descriptors)) {
932 : 200 : break;
933 : : }
934 [ # # ]: 141758 : desc = (struct spdk_blob_md_descriptor *)((uintptr_t)page->descriptors + cur_desc);
935 : : }
936 : :
937 : 68402 : return 0;
938 : 6023 : }
939 : :
940 : : static bool bs_load_cur_extent_page_valid(struct spdk_blob_md_page *page);
941 : :
942 : : static int
943 : 32100 : blob_parse_extent_page(struct spdk_blob_md_page *extent_page, struct spdk_blob *blob)
944 : : {
945 [ + + # # ]: 32100 : assert(blob != NULL);
946 [ - + # # : 32100 : assert(blob->state == SPDK_BLOB_STATE_LOADING);
# # # # ]
947 : :
948 [ + + ]: 32100 : if (bs_load_cur_extent_page_valid(extent_page) == false) {
949 : 0 : return -ENOENT;
950 : : }
951 : :
952 : 32100 : return blob_parse_page(extent_page, blob);
953 : 1567 : }
954 : :
955 : : static int
956 : 35865 : blob_parse(const struct spdk_blob_md_page *pages, uint32_t page_count,
957 : : struct spdk_blob *blob)
958 : : {
959 : : const struct spdk_blob_md_page *page;
960 : : uint32_t i;
961 : : int rc;
962 : : void *tmp;
963 : :
964 [ + + # # ]: 35865 : assert(page_count > 0);
965 [ + + # # : 35865 : assert(pages[0].sequence_num == 0);
# # # # #
# ]
966 [ + + # # ]: 35865 : assert(blob != NULL);
967 [ + + # # : 35865 : assert(blob->state == SPDK_BLOB_STATE_LOADING);
# # # # ]
968 [ - + # # : 35865 : assert(blob->active.clusters == NULL);
# # # # #
# ]
969 : :
970 : : /* The blobid provided doesn't match what's in the MD, this can
971 : : * happen for example if a bogus blobid is passed in through open.
972 : : */
973 [ + + # # : 35865 : if (blob->id != pages[0].id) {
# # # # #
# # # ]
974 [ # # # # : 20 : SPDK_ERRLOG("Blobid (0x%" PRIx64 ") doesn't match what's in metadata "
# # # # #
# ]
975 : : "(0x%" PRIx64 ")\n", blob->id, pages[0].id);
976 : 20 : return -ENOENT;
977 : : }
978 : :
979 [ # # # # : 35845 : tmp = realloc(blob->active.pages, page_count * sizeof(*blob->active.pages));
# # ]
980 [ + + ]: 35845 : if (!tmp) {
981 : 0 : return -ENOMEM;
982 : : }
983 [ # # # # : 35845 : blob->active.pages = tmp;
# # ]
984 : :
985 [ # # # # : 35845 : blob->active.pages[0] = pages[0].id;
# # # # #
# # # # #
# # ]
986 : :
987 [ + + ]: 36342 : for (i = 1; i < page_count; i++) {
988 [ + + # # : 497 : assert(spdk_bit_array_get(blob->bs->used_md_pages, pages[i - 1].next));
# # # # #
# # # # #
# # # # ]
989 [ # # # # : 497 : blob->active.pages[i] = pages[i - 1].next;
# # # # #
# # # # #
# # ]
990 : 123 : }
991 [ # # # # : 35845 : blob->active.num_pages = page_count;
# # ]
992 : :
993 [ + + ]: 72147 : for (i = 0; i < page_count; i++) {
994 [ # # ]: 36342 : page = &pages[i];
995 : :
996 [ + + # # : 36342 : assert(page->id == blob->id);
# # # # #
# # # ]
997 [ + + # # : 36342 : assert(page->sequence_num == i);
# # # # ]
998 : :
999 : 36342 : rc = blob_parse_page(page, blob);
1000 [ + + ]: 36342 : if (rc != 0) {
1001 : 40 : return rc;
1002 : : }
1003 : 4446 : }
1004 : :
1005 : 35805 : return 0;
1006 : 4338 : }
1007 : :
1008 : : static int
1009 : 298211 : blob_serialize_add_page(const struct spdk_blob *blob,
1010 : : struct spdk_blob_md_page **pages,
1011 : : uint32_t *page_count,
1012 : : struct spdk_blob_md_page **last_page)
1013 : : {
1014 : : struct spdk_blob_md_page *page, *tmp_pages;
1015 : :
1016 [ + + # # ]: 298211 : assert(pages != NULL);
1017 [ + + # # ]: 298211 : assert(page_count != NULL);
1018 : :
1019 [ # # ]: 298211 : *last_page = NULL;
1020 [ + + # # ]: 298211 : if (*page_count == 0) {
1021 [ + + # # : 297170 : assert(*pages == NULL);
# # ]
1022 [ # # # # : 297170 : *pages = spdk_malloc(blob->bs->md_page_size, 0,
# # # # #
# ]
1023 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
1024 [ + + # # ]: 297170 : if (*pages == NULL) {
1025 : 0 : return -ENOMEM;
1026 : : }
1027 [ # # ]: 297170 : *page_count = 1;
1028 : 5433 : } else {
1029 [ + + # # : 1041 : assert(*pages != NULL);
# # ]
1030 [ # # # # : 1041 : tmp_pages = spdk_realloc(*pages, blob->bs->md_page_size * (*page_count + 1), 0);
# # # # #
# # # ]
1031 [ + + ]: 1041 : if (tmp_pages == NULL) {
1032 : 0 : return -ENOMEM;
1033 : : }
1034 : 1041 : (*page_count)++;
1035 [ # # ]: 1041 : *pages = tmp_pages;
1036 : : }
1037 : :
1038 [ # # # # : 298211 : page = &(*pages)[*page_count - 1];
# # ]
1039 [ - + ]: 298211 : memset(page, 0, sizeof(*page));
1040 [ # # # # : 298211 : page->id = blob->id;
# # # # ]
1041 [ # # # # : 298211 : page->sequence_num = *page_count - 1;
# # ]
1042 [ # # # # ]: 298211 : page->next = SPDK_INVALID_MD_PAGE;
1043 [ # # ]: 298211 : *last_page = page;
1044 : :
1045 : 298211 : return 0;
1046 : 5542 : }
1047 : :
1048 : : /* Transform the in-memory representation 'xattr' into an on-disk xattr descriptor.
1049 : : * Update required_sz on both success and failure.
1050 : : *
1051 : : */
1052 : : static int
1053 : 322273 : blob_serialize_xattr(const struct spdk_xattr *xattr,
1054 : : uint8_t *buf, size_t buf_sz,
1055 : : size_t *required_sz, bool internal)
1056 : : {
1057 : : struct spdk_blob_md_descriptor_xattr *desc;
1058 : :
1059 [ # # ]: 644546 : *required_sz = sizeof(struct spdk_blob_md_descriptor_xattr) +
1060 [ - + # # : 324453 : strlen(xattr->name) +
# # ]
1061 [ # # # # ]: 322273 : xattr->value_len;
1062 : :
1063 [ + + # # ]: 322273 : if (buf_sz < *required_sz) {
1064 : 240 : return -1;
1065 : : }
1066 : :
1067 : 322033 : desc = (struct spdk_blob_md_descriptor_xattr *)buf;
1068 : :
1069 [ + + # # : 322033 : desc->type = internal ? SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL : SPDK_MD_DESCRIPTOR_TYPE_XATTR;
# # ]
1070 [ # # # # ]: 322033 : desc->length = sizeof(desc->name_length) +
1071 : 2120 : sizeof(desc->value_length) +
1072 [ - + # # : 324153 : strlen(xattr->name) +
# # ]
1073 [ # # # # ]: 322033 : xattr->value_len;
1074 [ - + # # : 322033 : desc->name_length = strlen(xattr->name);
# # # # #
# ]
1075 [ # # # # : 322033 : desc->value_length = xattr->value_len;
# # # # ]
1076 : :
1077 [ - + - + : 322033 : memcpy(desc->name, xattr->name, desc->name_length);
# # # # #
# # # #
# ]
1078 [ - + - + : 324153 : memcpy((void *)((uintptr_t)desc->name + desc->name_length),
# # # # #
# ]
1079 [ # # # # ]: 322033 : xattr->value,
1080 [ # # # # ]: 322033 : desc->value_length);
1081 : :
1082 : 322033 : return 0;
1083 : 2180 : }
1084 : :
1085 : : static void
1086 : 169642 : blob_serialize_extent_table_entry(const struct spdk_blob *blob,
1087 : : uint64_t start_ep, uint64_t *next_ep,
1088 : : uint8_t **buf, size_t *remaining_sz)
1089 : : {
1090 : : struct spdk_blob_md_descriptor_extent_table *desc;
1091 : : size_t cur_sz;
1092 : : uint64_t i, et_idx;
1093 : : uint32_t extent_page, ep_len;
1094 : :
1095 : : /* The buffer must have room for at least num_clusters entry */
1096 : 169642 : cur_sz = sizeof(struct spdk_blob_md_descriptor) + sizeof(desc->num_clusters);
1097 [ + + # # ]: 169642 : if (*remaining_sz < cur_sz) {
1098 [ # # ]: 120 : *next_ep = start_ep;
1099 : 120 : return;
1100 : : }
1101 : :
1102 [ # # ]: 169522 : desc = (struct spdk_blob_md_descriptor_extent_table *)*buf;
1103 [ # # # # ]: 169522 : desc->type = SPDK_MD_DESCRIPTOR_TYPE_EXTENT_TABLE;
1104 : :
1105 [ # # # # : 169522 : desc->num_clusters = blob->active.num_clusters;
# # # # #
# ]
1106 : :
1107 : 169522 : ep_len = 1;
1108 : 169522 : et_idx = 0;
1109 [ + + # # : 1146108 : for (i = start_ep; i < blob->active.num_extent_pages; i++) {
# # # # ]
1110 [ + + # # ]: 977191 : if (*remaining_sz < cur_sz + sizeof(desc->extent_page[0])) {
1111 : : /* If we ran out of buffer space, return */
1112 : 605 : break;
1113 : : }
1114 : :
1115 [ # # # # : 976586 : extent_page = blob->active.extent_pages[i];
# # # # #
# ]
1116 : : /* Verify that next extent_page is unallocated */
1117 [ + + - + ]: 978203 : if (extent_page == 0 &&
1118 [ + + + + : 410186 : (i + 1 < blob->active.num_extent_pages && blob->active.extent_pages[i + 1] == 0)) {
# # # # #
# # # # #
# # # # ]
1119 : 268653 : ep_len++;
1120 : 268653 : continue;
1121 : : }
1122 [ # # # # : 707933 : desc->extent_page[et_idx].page_idx = extent_page;
# # # # ]
1123 [ # # # # : 707933 : desc->extent_page[et_idx].num_pages = ep_len;
# # # # ]
1124 : 707933 : et_idx++;
1125 : :
1126 : 707933 : ep_len = 1;
1127 : 707933 : cur_sz += sizeof(desc->extent_page[et_idx]);
1128 : 2247 : }
1129 [ # # ]: 169522 : *next_ep = i;
1130 : :
1131 [ # # # # ]: 169522 : desc->length = sizeof(desc->num_clusters) + sizeof(desc->extent_page[0]) * et_idx;
1132 [ # # # # : 169522 : *remaining_sz -= sizeof(struct spdk_blob_md_descriptor) + desc->length;
# # ]
1133 [ # # # # : 169522 : *buf += sizeof(struct spdk_blob_md_descriptor) + desc->length;
# # # # ]
1134 : 2525 : }
1135 : :
1136 : : static int
1137 : 168929 : blob_serialize_extent_table(const struct spdk_blob *blob,
1138 : : struct spdk_blob_md_page **pages,
1139 : : struct spdk_blob_md_page *cur_page,
1140 : : uint32_t *page_count, uint8_t **buf,
1141 : : size_t *remaining_sz)
1142 : : {
1143 : 166431 : uint64_t last_extent_page;
1144 : : int rc;
1145 : :
1146 : 168929 : last_extent_page = 0;
1147 : : /* At least single extent table entry has to be always persisted.
1148 : : * Such case occurs with num_extent_pages == 0. */
1149 [ + + # # : 169642 : while (last_extent_page <= blob->active.num_extent_pages) {
# # # # ]
1150 : 172167 : blob_serialize_extent_table_entry(blob, last_extent_page, &last_extent_page, buf,
1151 : 2525 : remaining_sz);
1152 : :
1153 [ + + # # : 169642 : if (last_extent_page == blob->active.num_extent_pages) {
# # # # ]
1154 : 168929 : break;
1155 : : }
1156 : :
1157 : 713 : rc = blob_serialize_add_page(blob, pages, page_count, &cur_page);
1158 [ - + ]: 713 : if (rc < 0) {
1159 : 0 : return rc;
1160 : : }
1161 : :
1162 [ # # # # ]: 713 : *buf = (uint8_t *)cur_page->descriptors;
1163 [ # # ]: 713 : *remaining_sz = sizeof(cur_page->descriptors);
1164 : : }
1165 : :
1166 : 168929 : return 0;
1167 : 2498 : }
1168 : :
1169 : : static void
1170 : 7004 : blob_serialize_extent_rle(const struct spdk_blob *blob,
1171 : : uint64_t start_cluster, uint64_t *next_cluster,
1172 : : uint8_t **buf, size_t *buf_sz)
1173 : : {
1174 : : struct spdk_blob_md_descriptor_extent_rle *desc_extent_rle;
1175 : : size_t cur_sz;
1176 : : uint64_t i, extent_idx;
1177 : : uint64_t lba, lba_per_cluster, lba_count;
1178 : :
1179 : : /* The buffer must have room for at least one extent */
1180 : 7004 : cur_sz = sizeof(struct spdk_blob_md_descriptor) + sizeof(desc_extent_rle->extents[0]);
1181 [ + + # # ]: 7004 : if (*buf_sz < cur_sz) {
1182 [ # # ]: 72 : *next_cluster = start_cluster;
1183 : 72 : return;
1184 : : }
1185 : :
1186 [ # # ]: 6932 : desc_extent_rle = (struct spdk_blob_md_descriptor_extent_rle *)*buf;
1187 [ # # # # ]: 6932 : desc_extent_rle->type = SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE;
1188 : :
1189 [ # # # # ]: 6932 : lba_per_cluster = bs_cluster_to_lba(blob->bs, 1);
1190 : : /* Assert for scan-build false positive */
1191 [ + + # # ]: 6932 : assert(lba_per_cluster > 0);
1192 : :
1193 [ # # # # : 6932 : lba = blob->active.clusters[start_cluster];
# # # # #
# ]
1194 : 6932 : lba_count = lba_per_cluster;
1195 : 6932 : extent_idx = 0;
1196 [ + + # # : 3241856 : for (i = start_cluster + 1; i < blob->active.num_clusters; i++) {
# # # # ]
1197 [ + + + + : 3234940 : if ((lba + lba_count) == blob->active.clusters[i] && lba != 0) {
# # # # #
# # # #
# ]
1198 : : /* Run-length encode sequential non-zero LBA */
1199 : 29104 : lba_count += lba_per_cluster;
1200 : 29104 : continue;
1201 [ + + + + : 3205836 : } else if (lba == 0 && blob->active.clusters[i] == 0) {
# # # # #
# # # #
# ]
1202 : : /* Run-length encode unallocated clusters */
1203 : 3201064 : lba_count += lba_per_cluster;
1204 : 3201064 : continue;
1205 : : }
1206 [ - + # # : 4772 : desc_extent_rle->extents[extent_idx].cluster_idx = lba / lba_per_cluster;
# # # # #
# ]
1207 [ - + # # : 4772 : desc_extent_rle->extents[extent_idx].length = lba_count / lba_per_cluster;
# # # # #
# ]
1208 : 4772 : extent_idx++;
1209 : :
1210 : 4772 : cur_sz += sizeof(desc_extent_rle->extents[extent_idx]);
1211 : :
1212 [ + + # # ]: 4772 : if (*buf_sz < cur_sz) {
1213 : : /* If we ran out of buffer space, return */
1214 [ # # ]: 16 : *next_cluster = i;
1215 : 16 : break;
1216 : : }
1217 : :
1218 [ # # # # : 4756 : lba = blob->active.clusters[i];
# # # # #
# ]
1219 : 4756 : lba_count = lba_per_cluster;
1220 : 1189 : }
1221 : :
1222 [ + + # # ]: 6932 : if (*buf_sz >= cur_sz) {
1223 [ - + # # : 6916 : desc_extent_rle->extents[extent_idx].cluster_idx = lba / lba_per_cluster;
# # # # #
# ]
1224 [ - + # # : 6916 : desc_extent_rle->extents[extent_idx].length = lba_count / lba_per_cluster;
# # # # #
# ]
1225 : 6916 : extent_idx++;
1226 : :
1227 [ # # # # : 6916 : *next_cluster = blob->active.num_clusters;
# # # # ]
1228 : 1729 : }
1229 : :
1230 [ # # # # ]: 6932 : desc_extent_rle->length = sizeof(desc_extent_rle->extents[0]) * extent_idx;
1231 [ # # # # : 6932 : *buf_sz -= sizeof(struct spdk_blob_md_descriptor) + desc_extent_rle->length;
# # ]
1232 [ # # # # : 6932 : *buf += sizeof(struct spdk_blob_md_descriptor) + desc_extent_rle->length;
# # # # ]
1233 : 1751 : }
1234 : :
1235 : : static int
1236 : 7772 : blob_serialize_extents_rle(const struct spdk_blob *blob,
1237 : : struct spdk_blob_md_page **pages,
1238 : : struct spdk_blob_md_page *cur_page,
1239 : : uint32_t *page_count, uint8_t **buf,
1240 : : size_t *remaining_sz)
1241 : : {
1242 : 5829 : uint64_t last_cluster;
1243 : : int rc;
1244 : :
1245 : 7772 : last_cluster = 0;
1246 [ + + # # : 7860 : while (last_cluster < blob->active.num_clusters) {
# # # # ]
1247 : 7004 : blob_serialize_extent_rle(blob, last_cluster, &last_cluster, buf, remaining_sz);
1248 : :
1249 [ + + # # : 7004 : if (last_cluster == blob->active.num_clusters) {
# # # # ]
1250 : 6916 : break;
1251 : : }
1252 : :
1253 : 88 : rc = blob_serialize_add_page(blob, pages, page_count, &cur_page);
1254 [ - + ]: 88 : if (rc < 0) {
1255 : 0 : return rc;
1256 : : }
1257 : :
1258 [ # # # # ]: 88 : *buf = (uint8_t *)cur_page->descriptors;
1259 [ # # ]: 88 : *remaining_sz = sizeof(cur_page->descriptors);
1260 : : }
1261 : :
1262 : 7772 : return 0;
1263 : 1943 : }
1264 : :
1265 : : static void
1266 : 155396 : blob_serialize_extent_page(const struct spdk_blob *blob,
1267 : : uint64_t cluster, struct spdk_blob_md_page *page)
1268 : : {
1269 : : struct spdk_blob_md_descriptor_extent_page *desc_extent;
1270 : : uint64_t i, extent_idx;
1271 : : uint64_t lba, lba_per_cluster;
1272 [ - + # # : 155396 : uint64_t start_cluster_idx = (cluster / SPDK_EXTENTS_PER_EP) * SPDK_EXTENTS_PER_EP;
# # ]
1273 : :
1274 [ # # ]: 155396 : desc_extent = (struct spdk_blob_md_descriptor_extent_page *) page->descriptors;
1275 [ # # # # ]: 155396 : desc_extent->type = SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE;
1276 : :
1277 [ # # # # ]: 155396 : lba_per_cluster = bs_cluster_to_lba(blob->bs, 1);
1278 : :
1279 [ # # # # ]: 155396 : desc_extent->start_cluster_idx = start_cluster_idx;
1280 : 155396 : extent_idx = 0;
1281 [ + + # # : 24344418 : for (i = start_cluster_idx; i < blob->active.num_clusters; i++) {
# # # # ]
1282 [ # # # # : 24225863 : lba = blob->active.clusters[i];
# # # # #
# ]
1283 [ - + # # : 24225863 : desc_extent->cluster_idx[extent_idx++] = lba / lba_per_cluster;
# # # # ]
1284 [ + + # # ]: 24225863 : if (extent_idx >= SPDK_EXTENTS_PER_EP) {
1285 : 36841 : break;
1286 : : }
1287 : 61966 : }
1288 [ # # # # ]: 155396 : desc_extent->length = sizeof(desc_extent->start_cluster_idx) +
1289 : 1649 : sizeof(desc_extent->cluster_idx[0]) * extent_idx;
1290 : 155396 : }
1291 : :
1292 : : static void
1293 : 176701 : blob_serialize_flags(const struct spdk_blob *blob,
1294 : : uint8_t *buf, size_t *buf_sz)
1295 : : {
1296 : : struct spdk_blob_md_descriptor_flags *desc;
1297 : :
1298 : : /*
1299 : : * Flags get serialized first, so we should always have room for the flags
1300 : : * descriptor.
1301 : : */
1302 [ + + # # : 176701 : assert(*buf_sz >= sizeof(*desc));
# # ]
1303 : :
1304 : 176701 : desc = (struct spdk_blob_md_descriptor_flags *)buf;
1305 [ # # # # ]: 176701 : desc->type = SPDK_MD_DESCRIPTOR_TYPE_FLAGS;
1306 [ # # # # ]: 176701 : desc->length = sizeof(*desc) - sizeof(struct spdk_blob_md_descriptor);
1307 [ # # # # : 176701 : desc->invalid_flags = blob->invalid_flags;
# # # # ]
1308 [ # # # # : 176701 : desc->data_ro_flags = blob->data_ro_flags;
# # # # ]
1309 [ # # # # : 176701 : desc->md_ro_flags = blob->md_ro_flags;
# # # # ]
1310 : :
1311 [ # # ]: 176701 : *buf_sz -= sizeof(*desc);
1312 : 176701 : }
1313 : :
1314 : : static int
1315 : 353402 : blob_serialize_xattrs(const struct spdk_blob *blob,
1316 : : const struct spdk_xattr_tailq *xattrs, bool internal,
1317 : : struct spdk_blob_md_page **pages,
1318 : : struct spdk_blob_md_page *cur_page,
1319 : : uint32_t *page_count, uint8_t **buf,
1320 : : size_t *remaining_sz)
1321 : : {
1322 : : const struct spdk_xattr *xattr;
1323 : : int rc;
1324 : :
1325 [ + + # # : 675435 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
1326 : 322033 : size_t required_sz = 0;
1327 : :
1328 : 324153 : rc = blob_serialize_xattr(xattr,
1329 [ # # # # ]: 2120 : *buf, *remaining_sz,
1330 [ # # ]: 2120 : &required_sz, internal);
1331 [ + + ]: 322033 : if (rc < 0) {
1332 : : /* Need to add a new page to the chain */
1333 : 240 : rc = blob_serialize_add_page(blob, pages, page_count,
1334 : : &cur_page);
1335 [ + + ]: 240 : if (rc < 0) {
1336 [ # # ]: 0 : spdk_free(*pages);
1337 [ # # ]: 0 : *pages = NULL;
1338 [ # # ]: 0 : *page_count = 0;
1339 : 0 : return rc;
1340 : : }
1341 : :
1342 [ # # # # ]: 240 : *buf = (uint8_t *)cur_page->descriptors;
1343 [ # # ]: 240 : *remaining_sz = sizeof(cur_page->descriptors);
1344 : :
1345 : : /* Try again */
1346 : 240 : required_sz = 0;
1347 : 300 : rc = blob_serialize_xattr(xattr,
1348 [ # # # # ]: 60 : *buf, *remaining_sz,
1349 [ # # ]: 60 : &required_sz, internal);
1350 : :
1351 [ + + ]: 240 : if (rc < 0) {
1352 [ # # ]: 0 : spdk_free(*pages);
1353 [ # # ]: 0 : *pages = NULL;
1354 [ # # ]: 0 : *page_count = 0;
1355 : 0 : return rc;
1356 : : }
1357 : 60 : }
1358 : :
1359 [ # # ]: 322033 : *remaining_sz -= required_sz;
1360 [ # # # # ]: 322033 : *buf += required_sz;
1361 : 2120 : }
1362 : :
1363 : 353402 : return 0;
1364 : 8882 : }
1365 : :
1366 : : static int
1367 : 176701 : blob_serialize(const struct spdk_blob *blob, struct spdk_blob_md_page **pages,
1368 : : uint32_t *page_count)
1369 : : {
1370 : 172260 : struct spdk_blob_md_page *cur_page;
1371 : : int rc;
1372 : 172260 : uint8_t *buf;
1373 : 172260 : size_t remaining_sz;
1374 : :
1375 [ + + # # ]: 176701 : assert(pages != NULL);
1376 [ + + # # ]: 176701 : assert(page_count != NULL);
1377 [ + + # # ]: 176701 : assert(blob != NULL);
1378 [ - + # # : 176701 : assert(blob->state == SPDK_BLOB_STATE_DIRTY);
# # # # ]
1379 : :
1380 [ # # ]: 176701 : *pages = NULL;
1381 [ # # ]: 176701 : *page_count = 0;
1382 : :
1383 : : /* A blob always has at least 1 page, even if it has no descriptors */
1384 : 176701 : rc = blob_serialize_add_page(blob, pages, page_count, &cur_page);
1385 [ + + ]: 176701 : if (rc < 0) {
1386 : 0 : return rc;
1387 : : }
1388 : :
1389 [ # # ]: 176701 : buf = (uint8_t *)cur_page->descriptors;
1390 : 176701 : remaining_sz = sizeof(cur_page->descriptors);
1391 : :
1392 : : /* Serialize flags */
1393 : 176701 : blob_serialize_flags(blob, buf, &remaining_sz);
1394 [ # # ]: 176701 : buf += sizeof(struct spdk_blob_md_descriptor_flags);
1395 : :
1396 : : /* Serialize xattrs */
1397 [ # # ]: 181142 : rc = blob_serialize_xattrs(blob, &blob->xattrs, false,
1398 : 4441 : pages, cur_page, page_count, &buf, &remaining_sz);
1399 [ - + ]: 176701 : if (rc < 0) {
1400 : 0 : return rc;
1401 : : }
1402 : :
1403 : : /* Serialize internal xattrs */
1404 [ # # ]: 181142 : rc = blob_serialize_xattrs(blob, &blob->xattrs_internal, true,
1405 : 4441 : pages, cur_page, page_count, &buf, &remaining_sz);
1406 [ + + ]: 176701 : if (rc < 0) {
1407 : 0 : return rc;
1408 : : }
1409 : :
1410 [ + + + + : 176701 : if (blob->use_extent_table) {
# # # # ]
1411 : : /* Serialize extent table */
1412 : 168929 : rc = blob_serialize_extent_table(blob, pages, cur_page, page_count, &buf, &remaining_sz);
1413 : 2498 : } else {
1414 : : /* Serialize extents */
1415 : 7772 : rc = blob_serialize_extents_rle(blob, pages, cur_page, page_count, &buf, &remaining_sz);
1416 : : }
1417 : :
1418 : 176701 : return rc;
1419 : 4441 : }
1420 : :
1421 : : struct spdk_blob_load_ctx {
1422 : : struct spdk_blob *blob;
1423 : :
1424 : : struct spdk_blob_md_page *pages;
1425 : : uint32_t num_pages;
1426 : : uint32_t next_extent_page;
1427 : : spdk_bs_sequence_t *seq;
1428 : :
1429 : : spdk_bs_sequence_cpl cb_fn;
1430 : : void *cb_arg;
1431 : : };
1432 : :
1433 : : static uint32_t
1434 : 485320 : blob_md_page_calc_crc(void *page)
1435 : : {
1436 : : uint32_t crc;
1437 : :
1438 : 485320 : crc = BLOB_CRC32C_INITIAL;
1439 : 485320 : crc = spdk_crc32c_update(page, SPDK_BS_PAGE_SIZE - 4, crc);
1440 : 485320 : crc ^= BLOB_CRC32C_INITIAL;
1441 : :
1442 : 485320 : return crc;
1443 : :
1444 : : }
1445 : :
1446 : : static void
1447 : 36005 : blob_load_final(struct spdk_blob_load_ctx *ctx, int bserrno)
1448 : : {
1449 [ # # # # ]: 36005 : struct spdk_blob *blob = ctx->blob;
1450 : :
1451 [ + + ]: 36005 : if (bserrno == 0) {
1452 : 35677 : blob_mark_clean(blob);
1453 : 4291 : }
1454 : :
1455 [ # # # # : 36005 : ctx->cb_fn(ctx->seq, ctx->cb_arg, bserrno);
# # # # #
# # # # #
# # ]
1456 : :
1457 : : /* Free the memory */
1458 [ # # # # ]: 36005 : spdk_free(ctx->pages);
1459 : 36005 : free(ctx);
1460 : 36005 : }
1461 : :
1462 : : static void
1463 : 2457 : blob_load_snapshot_cpl(void *cb_arg, struct spdk_blob *snapshot, int bserrno)
1464 : : {
1465 : 2457 : struct spdk_blob_load_ctx *ctx = cb_arg;
1466 [ # # # # ]: 2457 : struct spdk_blob *blob = ctx->blob;
1467 : :
1468 [ + + ]: 2457 : if (bserrno == 0) {
1469 [ # # # # ]: 2425 : blob->back_bs_dev = bs_create_blob_bs_dev(snapshot);
1470 [ - + # # : 2425 : if (blob->back_bs_dev == NULL) {
# # ]
1471 : 0 : bserrno = -ENOMEM;
1472 : 0 : }
1473 : 577 : }
1474 [ + + ]: 2457 : if (bserrno != 0) {
1475 : 32 : SPDK_ERRLOG("Snapshot fail\n");
1476 : 8 : }
1477 : :
1478 : 2457 : blob_load_final(ctx, bserrno);
1479 : 2457 : }
1480 : :
1481 : : static void blob_update_clear_method(struct spdk_blob *blob);
1482 : :
1483 : : static int
1484 : 677 : blob_load_esnap(struct spdk_blob *blob, void *blob_ctx)
1485 : : {
1486 [ # # # # ]: 677 : struct spdk_blob_store *bs = blob->bs;
1487 : 677 : struct spdk_bs_dev *bs_dev = NULL;
1488 : 677 : const void *esnap_id = NULL;
1489 : 677 : size_t id_len = 0;
1490 : : int rc;
1491 : :
1492 [ + + # # : 677 : if (bs->esnap_bs_dev_create == NULL) {
# # ]
1493 [ # # # # ]: 40 : SPDK_NOTICELOG("blob 0x%" PRIx64 " is an esnap clone but the blobstore was opened "
1494 : : "without support for esnap clones\n", blob->id);
1495 : 40 : return -ENOTSUP;
1496 : : }
1497 [ + + # # : 637 : assert(blob->back_bs_dev == NULL);
# # # # ]
1498 : :
1499 : 637 : rc = blob_get_xattr_value(blob, BLOB_EXTERNAL_SNAPSHOT_ID, &esnap_id, &id_len, true);
1500 [ - + ]: 637 : if (rc != 0) {
1501 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " is an esnap clone but has no esnap ID\n", blob->id);
1502 : 0 : return -EINVAL;
1503 : : }
1504 [ + - + - ]: 637 : assert(id_len > 0 && id_len < UINT32_MAX);
1505 : :
1506 [ + + - + : 637 : SPDK_INFOLOG(blob, "Creating external snapshot device\n");
# # ]
1507 : :
1508 [ # # # # : 637 : rc = bs->esnap_bs_dev_create(bs->esnap_ctx, blob_ctx, blob, esnap_id, (uint32_t)id_len,
# # # # #
# # # ]
1509 : : &bs_dev);
1510 [ - + ]: 637 : if (rc != 0) {
1511 [ # # # # : 0 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": failed to load back_bs_dev "
# # # # #
# ]
1512 : : "with error %d\n", blob->id, rc);
1513 : 0 : return rc;
1514 : : }
1515 : :
1516 : : /*
1517 : : * Note: bs_dev might be NULL if the consumer chose to not open the external snapshot.
1518 : : * This especially might happen during spdk_bs_load() iteration.
1519 : : */
1520 [ + + ]: 637 : if (bs_dev != NULL) {
1521 [ + + - + : 593 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": loaded back_bs_dev\n", blob->id);
# # # # #
# ]
1522 [ + + + + : 593 : if ((bs->io_unit_size % bs_dev->blocklen) != 0) {
# # # # #
# # # ]
1523 [ # # # # : 20 : SPDK_NOTICELOG("blob 0x%" PRIx64 " external snapshot device block size %u "
# # # # #
# # # ]
1524 : : "is not compatible with blobstore block size %u\n",
1525 : : blob->id, bs_dev->blocklen, bs->io_unit_size);
1526 [ # # # # : 20 : bs_dev->destroy(bs_dev);
# # # # ]
1527 : 20 : return -EINVAL;
1528 : : }
1529 : 135 : }
1530 : :
1531 [ # # # # ]: 617 : blob->back_bs_dev = bs_dev;
1532 [ # # # # ]: 617 : blob->parent_id = SPDK_BLOBID_EXTERNAL_SNAPSHOT;
1533 : :
1534 : 617 : return 0;
1535 : 150 : }
1536 : :
1537 : : static void
1538 : 35769 : blob_load_backing_dev(spdk_bs_sequence_t *seq, void *cb_arg)
1539 : : {
1540 : 35769 : struct spdk_blob_load_ctx *ctx = cb_arg;
1541 [ # # # # ]: 35769 : struct spdk_blob *blob = ctx->blob;
1542 : 31455 : const void *value;
1543 : 31455 : size_t len;
1544 : : int rc;
1545 : :
1546 [ + + ]: 35769 : if (blob_is_esnap_clone(blob)) {
1547 [ # # # # : 677 : rc = blob_load_esnap(blob, seq->cpl.u.blob_handle.esnap_ctx);
# # # # #
# ]
1548 : 677 : blob_load_final(ctx, rc);
1549 : 677 : return;
1550 : : }
1551 : :
1552 [ + + ]: 35092 : if (spdk_blob_is_thin_provisioned(blob)) {
1553 : 5630 : rc = blob_get_xattr_value(blob, BLOB_SNAPSHOT, &value, &len, true);
1554 [ + + ]: 5630 : if (rc == 0) {
1555 [ - + ]: 2457 : if (len != sizeof(spdk_blob_id)) {
1556 : 0 : blob_load_final(ctx, -EINVAL);
1557 : 0 : return;
1558 : : }
1559 : : /* open snapshot blob and continue in the callback function */
1560 [ # # # # : 2457 : blob->parent_id = *(spdk_blob_id *)value;
# # ]
1561 [ # # # # : 3042 : spdk_bs_open_blob(blob->bs, blob->parent_id,
# # # # ]
1562 : 585 : blob_load_snapshot_cpl, ctx);
1563 : 2457 : return;
1564 : : } else {
1565 : : /* add zeroes_dev for thin provisioned blob */
1566 [ # # # # ]: 3173 : blob->back_bs_dev = bs_create_zeroes_dev();
1567 : : }
1568 : 732 : } else {
1569 : : /* standard blob */
1570 [ # # # # ]: 29462 : blob->back_bs_dev = NULL;
1571 : : }
1572 : 32635 : blob_load_final(ctx, 0);
1573 : 4314 : }
1574 : :
1575 : : static void
1576 : 61273 : blob_load_cpl_extents_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
1577 : : {
1578 : 61273 : struct spdk_blob_load_ctx *ctx = cb_arg;
1579 [ # # # # ]: 61273 : struct spdk_blob *blob = ctx->blob;
1580 : : struct spdk_blob_md_page *page;
1581 : : uint64_t i;
1582 : : uint32_t crc;
1583 : : uint64_t lba;
1584 : : void *tmp;
1585 : : uint64_t sz;
1586 : :
1587 [ + + ]: 61273 : if (bserrno) {
1588 : 36 : SPDK_ERRLOG("Extent page read failed: %d\n", bserrno);
1589 : 36 : blob_load_final(ctx, bserrno);
1590 : 36 : return;
1591 : : }
1592 : :
1593 [ + + # # : 61237 : if (ctx->pages == NULL) {
# # ]
1594 : : /* First iteration of this function, allocate buffer for single EXTENT_PAGE */
1595 [ # # # # : 29137 : ctx->pages = spdk_zmalloc(blob->bs->md_page_size, 0,
# # # # #
# # # ]
1596 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
1597 [ + + # # : 29137 : if (!ctx->pages) {
# # ]
1598 : 0 : blob_load_final(ctx, -ENOMEM);
1599 : 0 : return;
1600 : : }
1601 [ # # # # ]: 29137 : ctx->num_pages = 1;
1602 [ # # # # ]: 29137 : ctx->next_extent_page = 0;
1603 : 2656 : } else {
1604 [ # # # # : 32100 : page = &ctx->pages[0];
# # ]
1605 : 32100 : crc = blob_md_page_calc_crc(page);
1606 [ - + # # : 32100 : if (crc != page->crc) {
# # ]
1607 : 0 : blob_load_final(ctx, -EINVAL);
1608 : 0 : return;
1609 : : }
1610 : :
1611 [ - + # # : 32100 : if (page->next != SPDK_INVALID_MD_PAGE) {
# # ]
1612 : 0 : blob_load_final(ctx, -EINVAL);
1613 : 0 : return;
1614 : : }
1615 : :
1616 : 32100 : bserrno = blob_parse_extent_page(page, blob);
1617 [ + + ]: 32100 : if (bserrno) {
1618 : 0 : blob_load_final(ctx, bserrno);
1619 : 0 : return;
1620 : : }
1621 : : }
1622 : :
1623 [ + + # # : 69260 : for (i = ctx->next_extent_page; i < blob->active.num_extent_pages; i++) {
# # # # #
# # # ]
1624 [ + + # # : 40159 : if (blob->active.extent_pages[i] != 0) {
# # # # #
# # # ]
1625 : : /* Extent page was allocated, read and parse it. */
1626 [ # # # # : 32136 : lba = bs_md_page_to_lba(blob->bs, blob->active.extent_pages[i]);
# # # # #
# # # #
# ]
1627 [ # # # # ]: 32136 : ctx->next_extent_page = i + 1;
1628 : :
1629 [ # # # # : 33712 : bs_sequence_read_dev(seq, &ctx->pages[0], lba,
# # ]
1630 [ # # # # : 32136 : bs_byte_to_lba(blob->bs, blob->bs->md_page_size),
# # # # #
# # # ]
1631 : 1576 : blob_load_cpl_extents_cpl, ctx);
1632 : 32136 : return;
1633 : : } else {
1634 : : /* Thin provisioned blobs can point to unallocated extent pages.
1635 : : * In this case blob size should be increased by up to the amount left in remaining_clusters_in_et. */
1636 : :
1637 [ + + # # : 8023 : sz = spdk_min(blob->remaining_clusters_in_et, SPDK_EXTENTS_PER_EP);
# # # # #
# # # #
# ]
1638 [ # # # # : 8023 : blob->active.num_clusters += sz;
# # ]
1639 [ # # # # ]: 8023 : blob->remaining_clusters_in_et -= sz;
1640 : :
1641 [ + + # # ]: 8023 : assert(spdk_blob_is_thin_provisioned(blob));
1642 [ + + - + : 8023 : assert(i + 1 < blob->active.num_extent_pages || blob->remaining_clusters_in_et == 0);
# # # # #
# # # # #
# # ]
1643 : :
1644 [ # # # # : 8023 : tmp = realloc(blob->active.clusters, blob->active.num_clusters * sizeof(*blob->active.clusters));
# # # # #
# # # ]
1645 [ + + ]: 8023 : if (tmp == NULL) {
1646 : 0 : blob_load_final(ctx, -ENOMEM);
1647 : 0 : return;
1648 : : }
1649 [ - + # # : 8675 : memset(tmp + sizeof(*blob->active.clusters) * blob->active.cluster_array_size, 0,
# # # # ]
1650 [ # # # # : 8023 : sizeof(*blob->active.clusters) * (blob->active.num_clusters - blob->active.cluster_array_size));
# # # # #
# # # ]
1651 [ # # # # : 8023 : blob->active.clusters = tmp;
# # ]
1652 [ # # # # : 8023 : blob->active.cluster_array_size = blob->active.num_clusters;
# # # # #
# # # ]
1653 : : }
1654 : 652 : }
1655 : :
1656 : 29101 : blob_load_backing_dev(seq, ctx);
1657 : 4232 : }
1658 : :
1659 : : static void
1660 : 36502 : blob_load_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
1661 : : {
1662 : 36502 : struct spdk_blob_load_ctx *ctx = cb_arg;
1663 [ # # # # ]: 36502 : struct spdk_blob *blob = ctx->blob;
1664 : : struct spdk_blob_md_page *page;
1665 : : int rc;
1666 : : uint32_t crc;
1667 : : uint32_t current_page;
1668 : :
1669 [ + + # # : 36502 : if (ctx->num_pages == 1) {
# # ]
1670 [ # # # # ]: 36005 : current_page = bs_blobid_to_page(blob->id);
1671 : 4373 : } else {
1672 [ + + # # : 497 : assert(ctx->num_pages != 0);
# # # # ]
1673 [ # # # # : 497 : page = &ctx->pages[ctx->num_pages - 2];
# # # # #
# ]
1674 [ # # # # ]: 497 : current_page = page->next;
1675 : : }
1676 : :
1677 [ + + ]: 36502 : if (bserrno) {
1678 [ # # # # ]: 100 : SPDK_ERRLOG("Metadata page %d read failed for blobid 0x%" PRIx64 ": %d\n",
1679 : : current_page, blob->id, bserrno);
1680 : 100 : blob_load_final(ctx, bserrno);
1681 : 100 : return;
1682 : : }
1683 : :
1684 [ # # # # : 36402 : page = &ctx->pages[ctx->num_pages - 1];
# # # # #
# ]
1685 : 36402 : crc = blob_md_page_calc_crc(page);
1686 [ + + # # : 36402 : if (crc != page->crc) {
# # ]
1687 [ # # # # ]: 40 : SPDK_ERRLOG("Metadata page %d crc mismatch for blobid 0x%" PRIx64 "\n",
1688 : : current_page, blob->id);
1689 : 40 : blob_load_final(ctx, -EINVAL);
1690 : 40 : return;
1691 : : }
1692 : :
1693 [ + + # # : 36362 : if (page->next != SPDK_INVALID_MD_PAGE) {
# # ]
1694 : : struct spdk_blob_md_page *tmp_pages;
1695 [ # # # # ]: 497 : uint32_t next_page = page->next;
1696 [ # # # # ]: 497 : uint64_t next_lba = bs_md_page_to_lba(blob->bs, next_page);
1697 : :
1698 : : /* Read the next page */
1699 [ # # # # : 497 : tmp_pages = spdk_realloc(ctx->pages, (sizeof(*page) * (ctx->num_pages + 1)), 0);
# # # # ]
1700 [ + + ]: 497 : if (tmp_pages == NULL) {
1701 : 0 : blob_load_final(ctx, -ENOMEM);
1702 : 0 : return;
1703 : : }
1704 [ # # ]: 497 : ctx->num_pages++;
1705 [ # # # # ]: 497 : ctx->pages = tmp_pages;
1706 : :
1707 [ # # # # : 620 : bs_sequence_read_dev(seq, &ctx->pages[ctx->num_pages - 1],
# # # # #
# ]
1708 : 123 : next_lba,
1709 [ # # # # ]: 497 : bs_byte_to_lba(blob->bs, sizeof(*page)),
1710 : 123 : blob_load_cpl, ctx);
1711 : 497 : return;
1712 : : }
1713 : :
1714 : : /* Parse the pages */
1715 [ # # # # : 35865 : rc = blob_parse(ctx->pages, ctx->num_pages, blob);
# # # # ]
1716 [ + + ]: 35865 : if (rc) {
1717 : 60 : blob_load_final(ctx, rc);
1718 : 60 : return;
1719 : : }
1720 : :
1721 [ + + + + : 35805 : if (blob->extent_table_found == true) {
# # # # ]
1722 : : /* If EXTENT_TABLE was found, that means support for it should be enabled. */
1723 [ - + - + : 29137 : assert(blob->extent_rle_found == false);
# # # # #
# ]
1724 [ # # # # ]: 29137 : blob->use_extent_table = true;
1725 : 2656 : } else {
1726 : : /* If EXTENT_RLE or no extent_* descriptor was found disable support
1727 : : * for extent table. No extent_* descriptors means that blob has length of 0
1728 : : * and no extent_rle descriptors were persisted for it.
1729 : : * EXTENT_TABLE if used, is always present in metadata regardless of length. */
1730 [ # # # # ]: 6668 : blob->use_extent_table = false;
1731 : : }
1732 : :
1733 : : /* Check the clear_method stored in metadata vs what may have been passed
1734 : : * via spdk_bs_open_blob_ext() and update accordingly.
1735 : : */
1736 : 35805 : blob_update_clear_method(blob);
1737 : :
1738 [ # # # # ]: 35805 : spdk_free(ctx->pages);
1739 [ # # # # ]: 35805 : ctx->pages = NULL;
1740 : :
1741 [ + + + + : 35805 : if (blob->extent_table_found) {
# # # # ]
1742 : 29137 : blob_load_cpl_extents_cpl(seq, ctx, 0);
1743 : 2656 : } else {
1744 : 6668 : blob_load_backing_dev(seq, ctx);
1745 : : }
1746 : 4496 : }
1747 : :
1748 : : /* Load a blob from disk given a blobid */
1749 : : static void
1750 : 36005 : blob_load(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
1751 : : spdk_bs_sequence_cpl cb_fn, void *cb_arg)
1752 : : {
1753 : : struct spdk_blob_load_ctx *ctx;
1754 : : struct spdk_blob_store *bs;
1755 : : uint32_t page_num;
1756 : : uint64_t lba;
1757 : :
1758 : 36005 : blob_verify_md_op(blob);
1759 : :
1760 [ # # # # ]: 36005 : bs = blob->bs;
1761 : :
1762 : 36005 : ctx = calloc(1, sizeof(*ctx));
1763 [ + + ]: 36005 : if (!ctx) {
1764 [ # # # # ]: 0 : cb_fn(seq, cb_arg, -ENOMEM);
1765 : 0 : return;
1766 : : }
1767 : :
1768 [ # # # # ]: 36005 : ctx->blob = blob;
1769 [ # # # # : 36005 : ctx->pages = spdk_realloc(ctx->pages, bs->md_page_size, 0);
# # # # #
# # # ]
1770 [ - + # # : 36005 : if (!ctx->pages) {
# # ]
1771 : 0 : free(ctx);
1772 [ # # # # ]: 0 : cb_fn(seq, cb_arg, -ENOMEM);
1773 : 0 : return;
1774 : : }
1775 [ # # # # ]: 36005 : ctx->num_pages = 1;
1776 [ # # # # ]: 36005 : ctx->cb_fn = cb_fn;
1777 [ # # # # ]: 36005 : ctx->cb_arg = cb_arg;
1778 [ # # # # ]: 36005 : ctx->seq = seq;
1779 : :
1780 [ # # # # ]: 36005 : page_num = bs_blobid_to_page(blob->id);
1781 [ # # # # ]: 36005 : lba = bs_md_page_to_lba(blob->bs, page_num);
1782 : :
1783 [ # # # # ]: 36005 : blob->state = SPDK_BLOB_STATE_LOADING;
1784 : :
1785 [ # # # # : 40378 : bs_sequence_read_dev(seq, &ctx->pages[0], lba,
# # ]
1786 [ # # # # ]: 36005 : bs_byte_to_lba(bs, bs->md_page_size),
1787 : 4373 : blob_load_cpl, ctx);
1788 : 4373 : }
1789 : :
1790 : : struct spdk_blob_persist_ctx {
1791 : : struct spdk_blob *blob;
1792 : :
1793 : : struct spdk_blob_md_page *pages;
1794 : : uint32_t next_extent_page;
1795 : : struct spdk_blob_md_page *extent_page;
1796 : :
1797 : : spdk_bs_sequence_t *seq;
1798 : : spdk_bs_sequence_cpl cb_fn;
1799 : : void *cb_arg;
1800 : : TAILQ_ENTRY(spdk_blob_persist_ctx) link;
1801 : : };
1802 : :
1803 : : static void
1804 : 39582 : bs_batch_clear_dev(struct spdk_blob *blob, spdk_bs_batch_t *batch, uint64_t lba,
1805 : : uint64_t lba_count)
1806 : : {
1807 [ + - + - : 39582 : switch (blob->clear_method) {
# # # # ]
1808 : 37996 : case BLOB_CLEAR_WITH_DEFAULT:
1809 : : case BLOB_CLEAR_WITH_UNMAP:
1810 : 39581 : bs_batch_unmap_dev(batch, lba, lba_count);
1811 : 39581 : break;
1812 : 0 : case BLOB_CLEAR_WITH_WRITE_ZEROES:
1813 : 0 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
1814 : 0 : break;
1815 : 1 : case BLOB_CLEAR_WITH_NONE:
1816 : : default:
1817 : 1 : break;
1818 : : }
1819 : 39582 : }
1820 : :
1821 : : static int
1822 : 12175 : bs_super_validate(struct spdk_bs_super_block *super, struct spdk_blob_store *bs)
1823 : : {
1824 : : uint32_t crc;
1825 : : static const char zeros[SPDK_BLOBSTORE_TYPE_LENGTH];
1826 : :
1827 [ + + + + : 12220 : if (super->version > SPDK_BS_VERSION ||
+ - + - ]
1828 [ + + + - ]: 11454 : super->version < SPDK_BS_INITIAL_VERSION) {
1829 : 5736 : return -EILSEQ;
1830 : : }
1831 : :
1832 [ - + + + : 7895 : if (memcmp(super->signature, SPDK_BS_SUPER_BLOCK_SIG,
# # # # #
# ]
1833 : 1456 : sizeof(super->signature)) != 0) {
1834 : 97 : return -EILSEQ;
1835 : : }
1836 : :
1837 : 6342 : crc = blob_md_page_calc_crc(super);
1838 [ + + # # : 6342 : if (crc != super->crc) {
# # ]
1839 : 20 : return -EILSEQ;
1840 : : }
1841 : :
1842 [ + + - + : 6322 : if (memcmp(&bs->bstype, &super->bstype, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {
+ + # # #
# ]
1843 [ + + - + : 6236 : SPDK_DEBUGLOG(blob, "Bstype matched - loading blobstore\n");
# # ]
1844 [ + + + + : 1520 : } else if (memcmp(&bs->bstype, zeros, SPDK_BLOBSTORE_TYPE_LENGTH) == 0) {
# # # # ]
1845 [ - + - + : 38 : SPDK_DEBUGLOG(blob, "Bstype wildcard used - loading blobstore regardless bstype\n");
# # ]
1846 : 7 : } else {
1847 [ + + - + : 48 : SPDK_DEBUGLOG(blob, "Unexpected bstype\n");
# # ]
1848 [ + + - + : 48 : SPDK_LOGDUMP(blob, "Expected:", bs->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
# # # # #
# ]
1849 [ + + - + : 48 : SPDK_LOGDUMP(blob, "Found:", super->bstype.bstype, SPDK_BLOBSTORE_TYPE_LENGTH);
# # # # #
# ]
1850 : 48 : return -ENXIO;
1851 : : }
1852 : :
1853 [ + + # # : 6274 : if (super->size > bs->dev->blockcnt * bs->dev->blocklen) {
# # # # #
# # # # #
# # # # #
# # # ]
1854 [ # # # # : 40 : SPDK_NOTICELOG("Size mismatch, dev size: %" PRIu64 ", blobstore size: %" PRIu64 "\n",
# # # # #
# # # # #
# # # # #
# ]
1855 : : bs->dev->blockcnt * bs->dev->blocklen, super->size);
1856 : 40 : return -EILSEQ;
1857 : : }
1858 : :
1859 : 6234 : return 0;
1860 : 1748 : }
1861 : :
1862 : : static void bs_mark_dirty(spdk_bs_sequence_t *seq, struct spdk_blob_store *bs,
1863 : : spdk_bs_sequence_cpl cb_fn, void *cb_arg);
1864 : :
1865 : : static void
1866 : 185343 : blob_persist_complete_cb(void *arg)
1867 : : {
1868 : 185343 : struct spdk_blob_persist_ctx *ctx = arg;
1869 : :
1870 : : /* Call user callback */
1871 [ # # # # : 185343 : ctx->cb_fn(ctx->seq, ctx->cb_arg, 0);
# # # # #
# # # # #
# # ]
1872 : :
1873 : : /* Free the memory */
1874 [ # # # # ]: 185343 : spdk_free(ctx->pages);
1875 : 185343 : free(ctx);
1876 : 185343 : }
1877 : :
1878 : : static void blob_persist_start(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno);
1879 : :
1880 : : static void
1881 : 185343 : blob_persist_complete(spdk_bs_sequence_t *seq, struct spdk_blob_persist_ctx *ctx, int bserrno)
1882 : : {
1883 : : struct spdk_blob_persist_ctx *next_persist, *tmp;
1884 [ # # # # ]: 185343 : struct spdk_blob *blob = ctx->blob;
1885 : :
1886 [ + + ]: 185343 : if (bserrno == 0) {
1887 : 185083 : blob_mark_clean(blob);
1888 : 6253 : }
1889 : :
1890 [ + + # # : 185343 : assert(ctx == TAILQ_FIRST(&blob->persists_to_complete));
# # # # #
# ]
1891 : :
1892 : : /* Complete all persists that were pending when the current persist started */
1893 [ + + + + : 370686 : TAILQ_FOREACH_SAFE(next_persist, &blob->persists_to_complete, link, tmp) {
# # # # #
# # # # #
# # ]
1894 [ - + # # : 185343 : TAILQ_REMOVE(&blob->persists_to_complete, next_persist, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
1895 : 185343 : spdk_thread_send_msg(spdk_get_thread(), blob_persist_complete_cb, next_persist);
1896 : 6318 : }
1897 : :
1898 [ + + # # : 185343 : if (TAILQ_EMPTY(&blob->pending_persists)) {
# # # # ]
1899 : 185229 : return;
1900 : : }
1901 : :
1902 : : /* Queue up all pending persists for completion and start blob persist with first one */
1903 [ + - - + : 114 : TAILQ_SWAP(&blob->persists_to_complete, &blob->pending_persists, spdk_blob_persist_ctx, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ]
1904 [ # # # # : 114 : next_persist = TAILQ_FIRST(&blob->persists_to_complete);
# # ]
1905 : :
1906 [ # # # # ]: 114 : blob->state = SPDK_BLOB_STATE_DIRTY;
1907 [ # # # # ]: 114 : bs_mark_dirty(seq, blob->bs, blob_persist_start, next_persist);
1908 : 6318 : }
1909 : :
1910 : : static void
1911 : 185083 : blob_persist_clear_extents_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
1912 : : {
1913 : 185083 : struct spdk_blob_persist_ctx *ctx = cb_arg;
1914 [ # # # # ]: 185083 : struct spdk_blob *blob = ctx->blob;
1915 [ # # # # ]: 185083 : struct spdk_blob_store *bs = blob->bs;
1916 : : size_t i;
1917 : :
1918 [ - + ]: 185083 : if (bserrno != 0) {
1919 : 0 : blob_persist_complete(seq, ctx, bserrno);
1920 : 0 : return;
1921 : : }
1922 : :
1923 [ # # ]: 185083 : spdk_spin_lock(&bs->used_lock);
1924 : :
1925 : : /* Release all extent_pages that were truncated */
1926 [ + + # # : 202260 : for (i = blob->active.num_extent_pages; i < blob->active.extent_pages_array_size; i++) {
# # # # #
# # # #
# ]
1927 : : /* Nothing to release if it was not allocated */
1928 [ + + # # : 17177 : if (blob->active.extent_pages[i] != 0) {
# # # # #
# # # ]
1929 [ # # # # : 10230 : bs_release_md_page(bs, blob->active.extent_pages[i]);
# # # # #
# ]
1930 : 937 : }
1931 : 2602 : }
1932 : :
1933 [ # # ]: 185083 : spdk_spin_unlock(&bs->used_lock);
1934 : :
1935 [ + + # # : 185083 : if (blob->active.num_extent_pages == 0) {
# # # # ]
1936 [ # # # # : 20183 : free(blob->active.extent_pages);
# # ]
1937 [ # # # # : 20183 : blob->active.extent_pages = NULL;
# # ]
1938 [ # # # # : 20183 : blob->active.extent_pages_array_size = 0;
# # ]
1939 [ + + # # : 169041 : } else if (blob->active.num_extent_pages != blob->active.extent_pages_array_size) {
# # # # #
# # # #
# ]
1940 : : #ifndef __clang_analyzer__
1941 : : void *tmp;
1942 : :
1943 : : /* scan-build really can't figure reallocs, workaround it */
1944 [ # # # # : 12 : tmp = realloc(blob->active.extent_pages, sizeof(uint32_t) * blob->active.num_extent_pages);
# # # # #
# # # ]
1945 [ + + # # ]: 12 : assert(tmp != NULL);
1946 [ # # # # : 12 : blob->active.extent_pages = tmp;
# # ]
1947 : : #endif
1948 [ # # # # : 12 : blob->active.extent_pages_array_size = blob->active.num_extent_pages;
# # # # #
# # # ]
1949 : 3 : }
1950 : :
1951 : 185083 : blob_persist_complete(seq, ctx, bserrno);
1952 : 6253 : }
1953 : :
1954 : : static void
1955 : 185083 : blob_persist_clear_extents(spdk_bs_sequence_t *seq, struct spdk_blob_persist_ctx *ctx)
1956 : : {
1957 [ # # # # ]: 185083 : struct spdk_blob *blob = ctx->blob;
1958 [ # # # # ]: 185083 : struct spdk_blob_store *bs = blob->bs;
1959 : : size_t i;
1960 : : uint64_t lba;
1961 : : uint64_t lba_count;
1962 : : spdk_bs_batch_t *batch;
1963 : :
1964 : 185083 : batch = bs_sequence_to_batch(seq, blob_persist_clear_extents_cpl, ctx);
1965 [ # # # # ]: 185083 : lba_count = bs_byte_to_lba(bs, bs->md_page_size);
1966 : :
1967 : : /* Clear all extent_pages that were truncated */
1968 [ + + # # : 202260 : for (i = blob->active.num_extent_pages; i < blob->active.extent_pages_array_size; i++) {
# # # # #
# # # #
# ]
1969 : : /* Nothing to clear if it was not allocated */
1970 [ + + # # : 17177 : if (blob->active.extent_pages[i] != 0) {
# # # # #
# # # ]
1971 [ # # # # : 10230 : lba = bs_md_page_to_lba(bs, blob->active.extent_pages[i]);
# # # # #
# ]
1972 : 10230 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
1973 : 937 : }
1974 : 2602 : }
1975 : :
1976 : 185083 : bs_batch_close(batch);
1977 : 185083 : }
1978 : :
1979 : : static void
1980 : 185083 : blob_persist_clear_clusters_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
1981 : : {
1982 : 185083 : struct spdk_blob_persist_ctx *ctx = cb_arg;
1983 [ # # # # ]: 185083 : struct spdk_blob *blob = ctx->blob;
1984 [ # # # # ]: 185083 : struct spdk_blob_store *bs = blob->bs;
1985 : : size_t i;
1986 : :
1987 [ - + ]: 185083 : if (bserrno != 0) {
1988 : 0 : blob_persist_complete(seq, ctx, bserrno);
1989 : 0 : return;
1990 : : }
1991 : :
1992 [ # # ]: 185083 : spdk_spin_lock(&bs->used_lock);
1993 : : /* Release all clusters that were truncated */
1994 [ + + # # : 8599021 : for (i = blob->active.num_clusters; i < blob->active.cluster_array_size; i++) {
# # # # #
# # # #
# ]
1995 [ # # # # : 8413938 : uint32_t cluster_num = bs_lba_to_cluster(bs, blob->active.clusters[i]);
# # # # #
# ]
1996 : :
1997 : : /* Nothing to release if it was not allocated */
1998 [ + + # # : 8413938 : if (blob->active.clusters[i] != 0) {
# # # # #
# # # ]
1999 : 2518610 : bs_release_cluster(bs, cluster_num);
2000 : 2958 : }
2001 : 1336379 : }
2002 [ # # ]: 185083 : spdk_spin_unlock(&bs->used_lock);
2003 : :
2004 [ + + # # : 185083 : if (blob->active.num_clusters == 0) {
# # # # ]
2005 [ # # # # : 13339 : free(blob->active.clusters);
# # ]
2006 [ # # # # : 13339 : blob->active.clusters = NULL;
# # ]
2007 [ # # # # : 13339 : blob->active.cluster_array_size = 0;
# # ]
2008 [ + + # # : 174174 : } else if (blob->active.num_clusters != blob->active.cluster_array_size) {
# # # # #
# # # #
# ]
2009 : : #ifndef __clang_analyzer__
2010 : : void *tmp;
2011 : :
2012 : : /* scan-build really can't figure reallocs, workaround it */
2013 [ # # # # : 91 : tmp = realloc(blob->active.clusters, sizeof(*blob->active.clusters) * blob->active.num_clusters);
# # # # #
# # # ]
2014 [ + + # # ]: 91 : assert(tmp != NULL);
2015 [ # # # # : 91 : blob->active.clusters = tmp;
# # ]
2016 : :
2017 : : #endif
2018 [ # # # # : 91 : blob->active.cluster_array_size = blob->active.num_clusters;
# # # # #
# # # ]
2019 : 22 : }
2020 : :
2021 : : /* Move on to clearing extent pages */
2022 : 185083 : blob_persist_clear_extents(seq, ctx);
2023 : 6253 : }
2024 : :
2025 : : static void
2026 : 185083 : blob_persist_clear_clusters(spdk_bs_sequence_t *seq, struct spdk_blob_persist_ctx *ctx)
2027 : : {
2028 [ # # # # ]: 185083 : struct spdk_blob *blob = ctx->blob;
2029 [ # # # # ]: 185083 : struct spdk_blob_store *bs = blob->bs;
2030 : : spdk_bs_batch_t *batch;
2031 : : size_t i;
2032 : : uint64_t lba;
2033 : : uint64_t lba_count;
2034 : :
2035 : : /* Clusters don't move around in blobs. The list shrinks or grows
2036 : : * at the end, but no changes ever occur in the middle of the list.
2037 : : */
2038 : :
2039 : 185083 : batch = bs_sequence_to_batch(seq, blob_persist_clear_clusters_cpl, ctx);
2040 : :
2041 : : /* Clear all clusters that were truncated */
2042 : 185083 : lba = 0;
2043 : 185083 : lba_count = 0;
2044 [ + + # # : 8599021 : for (i = blob->active.num_clusters; i < blob->active.cluster_array_size; i++) {
# # # # #
# # # #
# ]
2045 [ # # # # : 8413938 : uint64_t next_lba = blob->active.clusters[i];
# # # # #
# ]
2046 : 8413938 : uint64_t next_lba_count = bs_cluster_to_lba(bs, 1);
2047 : :
2048 [ + + + + ]: 8413938 : if (next_lba > 0 && (lba + lba_count) == next_lba) {
2049 : : /* This cluster is contiguous with the previous one. */
2050 : 2479064 : lba_count += next_lba_count;
2051 : 2479064 : continue;
2052 [ + + ]: 5934874 : } else if (next_lba == 0) {
2053 : 5895328 : continue;
2054 : : }
2055 : :
2056 : : /* This cluster is not contiguous with the previous one. */
2057 : :
2058 : : /* If a run of LBAs previously existing, clear them now */
2059 [ + + ]: 39546 : if (lba_count > 0) {
2060 [ # # # # ]: 32448 : bs_batch_clear_dev(ctx->blob, batch, lba, lba_count);
2061 : 45 : }
2062 : :
2063 : : /* Start building the next batch */
2064 : 39546 : lba = next_lba;
2065 [ + - ]: 39546 : if (next_lba > 0) {
2066 : 39546 : lba_count = next_lba_count;
2067 : 1580 : } else {
2068 : 0 : lba_count = 0;
2069 : : }
2070 : 1580 : }
2071 : :
2072 : : /* If we ended with a contiguous set of LBAs, clear them now */
2073 [ + + ]: 185083 : if (lba_count > 0) {
2074 [ # # # # ]: 7098 : bs_batch_clear_dev(ctx->blob, batch, lba, lba_count);
2075 : 1535 : }
2076 : :
2077 : 185083 : bs_batch_close(batch);
2078 : 185083 : }
2079 : :
2080 : : static void
2081 : 185103 : blob_persist_zero_pages_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2082 : : {
2083 : 185103 : struct spdk_blob_persist_ctx *ctx = cb_arg;
2084 [ # # # # ]: 185103 : struct spdk_blob *blob = ctx->blob;
2085 [ # # # # ]: 185103 : struct spdk_blob_store *bs = blob->bs;
2086 : : size_t i;
2087 : :
2088 [ + + ]: 185103 : if (bserrno != 0) {
2089 : 20 : blob_persist_complete(seq, ctx, bserrno);
2090 : 20 : return;
2091 : : }
2092 : :
2093 [ # # ]: 185083 : spdk_spin_lock(&bs->used_lock);
2094 : :
2095 : : /* This loop starts at 1 because the first page is special and handled
2096 : : * below. The pages (except the first) are never written in place,
2097 : : * so any pages in the clean list must be zeroed.
2098 : : */
2099 [ + + # # : 186028 : for (i = 1; i < blob->clean.num_pages; i++) {
# # # # ]
2100 [ # # # # : 945 : bs_release_md_page(bs, blob->clean.pages[i]);
# # # # #
# ]
2101 : 85 : }
2102 : :
2103 [ + + # # : 185083 : if (blob->active.num_pages == 0) {
# # # # ]
2104 : : uint32_t page_num;
2105 : :
2106 [ # # # # ]: 8582 : page_num = bs_blobid_to_page(blob->id);
2107 : 8582 : bs_release_md_page(bs, page_num);
2108 : 1862 : }
2109 : :
2110 [ # # ]: 185083 : spdk_spin_unlock(&bs->used_lock);
2111 : :
2112 : : /* Move on to clearing clusters */
2113 : 185083 : blob_persist_clear_clusters(seq, ctx);
2114 : 6258 : }
2115 : :
2116 : : static void
2117 : 185303 : blob_persist_zero_pages(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2118 : : {
2119 : 185303 : struct spdk_blob_persist_ctx *ctx = cb_arg;
2120 [ # # # # ]: 185303 : struct spdk_blob *blob = ctx->blob;
2121 [ # # # # ]: 185303 : struct spdk_blob_store *bs = blob->bs;
2122 : : uint64_t lba;
2123 : : uint64_t lba_count;
2124 : : spdk_bs_batch_t *batch;
2125 : : size_t i;
2126 : :
2127 [ + + ]: 185303 : if (bserrno != 0) {
2128 : 200 : blob_persist_complete(seq, ctx, bserrno);
2129 : 200 : return;
2130 : : }
2131 : :
2132 : 185103 : batch = bs_sequence_to_batch(seq, blob_persist_zero_pages_cpl, ctx);
2133 : :
2134 [ # # # # ]: 185103 : lba_count = bs_byte_to_lba(bs, bs->md_page_size);
2135 : :
2136 : : /* This loop starts at 1 because the first page is special and handled
2137 : : * below. The pages (except the first) are never written in place,
2138 : : * so any pages in the clean list must be zeroed.
2139 : : */
2140 [ + + # # : 186048 : for (i = 1; i < blob->clean.num_pages; i++) {
# # # # ]
2141 [ # # # # : 945 : lba = bs_md_page_to_lba(bs, blob->clean.pages[i]);
# # # # #
# ]
2142 : :
2143 : 945 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
2144 : 85 : }
2145 : :
2146 : : /* The first page will only be zeroed if this is a delete. */
2147 [ + + # # : 185103 : if (blob->active.num_pages == 0) {
# # # # ]
2148 : : uint32_t page_num;
2149 : :
2150 : : /* The first page in the metadata goes where the blobid indicates */
2151 [ # # # # ]: 8602 : page_num = bs_blobid_to_page(blob->id);
2152 : 8602 : lba = bs_md_page_to_lba(bs, page_num);
2153 : :
2154 : 8602 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
2155 : 1867 : }
2156 : :
2157 : 185103 : bs_batch_close(batch);
2158 : 6308 : }
2159 : :
2160 : : static void
2161 : 176701 : blob_persist_write_page_root(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2162 : : {
2163 : 176701 : struct spdk_blob_persist_ctx *ctx = cb_arg;
2164 [ # # # # ]: 176701 : struct spdk_blob *blob = ctx->blob;
2165 [ # # # # ]: 176701 : struct spdk_blob_store *bs = blob->bs;
2166 : : uint64_t lba;
2167 : : uint32_t lba_count;
2168 : : struct spdk_blob_md_page *page;
2169 : :
2170 [ - + ]: 176701 : if (bserrno != 0) {
2171 : 0 : blob_persist_complete(seq, ctx, bserrno);
2172 : 0 : return;
2173 : : }
2174 : :
2175 [ - + # # : 176701 : if (blob->active.num_pages == 0) {
# # # # ]
2176 : : /* Move on to the next step */
2177 : 0 : blob_persist_zero_pages(seq, ctx, 0);
2178 : 0 : return;
2179 : : }
2180 : :
2181 [ # # # # ]: 176701 : lba_count = bs_byte_to_lba(bs, bs->md_page_size);
2182 : :
2183 [ # # # # : 176701 : page = &ctx->pages[0];
# # ]
2184 : : /* The first page in the metadata goes where the blobid indicates */
2185 [ # # # # ]: 176701 : lba = bs_md_page_to_lba(bs, bs_blobid_to_page(blob->id));
2186 : :
2187 : 181142 : bs_sequence_write_dev(seq, page, lba, lba_count,
2188 : 4441 : blob_persist_zero_pages, ctx);
2189 : 4441 : }
2190 : :
2191 : : static void
2192 : 176701 : blob_persist_write_page_chain(spdk_bs_sequence_t *seq, struct spdk_blob_persist_ctx *ctx)
2193 : : {
2194 [ # # # # ]: 176701 : struct spdk_blob *blob = ctx->blob;
2195 [ # # # # ]: 176701 : struct spdk_blob_store *bs = blob->bs;
2196 : : uint64_t lba;
2197 : : uint32_t lba_count;
2198 : : struct spdk_blob_md_page *page;
2199 : : spdk_bs_batch_t *batch;
2200 : : size_t i;
2201 : :
2202 : : /* Clusters don't move around in blobs. The list shrinks or grows
2203 : : * at the end, but no changes ever occur in the middle of the list.
2204 : : */
2205 : :
2206 : 176701 : lba_count = bs_byte_to_lba(bs, sizeof(*page));
2207 : :
2208 : 176701 : batch = bs_sequence_to_batch(seq, blob_persist_write_page_root, ctx);
2209 : :
2210 : : /* This starts at 1. The root page is not written until
2211 : : * all of the others are finished
2212 : : */
2213 [ + + # # : 177742 : for (i = 1; i < blob->active.num_pages; i++) {
# # # # ]
2214 [ # # # # : 1041 : page = &ctx->pages[i];
# # ]
2215 [ + + # # : 1041 : assert(page->sequence_num == i);
# # # # ]
2216 : :
2217 [ # # # # : 1041 : lba = bs_md_page_to_lba(bs, blob->active.pages[i]);
# # # # #
# ]
2218 : :
2219 : 1041 : bs_batch_write_dev(batch, page, lba, lba_count);
2220 : 109 : }
2221 : :
2222 : 176701 : bs_batch_close(batch);
2223 : 176701 : }
2224 : :
2225 : : static int
2226 : 133314 : blob_resize(struct spdk_blob *blob, uint64_t sz)
2227 : : {
2228 : : uint64_t i;
2229 : : uint64_t *tmp;
2230 : 128839 : uint64_t cluster;
2231 : 128839 : uint32_t lfmd; /* lowest free md page */
2232 : : uint64_t num_clusters;
2233 : : uint32_t *ep_tmp;
2234 : 133314 : uint64_t new_num_ep = 0, current_num_ep = 0;
2235 : : struct spdk_blob_store *bs;
2236 : : int rc;
2237 : :
2238 [ # # # # ]: 133314 : bs = blob->bs;
2239 : :
2240 : 133314 : blob_verify_md_op(blob);
2241 : :
2242 [ + + # # : 133314 : if (blob->active.num_clusters == sz) {
# # # # ]
2243 : 4692 : return 0;
2244 : : }
2245 : :
2246 [ - + # # : 128622 : if (blob->active.num_clusters < blob->active.cluster_array_size) {
# # # # #
# # # #
# ]
2247 : : /* If this blob was resized to be larger, then smaller, then
2248 : : * larger without syncing, then the cluster array already
2249 : : * contains spare assigned clusters we can use.
2250 : : */
2251 [ # # # # : 0 : num_clusters = spdk_min(blob->active.cluster_array_size,
# # # # #
# # # #
# ]
2252 : : sz);
2253 : 0 : } else {
2254 [ # # # # : 128622 : num_clusters = blob->active.num_clusters;
# # ]
2255 : : }
2256 : :
2257 [ + + + + : 128622 : if (blob->use_extent_table) {
# # # # ]
2258 : : /* Round up since every cluster beyond current Extent Table size,
2259 : : * requires new extent page. */
2260 [ # # ]: 122462 : new_num_ep = spdk_divide_round_up(sz, SPDK_EXTENTS_PER_EP);
2261 [ # # ]: 122462 : current_num_ep = spdk_divide_round_up(num_clusters, SPDK_EXTENTS_PER_EP);
2262 : 2367 : }
2263 : :
2264 [ - + # # : 128622 : assert(!spdk_spin_held(&bs->used_lock));
# # ]
2265 : :
2266 : : /* Check first that we have enough clusters and md pages before we start claiming them.
2267 : : * bs->used_lock is held to ensure that clusters we think are free are still free when we go
2268 : : * to claim them later in this function.
2269 : : */
2270 [ + + + + ]: 128622 : if (sz > num_clusters && spdk_blob_is_thin_provisioned(blob) == false) {
2271 [ # # ]: 118366 : spdk_spin_lock(&bs->used_lock);
2272 [ + + # # : 118366 : if ((sz - num_clusters) > bs->num_free_clusters) {
# # ]
2273 : 43 : rc = -ENOSPC;
2274 : 43 : goto out;
2275 : : }
2276 : 118323 : lfmd = 0;
2277 [ + + ]: 129273 : for (i = current_num_ep; i < new_num_ep ; i++) {
2278 [ # # # # : 10950 : lfmd = spdk_bit_array_find_first_clear(blob->bs->used_md_pages, lfmd);
# # # # ]
2279 [ + + ]: 10950 : if (lfmd == UINT32_MAX) {
2280 : : /* No more free md pages. Cannot satisfy the request */
2281 : 0 : rc = -ENOSPC;
2282 : 0 : goto out;
2283 : : }
2284 : 959 : }
2285 : 1615 : }
2286 : :
2287 [ + + ]: 128579 : if (sz > num_clusters) {
2288 : : /* Expand the cluster array if necessary.
2289 : : * We only shrink the array when persisting.
2290 : : */
2291 [ # # # # : 120532 : tmp = realloc(blob->active.clusters, sizeof(*blob->active.clusters) * sz);
# # ]
2292 [ + - + + ]: 120532 : if (sz > 0 && tmp == NULL) {
2293 : 0 : rc = -ENOMEM;
2294 : 0 : goto out;
2295 : : }
2296 [ - + # # : 122666 : memset(tmp + blob->active.cluster_array_size, 0,
# # # # #
# ]
2297 [ # # # # : 120532 : sizeof(*blob->active.clusters) * (sz - blob->active.cluster_array_size));
# # ]
2298 [ # # # # : 120532 : blob->active.clusters = tmp;
# # ]
2299 [ # # # # : 120532 : blob->active.cluster_array_size = sz;
# # ]
2300 : :
2301 : : /* Expand the extents table, only if enough clusters were added */
2302 [ + + - + : 120532 : if (new_num_ep > current_num_ep && blob->use_extent_table) {
+ - # # #
# ]
2303 [ # # # # : 7654 : ep_tmp = realloc(blob->active.extent_pages, sizeof(*blob->active.extent_pages) * new_num_ep);
# # ]
2304 [ + - + + ]: 7654 : if (new_num_ep > 0 && ep_tmp == NULL) {
2305 : 0 : rc = -ENOMEM;
2306 : 0 : goto out;
2307 : : }
2308 [ - + # # : 8913 : memset(ep_tmp + blob->active.extent_pages_array_size, 0,
# # # # #
# ]
2309 [ # # # # : 7654 : sizeof(*blob->active.extent_pages) * (new_num_ep - blob->active.extent_pages_array_size));
# # ]
2310 [ # # # # : 7654 : blob->active.extent_pages = ep_tmp;
# # ]
2311 [ # # # # : 7654 : blob->active.extent_pages_array_size = new_num_ep;
# # ]
2312 : 1259 : }
2313 : 2134 : }
2314 : :
2315 [ # # # # ]: 128579 : blob->state = SPDK_BLOB_STATE_DIRTY;
2316 : :
2317 [ + + ]: 128579 : if (spdk_blob_is_thin_provisioned(blob) == false) {
2318 : 124877 : cluster = 0;
2319 : 124877 : lfmd = 0;
2320 [ + + ]: 2763638 : for (i = num_clusters; i < sz; i++) {
2321 : 2638761 : bs_allocate_cluster(blob, i, &cluster, &lfmd, true);
2322 : : /* Do not increment lfmd here. lfmd will get updated
2323 : : * to the md_page allocated (if any) when a new extent
2324 : : * page is needed. Just pass that value again,
2325 : : * bs_allocate_cluster will just start at that index
2326 : : * to find the next free md_page when needed.
2327 : : */
2328 : 9285 : }
2329 : 3030 : }
2330 : :
2331 : : /* If we are shrinking the blob, we must adjust num_allocated_clusters */
2332 [ + + ]: 8542717 : for (i = sz; i < num_clusters; i++) {
2333 [ + + # # : 8414138 : if (blob->active.clusters[i] != 0) {
# # # # #
# # # ]
2334 [ # # # # ]: 2518610 : blob->active.num_allocated_clusters--;
2335 : 2958 : }
2336 : 1336429 : }
2337 : :
2338 [ # # # # : 128579 : blob->active.num_clusters = sz;
# # ]
2339 [ # # # # : 128579 : blob->active.num_extent_pages = new_num_ep;
# # ]
2340 : :
2341 : 128579 : rc = 0;
2342 : 124715 : out:
2343 [ + + # # ]: 128622 : if (spdk_spin_held(&bs->used_lock)) {
2344 [ # # ]: 118366 : spdk_spin_unlock(&bs->used_lock);
2345 : 1625 : }
2346 : :
2347 : 128622 : return rc;
2348 : 4475 : }
2349 : :
2350 : : static void
2351 : 176701 : blob_persist_generate_new_md(struct spdk_blob_persist_ctx *ctx)
2352 : : {
2353 [ # # # # ]: 176701 : spdk_bs_sequence_t *seq = ctx->seq;
2354 [ # # # # ]: 176701 : struct spdk_blob *blob = ctx->blob;
2355 [ # # # # ]: 176701 : struct spdk_blob_store *bs = blob->bs;
2356 : : uint64_t i;
2357 : : uint32_t page_num;
2358 : : void *tmp;
2359 : : int rc;
2360 : :
2361 : : /* Generate the new metadata */
2362 [ # # # # : 176701 : rc = blob_serialize(blob, &ctx->pages, &blob->active.num_pages);
# # ]
2363 [ + + ]: 176701 : if (rc < 0) {
2364 : 0 : blob_persist_complete(seq, ctx, rc);
2365 : 0 : return;
2366 : : }
2367 : :
2368 [ + + # # : 176701 : assert(blob->active.num_pages >= 1);
# # # # #
# ]
2369 : :
2370 : : /* Resize the cache of page indices */
2371 [ # # # # : 176701 : tmp = realloc(blob->active.pages, blob->active.num_pages * sizeof(*blob->active.pages));
# # # # #
# # # ]
2372 [ + + ]: 176701 : if (!tmp) {
2373 : 0 : blob_persist_complete(seq, ctx, -ENOMEM);
2374 : 0 : return;
2375 : : }
2376 [ # # # # : 176701 : blob->active.pages = tmp;
# # ]
2377 : :
2378 : : /* Assign this metadata to pages. This requires two passes - one to verify that there are
2379 : : * enough pages and a second to actually claim them. The used_lock is held across
2380 : : * both passes to ensure things don't change in the middle.
2381 : : */
2382 [ # # ]: 176701 : spdk_spin_lock(&bs->used_lock);
2383 : 176701 : page_num = 0;
2384 : : /* Note that this loop starts at one. The first page location is fixed by the blobid. */
2385 [ + + # # : 177742 : for (i = 1; i < blob->active.num_pages; i++) {
# # # # ]
2386 [ # # # # ]: 1041 : page_num = spdk_bit_array_find_first_clear(bs->used_md_pages, page_num);
2387 [ + + ]: 1041 : if (page_num == UINT32_MAX) {
2388 [ # # ]: 0 : spdk_spin_unlock(&bs->used_lock);
2389 : 0 : blob_persist_complete(seq, ctx, -ENOMEM);
2390 : 0 : return;
2391 : : }
2392 : 1041 : page_num++;
2393 : 109 : }
2394 : :
2395 : 176701 : page_num = 0;
2396 [ # # # # : 176701 : blob->active.pages[0] = bs_blobid_to_page(blob->id);
# # # # #
# # # #
# ]
2397 [ + + # # : 177742 : for (i = 1; i < blob->active.num_pages; i++) {
# # # # ]
2398 [ # # # # ]: 1041 : page_num = spdk_bit_array_find_first_clear(bs->used_md_pages, page_num);
2399 [ # # # # : 1041 : ctx->pages[i - 1].next = page_num;
# # # # #
# ]
2400 : : /* Now that previous metadata page is complete, calculate the crc for it. */
2401 [ # # # # : 1041 : ctx->pages[i - 1].crc = blob_md_page_calc_crc(&ctx->pages[i - 1]);
# # # # #
# # # # #
# # ]
2402 [ # # # # : 1041 : blob->active.pages[i] = page_num;
# # # # #
# ]
2403 : 1041 : bs_claim_md_page(bs, page_num);
2404 [ + + - + : 1041 : SPDK_DEBUGLOG(blob, "Claiming page %u for blob 0x%" PRIx64 "\n", page_num,
# # # # #
# ]
2405 : : blob->id);
2406 : 1041 : page_num++;
2407 : 109 : }
2408 [ # # ]: 176701 : spdk_spin_unlock(&bs->used_lock);
2409 [ # # # # : 176701 : ctx->pages[i - 1].crc = blob_md_page_calc_crc(&ctx->pages[i - 1]);
# # # # #
# # # # #
# # ]
2410 : : /* Start writing the metadata from last page to first */
2411 [ # # # # ]: 176701 : blob->state = SPDK_BLOB_STATE_CLEAN;
2412 : 176701 : blob_persist_write_page_chain(seq, ctx);
2413 : 4441 : }
2414 : :
2415 : : static void
2416 : 240954 : blob_persist_write_extent_pages(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2417 : : {
2418 : 240954 : struct spdk_blob_persist_ctx *ctx = cb_arg;
2419 [ # # # # ]: 240954 : struct spdk_blob *blob = ctx->blob;
2420 : : size_t i;
2421 : : uint32_t extent_page_id;
2422 : 240954 : uint32_t page_count = 0;
2423 : : int rc;
2424 : :
2425 [ + + # # : 240954 : if (ctx->extent_page != NULL) {
# # ]
2426 [ # # # # ]: 120469 : spdk_free(ctx->extent_page);
2427 [ # # # # ]: 120469 : ctx->extent_page = NULL;
2428 : 992 : }
2429 : :
2430 [ - + ]: 240954 : if (bserrno != 0) {
2431 : 0 : blob_persist_complete(seq, ctx, bserrno);
2432 : 0 : return;
2433 : : }
2434 : :
2435 : : /* Only write out Extent Pages when blob was resized. */
2436 [ + + # # : 255782 : for (i = ctx->next_extent_page; i < blob->active.extent_pages_array_size; i++) {
# # # # #
# # # ]
2437 [ # # # # : 135297 : extent_page_id = blob->active.extent_pages[i];
# # # # #
# ]
2438 [ + + ]: 135297 : if (extent_page_id == 0) {
2439 : : /* No Extent Page to persist */
2440 [ + + # # ]: 14828 : assert(spdk_blob_is_thin_provisioned(blob));
2441 : 14828 : continue;
2442 : : }
2443 [ - + # # : 120469 : assert(spdk_bit_array_get(blob->bs->used_md_pages, extent_page_id));
# # # # #
# # # ]
2444 [ # # # # ]: 120469 : ctx->next_extent_page = i + 1;
2445 [ # # # # : 120469 : rc = blob_serialize_add_page(ctx->blob, &ctx->extent_page, &page_count, &ctx->extent_page);
# # # # ]
2446 [ + + ]: 120469 : if (rc < 0) {
2447 : 0 : blob_persist_complete(seq, ctx, rc);
2448 : 0 : return;
2449 : : }
2450 : :
2451 [ # # # # ]: 120469 : blob->state = SPDK_BLOB_STATE_DIRTY;
2452 [ # # # # : 120469 : blob_serialize_extent_page(blob, i * SPDK_EXTENTS_PER_EP, ctx->extent_page);
# # ]
2453 : :
2454 [ # # # # : 120469 : ctx->extent_page->crc = blob_md_page_calc_crc(ctx->extent_page);
# # # # #
# # # ]
2455 : :
2456 [ # # # # : 121461 : bs_sequence_write_dev(seq, ctx->extent_page, bs_md_page_to_lba(blob->bs, extent_page_id),
# # # # ]
2457 [ # # # # : 120469 : bs_byte_to_lba(blob->bs, blob->bs->md_page_size),
# # # # #
# # # ]
2458 : 992 : blob_persist_write_extent_pages, ctx);
2459 : 120469 : return;
2460 : : }
2461 : :
2462 : 120485 : blob_persist_generate_new_md(ctx);
2463 : 3113 : }
2464 : :
2465 : : static void
2466 : 185343 : blob_persist_start(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2467 : : {
2468 : 185343 : struct spdk_blob_persist_ctx *ctx = cb_arg;
2469 [ # # # # ]: 185343 : struct spdk_blob *blob = ctx->blob;
2470 : :
2471 [ + + ]: 185343 : if (bserrno != 0) {
2472 : 40 : blob_persist_complete(seq, ctx, bserrno);
2473 : 40 : return;
2474 : : }
2475 : :
2476 [ + + # # : 185303 : if (blob->active.num_pages == 0) {
# # # # ]
2477 : : /* This is the signal that the blob should be deleted.
2478 : : * Immediately jump to the clean up routine. */
2479 [ + + # # : 8602 : assert(blob->clean.num_pages > 0);
# # # # #
# ]
2480 [ # # # # ]: 8602 : blob->state = SPDK_BLOB_STATE_CLEAN;
2481 : 8602 : blob_persist_zero_pages(seq, ctx, 0);
2482 : 8602 : return;
2483 : :
2484 : : }
2485 : :
2486 [ + + # # : 176701 : if (blob->clean.num_clusters < blob->active.num_clusters) {
# # # # #
# # # #
# ]
2487 : : /* Blob was resized up */
2488 [ + + # # : 120392 : assert(blob->clean.num_extent_pages <= blob->active.num_extent_pages);
# # # # #
# # # # #
# # ]
2489 [ + + # # : 120392 : ctx->next_extent_page = spdk_max(1, blob->clean.num_extent_pages) - 1;
# # # # #
# # # # #
# # # # ]
2490 [ + + # # : 58408 : } else if (blob->active.num_clusters < blob->active.cluster_array_size) {
# # # # #
# # # #
# ]
2491 : : /* Blob was resized down */
2492 [ - + # # : 93 : assert(blob->clean.num_extent_pages >= blob->active.num_extent_pages);
# # # # #
# # # # #
# # ]
2493 [ + + # # : 93 : ctx->next_extent_page = spdk_max(1, blob->active.num_extent_pages) - 1;
# # # # #
# # # # #
# # # # ]
2494 : 22 : } else {
2495 : : /* No change in size occurred */
2496 : 56216 : blob_persist_generate_new_md(ctx);
2497 : 56216 : return;
2498 : : }
2499 : :
2500 : 120485 : blob_persist_write_extent_pages(seq, ctx, 0);
2501 : 6318 : }
2502 : :
2503 : : struct spdk_bs_mark_dirty {
2504 : : struct spdk_blob_store *bs;
2505 : : struct spdk_bs_super_block *super;
2506 : : spdk_bs_sequence_cpl cb_fn;
2507 : : void *cb_arg;
2508 : : };
2509 : :
2510 : : static void
2511 : 837 : bs_mark_dirty_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2512 : : {
2513 : 837 : struct spdk_bs_mark_dirty *ctx = cb_arg;
2514 : :
2515 [ + + ]: 837 : if (bserrno == 0) {
2516 [ # # # # : 797 : ctx->bs->clean = 0;
# # # # ]
2517 : 188 : }
2518 : :
2519 [ # # # # : 837 : ctx->cb_fn(seq, ctx->cb_arg, bserrno);
# # # # #
# # # ]
2520 : :
2521 [ # # # # ]: 837 : spdk_free(ctx->super);
2522 : 837 : free(ctx);
2523 : 837 : }
2524 : :
2525 : : static void bs_write_super(spdk_bs_sequence_t *seq, struct spdk_blob_store *bs,
2526 : : struct spdk_bs_super_block *super, spdk_bs_sequence_cpl cb_fn, void *cb_arg);
2527 : :
2528 : :
2529 : : static void
2530 : 837 : bs_mark_dirty_write(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2531 : : {
2532 : 837 : struct spdk_bs_mark_dirty *ctx = cb_arg;
2533 : : int rc;
2534 : :
2535 [ + + ]: 837 : if (bserrno != 0) {
2536 : 20 : bs_mark_dirty_write_cpl(seq, ctx, bserrno);
2537 : 20 : return;
2538 : : }
2539 : :
2540 [ # # # # : 817 : rc = bs_super_validate(ctx->super, ctx->bs);
# # # # ]
2541 [ - + ]: 817 : if (rc != 0) {
2542 : 0 : bs_mark_dirty_write_cpl(seq, ctx, rc);
2543 : 0 : return;
2544 : : }
2545 : :
2546 [ # # # # : 817 : ctx->super->clean = 0;
# # # # ]
2547 [ + + # # : 817 : if (ctx->super->size == 0) {
# # # # #
# ]
2548 [ # # # # : 20 : ctx->super->size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
2549 : 5 : }
2550 : :
2551 [ # # # # : 817 : bs_write_super(seq, ctx->bs, ctx->super, bs_mark_dirty_write_cpl, ctx);
# # # # ]
2552 : 198 : }
2553 : :
2554 : : static void
2555 : 220270 : bs_mark_dirty(spdk_bs_sequence_t *seq, struct spdk_blob_store *bs,
2556 : : spdk_bs_sequence_cpl cb_fn, void *cb_arg)
2557 : : {
2558 : : struct spdk_bs_mark_dirty *ctx;
2559 : :
2560 : : /* Blobstore is already marked dirty */
2561 [ + + + + : 220270 : if (bs->clean == 0) {
# # # # ]
2562 [ # # # # ]: 219433 : cb_fn(seq, cb_arg, 0);
2563 : 219433 : return;
2564 : : }
2565 : :
2566 : 837 : ctx = calloc(1, sizeof(*ctx));
2567 [ + + ]: 837 : if (!ctx) {
2568 [ # # # # ]: 0 : cb_fn(seq, cb_arg, -ENOMEM);
2569 : 0 : return;
2570 : : }
2571 [ # # # # ]: 837 : ctx->bs = bs;
2572 [ # # # # ]: 837 : ctx->cb_fn = cb_fn;
2573 [ # # # # ]: 837 : ctx->cb_arg = cb_arg;
2574 : :
2575 [ # # # # ]: 837 : ctx->super = spdk_zmalloc(sizeof(*ctx->super), 0x1000, NULL,
2576 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
2577 [ - + # # : 837 : if (!ctx->super) {
# # ]
2578 : 0 : free(ctx);
2579 [ # # # # ]: 0 : cb_fn(seq, cb_arg, -ENOMEM);
2580 : 0 : return;
2581 : : }
2582 : :
2583 [ # # # # ]: 1035 : bs_sequence_read_dev(seq, ctx->super, bs_page_to_lba(bs, 0),
2584 : 837 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
2585 : 198 : bs_mark_dirty_write, ctx);
2586 : 6975 : }
2587 : :
2588 : : /* Write a blob to disk */
2589 : : static void
2590 : 222319 : blob_persist(spdk_bs_sequence_t *seq, struct spdk_blob *blob,
2591 : : spdk_bs_sequence_cpl cb_fn, void *cb_arg)
2592 : : {
2593 : : struct spdk_blob_persist_ctx *ctx;
2594 : :
2595 : 222319 : blob_verify_md_op(blob);
2596 : :
2597 [ + + + + : 222319 : if (blob->state == SPDK_BLOB_STATE_CLEAN && TAILQ_EMPTY(&blob->persists_to_complete)) {
# # # # #
# # # #
# ]
2598 [ # # # # ]: 36976 : cb_fn(seq, cb_arg, 0);
2599 : 36976 : return;
2600 : : }
2601 : :
2602 : 185343 : ctx = calloc(1, sizeof(*ctx));
2603 [ + + ]: 185343 : if (!ctx) {
2604 [ # # # # ]: 0 : cb_fn(seq, cb_arg, -ENOMEM);
2605 : 0 : return;
2606 : : }
2607 [ # # # # ]: 185343 : ctx->blob = blob;
2608 [ # # # # ]: 185343 : ctx->seq = seq;
2609 [ # # # # ]: 185343 : ctx->cb_fn = cb_fn;
2610 [ # # # # ]: 185343 : ctx->cb_arg = cb_arg;
2611 : :
2612 : : /* Multiple blob persists can affect one another, via blob->state or
2613 : : * blob mutable data changes. To prevent it, queue up the persists. */
2614 [ + + # # : 185343 : if (!TAILQ_EMPTY(&blob->persists_to_complete)) {
# # # # ]
2615 [ # # # # : 114 : TAILQ_INSERT_TAIL(&blob->pending_persists, ctx, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2616 : 114 : return;
2617 : : }
2618 [ + + # # : 185229 : TAILQ_INSERT_HEAD(&blob->persists_to_complete, ctx, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2619 : :
2620 [ # # # # ]: 185229 : bs_mark_dirty(seq, blob->bs, blob_persist_start, ctx);
2621 : 11399 : }
2622 : :
2623 : : struct spdk_blob_copy_cluster_ctx {
2624 : : struct spdk_blob *blob;
2625 : : uint8_t *buf;
2626 : : uint64_t io_unit;
2627 : : uint64_t new_cluster;
2628 : : uint32_t new_extent_page;
2629 : : spdk_bs_sequence_t *seq;
2630 : : struct spdk_blob_md_page *new_cluster_page;
2631 : : };
2632 : :
2633 : : struct spdk_blob_free_cluster_ctx {
2634 : : struct spdk_blob *blob;
2635 : : uint64_t page;
2636 : : struct spdk_blob_md_page *md_page;
2637 : : uint64_t cluster_num;
2638 : : uint32_t extent_page;
2639 : : spdk_bs_sequence_t *seq;
2640 : : };
2641 : :
2642 : : static void
2643 : 36411 : blob_allocate_and_copy_cluster_cpl(void *cb_arg, int bserrno)
2644 : : {
2645 : 36411 : struct spdk_blob_copy_cluster_ctx *ctx = cb_arg;
2646 [ # # # # ]: 36411 : struct spdk_bs_request_set *set = (struct spdk_bs_request_set *)ctx->seq;
2647 : 35386 : TAILQ_HEAD(, spdk_bs_request_set) requests;
2648 : : spdk_bs_user_op_t *op;
2649 : :
2650 [ # # ]: 36411 : TAILQ_INIT(&requests);
2651 [ + + + + : 36411 : TAILQ_SWAP(&set->channel->need_cluster_alloc, &requests, spdk_bs_request_set, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
2652 : :
2653 [ + + ]: 179540 : while (!TAILQ_EMPTY(&requests)) {
2654 : 143129 : op = TAILQ_FIRST(&requests);
2655 [ + + # # : 143129 : TAILQ_REMOVE(&requests, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
2656 [ + - ]: 143129 : if (bserrno == 0) {
2657 : 143129 : bs_user_op_execute(op);
2658 : 1025 : } else {
2659 : 0 : bs_user_op_abort(op, bserrno);
2660 : : }
2661 : : }
2662 : :
2663 [ # # # # ]: 36411 : spdk_free(ctx->buf);
2664 : 36411 : free(ctx);
2665 : 36411 : }
2666 : :
2667 : : static void
2668 : 300 : blob_free_cluster_cpl(void *cb_arg, int bserrno)
2669 : : {
2670 : 300 : struct spdk_blob_free_cluster_ctx *ctx = cb_arg;
2671 [ # # # # ]: 300 : spdk_bs_sequence_t *seq = ctx->seq;
2672 : :
2673 : 300 : bs_sequence_finish(seq, bserrno);
2674 : :
2675 : 300 : free(ctx);
2676 : 300 : }
2677 : :
2678 : : static void
2679 : 36 : blob_insert_cluster_revert(struct spdk_blob_copy_cluster_ctx *ctx)
2680 : : {
2681 [ # # # # : 36 : spdk_spin_lock(&ctx->blob->bs->used_lock);
# # # # #
# ]
2682 [ # # # # : 36 : bs_release_cluster(ctx->blob->bs, ctx->new_cluster);
# # # # #
# # # ]
2683 [ + + # # : 36 : if (ctx->new_extent_page != 0) {
# # ]
2684 [ # # # # : 13 : bs_release_md_page(ctx->blob->bs, ctx->new_extent_page);
# # # # #
# # # ]
2685 : 3 : }
2686 [ # # # # : 36 : spdk_spin_unlock(&ctx->blob->bs->used_lock);
# # # # #
# ]
2687 : 36 : }
2688 : :
2689 : : static void
2690 : 36 : blob_insert_cluster_clear_cpl(void *cb_arg, int bserrno)
2691 : : {
2692 : 36 : struct spdk_blob_copy_cluster_ctx *ctx = cb_arg;
2693 : :
2694 [ - + ]: 36 : if (bserrno) {
2695 : 0 : SPDK_WARNLOG("Failed to clear cluster: %d\n", bserrno);
2696 : 0 : }
2697 : :
2698 : 36 : blob_insert_cluster_revert(ctx);
2699 [ # # # # ]: 36 : bs_sequence_finish(ctx->seq, bserrno);
2700 : 36 : }
2701 : :
2702 : : static void
2703 : 36 : blob_insert_cluster_clear(struct spdk_blob_copy_cluster_ctx *ctx)
2704 : : {
2705 : 31 : struct spdk_bs_cpl cpl;
2706 : : spdk_bs_batch_t *batch;
2707 [ # # # # : 36 : struct spdk_io_channel *ch = spdk_io_channel_from_ctx(ctx->seq->channel);
# # # # ]
2708 : :
2709 : : /*
2710 : : * We allocated a cluster and we copied data to it. But now, we realized that we don't need
2711 : : * this cluster and we want to release it. We must ensure that we clear the data on this
2712 : : * cluster.
2713 : : * The cluster may later be re-allocated by a thick-provisioned blob for example. When
2714 : : * reading from this thick-provisioned blob before writing data, we should read zeroes.
2715 : : */
2716 : :
2717 : 36 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
2718 [ # # # # : 36 : cpl.u.blob_basic.cb_fn = blob_insert_cluster_clear_cpl;
# # ]
2719 [ # # # # : 36 : cpl.u.blob_basic.cb_arg = ctx;
# # ]
2720 : :
2721 [ # # # # ]: 36 : batch = bs_batch_open(ch, &cpl, ctx->blob);
2722 [ - + ]: 36 : if (!batch) {
2723 : 0 : blob_insert_cluster_clear_cpl(ctx, -ENOMEM);
2724 : 0 : return;
2725 : : }
2726 : :
2727 [ # # # # : 41 : bs_batch_clear_dev(ctx->blob, batch, bs_cluster_to_lba(ctx->blob->bs, ctx->new_cluster),
# # # # #
# # # # #
# # ]
2728 [ # # # # : 36 : bs_cluster_to_lba(ctx->blob->bs, 1));
# # # # ]
2729 : 36 : bs_batch_close(batch);
2730 : 5 : }
2731 : :
2732 : : static void
2733 : 36411 : blob_insert_cluster_cpl(void *cb_arg, int bserrno)
2734 : : {
2735 : 36411 : struct spdk_blob_copy_cluster_ctx *ctx = cb_arg;
2736 : :
2737 [ + + ]: 36411 : if (bserrno) {
2738 [ + - ]: 36 : if (bserrno == -EEXIST) {
2739 : : /* The metadata insert failed because another thread
2740 : : * allocated the cluster first. Clear and free our cluster
2741 : : * but continue without error. */
2742 : 36 : blob_insert_cluster_clear(ctx);
2743 : 36 : return;
2744 : : }
2745 : :
2746 : 0 : blob_insert_cluster_revert(ctx);
2747 : 0 : }
2748 : :
2749 [ # # # # ]: 36375 : bs_sequence_finish(ctx->seq, bserrno);
2750 : 1025 : }
2751 : :
2752 : : static void
2753 : 2207 : blob_write_copy_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2754 : : {
2755 : 2207 : struct spdk_blob_copy_cluster_ctx *ctx = cb_arg;
2756 : : uint32_t cluster_number;
2757 : :
2758 [ - + ]: 2207 : if (bserrno) {
2759 : : /* The write failed, so jump to the final completion handler */
2760 : 0 : bs_sequence_finish(seq, bserrno);
2761 : 0 : return;
2762 : : }
2763 : :
2764 [ # # # # : 2207 : cluster_number = bs_io_unit_to_cluster(ctx->blob->bs, ctx->io_unit);
# # # # #
# # # ]
2765 : :
2766 [ # # # # : 2722 : blob_insert_cluster_on_md_thread(ctx->blob, cluster_number, ctx->new_cluster,
# # # # ]
2767 [ # # # # : 515 : ctx->new_extent_page, ctx->new_cluster_page, blob_insert_cluster_cpl, ctx);
# # # # ]
2768 : 515 : }
2769 : :
2770 : : static void
2771 : 1633 : blob_write_copy(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
2772 : : {
2773 : 1633 : struct spdk_blob_copy_cluster_ctx *ctx = cb_arg;
2774 : :
2775 [ - + ]: 1633 : if (bserrno != 0) {
2776 : : /* The read failed, so jump to the final completion handler */
2777 : 0 : bs_sequence_finish(seq, bserrno);
2778 : 0 : return;
2779 : : }
2780 : :
2781 : : /* Write whole cluster */
2782 [ # # # # ]: 2018 : bs_sequence_write_dev(seq, ctx->buf,
2783 [ # # # # : 1633 : bs_cluster_to_lba(ctx->blob->bs, ctx->new_cluster),
# # # # #
# # # ]
2784 [ # # # # : 1633 : bs_cluster_to_lba(ctx->blob->bs, 1),
# # # # ]
2785 : 385 : blob_write_copy_cpl, ctx);
2786 : 385 : }
2787 : :
2788 : : static bool
2789 : 36332 : blob_can_copy(struct spdk_blob *blob, uint64_t cluster_start_io_unit, uint64_t *base_lba)
2790 : : {
2791 [ # # # # ]: 36332 : uint64_t lba = bs_dev_io_unit_to_lba(blob, blob->back_bs_dev, cluster_start_io_unit);
2792 : :
2793 [ + + + + : 39318 : return (!blob_is_esnap_clone(blob) && blob->bs->dev->copy != NULL) &&
+ + # # #
# # # # #
# # ]
2794 [ # # # # : 2986 : blob->back_bs_dev->translate_lba(blob->back_bs_dev, lba, base_lba);
# # # # #
# # # # #
# # ]
2795 : : }
2796 : :
2797 : : static void
2798 : 574 : blob_copy(struct spdk_blob_copy_cluster_ctx *ctx, spdk_bs_user_op_t *op, uint64_t src_lba)
2799 : : {
2800 [ # # # # ]: 574 : struct spdk_blob *blob = ctx->blob;
2801 [ # # # # : 574 : uint64_t lba_count = bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz);
# # # # #
# # # ]
2802 : :
2803 [ # # # # ]: 704 : bs_sequence_copy_dev(ctx->seq,
2804 [ # # # # : 574 : bs_cluster_to_lba(blob->bs, ctx->new_cluster),
# # # # ]
2805 : 130 : src_lba,
2806 : 130 : lba_count,
2807 : 130 : blob_write_copy_cpl, ctx);
2808 : 574 : }
2809 : :
2810 : : static void
2811 : 143130 : bs_allocate_and_copy_cluster(struct spdk_blob *blob,
2812 : : struct spdk_io_channel *_ch,
2813 : : uint64_t io_unit, spdk_bs_user_op_t *op)
2814 : : {
2815 : 142105 : struct spdk_bs_cpl cpl;
2816 : : struct spdk_bs_channel *ch;
2817 : : struct spdk_blob_copy_cluster_ctx *ctx;
2818 : : uint64_t cluster_start_io_unit;
2819 : : uint32_t cluster_number;
2820 : : bool is_zeroes;
2821 : : bool can_copy;
2822 : : bool is_valid_range;
2823 : 142105 : uint64_t copy_src_lba;
2824 : : int rc;
2825 : :
2826 : 143130 : ch = spdk_io_channel_get_ctx(_ch);
2827 : :
2828 [ + + # # : 143130 : if (!TAILQ_EMPTY(&ch->need_cluster_alloc)) {
# # # # ]
2829 : : /* There are already operations pending. Queue this user op
2830 : : * and return because it will be re-executed when the outstanding
2831 : : * cluster allocation completes. */
2832 [ # # # # : 106718 : TAILQ_INSERT_TAIL(&ch->need_cluster_alloc, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2833 : 106718 : return;
2834 : : }
2835 : :
2836 : : /* Round the io_unit offset down to the first io_unit in the cluster */
2837 : 36412 : cluster_start_io_unit = bs_io_unit_to_cluster_start(blob, io_unit);
2838 : :
2839 : : /* Calculate which index in the metadata cluster array the corresponding
2840 : : * cluster is supposed to be at. */
2841 : 36412 : cluster_number = bs_io_unit_to_cluster_number(blob, io_unit);
2842 : :
2843 : 36412 : ctx = calloc(1, sizeof(*ctx));
2844 [ + + ]: 36412 : if (!ctx) {
2845 : 0 : bs_user_op_abort(op, -ENOMEM);
2846 : 0 : return;
2847 : : }
2848 : :
2849 [ - + - + : 36412 : assert(blob->bs->cluster_sz % blob->back_bs_dev->blocklen == 0);
# # # # #
# # # # #
# # # # #
# # # ]
2850 : :
2851 [ # # # # ]: 36412 : ctx->blob = blob;
2852 [ # # # # ]: 36412 : ctx->io_unit = cluster_start_io_unit;
2853 [ # # # # : 36412 : ctx->new_cluster_page = ch->new_cluster_page;
# # # # ]
2854 [ - + # # : 36412 : memset(ctx->new_cluster_page, 0, blob->bs->md_page_size);
# # # # #
# # # #
# ]
2855 : :
2856 : : /* Check if the cluster that we intend to do CoW for is valid for
2857 : : * the backing dev. For zeroes backing dev, it'll be always valid.
2858 : : * For other backing dev e.g. a snapshot, it could be invalid if
2859 : : * the blob has been resized after snapshot was taken. */
2860 [ # # # # : 72824 : is_valid_range = blob->back_bs_dev->is_range_valid(blob->back_bs_dev,
# # # # #
# # # # #
# # ]
2861 [ # # # # ]: 1025 : bs_dev_io_unit_to_lba(blob, blob->back_bs_dev, cluster_start_io_unit),
2862 [ # # # # : 36412 : bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz));
# # # # #
# # # ]
2863 : :
2864 [ + + + + ]: 36412 : can_copy = is_valid_range && blob_can_copy(blob, cluster_start_io_unit, ©_src_lba);
2865 : :
2866 [ + + + + : 71739 : is_zeroes = is_valid_range && blob->back_bs_dev->is_zeroes(blob->back_bs_dev,
# # # # #
# # # # #
# # # # #
# ]
2867 [ # # # # ]: 1005 : bs_dev_io_unit_to_lba(blob, blob->back_bs_dev, cluster_start_io_unit),
2868 [ # # # # : 36332 : bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz));
# # # # #
# # # ]
2869 [ + + + + : 36412 : if (blob->parent_id != SPDK_BLOBID_INVALID && !is_zeroes && !can_copy) {
+ + # # #
# # # #
# ]
2870 [ # # # # : 1633 : ctx->buf = spdk_malloc(blob->bs->cluster_sz, blob->back_bs_dev->blocklen,
# # # # #
# # # # #
# # # # #
# ]
2871 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
2872 [ + + # # : 1633 : if (!ctx->buf) {
# # ]
2873 [ # # # # : 0 : SPDK_ERRLOG("DMA allocation for cluster of size = %" PRIu32 " failed.\n",
# # # # ]
2874 : : blob->bs->cluster_sz);
2875 : 0 : free(ctx);
2876 : 0 : bs_user_op_abort(op, -ENOMEM);
2877 : 0 : return;
2878 : : }
2879 : 385 : }
2880 : :
2881 [ # # # # : 36412 : spdk_spin_lock(&blob->bs->used_lock);
# # ]
2882 [ # # # # ]: 36412 : rc = bs_allocate_cluster(blob, cluster_number, &ctx->new_cluster, &ctx->new_extent_page,
2883 : : false);
2884 [ # # # # : 36412 : spdk_spin_unlock(&blob->bs->used_lock);
# # ]
2885 [ + + ]: 36412 : if (rc != 0) {
2886 [ # # # # ]: 1 : spdk_free(ctx->buf);
2887 : 1 : free(ctx);
2888 : 1 : bs_user_op_abort(op, rc);
2889 : 1 : return;
2890 : : }
2891 : :
2892 : 36411 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
2893 [ # # # # : 36411 : cpl.u.blob_basic.cb_fn = blob_allocate_and_copy_cluster_cpl;
# # ]
2894 [ # # # # : 36411 : cpl.u.blob_basic.cb_arg = ctx;
# # ]
2895 : :
2896 [ # # # # ]: 36411 : ctx->seq = bs_sequence_start_blob(_ch, &cpl, blob);
2897 [ + + # # : 36411 : if (!ctx->seq) {
# # ]
2898 [ # # # # : 0 : spdk_spin_lock(&blob->bs->used_lock);
# # ]
2899 [ # # # # : 0 : bs_release_cluster(blob->bs, ctx->new_cluster);
# # # # ]
2900 [ # # # # : 0 : spdk_spin_unlock(&blob->bs->used_lock);
# # ]
2901 [ # # # # ]: 0 : spdk_free(ctx->buf);
2902 : 0 : free(ctx);
2903 : 0 : bs_user_op_abort(op, -ENOMEM);
2904 : 0 : return;
2905 : : }
2906 : :
2907 : : /* Queue the user op to block other incoming operations */
2908 [ # # # # : 36411 : TAILQ_INSERT_TAIL(&ch->need_cluster_alloc, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
2909 : :
2910 [ + + + + : 36411 : if (blob->parent_id != SPDK_BLOBID_INVALID && !is_zeroes) {
# # # # #
# ]
2911 [ + + # # ]: 2207 : if (can_copy) {
2912 : 574 : blob_copy(ctx, op, copy_src_lba);
2913 : 130 : } else {
2914 : : /* Read cluster from backing device */
2915 [ # # # # : 2018 : bs_sequence_read_bs_dev(ctx->seq, blob->back_bs_dev, ctx->buf,
# # # # #
# # # ]
2916 [ # # # # ]: 385 : bs_dev_io_unit_to_lba(blob, blob->back_bs_dev, cluster_start_io_unit),
2917 [ # # # # : 1633 : bs_dev_byte_to_lba(blob->back_bs_dev, blob->bs->cluster_sz),
# # # # #
# # # ]
2918 : 385 : blob_write_copy, ctx);
2919 : : }
2920 : :
2921 : 515 : } else {
2922 [ # # # # : 34714 : blob_insert_cluster_on_md_thread(ctx->blob, cluster_number, ctx->new_cluster,
# # # # ]
2923 [ # # # # : 510 : ctx->new_extent_page, ctx->new_cluster_page, blob_insert_cluster_cpl, ctx);
# # # # ]
2924 : : }
2925 : 1025 : }
2926 : :
2927 : : static inline bool
2928 : 23406003 : blob_calculate_lba_and_lba_count(struct spdk_blob *blob, uint64_t io_unit, uint64_t length,
2929 : : uint64_t *lba, uint64_t *lba_count)
2930 : : {
2931 [ # # ]: 23406003 : *lba_count = length;
2932 : :
2933 [ + + ]: 23406003 : if (!bs_io_unit_is_allocated(blob, io_unit)) {
2934 [ + + # # : 1495753 : assert(blob->back_bs_dev != NULL);
# # # # ]
2935 [ # # ]: 1495753 : *lba = bs_io_unit_to_back_dev_lba(blob, io_unit);
2936 [ # # # # ]: 1495753 : *lba_count = bs_io_unit_to_back_dev_lba(blob, *lba_count);
2937 : 1495753 : return false;
2938 : : } else {
2939 [ # # ]: 21910250 : *lba = bs_blob_io_unit_to_lba(blob, io_unit);
2940 : 21910250 : return true;
2941 : : }
2942 : 56788 : }
2943 : :
2944 : : struct op_split_ctx {
2945 : : struct spdk_blob *blob;
2946 : : struct spdk_io_channel *channel;
2947 : : uint64_t io_unit_offset;
2948 : : uint64_t io_units_remaining;
2949 : : void *curr_payload;
2950 : : enum spdk_blob_op_type op_type;
2951 : : spdk_bs_sequence_t *seq;
2952 : : bool in_submit_ctx;
2953 : : bool completed_in_submit_ctx;
2954 : : bool done;
2955 : : };
2956 : :
2957 : : static void
2958 : 69247 : blob_request_submit_op_split_next(void *cb_arg, int bserrno)
2959 : : {
2960 : 69247 : struct op_split_ctx *ctx = cb_arg;
2961 [ # # # # ]: 69247 : struct spdk_blob *blob = ctx->blob;
2962 [ # # # # ]: 69247 : struct spdk_io_channel *ch = ctx->channel;
2963 [ # # # # ]: 69247 : enum spdk_blob_op_type op_type = ctx->op_type;
2964 : : uint8_t *buf;
2965 : : uint64_t offset;
2966 : : uint64_t length;
2967 : : uint64_t op_length;
2968 : :
2969 [ + - + + : 69247 : if (bserrno != 0 || ctx->io_units_remaining == 0) {
# # # # ]
2970 [ # # # # ]: 2869 : bs_sequence_finish(ctx->seq, bserrno);
2971 [ + + + + : 2869 : if (ctx->in_submit_ctx) {
# # # # ]
2972 : : /* Defer freeing of the ctx object, since it will be
2973 : : * accessed when this unwinds back to the submission
2974 : : * context.
2975 : : */
2976 [ # # # # ]: 200 : ctx->done = true;
2977 : 50 : } else {
2978 : 2669 : free(ctx);
2979 : : }
2980 : 2869 : return;
2981 : : }
2982 : :
2983 [ + + + + : 66378 : if (ctx->in_submit_ctx) {
# # # # ]
2984 : : /* If this split operation completed in the context
2985 : : * of its submission, mark the flag and return immediately
2986 : : * to avoid recursion.
2987 : : */
2988 [ # # # # ]: 340 : ctx->completed_in_submit_ctx = true;
2989 : 340 : return;
2990 : : }
2991 : :
2992 : 659 : while (true) {
2993 [ # # # # ]: 66378 : ctx->completed_in_submit_ctx = false;
2994 : :
2995 [ # # # # ]: 66378 : offset = ctx->io_unit_offset;
2996 [ # # # # ]: 66378 : length = ctx->io_units_remaining;
2997 [ # # # # ]: 66378 : buf = ctx->curr_payload;
2998 [ + + ]: 66378 : op_length = spdk_min(length, bs_num_io_units_to_cluster_boundary(blob,
2999 : : offset));
3000 : :
3001 : : /* Update length and payload for next operation */
3002 [ # # # # ]: 66378 : ctx->io_units_remaining -= op_length;
3003 [ # # # # ]: 66378 : ctx->io_unit_offset += op_length;
3004 [ + + + + ]: 66378 : if (op_type == SPDK_BLOB_WRITE || op_type == SPDK_BLOB_READ) {
3005 [ # # # # : 2636 : ctx->curr_payload += op_length * blob->bs->io_unit_size;
# # # # #
# # # ]
3006 : 659 : }
3007 : :
3008 [ + + - + : 66378 : assert(!ctx->in_submit_ctx);
# # # # #
# ]
3009 [ # # # # ]: 66378 : ctx->in_submit_ctx = true;
3010 : :
3011 [ + + + + : 66378 : switch (op_type) {
+ + ]
3012 : 1566 : case SPDK_BLOB_READ:
3013 : 2610 : spdk_blob_io_read(blob, ch, buf, offset, op_length,
3014 : 522 : blob_request_submit_op_split_next, ctx);
3015 : 2088 : break;
3016 : 411 : case SPDK_BLOB_WRITE:
3017 : 685 : spdk_blob_io_write(blob, ch, buf, offset, op_length,
3018 : 137 : blob_request_submit_op_split_next, ctx);
3019 : 548 : break;
3020 : 63395 : case SPDK_BLOB_UNMAP:
3021 : 63485 : spdk_blob_io_unmap(blob, ch, offset, op_length,
3022 : 45 : blob_request_submit_op_split_next, ctx);
3023 : 63440 : break;
3024 : 262 : case SPDK_BLOB_WRITE_ZEROES:
3025 : 342 : spdk_blob_io_write_zeroes(blob, ch, offset, op_length,
3026 : 40 : blob_request_submit_op_split_next, ctx);
3027 : 302 : break;
3028 : 0 : case SPDK_BLOB_READV:
3029 : : case SPDK_BLOB_WRITEV:
3030 : 0 : SPDK_ERRLOG("readv/write not valid\n");
3031 [ # # # # ]: 0 : bs_sequence_finish(ctx->seq, -EINVAL);
3032 : 0 : free(ctx);
3033 : 0 : return;
3034 : : }
3035 : :
3036 : : #ifndef __clang_analyzer__
3037 : : /* scan-build reports a false positive around accessing the ctx here. It
3038 : : * forms a path that recursively calls this function, but then says
3039 : : * "assuming ctx->in_submit_ctx is false", when that isn't possible.
3040 : : * This path does free(ctx), returns to here, and reports a use-after-free
3041 : : * bug. Wrapping this bit of code so that scan-build doesn't see it
3042 : : * works around the scan-build bug.
3043 : : */
3044 [ - + - + : 66378 : assert(ctx->in_submit_ctx);
# # # # #
# ]
3045 [ # # # # ]: 66378 : ctx->in_submit_ctx = false;
3046 : :
3047 : : /* If the operation completed immediately, loop back and submit the
3048 : : * next operation. Otherwise we can return and the next split
3049 : : * operation will get submitted when this current operation is
3050 : : * later completed asynchronously.
3051 : : */
3052 [ + + + + : 66378 : if (ctx->completed_in_submit_ctx) {
# # # # ]
3053 : 340 : continue;
3054 [ + + + + : 66038 : } else if (ctx->done) {
# # # # ]
3055 : 200 : free(ctx);
3056 : 50 : }
3057 : : #endif
3058 : 66038 : break;
3059 : : }
3060 : 966 : }
3061 : :
3062 : : static void
3063 : 2869 : blob_request_submit_op_split(struct spdk_io_channel *ch, struct spdk_blob *blob,
3064 : : void *payload, uint64_t offset, uint64_t length,
3065 : : spdk_blob_op_complete cb_fn, void *cb_arg, enum spdk_blob_op_type op_type)
3066 : : {
3067 : : struct op_split_ctx *ctx;
3068 : : spdk_bs_sequence_t *seq;
3069 : 2647 : struct spdk_bs_cpl cpl;
3070 : :
3071 [ + + # # ]: 2869 : assert(blob != NULL);
3072 : :
3073 : 2869 : ctx = calloc(1, sizeof(struct op_split_ctx));
3074 [ + + ]: 2869 : if (ctx == NULL) {
3075 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3076 : 0 : return;
3077 : : }
3078 : :
3079 : 2869 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
3080 [ # # # # : 2869 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
3081 [ # # # # : 2869 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
3082 : :
3083 : 2869 : seq = bs_sequence_start_blob(ch, &cpl, blob);
3084 [ + + ]: 2869 : if (!seq) {
3085 : 0 : free(ctx);
3086 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3087 : 0 : return;
3088 : : }
3089 : :
3090 [ # # # # ]: 2869 : ctx->blob = blob;
3091 [ # # # # ]: 2869 : ctx->channel = ch;
3092 [ # # # # ]: 2869 : ctx->curr_payload = payload;
3093 [ # # # # ]: 2869 : ctx->io_unit_offset = offset;
3094 [ # # # # ]: 2869 : ctx->io_units_remaining = length;
3095 [ # # # # ]: 2869 : ctx->op_type = op_type;
3096 [ # # # # ]: 2869 : ctx->seq = seq;
3097 : :
3098 : 2869 : blob_request_submit_op_split_next(ctx, 0);
3099 : 222 : }
3100 : :
3101 : : static void
3102 : 300 : spdk_free_cluster_unmap_complete(void *cb_arg, int bserrno)
3103 : : {
3104 : 300 : struct spdk_blob_free_cluster_ctx *ctx = cb_arg;
3105 : :
3106 [ - + ]: 300 : if (bserrno) {
3107 [ # # # # ]: 0 : bs_sequence_finish(ctx->seq, bserrno);
3108 : 0 : free(ctx);
3109 : 0 : return;
3110 : : }
3111 : :
3112 [ # # # # : 375 : blob_free_cluster_on_md_thread(ctx->blob, ctx->cluster_num,
# # # # ]
3113 [ # # # # : 75 : ctx->extent_page, ctx->md_page, blob_free_cluster_cpl, ctx);
# # # # ]
3114 : 75 : }
3115 : :
3116 : : static void
3117 : 5127373 : blob_request_submit_op_single(struct spdk_io_channel *_ch, struct spdk_blob *blob,
3118 : : void *payload, uint64_t offset, uint64_t length,
3119 : : spdk_blob_op_complete cb_fn, void *cb_arg, enum spdk_blob_op_type op_type)
3120 : : {
3121 : 5074543 : struct spdk_bs_cpl cpl;
3122 : 5074543 : uint64_t lba;
3123 : 5074543 : uint64_t lba_count;
3124 : : bool is_allocated;
3125 : :
3126 [ + + # # ]: 5127373 : assert(blob != NULL);
3127 : :
3128 : 5127373 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
3129 [ # # # # : 5127373 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
3130 [ # # # # : 5127373 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
3131 : :
3132 [ + + # # : 5127373 : if (blob->frozen_refcnt) {
# # ]
3133 : : /* This blob I/O is frozen */
3134 : : spdk_bs_user_op_t *op;
3135 : 78 : struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_ch);
3136 : :
3137 : 78 : op = bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length);
3138 [ + + ]: 78 : if (!op) {
3139 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3140 : 0 : return;
3141 : : }
3142 : :
3143 [ # # # # : 78 : TAILQ_INSERT_TAIL(&bs_channel->queued_io, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
3144 : :
3145 : 78 : return;
3146 : : }
3147 : :
3148 : 5127295 : is_allocated = blob_calculate_lba_and_lba_count(blob, offset, length, &lba, &lba_count);
3149 : :
3150 [ + + + + : 5127295 : switch (op_type) {
+ ]
3151 : 4082261 : case SPDK_BLOB_READ: {
3152 : : spdk_bs_batch_t *batch;
3153 : :
3154 : 4107638 : batch = bs_batch_open(_ch, &cpl, blob);
3155 [ + + ]: 4107638 : if (!batch) {
3156 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3157 : 0 : return;
3158 : : }
3159 : :
3160 [ + + # # ]: 4107638 : if (is_allocated) {
3161 : : /* Read from the blob */
3162 : 4100254 : bs_batch_read_dev(batch, payload, lba, lba_count);
3163 : 23531 : } else {
3164 : : /* Read from the backing block device */
3165 [ # # # # ]: 7384 : bs_batch_read_bs_dev(batch, blob->back_bs_dev, payload, lba, lba_count);
3166 : : }
3167 : :
3168 : 4107638 : bs_batch_close(batch);
3169 : 4107638 : break;
3170 : : }
3171 : 781252 : case SPDK_BLOB_WRITE:
3172 : : case SPDK_BLOB_WRITE_ZEROES: {
3173 [ + + # # ]: 808580 : if (is_allocated) {
3174 : : /* Write to the blob */
3175 : : spdk_bs_batch_t *batch;
3176 : :
3177 [ + + ]: 806820 : if (lba_count == 0) {
3178 [ # # # # ]: 0 : cb_fn(cb_arg, 0);
3179 : 0 : return;
3180 : : }
3181 : :
3182 : 806820 : batch = bs_batch_open(_ch, &cpl, blob);
3183 [ + + ]: 806820 : if (!batch) {
3184 [ # # # # ]: 53 : cb_fn(cb_arg, -ENOMEM);
3185 : 53 : return;
3186 : : }
3187 : :
3188 [ + + ]: 806767 : if (op_type == SPDK_BLOB_WRITE) {
3189 : 804481 : bs_batch_write_dev(batch, payload, lba, lba_count);
3190 : 26848 : } else {
3191 : 2286 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
3192 : : }
3193 : :
3194 : 806767 : bs_batch_close(batch);
3195 : 26888 : } else {
3196 : : /* Queue this operation and allocate the cluster */
3197 : : spdk_bs_user_op_t *op;
3198 : :
3199 : 1760 : op = bs_user_op_alloc(_ch, &cpl, op_type, blob, payload, 0, offset, length);
3200 [ + + ]: 1760 : if (!op) {
3201 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3202 : 0 : return;
3203 : : }
3204 : :
3205 : 1760 : bs_allocate_and_copy_cluster(blob, _ch, offset, op);
3206 : : }
3207 : 808527 : break;
3208 : : }
3209 : 210957 : case SPDK_BLOB_UNMAP: {
3210 : 211077 : struct spdk_blob_free_cluster_ctx *ctx = NULL;
3211 : : spdk_bs_batch_t *batch;
3212 : :
3213 : : /* if aligned with cluster release cluster */
3214 [ + + + - : 211432 : if (spdk_blob_is_thin_provisioned(blob) && is_allocated &&
+ + # # ]
3215 [ + + ]: 615 : blob_backed_with_zeroes_dev(blob) &&
3216 : 340 : bs_io_units_per_cluster(blob) == length) {
3217 : 300 : struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_ch);
3218 : : uint64_t cluster_start_page;
3219 : : uint32_t cluster_number;
3220 : :
3221 [ + + - + : 300 : assert(offset % bs_io_units_per_cluster(blob) == 0);
# # ]
3222 : :
3223 : : /* Round the io_unit offset down to the first page in the cluster */
3224 : 300 : cluster_start_page = bs_io_unit_to_cluster_start(blob, offset);
3225 : :
3226 : : /* Calculate which index in the metadata cluster array the corresponding
3227 : : * cluster is supposed to be at. */
3228 : 300 : cluster_number = bs_io_unit_to_cluster_number(blob, offset);
3229 : :
3230 : 300 : ctx = calloc(1, sizeof(*ctx));
3231 [ + + ]: 300 : if (!ctx) {
3232 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3233 : 0 : return;
3234 : : }
3235 : : /* When freeing a cluster the flow should be (in order):
3236 : : * 1. Unmap the underlying area (so if the cluster is reclaimed in the future, it won't leak
3237 : : * old data)
3238 : : * 2. Once the unmap completes (to avoid any races with incoming writes that may claim the
3239 : : * cluster), update and sync metadata freeing the cluster
3240 : : * 3. Once metadata update is done, complete the user unmap request
3241 : : */
3242 [ # # # # ]: 300 : ctx->blob = blob;
3243 [ # # # # ]: 300 : ctx->page = cluster_start_page;
3244 [ # # # # ]: 300 : ctx->cluster_num = cluster_number;
3245 [ # # # # : 300 : ctx->md_page = bs_channel->new_cluster_page;
# # # # ]
3246 [ # # # # ]: 300 : ctx->seq = bs_sequence_start_bs(_ch, &cpl);
3247 [ - + # # : 300 : if (!ctx->seq) {
# # ]
3248 : 0 : free(ctx);
3249 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3250 : 0 : return;
3251 : : }
3252 : :
3253 [ + + + + : 300 : if (blob->use_extent_table) {
# # # # ]
3254 [ # # # # : 180 : ctx->extent_page = *bs_cluster_to_extent_page(blob, cluster_number);
# # ]
3255 : 45 : }
3256 : :
3257 [ # # # # : 300 : cpl.u.blob_basic.cb_fn = spdk_free_cluster_unmap_complete;
# # ]
3258 [ # # # # : 300 : cpl.u.blob_basic.cb_arg = ctx;
# # ]
3259 : 75 : }
3260 : :
3261 : 211077 : batch = bs_batch_open(_ch, &cpl, blob);
3262 [ + + ]: 211077 : if (!batch) {
3263 : 0 : free(ctx);
3264 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3265 : 0 : return;
3266 : : }
3267 : :
3268 [ + + # # ]: 211077 : if (is_allocated) {
3269 : 211077 : bs_batch_unmap_dev(batch, lba, lba_count);
3270 : 120 : }
3271 : :
3272 : 211077 : bs_batch_close(batch);
3273 : 211077 : break;
3274 : : }
3275 : 0 : case SPDK_BLOB_READV:
3276 : : case SPDK_BLOB_WRITEV:
3277 : 0 : SPDK_ERRLOG("readv/write not valid\n");
3278 [ # # # # ]: 0 : cb_fn(cb_arg, -EINVAL);
3279 : 0 : break;
3280 : : }
3281 : 52830 : }
3282 : :
3283 : : static void
3284 : 5132843 : blob_request_submit_op(struct spdk_blob *blob, struct spdk_io_channel *_channel,
3285 : : void *payload, uint64_t offset, uint64_t length,
3286 : : spdk_blob_op_complete cb_fn, void *cb_arg, enum spdk_blob_op_type op_type)
3287 : : {
3288 [ + + # # ]: 5132843 : assert(blob != NULL);
3289 : :
3290 [ + + + + : 5132843 : if (blob->data_ro && op_type != SPDK_BLOB_READ) {
+ + # # #
# ]
3291 [ # # # # ]: 20 : cb_fn(cb_arg, -EPERM);
3292 : 20 : return;
3293 : : }
3294 : :
3295 [ + + ]: 5132823 : if (length == 0) {
3296 [ # # # # ]: 2503 : cb_fn(cb_arg, 0);
3297 : 2503 : return;
3298 : : }
3299 : :
3300 [ + + # # : 5130320 : if (offset + length > bs_cluster_to_lba(blob->bs, blob->active.num_clusters)) {
# # # # #
# # # ]
3301 [ # # # # ]: 120 : cb_fn(cb_arg, -EINVAL);
3302 : 120 : return;
3303 : : }
3304 [ + + ]: 5130200 : if (length <= bs_num_io_units_to_cluster_boundary(blob, offset)) {
3305 : 5180151 : blob_request_submit_op_single(_channel, blob, payload, offset, length,
3306 : 52820 : cb_fn, cb_arg, op_type);
3307 : 52820 : } else {
3308 : 3091 : blob_request_submit_op_split(_channel, blob, payload, offset, length,
3309 : 222 : cb_fn, cb_arg, op_type);
3310 : : }
3311 : 53692 : }
3312 : :
3313 : : struct rw_iov_ctx {
3314 : : struct spdk_blob *blob;
3315 : : struct spdk_io_channel *channel;
3316 : : spdk_blob_op_complete cb_fn;
3317 : : void *cb_arg;
3318 : : bool read;
3319 : : int iovcnt;
3320 : : struct iovec *orig_iov;
3321 : : uint64_t io_unit_offset;
3322 : : uint64_t io_units_remaining;
3323 : : uint64_t io_units_done;
3324 : : struct spdk_blob_ext_io_opts *ext_io_opts;
3325 : : struct iovec iov[0];
3326 : : };
3327 : :
3328 : : static void
3329 : 18068126 : rw_iov_done(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
3330 : : {
3331 [ + + # # ]: 18068126 : assert(cb_arg == NULL);
3332 : 18068126 : bs_sequence_finish(seq, bserrno);
3333 : 18068126 : }
3334 : :
3335 : : static void
3336 : 3720 : rw_iov_split_next(void *cb_arg, int bserrno)
3337 : : {
3338 : 3720 : struct rw_iov_ctx *ctx = cb_arg;
3339 [ # # # # ]: 3720 : struct spdk_blob *blob = ctx->blob;
3340 : : struct iovec *iov, *orig_iov;
3341 : : int iovcnt;
3342 : : size_t orig_iovoff;
3343 : : uint64_t io_units_count, io_units_to_boundary, io_unit_offset;
3344 : : uint64_t byte_count;
3345 : :
3346 [ + - + + : 3720 : if (bserrno != 0 || ctx->io_units_remaining == 0) {
# # # # ]
3347 [ # # # # : 1020 : ctx->cb_fn(ctx->cb_arg, bserrno);
# # # # #
# # # ]
3348 : 1020 : free(ctx);
3349 : 1020 : return;
3350 : : }
3351 : :
3352 [ # # # # ]: 2700 : io_unit_offset = ctx->io_unit_offset;
3353 : 2700 : io_units_to_boundary = bs_num_io_units_to_cluster_boundary(blob, io_unit_offset);
3354 [ + + # # : 2700 : io_units_count = spdk_min(ctx->io_units_remaining, io_units_to_boundary);
# # # # #
# ]
3355 : : /*
3356 : : * Get index and offset into the original iov array for our current position in the I/O sequence.
3357 : : * byte_count will keep track of how many bytes remaining until orig_iov and orig_iovoff will
3358 : : * point to the current position in the I/O sequence.
3359 : : */
3360 [ # # # # : 2700 : byte_count = ctx->io_units_done * blob->bs->io_unit_size;
# # # # #
# # # ]
3361 [ # # # # : 2700 : orig_iov = &ctx->orig_iov[0];
# # ]
3362 : 2700 : orig_iovoff = 0;
3363 [ + + ]: 5740 : while (byte_count > 0) {
3364 [ + + # # : 3040 : if (byte_count >= orig_iov->iov_len) {
# # ]
3365 [ # # # # ]: 1760 : byte_count -= orig_iov->iov_len;
3366 [ # # ]: 1760 : orig_iov++;
3367 : 440 : } else {
3368 : 1280 : orig_iovoff = byte_count;
3369 : 1280 : byte_count = 0;
3370 : : }
3371 : : }
3372 : :
3373 : : /*
3374 : : * Build an iov array for the next I/O in the sequence. byte_count will keep track of how many
3375 : : * bytes of this next I/O remain to be accounted for in the new iov array.
3376 : : */
3377 [ # # # # : 2700 : byte_count = io_units_count * blob->bs->io_unit_size;
# # # # ]
3378 [ # # # # ]: 2700 : iov = &ctx->iov[0];
3379 : 2700 : iovcnt = 0;
3380 [ + + ]: 6900 : while (byte_count > 0) {
3381 [ + + # # : 4200 : assert(iovcnt < ctx->iovcnt);
# # # # ]
3382 [ + + # # : 4200 : iov->iov_len = spdk_min(byte_count, orig_iov->iov_len - orig_iovoff);
# # # # #
# # # #
# ]
3383 [ # # # # : 4200 : iov->iov_base = orig_iov->iov_base + orig_iovoff;
# # # # ]
3384 [ # # # # ]: 4200 : byte_count -= iov->iov_len;
3385 : 4200 : orig_iovoff = 0;
3386 [ # # ]: 4200 : orig_iov++;
3387 [ # # ]: 4200 : iov++;
3388 [ # # ]: 4200 : iovcnt++;
3389 : : }
3390 : :
3391 [ # # # # ]: 2700 : ctx->io_unit_offset += io_units_count;
3392 [ # # # # ]: 2700 : ctx->io_units_remaining -= io_units_count;
3393 [ # # # # ]: 2700 : ctx->io_units_done += io_units_count;
3394 [ # # # # ]: 2700 : iov = &ctx->iov[0];
3395 : :
3396 [ + + + + : 2700 : if (ctx->read) {
# # # # ]
3397 [ # # # # : 2550 : spdk_blob_io_readv_ext(ctx->blob, ctx->channel, iov, iovcnt, io_unit_offset,
# # # # ]
3398 [ # # # # ]: 510 : io_units_count, rw_iov_split_next, ctx, ctx->ext_io_opts);
3399 : 510 : } else {
3400 [ # # # # : 825 : spdk_blob_io_writev_ext(ctx->blob, ctx->channel, iov, iovcnt, io_unit_offset,
# # # # ]
3401 [ # # # # ]: 165 : io_units_count, rw_iov_split_next, ctx, ctx->ext_io_opts);
3402 : : }
3403 : 930 : }
3404 : :
3405 : : static void
3406 : 18282507 : blob_request_submit_rw_iov(struct spdk_blob *blob, struct spdk_io_channel *_channel,
3407 : : struct iovec *iov, int iovcnt,
3408 : : uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg, bool read,
3409 : : struct spdk_blob_ext_io_opts *ext_io_opts)
3410 : : {
3411 : 18278279 : struct spdk_bs_cpl cpl;
3412 : :
3413 [ + + # # ]: 18282507 : assert(blob != NULL);
3414 : :
3415 [ + + + + : 18282507 : if (!read && blob->data_ro) {
+ + # # #
# # # ]
3416 [ # # # # ]: 54 : cb_fn(cb_arg, -EPERM);
3417 : 54 : return;
3418 : : }
3419 : :
3420 [ + + ]: 18282453 : if (length == 0) {
3421 [ # # # # ]: 0 : cb_fn(cb_arg, 0);
3422 : 0 : return;
3423 : : }
3424 : :
3425 [ - + # # : 18282453 : if (offset + length > bs_cluster_to_lba(blob->bs, blob->active.num_clusters)) {
# # # # #
# # # ]
3426 [ # # # # ]: 0 : cb_fn(cb_arg, -EINVAL);
3427 : 0 : return;
3428 : : }
3429 : :
3430 : : /*
3431 : : * For now, we implement readv/writev using a sequence (instead of a batch) to account for having
3432 : : * to split a request that spans a cluster boundary. For I/O that do not span a cluster boundary,
3433 : : * there will be no noticeable difference compared to using a batch. For I/O that do span a cluster
3434 : : * boundary, the target LBAs (after blob offset to LBA translation) may not be contiguous, so we need
3435 : : * to allocate a separate iov array and split the I/O such that none of the resulting
3436 : : * smaller I/O cross a cluster boundary. These smaller I/O will be issued in sequence (not in parallel)
3437 : : * but since this case happens very infrequently, any performance impact will be negligible.
3438 : : *
3439 : : * This could be optimized in the future to allocate a big enough iov array to account for all of the iovs
3440 : : * for all of the smaller I/Os, pre-build all of the iov arrays for the smaller I/Os, then issue them
3441 : : * in a batch. That would also require creating an intermediate spdk_bs_cpl that would get called
3442 : : * when the batch was completed, to allow for freeing the memory for the iov arrays.
3443 : : */
3444 [ + + ]: 18282453 : if (spdk_likely(length <= bs_num_io_units_to_cluster_boundary(blob, offset))) {
3445 : 18277450 : uint64_t lba_count;
3446 : 18277450 : uint64_t lba;
3447 : : bool is_allocated;
3448 : :
3449 : 18281413 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
3450 [ # # # # : 18281413 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
3451 [ # # # # : 18281413 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
3452 : :
3453 [ + + # # : 18281413 : if (blob->frozen_refcnt) {
# # ]
3454 : : /* This blob I/O is frozen */
3455 : : enum spdk_blob_op_type op_type;
3456 : : spdk_bs_user_op_t *op;
3457 : 2705 : struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(_channel);
3458 : :
3459 [ - + ]: 2705 : op_type = read ? SPDK_BLOB_READV : SPDK_BLOB_WRITEV;
3460 : 2705 : op = bs_user_op_alloc(_channel, &cpl, op_type, blob, iov, iovcnt, offset, length);
3461 [ - + ]: 2705 : if (!op) {
3462 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3463 : 0 : return;
3464 : : }
3465 : :
3466 [ # # # # : 2705 : TAILQ_INSERT_TAIL(&bs_channel->queued_io, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
3467 : :
3468 : 2705 : return;
3469 : : }
3470 : :
3471 : 18278708 : is_allocated = blob_calculate_lba_and_lba_count(blob, offset, length, &lba, &lba_count);
3472 : :
3473 [ + + # # ]: 18278708 : if (read) {
3474 : : spdk_bs_sequence_t *seq;
3475 : :
3476 : 8424751 : seq = bs_sequence_start_blob(_channel, &cpl, blob);
3477 [ + + ]: 8424751 : if (!seq) {
3478 [ # # # # ]: 730 : cb_fn(cb_arg, -ENOMEM);
3479 : 730 : return;
3480 : : }
3481 : :
3482 [ # # # # ]: 8424021 : seq->ext_io_opts = ext_io_opts;
3483 : :
3484 [ + + # # ]: 8424021 : if (is_allocated) {
3485 : 7076479 : bs_sequence_readv_dev(seq, iov, iovcnt, lba, lba_count, rw_iov_done, NULL);
3486 : 693 : } else {
3487 [ # # # # ]: 1347542 : bs_sequence_readv_bs_dev(seq, blob->back_bs_dev, iov, iovcnt, lba, lba_count,
3488 : : rw_iov_done, NULL);
3489 : : }
3490 : 3598 : } else {
3491 [ + + # # ]: 9853957 : if (is_allocated) {
3492 : : spdk_bs_sequence_t *seq;
3493 : :
3494 : 9714890 : seq = bs_sequence_start_blob(_channel, &cpl, blob);
3495 [ + + ]: 9714890 : if (!seq) {
3496 [ # # # # ]: 70785 : cb_fn(cb_arg, -ENOMEM);
3497 : 70785 : return;
3498 : : }
3499 : :
3500 [ # # # # ]: 9644105 : seq->ext_io_opts = ext_io_opts;
3501 : :
3502 : 9644105 : bs_sequence_writev_dev(seq, iov, iovcnt, lba, lba_count, rw_iov_done, NULL);
3503 : 345 : } else {
3504 : : /* Queue this operation and allocate the cluster */
3505 : : spdk_bs_user_op_t *op;
3506 : :
3507 : 139087 : op = bs_user_op_alloc(_channel, &cpl, SPDK_BLOB_WRITEV, blob, iov, iovcnt, offset,
3508 : 20 : length);
3509 [ + + ]: 139067 : if (!op) {
3510 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
3511 : 0 : return;
3512 : : }
3513 : :
3514 [ # # # # ]: 139067 : op->ext_io_opts = ext_io_opts;
3515 : :
3516 : 139067 : bs_allocate_and_copy_cluster(blob, _channel, offset, op);
3517 : : }
3518 : : }
3519 : 3963 : } else {
3520 : : struct rw_iov_ctx *ctx;
3521 : :
3522 : 1040 : ctx = calloc(1, sizeof(struct rw_iov_ctx) + iovcnt * sizeof(struct iovec));
3523 [ + + ]: 1040 : if (ctx == NULL) {
3524 [ # # # # ]: 20 : cb_fn(cb_arg, -ENOMEM);
3525 : 20 : return;
3526 : : }
3527 : :
3528 [ # # # # ]: 1020 : ctx->blob = blob;
3529 [ # # # # ]: 1020 : ctx->channel = _channel;
3530 [ # # # # ]: 1020 : ctx->cb_fn = cb_fn;
3531 [ # # # # ]: 1020 : ctx->cb_arg = cb_arg;
3532 [ # # # # : 1020 : ctx->read = read;
# # ]
3533 [ # # # # ]: 1020 : ctx->orig_iov = iov;
3534 [ # # # # ]: 1020 : ctx->iovcnt = iovcnt;
3535 [ # # # # ]: 1020 : ctx->io_unit_offset = offset;
3536 [ # # # # ]: 1020 : ctx->io_units_remaining = length;
3537 [ # # # # ]: 1020 : ctx->io_units_done = 0;
3538 [ # # # # ]: 1020 : ctx->ext_io_opts = ext_io_opts;
3539 : :
3540 : 1020 : rw_iov_split_next(ctx, 0);
3541 : : }
3542 : 4228 : }
3543 : :
3544 : : static struct spdk_blob *
3545 : 76212 : blob_lookup(struct spdk_blob_store *bs, spdk_blob_id blobid)
3546 : : {
3547 : 66473 : struct spdk_blob find;
3548 : :
3549 [ + + # # : 76212 : if (spdk_bit_array_get(bs->open_blobids, blobid) == 0) {
# # ]
3550 : 71991 : return NULL;
3551 : : }
3552 : :
3553 [ # # ]: 4221 : find.id = blobid;
3554 [ # # ]: 4221 : return RB_FIND(spdk_blob_tree, &bs->open_blobs, &find);
3555 : 9739 : }
3556 : :
3557 : : static void
3558 : 10235 : blob_get_snapshot_and_clone_entries(struct spdk_blob *blob,
3559 : : struct spdk_blob_list **snapshot_entry, struct spdk_blob_list **clone_entry)
3560 : : {
3561 [ + + # # ]: 10235 : assert(blob != NULL);
3562 [ # # ]: 10235 : *snapshot_entry = NULL;
3563 [ # # ]: 10235 : *clone_entry = NULL;
3564 : :
3565 [ + + # # : 10235 : if (blob->parent_id == SPDK_BLOBID_INVALID) {
# # ]
3566 : 8735 : return;
3567 : : }
3568 : :
3569 [ + + # # : 2231 : TAILQ_FOREACH(*snapshot_entry, &blob->bs->snapshots, link) {
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
3570 [ + + # # : 1954 : if ((*snapshot_entry)->id == blob->parent_id) {
# # # # #
# # # ]
3571 : 1223 : break;
3572 : : }
3573 : 180 : }
3574 : :
3575 [ + + # # ]: 1500 : if (*snapshot_entry != NULL) {
3576 [ + + # # : 1460 : TAILQ_FOREACH(*clone_entry, &(*snapshot_entry)->clones, link) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
3577 [ + + # # : 1460 : if ((*clone_entry)->id == blob->id) {
# # # # #
# # # ]
3578 : 1223 : break;
3579 : : }
3580 : 56 : }
3581 : :
3582 [ - + # # : 1223 : assert(*clone_entry != NULL);
# # ]
3583 : 292 : }
3584 : 2262 : }
3585 : :
3586 : : static int
3587 : 10361 : bs_channel_create(void *io_device, void *ctx_buf)
3588 : : {
3589 : 10361 : struct spdk_blob_store *bs = io_device;
3590 : 10361 : struct spdk_bs_channel *channel = ctx_buf;
3591 : : struct spdk_bs_dev *dev;
3592 [ + - + - ]: 10361 : uint32_t max_ops = bs->max_channel_ops;
3593 : : uint32_t i;
3594 : :
3595 [ + - + - ]: 10361 : dev = bs->dev;
3596 : :
3597 [ + - + - ]: 10361 : channel->req_mem = calloc(max_ops, sizeof(struct spdk_bs_request_set));
3598 [ + + + - : 10361 : if (!channel->req_mem) {
+ - ]
3599 : 0 : return -1;
3600 : : }
3601 : :
3602 [ + - + - : 10361 : TAILQ_INIT(&channel->reqs);
+ - + - +
- + - + -
+ - ]
3603 : :
3604 [ + + ]: 5315193 : for (i = 0; i < max_ops; i++) {
3605 [ + - + - : 5304832 : TAILQ_INSERT_TAIL(&channel->reqs, &channel->req_mem[i], link);
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
3606 : 661504 : }
3607 : :
3608 [ + - + - ]: 10361 : channel->bs = bs;
3609 [ + - + - ]: 10361 : channel->dev = dev;
3610 [ + - + - : 10361 : channel->dev_channel = dev->create_channel(dev);
- + + - +
- + - ]
3611 : :
3612 [ + + + - : 10361 : if (!channel->dev_channel) {
+ - ]
3613 : 0 : SPDK_ERRLOG("Failed to create device channel.\n");
3614 [ # # # # ]: 0 : free(channel->req_mem);
3615 : 0 : return -1;
3616 : : }
3617 : :
3618 [ + - + - : 10361 : channel->new_cluster_page = spdk_zmalloc(bs->md_page_size, 0, NULL, SPDK_ENV_NUMA_ID_ANY,
+ - + - ]
3619 : : SPDK_MALLOC_DMA);
3620 [ + + + - : 10361 : if (!channel->new_cluster_page) {
+ - ]
3621 : 0 : SPDK_ERRLOG("Failed to allocate new cluster page\n");
3622 [ # # # # ]: 0 : free(channel->req_mem);
3623 [ # # # # : 0 : channel->dev->destroy_channel(channel->dev, channel->dev_channel);
# # # # #
# # # # #
# # # # #
# ]
3624 : 0 : return -1;
3625 : : }
3626 : :
3627 [ + - + - : 10361 : TAILQ_INIT(&channel->need_cluster_alloc);
+ - + - +
- + - + -
+ - ]
3628 [ + - + - : 10361 : TAILQ_INIT(&channel->queued_io);
+ - + - +
- + - + -
+ - ]
3629 [ + - + - : 10361 : RB_INIT(&channel->esnap_channels);
+ - ]
3630 : :
3631 : 10361 : return 0;
3632 : 1292 : }
3633 : :
3634 : : static void
3635 : 10361 : bs_channel_destroy(void *io_device, void *ctx_buf)
3636 : : {
3637 : 10361 : struct spdk_bs_channel *channel = ctx_buf;
3638 : : spdk_bs_user_op_t *op;
3639 : :
3640 [ + + + - : 10361 : while (!TAILQ_EMPTY(&channel->need_cluster_alloc)) {
+ - - + ]
3641 [ # # # # : 0 : op = TAILQ_FIRST(&channel->need_cluster_alloc);
# # ]
3642 [ # # # # : 0 : TAILQ_REMOVE(&channel->need_cluster_alloc, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
3643 : 0 : bs_user_op_abort(op, -EIO);
3644 : : }
3645 : :
3646 [ + + + - : 10361 : while (!TAILQ_EMPTY(&channel->queued_io)) {
+ - + - ]
3647 [ # # # # : 0 : op = TAILQ_FIRST(&channel->queued_io);
# # ]
3648 [ # # # # : 0 : TAILQ_REMOVE(&channel->queued_io, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
3649 : 0 : bs_user_op_abort(op, -EIO);
3650 : : }
3651 : :
3652 : 10361 : blob_esnap_destroy_bs_channel(channel);
3653 : :
3654 [ + - + - ]: 10361 : free(channel->req_mem);
3655 [ + - + - ]: 10361 : spdk_free(channel->new_cluster_page);
3656 [ + - + - : 10361 : channel->dev->destroy_channel(channel->dev, channel->dev_channel);
+ - + - -
+ + - + -
+ - + - +
- ]
3657 : 10361 : }
3658 : :
3659 : : static void
3660 : 10065 : bs_dev_destroy(void *io_device)
3661 : : {
3662 : 10065 : struct spdk_blob_store *bs = io_device;
3663 : : struct spdk_blob *blob, *blob_tmp;
3664 : :
3665 [ + - + - : 10065 : bs->dev->destroy(bs->dev);
+ - + - -
+ + - + -
+ - ]
3666 : :
3667 [ + + + + : 10065 : RB_FOREACH_SAFE(blob, spdk_blob_tree, &bs->open_blobs, blob_tmp) {
+ - ]
3668 [ # # ]: 0 : RB_REMOVE(spdk_blob_tree, &bs->open_blobs, blob);
3669 [ # # # # : 0 : spdk_bit_array_clear(bs->open_blobids, blob->id);
# # # # ]
3670 : 0 : blob_free(blob);
3671 : 0 : }
3672 : :
3673 [ + - ]: 10065 : spdk_spin_destroy(&bs->used_lock);
3674 : :
3675 [ + - ]: 10065 : spdk_bit_array_free(&bs->open_blobids);
3676 [ + - ]: 10065 : spdk_bit_array_free(&bs->used_blobids);
3677 [ + - ]: 10065 : spdk_bit_array_free(&bs->used_md_pages);
3678 [ + - ]: 10065 : spdk_bit_pool_free(&bs->used_clusters);
3679 : : /*
3680 : : * If this function is called for any reason except a successful unload,
3681 : : * the unload_cpl type will be NONE and this will be a nop.
3682 : : */
3683 [ + - + - : 10065 : bs_call_cpl(&bs->unload_cpl, bs->unload_err);
+ - ]
3684 : :
3685 : 10065 : free(bs);
3686 : 10065 : }
3687 : :
3688 : : static int
3689 : 11460 : bs_blob_list_add(struct spdk_blob *blob)
3690 : : {
3691 : : spdk_blob_id snapshot_id;
3692 : 11460 : struct spdk_blob_list *snapshot_entry = NULL;
3693 : 11460 : struct spdk_blob_list *clone_entry = NULL;
3694 : :
3695 [ + + # # ]: 11460 : assert(blob != NULL);
3696 : :
3697 [ # # # # ]: 11460 : snapshot_id = blob->parent_id;
3698 [ + + + + ]: 11460 : if (snapshot_id == SPDK_BLOBID_INVALID ||
3699 : 571 : snapshot_id == SPDK_BLOBID_EXTERNAL_SNAPSHOT) {
3700 : 9278 : return 0;
3701 : : }
3702 : :
3703 [ # # # # ]: 2182 : snapshot_entry = bs_get_snapshot_entry(blob->bs, snapshot_id);
3704 [ + + ]: 2182 : if (snapshot_entry == NULL) {
3705 : : /* Snapshot not found */
3706 : 1504 : snapshot_entry = calloc(1, sizeof(struct spdk_blob_list));
3707 [ + + ]: 1504 : if (snapshot_entry == NULL) {
3708 : 0 : return -ENOMEM;
3709 : : }
3710 [ # # # # ]: 1504 : snapshot_entry->id = snapshot_id;
3711 [ # # # # : 1504 : TAILQ_INIT(&snapshot_entry->clones);
# # # # #
# # # # #
# # ]
3712 [ # # # # : 1504 : TAILQ_INSERT_TAIL(&blob->bs->snapshots, snapshot_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
3713 : 364 : } else {
3714 [ + + # # : 1093 : TAILQ_FOREACH(clone_entry, &snapshot_entry->clones, link) {
# # # # #
# # # #
# ]
3715 [ + + # # : 415 : if (clone_entry->id == blob->id) {
# # # # #
# ]
3716 : 0 : break;
3717 : : }
3718 : 97 : }
3719 : : }
3720 : :
3721 [ + + ]: 2182 : if (clone_entry == NULL) {
3722 : : /* Clone not found */
3723 : 2182 : clone_entry = calloc(1, sizeof(struct spdk_blob_list));
3724 [ + + ]: 2182 : if (clone_entry == NULL) {
3725 : 0 : return -ENOMEM;
3726 : : }
3727 [ # # # # : 2182 : clone_entry->id = blob->id;
# # # # ]
3728 [ # # # # : 2182 : TAILQ_INIT(&clone_entry->clones);
# # # # #
# # # # #
# # ]
3729 [ # # # # : 2182 : TAILQ_INSERT_TAIL(&snapshot_entry->clones, clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
3730 [ # # ]: 2182 : snapshot_entry->clone_count++;
3731 : 526 : }
3732 : :
3733 : 2182 : return 0;
3734 : 1147 : }
3735 : :
3736 : : static void
3737 : 9834 : bs_blob_list_remove(struct spdk_blob *blob)
3738 : : {
3739 : 9834 : struct spdk_blob_list *snapshot_entry = NULL;
3740 : 9834 : struct spdk_blob_list *clone_entry = NULL;
3741 : :
3742 : 9834 : blob_get_snapshot_and_clone_entries(blob, &snapshot_entry, &clone_entry);
3743 : :
3744 [ + + ]: 9834 : if (snapshot_entry == NULL) {
3745 : 8693 : return;
3746 : : }
3747 : :
3748 [ # # # # ]: 1141 : blob->parent_id = SPDK_BLOBID_INVALID;
3749 [ + + # # : 1141 : TAILQ_REMOVE(&snapshot_entry->clones, clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
3750 : 1141 : free(clone_entry);
3751 : :
3752 [ # # ]: 1141 : snapshot_entry->clone_count--;
3753 : 2164 : }
3754 : :
3755 : : static int
3756 : 10065 : bs_blob_list_free(struct spdk_blob_store *bs)
3757 : : {
3758 : : struct spdk_blob_list *snapshot_entry;
3759 : : struct spdk_blob_list *snapshot_entry_tmp;
3760 : : struct spdk_blob_list *clone_entry;
3761 : : struct spdk_blob_list *clone_entry_tmp;
3762 : :
3763 [ + + + + : 10810 : TAILQ_FOREACH_SAFE(snapshot_entry, &bs->snapshots, link, snapshot_entry_tmp) {
+ - + - #
# # # # #
+ - ]
3764 [ + + + + : 1538 : TAILQ_FOREACH_SAFE(clone_entry, &snapshot_entry->clones, link, clone_entry_tmp) {
# # # # #
# # # # #
# # ]
3765 [ + + # # : 793 : TAILQ_REMOVE(&snapshot_entry->clones, clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
3766 : 793 : free(clone_entry);
3767 : 194 : }
3768 [ + + # # : 745 : TAILQ_REMOVE(&bs->snapshots, snapshot_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
3769 : 745 : free(snapshot_entry);
3770 : 183 : }
3771 : :
3772 : 10065 : return 0;
3773 : : }
3774 : :
3775 : : static void
3776 : 10065 : bs_free(struct spdk_blob_store *bs)
3777 : : {
3778 : 10065 : bs_blob_list_free(bs);
3779 : :
3780 : 10065 : bs_unregister_md_thread(bs);
3781 : 10065 : spdk_io_device_unregister(bs, bs_dev_destroy);
3782 : 10065 : }
3783 : :
3784 : : void
3785 : 17708 : spdk_bs_opts_init(struct spdk_bs_opts *opts, size_t opts_size)
3786 : : {
3787 : :
3788 [ + + ]: 17708 : if (!opts) {
3789 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
3790 : 0 : return;
3791 : : }
3792 : :
3793 [ + + ]: 17708 : if (!opts_size) {
3794 : 0 : SPDK_ERRLOG("opts_size should not be zero value\n");
3795 : 0 : return;
3796 : : }
3797 : :
3798 [ + + ]: 17708 : memset(opts, 0, opts_size);
3799 [ + - + - ]: 17708 : opts->opts_size = opts_size;
3800 : :
3801 : : #define FIELD_OK(field) \
3802 : : offsetof(struct spdk_bs_opts, field) + sizeof(opts->field) <= opts_size
3803 : :
3804 : : #define SET_FIELD(field, value) \
3805 : : if (FIELD_OK(field)) { \
3806 : : opts->field = value; \
3807 : : } \
3808 : :
3809 [ + + + - : 17708 : SET_FIELD(cluster_sz, SPDK_BLOB_OPTS_CLUSTER_SZ);
+ - ]
3810 [ + + + - : 17708 : SET_FIELD(num_md_pages, SPDK_BLOB_OPTS_NUM_MD_PAGES);
+ - ]
3811 [ + + + - : 17708 : SET_FIELD(max_md_ops, SPDK_BLOB_OPTS_NUM_MD_PAGES);
+ - ]
3812 [ + + + - : 17708 : SET_FIELD(max_channel_ops, SPDK_BLOB_OPTS_DEFAULT_CHANNEL_OPS);
+ - ]
3813 [ + + + - : 17708 : SET_FIELD(clear_method, BS_CLEAR_WITH_UNMAP);
+ - ]
3814 : :
3815 [ + + ]: 17708 : if (FIELD_OK(bstype)) {
3816 [ + + + - ]: 17708 : memset(&opts->bstype, 0, sizeof(opts->bstype));
3817 : 1899 : }
3818 : :
3819 [ + + + - : 17708 : SET_FIELD(iter_cb_fn, NULL);
+ - ]
3820 [ + + + - : 17708 : SET_FIELD(iter_cb_arg, NULL);
+ - ]
3821 [ + + + - : 17708 : SET_FIELD(force_recover, false);
+ - ]
3822 [ + + + - : 17708 : SET_FIELD(esnap_bs_dev_create, NULL);
+ - ]
3823 [ + + + - : 17708 : SET_FIELD(esnap_ctx, NULL);
+ - ]
3824 : :
3825 : : #undef FIELD_OK
3826 : : #undef SET_FIELD
3827 : 1899 : }
3828 : :
3829 : : static int
3830 : 2643 : bs_opts_verify(struct spdk_bs_opts *opts)
3831 : : {
3832 [ + + + - : 2643 : if (opts->cluster_sz == 0 || opts->num_md_pages == 0 || opts->max_md_ops == 0 ||
+ - - + #
# # # # #
# # # # #
# ]
3833 [ - + # # ]: 2623 : opts->max_channel_ops == 0) {
3834 : 20 : SPDK_ERRLOG("Blobstore options cannot be set to 0\n");
3835 : 20 : return -1;
3836 : : }
3837 : :
3838 [ + + # # : 2623 : if ((opts->cluster_sz % SPDK_BS_PAGE_SIZE) != 0) {
# # # # ]
3839 [ # # # # ]: 20 : SPDK_ERRLOG("Cluster size %" PRIu32 " is not an integral multiple of blocklen %" PRIu32"\n",
3840 : : opts->cluster_sz, SPDK_BS_PAGE_SIZE);
3841 : 20 : return -1;
3842 : : }
3843 : :
3844 : 2603 : return 0;
3845 : 608 : }
3846 : :
3847 : : /* START spdk_bs_load */
3848 : :
3849 : : /* spdk_bs_load_ctx is used for init, load, unload and dump code paths. */
3850 : :
3851 : : struct spdk_bs_load_ctx {
3852 : : struct spdk_blob_store *bs;
3853 : : struct spdk_bs_super_block *super;
3854 : :
3855 : : struct spdk_bs_md_mask *mask;
3856 : : bool in_page_chain;
3857 : : uint32_t page_index;
3858 : : uint32_t cur_page;
3859 : : struct spdk_blob_md_page *page;
3860 : :
3861 : : uint64_t num_extent_pages;
3862 : : uint32_t *extent_page_num;
3863 : : struct spdk_blob_md_page *extent_pages;
3864 : : struct spdk_bit_array *used_clusters;
3865 : :
3866 : : spdk_bs_sequence_t *seq;
3867 : : spdk_blob_op_with_handle_complete iter_cb_fn;
3868 : : void *iter_cb_arg;
3869 : : struct spdk_blob *blob;
3870 : : spdk_blob_id blobid;
3871 : :
3872 : : bool force_recover;
3873 : :
3874 : : /* These fields are used in the spdk_bs_dump path. */
3875 : : bool dumping;
3876 : : FILE *fp;
3877 : : spdk_bs_dump_print_xattr print_xattr_fn;
3878 : : char xattr_name[4096];
3879 : : };
3880 : :
3881 : : static void
3882 : 11606 : bs_init_per_cluster_fields(struct spdk_blob_store *bs)
3883 : : {
3884 [ + + + - : 11606 : bs->pages_per_cluster = bs->cluster_sz / bs->md_page_size;
+ - + - +
- + - +
- ]
3885 [ + + + - : 11606 : if (spdk_u32_is_pow2(bs->pages_per_cluster)) {
- + ]
3886 [ + - + - : 11606 : bs->pages_per_cluster_shift = spdk_u32log2(bs->pages_per_cluster);
+ - + - ]
3887 : 1634 : }
3888 [ + + + - : 11606 : bs->io_units_per_cluster = bs->cluster_sz / bs->io_unit_size;
+ - + - +
- + - +
- ]
3889 [ + + + - : 11606 : if (spdk_u32_is_pow2(bs->io_units_per_cluster)) {
- + ]
3890 [ + - + - : 11606 : bs->io_units_per_cluster_shift = spdk_u32log2(bs->io_units_per_cluster);
+ - + - ]
3891 : 1634 : }
3892 : 11606 : }
3893 : :
3894 : : static int
3895 : 10166 : bs_alloc(struct spdk_bs_dev *dev, struct spdk_bs_opts *opts, struct spdk_blob_store **_bs,
3896 : : struct spdk_bs_load_ctx **_ctx)
3897 : : {
3898 : : struct spdk_blob_store *bs;
3899 : : struct spdk_bs_load_ctx *ctx;
3900 : : uint64_t dev_size;
3901 : : uint32_t md_page_size;
3902 : : int rc;
3903 : :
3904 [ + - + - : 10166 : dev_size = dev->blocklen * dev->blockcnt;
+ - + - ]
3905 [ + + + - : 10166 : if (dev_size < opts->cluster_sz) {
+ + ]
3906 : : /* Device size cannot be smaller than cluster size of blobstore */
3907 [ + + + + : 101 : SPDK_INFOLOG(blob, "Device size %" PRIu64 " is smaller than cluster size %" PRIu32 "\n",
+ - # # #
# ]
3908 : : dev_size, opts->cluster_sz);
3909 : 101 : return -ENOSPC;
3910 : : }
3911 : :
3912 [ + + + - : 10065 : md_page_size = spdk_max(spdk_max(dev->phys_blocklen, SPDK_BS_PAGE_SIZE),
+ + # # #
# + - + -
+ - + - +
- - + # #
# # # # #
# ]
3913 : : opts->md_page_size);
3914 [ + + + - : 10065 : if (opts->cluster_sz < md_page_size) {
- + ]
3915 : : /* Cluster size cannot be smaller than page size */
3916 [ # # # # ]: 0 : SPDK_ERRLOG("Cluster size %" PRIu32 " is smaller than page size %d\n",
3917 : : opts->cluster_sz, md_page_size);
3918 : 0 : return -EINVAL;
3919 : : }
3920 : 10065 : bs = calloc(1, sizeof(struct spdk_blob_store));
3921 [ + + ]: 10065 : if (!bs) {
3922 : 0 : return -ENOMEM;
3923 : : }
3924 : :
3925 : 10065 : ctx = calloc(1, sizeof(struct spdk_bs_load_ctx));
3926 [ + + ]: 10065 : if (!ctx) {
3927 : 0 : free(bs);
3928 : 0 : return -ENOMEM;
3929 : : }
3930 : :
3931 [ + - + - ]: 10065 : ctx->bs = bs;
3932 [ + - + - : 10065 : ctx->iter_cb_fn = opts->iter_cb_fn;
+ - + - ]
3933 [ + - + - : 10065 : ctx->iter_cb_arg = opts->iter_cb_arg;
+ - + - ]
3934 [ + - + - : 10065 : ctx->force_recover = opts->force_recover;
+ - + - ]
3935 : :
3936 [ + - + - ]: 10065 : ctx->super = spdk_zmalloc(sizeof(*ctx->super), 0x1000, NULL,
3937 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
3938 [ + + + - : 10065 : if (!ctx->super) {
+ - ]
3939 : 0 : free(ctx);
3940 : 0 : free(bs);
3941 : 0 : return -ENOMEM;
3942 : : }
3943 : :
3944 [ + - + - : 10065 : RB_INIT(&bs->open_blobs);
+ - ]
3945 [ + - + - : 10065 : TAILQ_INIT(&bs->snapshots);
+ - + - +
- + - + -
+ - ]
3946 [ + - + - ]: 10065 : bs->dev = dev;
3947 [ + - + - ]: 10065 : bs->md_page_size = md_page_size;
3948 [ + - + - ]: 10065 : bs->md_thread = spdk_get_thread();
3949 [ + + + - : 10065 : assert(bs->md_thread != NULL);
+ - # # ]
3950 : :
3951 : : /*
3952 : : * Do not use bs_lba_to_cluster() here since blockcnt may not be an
3953 : : * even multiple of the cluster size.
3954 : : */
3955 [ + - + - : 10065 : bs->cluster_sz = opts->cluster_sz;
+ - + - ]
3956 [ + + + + : 10065 : bs->total_clusters = dev->blockcnt / (bs->cluster_sz / dev->blocklen);
+ - + - +
- + - + -
+ - + - +
- ]
3957 [ + - + - : 10065 : ctx->used_clusters = spdk_bit_array_create(bs->total_clusters);
+ - + - ]
3958 [ + + + - : 10065 : if (!ctx->used_clusters) {
+ - ]
3959 [ # # # # ]: 0 : spdk_free(ctx->super);
3960 : 0 : free(ctx);
3961 : 0 : free(bs);
3962 : 0 : return -ENOMEM;
3963 : : }
3964 : :
3965 [ + - + - : 10065 : bs->num_free_clusters = bs->total_clusters;
+ - + - ]
3966 [ + - + - : 10065 : bs->io_unit_size = dev->blocklen;
+ - + - ]
3967 : 10065 : bs_init_per_cluster_fields(bs);
3968 : :
3969 [ + - + - : 10065 : bs->max_channel_ops = opts->max_channel_ops;
+ - + - ]
3970 [ + - + - ]: 10065 : bs->super_blob = SPDK_BLOBID_INVALID;
3971 [ + - + - : 10065 : memcpy(&bs->bstype, &opts->bstype, sizeof(opts->bstype));
+ - + - ]
3972 [ + - + - : 10065 : bs->esnap_bs_dev_create = opts->esnap_bs_dev_create;
+ - + - ]
3973 [ + - + - : 10065 : bs->esnap_ctx = opts->esnap_ctx;
+ - + - ]
3974 : :
3975 : : /* The metadata is assumed to be at least 1 page */
3976 [ + - + - ]: 10065 : bs->used_md_pages = spdk_bit_array_create(1);
3977 [ + - + - ]: 10065 : bs->used_blobids = spdk_bit_array_create(0);
3978 [ + - + - ]: 10065 : bs->open_blobids = spdk_bit_array_create(0);
3979 : :
3980 [ + - ]: 10065 : spdk_spin_init(&bs->used_lock);
3981 : :
3982 : 10065 : spdk_io_device_register(bs, bs_channel_create, bs_channel_destroy,
3983 : : sizeof(struct spdk_bs_channel), "blobstore");
3984 : 10065 : rc = bs_register_md_thread(bs);
3985 [ + + ]: 10065 : if (rc == -1) {
3986 : 0 : spdk_io_device_unregister(bs, NULL);
3987 [ # # ]: 0 : spdk_spin_destroy(&bs->used_lock);
3988 [ # # ]: 0 : spdk_bit_array_free(&bs->open_blobids);
3989 [ # # ]: 0 : spdk_bit_array_free(&bs->used_blobids);
3990 [ # # ]: 0 : spdk_bit_array_free(&bs->used_md_pages);
3991 [ # # ]: 0 : spdk_bit_array_free(&ctx->used_clusters);
3992 [ # # # # ]: 0 : spdk_free(ctx->super);
3993 : 0 : free(ctx);
3994 : 0 : free(bs);
3995 : : /* FIXME: this is a lie but don't know how to get a proper error code here */
3996 : 0 : return -ENOMEM;
3997 : : }
3998 : :
3999 [ + - ]: 10065 : *_ctx = ctx;
4000 [ + - ]: 10065 : *_bs = bs;
4001 : 10065 : return 0;
4002 : 1276 : }
4003 : :
4004 : : static void
4005 : 4553 : bs_write_super(spdk_bs_sequence_t *seq, struct spdk_blob_store *bs,
4006 : : struct spdk_bs_super_block *super, spdk_bs_sequence_cpl cb_fn, void *cb_arg)
4007 : : {
4008 : : /* Update the values in the super block */
4009 [ # # # # : 4553 : super->super_blob = bs->super_blob;
# # # # ]
4010 [ # # # # : 4553 : memcpy(&super->bstype, &bs->bstype, sizeof(bs->bstype));
# # # # ]
4011 [ # # # # ]: 4553 : super->crc = blob_md_page_calc_crc(super);
4012 : 5587 : bs_sequence_write_dev(seq, super, bs_page_to_lba(bs, 0),
4013 : 4553 : bs_byte_to_lba(bs, sizeof(*super)),
4014 : 1034 : cb_fn, cb_arg);
4015 : 4553 : }
4016 : :
4017 : : static void
4018 : 3986 : bs_write_used_clusters(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequence_cpl cb_fn)
4019 : : {
4020 : 3986 : struct spdk_bs_load_ctx *ctx = arg;
4021 : : uint64_t mask_size, lba, lba_count;
4022 : :
4023 : : /* Write out the used clusters mask */
4024 [ # # # # : 3986 : mask_size = ctx->super->used_cluster_mask_len * ctx->bs->md_page_size;
# # # # #
# # # # #
# # ]
4025 [ # # # # ]: 3986 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL,
4026 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
4027 [ + + # # : 3986 : if (!ctx->mask) {
# # ]
4028 [ # # # # ]: 0 : cb_fn(seq, arg, -ENOMEM);
4029 : 0 : return;
4030 : : }
4031 : :
4032 [ # # # # : 3986 : ctx->mask->type = SPDK_MD_MASK_TYPE_USED_CLUSTERS;
# # # # ]
4033 [ # # # # : 3986 : ctx->mask->length = ctx->bs->total_clusters;
# # # # #
# # # # #
# # ]
4034 : : /* We could get here through the normal unload path, or through dirty
4035 : : * shutdown recovery. For the normal unload path, we use the mask from
4036 : : * the bit pool. For dirty shutdown recovery, we don't have a bit pool yet -
4037 : : * only the bit array from the load ctx.
4038 : : */
4039 [ + + # # : 3986 : if (ctx->bs->used_clusters) {
# # # # #
# ]
4040 [ + + # # : 3442 : assert(ctx->mask->length == spdk_bit_pool_capacity(ctx->bs->used_clusters));
# # # # #
# # # # #
# # # # #
# ]
4041 [ # # # # : 3442 : spdk_bit_pool_store_mask(ctx->bs->used_clusters, ctx->mask->mask);
# # # # #
# # # #
# ]
4042 : 820 : } else {
4043 [ - + # # : 544 : assert(ctx->mask->length == spdk_bit_array_capacity(ctx->used_clusters));
# # # # #
# # # # #
# # ]
4044 [ # # # # : 544 : spdk_bit_array_store_mask(ctx->used_clusters, ctx->mask->mask);
# # # # #
# ]
4045 : : }
4046 [ # # # # : 3986 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
# # # # #
# # # ]
4047 [ # # # # : 3986 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
# # # # #
# # # ]
4048 [ # # # # ]: 3986 : bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
4049 : 954 : }
4050 : :
4051 : : static void
4052 : 4026 : bs_write_used_md(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequence_cpl cb_fn)
4053 : : {
4054 : 4026 : struct spdk_bs_load_ctx *ctx = arg;
4055 : : uint64_t mask_size, lba, lba_count;
4056 : :
4057 [ # # # # : 4026 : mask_size = ctx->super->used_page_mask_len * ctx->bs->md_page_size;
# # # # #
# # # # #
# # ]
4058 [ # # # # ]: 4026 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL,
4059 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
4060 [ + + # # : 4026 : if (!ctx->mask) {
# # ]
4061 [ # # # # ]: 20 : cb_fn(seq, arg, -ENOMEM);
4062 : 20 : return;
4063 : : }
4064 : :
4065 [ # # # # : 4006 : ctx->mask->type = SPDK_MD_MASK_TYPE_USED_PAGES;
# # # # ]
4066 [ # # # # : 4006 : ctx->mask->length = ctx->super->md_len;
# # # # #
# # # # #
# # ]
4067 [ - + # # : 4006 : assert(ctx->mask->length == spdk_bit_array_capacity(ctx->bs->used_md_pages));
# # # # #
# # # # #
# # # # #
# ]
4068 : :
4069 [ # # # # : 4006 : spdk_bit_array_store_mask(ctx->bs->used_md_pages, ctx->mask->mask);
# # # # #
# # # #
# ]
4070 [ # # # # : 4006 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start);
# # # # #
# # # ]
4071 [ # # # # : 4006 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len);
# # # # #
# # # ]
4072 [ # # # # ]: 4006 : bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
4073 : 964 : }
4074 : :
4075 : : static void
4076 : 3986 : bs_write_used_blobids(spdk_bs_sequence_t *seq, void *arg, spdk_bs_sequence_cpl cb_fn)
4077 : : {
4078 : 3986 : struct spdk_bs_load_ctx *ctx = arg;
4079 : : uint64_t mask_size, lba, lba_count;
4080 : :
4081 [ + + # # : 3986 : if (ctx->super->used_blobid_mask_len == 0) {
# # # # #
# ]
4082 : : /*
4083 : : * This is a pre-v3 on-disk format where the blobid mask does not get
4084 : : * written to disk.
4085 : : */
4086 [ # # # # ]: 120 : cb_fn(seq, arg, 0);
4087 : 120 : return;
4088 : : }
4089 : :
4090 [ # # # # : 3866 : mask_size = ctx->super->used_blobid_mask_len * ctx->bs->md_page_size;
# # # # #
# # # # #
# # ]
4091 [ # # # # ]: 3866 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL, SPDK_ENV_NUMA_ID_ANY,
4092 : : SPDK_MALLOC_DMA);
4093 [ + + # # : 3866 : if (!ctx->mask) {
# # ]
4094 [ # # # # ]: 0 : cb_fn(seq, arg, -ENOMEM);
4095 : 0 : return;
4096 : : }
4097 : :
4098 [ # # # # : 3866 : ctx->mask->type = SPDK_MD_MASK_TYPE_USED_BLOBIDS;
# # # # ]
4099 [ # # # # : 3866 : ctx->mask->length = ctx->super->md_len;
# # # # #
# # # # #
# # ]
4100 [ + + # # : 3866 : assert(ctx->mask->length == spdk_bit_array_capacity(ctx->bs->used_blobids));
# # # # #
# # # # #
# # # # #
# ]
4101 : :
4102 [ # # # # : 3866 : spdk_bit_array_store_mask(ctx->bs->used_blobids, ctx->mask->mask);
# # # # #
# # # #
# ]
4103 [ # # # # : 3866 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start);
# # # # #
# # # ]
4104 [ # # # # : 3866 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len);
# # # # #
# # # ]
4105 [ # # # # ]: 3866 : bs_sequence_write_dev(seq, ctx->mask, lba, lba_count, cb_fn, arg);
4106 : 954 : }
4107 : :
4108 : : static void
4109 : 3723 : blob_set_thin_provision(struct spdk_blob *blob)
4110 : : {
4111 : 3723 : blob_verify_md_op(blob);
4112 [ # # # # : 3723 : blob->invalid_flags |= SPDK_BLOB_THIN_PROV;
# # ]
4113 [ # # # # ]: 3723 : blob->state = SPDK_BLOB_STATE_DIRTY;
4114 : 3723 : }
4115 : :
4116 : : static void
4117 : 13350 : blob_set_clear_method(struct spdk_blob *blob, enum blob_clear_method clear_method)
4118 : : {
4119 : 13350 : blob_verify_md_op(blob);
4120 [ # # # # ]: 13350 : blob->clear_method = clear_method;
4121 [ # # # # : 13350 : blob->md_ro_flags |= (clear_method << SPDK_BLOB_CLEAR_METHOD_SHIFT);
# # ]
4122 [ # # # # ]: 13350 : blob->state = SPDK_BLOB_STATE_DIRTY;
4123 : 13350 : }
4124 : :
4125 : : static void bs_load_iter(void *arg, struct spdk_blob *blob, int bserrno);
4126 : :
4127 : : static void
4128 : 120 : bs_delete_corrupted_blob_cpl(void *cb_arg, int bserrno)
4129 : : {
4130 : 120 : struct spdk_bs_load_ctx *ctx = cb_arg;
4131 : : spdk_blob_id id;
4132 : : int64_t page_num;
4133 : :
4134 : : /* Iterate to next blob (we can't use spdk_bs_iter_next function as our
4135 : : * last blob has been removed */
4136 [ # # # # ]: 120 : page_num = bs_blobid_to_page(ctx->blobid);
4137 [ # # ]: 120 : page_num++;
4138 [ # # # # : 120 : page_num = spdk_bit_array_find_first_set(ctx->bs->used_blobids, page_num);
# # # # ]
4139 [ + - # # : 120 : if (page_num >= spdk_bit_array_capacity(ctx->bs->used_blobids)) {
# # # # #
# ]
4140 : 120 : bs_load_iter(ctx, NULL, -ENOENT);
4141 : 120 : return;
4142 : : }
4143 : :
4144 : 0 : id = bs_page_to_blobid(page_num);
4145 : :
4146 [ # # # # ]: 0 : spdk_bs_open_blob(ctx->bs, id, bs_load_iter, ctx);
4147 : 30 : }
4148 : :
4149 : : static void
4150 : 120 : bs_delete_corrupted_close_cb(void *cb_arg, int bserrno)
4151 : : {
4152 : 120 : struct spdk_bs_load_ctx *ctx = cb_arg;
4153 : :
4154 [ - + ]: 120 : if (bserrno != 0) {
4155 : 0 : SPDK_ERRLOG("Failed to close corrupted blob\n");
4156 [ # # # # : 0 : spdk_bs_iter_next(ctx->bs, ctx->blob, bs_load_iter, ctx);
# # # # ]
4157 : 0 : return;
4158 : : }
4159 : :
4160 [ # # # # : 120 : spdk_bs_delete_blob(ctx->bs, ctx->blobid, bs_delete_corrupted_blob_cpl, ctx);
# # # # ]
4161 : 30 : }
4162 : :
4163 : : static void
4164 : 120 : bs_delete_corrupted_blob(void *cb_arg, int bserrno)
4165 : : {
4166 : 120 : struct spdk_bs_load_ctx *ctx = cb_arg;
4167 : : uint64_t i;
4168 : :
4169 [ - + ]: 120 : if (bserrno != 0) {
4170 : 0 : SPDK_ERRLOG("Failed to close clone of a corrupted blob\n");
4171 [ # # # # : 0 : spdk_bs_iter_next(ctx->bs, ctx->blob, bs_load_iter, ctx);
# # # # ]
4172 : 0 : return;
4173 : : }
4174 : :
4175 : : /* Snapshot and clone have the same copy of cluster map and extent pages
4176 : : * at this point. Let's clear both for snapshot now,
4177 : : * so that it won't be cleared for clone later when we remove snapshot.
4178 : : * Also set thin provision to pass data corruption check */
4179 [ + + # # : 1320 : for (i = 0; i < ctx->blob->active.num_clusters; i++) {
# # # # #
# # # ]
4180 [ # # # # : 1200 : ctx->blob->active.clusters[i] = 0;
# # # # #
# # # #
# ]
4181 : 300 : }
4182 [ + + # # : 192 : for (i = 0; i < ctx->blob->active.num_extent_pages; i++) {
# # # # #
# # # ]
4183 [ # # # # : 72 : ctx->blob->active.extent_pages[i] = 0;
# # # # #
# # # #
# ]
4184 : 18 : }
4185 : :
4186 [ # # # # : 120 : ctx->blob->active.num_allocated_clusters = 0;
# # # # #
# ]
4187 : :
4188 [ # # # # : 120 : ctx->blob->md_ro = false;
# # # # ]
4189 : :
4190 [ # # # # ]: 120 : blob_set_thin_provision(ctx->blob);
4191 : :
4192 [ # # # # : 120 : ctx->blobid = ctx->blob->id;
# # # # #
# # # ]
4193 : :
4194 [ # # # # ]: 120 : spdk_blob_close(ctx->blob, bs_delete_corrupted_close_cb, ctx);
4195 : 30 : }
4196 : :
4197 : : static void
4198 : 60 : bs_update_corrupted_blob(void *cb_arg, int bserrno)
4199 : : {
4200 : 60 : struct spdk_bs_load_ctx *ctx = cb_arg;
4201 : :
4202 [ - + ]: 60 : if (bserrno != 0) {
4203 : 0 : SPDK_ERRLOG("Failed to close clone of a corrupted blob\n");
4204 [ # # # # : 0 : spdk_bs_iter_next(ctx->bs, ctx->blob, bs_load_iter, ctx);
# # # # ]
4205 : 0 : return;
4206 : : }
4207 : :
4208 [ # # # # : 60 : ctx->blob->md_ro = false;
# # # # ]
4209 [ # # # # ]: 60 : blob_remove_xattr(ctx->blob, SNAPSHOT_PENDING_REMOVAL, true);
4210 [ # # # # ]: 60 : blob_remove_xattr(ctx->blob, SNAPSHOT_IN_PROGRESS, true);
4211 [ # # # # ]: 60 : spdk_blob_set_read_only(ctx->blob);
4212 : :
4213 [ - + # # : 60 : if (ctx->iter_cb_fn) {
# # ]
4214 [ # # # # : 0 : ctx->iter_cb_fn(ctx->iter_cb_arg, ctx->blob, 0);
# # # # #
# # # # #
# # ]
4215 : 0 : }
4216 [ # # # # ]: 60 : bs_blob_list_add(ctx->blob);
4217 : :
4218 [ # # # # : 60 : spdk_bs_iter_next(ctx->bs, ctx->blob, bs_load_iter, ctx);
# # # # ]
4219 : 15 : }
4220 : :
4221 : : static void
4222 : 180 : bs_examine_clone(void *cb_arg, struct spdk_blob *blob, int bserrno)
4223 : : {
4224 : 180 : struct spdk_bs_load_ctx *ctx = cb_arg;
4225 : :
4226 [ - + ]: 180 : if (bserrno != 0) {
4227 : 0 : SPDK_ERRLOG("Failed to open clone of a corrupted blob\n");
4228 [ # # # # : 0 : spdk_bs_iter_next(ctx->bs, ctx->blob, bs_load_iter, ctx);
# # # # ]
4229 : 0 : return;
4230 : : }
4231 : :
4232 [ + + # # : 180 : if (blob->parent_id == ctx->blob->id) {
# # # # #
# # # #
# ]
4233 : : /* Power failure occurred before updating clone (snapshot delete case)
4234 : : * or after updating clone (creating snapshot case) - keep snapshot */
4235 : 60 : spdk_blob_close(blob, bs_update_corrupted_blob, ctx);
4236 : 15 : } else {
4237 : : /* Power failure occurred after updating clone (snapshot delete case)
4238 : : * or before updating clone (creating snapshot case) - remove snapshot */
4239 : 120 : spdk_blob_close(blob, bs_delete_corrupted_blob, ctx);
4240 : : }
4241 : 45 : }
4242 : :
4243 : : static void
4244 : 10501 : bs_load_iter(void *arg, struct spdk_blob *blob, int bserrno)
4245 : : {
4246 : 10501 : struct spdk_bs_load_ctx *ctx = arg;
4247 : 9592 : const void *value;
4248 : 9592 : size_t len;
4249 : 10501 : int rc = 0;
4250 : :
4251 [ + + ]: 10501 : if (bserrno == 0) {
4252 : : /* Examine blob if it is corrupted after power failure. Fix
4253 : : * the ones that can be fixed and remove any other corrupted
4254 : : * ones. If it is not corrupted just process it */
4255 : 9000 : rc = blob_get_xattr_value(blob, SNAPSHOT_PENDING_REMOVAL, &value, &len, true);
4256 [ + + ]: 9000 : if (rc != 0) {
4257 : 8900 : rc = blob_get_xattr_value(blob, SNAPSHOT_IN_PROGRESS, &value, &len, true);
4258 [ + + ]: 8900 : if (rc != 0) {
4259 : : /* Not corrupted - process it and continue with iterating through blobs */
4260 [ + + # # : 8820 : if (ctx->iter_cb_fn) {
# # ]
4261 [ # # # # : 5386 : ctx->iter_cb_fn(ctx->iter_cb_arg, blob, 0);
# # # # #
# # # ]
4262 : 42 : }
4263 : 8820 : bs_blob_list_add(blob);
4264 [ # # # # ]: 8820 : spdk_bs_iter_next(ctx->bs, blob, bs_load_iter, ctx);
4265 : 8820 : return;
4266 : : }
4267 : :
4268 : 20 : }
4269 : :
4270 [ + + # # ]: 180 : assert(len == sizeof(spdk_blob_id));
4271 : :
4272 [ # # # # ]: 180 : ctx->blob = blob;
4273 : :
4274 : : /* Open clone to check if we are able to fix this blob or should we remove it */
4275 [ # # # # : 180 : spdk_bs_open_blob(ctx->bs, *(spdk_blob_id *)value, bs_examine_clone, ctx);
# # ]
4276 : 180 : return;
4277 [ + - ]: 1501 : } else if (bserrno == -ENOENT) {
4278 : 1501 : bserrno = 0;
4279 : 352 : } else {
4280 : : /*
4281 : : * This case needs to be looked at further. Same problem
4282 : : * exists with applications that rely on explicit blob
4283 : : * iteration. We should just skip the blob that failed
4284 : : * to load and continue on to the next one.
4285 : : */
4286 : 0 : SPDK_ERRLOG("Error in iterating blobs\n");
4287 : : }
4288 : :
4289 [ # # # # ]: 1501 : ctx->iter_cb_fn = NULL;
4290 : :
4291 [ # # # # ]: 1501 : spdk_free(ctx->super);
4292 [ # # # # ]: 1501 : bs_sequence_finish(ctx->seq, bserrno);
4293 : 1501 : free(ctx);
4294 : 909 : }
4295 : :
4296 : : static void bs_dump_read_md_page(spdk_bs_sequence_t *seq, void *cb_arg);
4297 : :
4298 : : static void
4299 : 1501 : bs_load_complete(struct spdk_bs_load_ctx *ctx)
4300 : : {
4301 [ # # # # : 1501 : ctx->bs->used_clusters = spdk_bit_pool_create_from_array(ctx->used_clusters);
# # # # #
# # # ]
4302 [ - + - + : 1501 : if (ctx->dumping) {
# # # # ]
4303 [ # # # # ]: 0 : bs_dump_read_md_page(ctx->seq, ctx);
4304 : 0 : return;
4305 : : }
4306 [ # # # # ]: 1501 : spdk_bs_iter_first(ctx->bs, bs_load_iter, ctx);
4307 : 352 : }
4308 : :
4309 : : static void
4310 : 5961 : bs_load_ctx_fail(struct spdk_bs_load_ctx *ctx, int bserrno)
4311 : : {
4312 [ + + # # ]: 5961 : assert(bserrno != 0);
4313 : :
4314 [ + - + - ]: 5961 : spdk_free(ctx->mask);
4315 [ + - + - ]: 5961 : spdk_free(ctx->super);
4316 [ + - + - ]: 5961 : bs_sequence_finish(ctx->seq, bserrno);
4317 [ + - + - ]: 5961 : bs_free(ctx->bs);
4318 [ + - ]: 5961 : spdk_bit_array_free(&ctx->used_clusters);
4319 : 5961 : free(ctx);
4320 : 5961 : }
4321 : :
4322 : : static void
4323 : 957 : bs_load_used_blobids_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4324 : : {
4325 : 957 : struct spdk_bs_load_ctx *ctx = cb_arg;
4326 : : int rc;
4327 : :
4328 : : /* The type must be correct */
4329 [ + + # # : 957 : assert(ctx->mask->type == SPDK_MD_MASK_TYPE_USED_BLOBIDS);
# # # # #
# # # ]
4330 : :
4331 : : /* The length of the mask (in bits) must not be greater than
4332 : : * the length of the buffer (converted to bits) */
4333 [ + + # # : 957 : assert(ctx->mask->length <= (ctx->super->used_blobid_mask_len * ctx->super->md_page_size * 8));
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
4334 : :
4335 : : /* The length of the mask must be exactly equal to the size
4336 : : * (in pages) of the metadata region */
4337 [ - + # # : 957 : assert(ctx->mask->length == ctx->super->md_len);
# # # # #
# # # # #
# # # # #
# ]
4338 : :
4339 [ # # # # : 957 : rc = spdk_bit_array_resize(&ctx->bs->used_blobids, ctx->mask->length);
# # # # #
# # # #
# ]
4340 [ + + ]: 957 : if (rc < 0) {
4341 : 0 : bs_load_ctx_fail(ctx, rc);
4342 : 0 : return;
4343 : : }
4344 : :
4345 [ # # # # : 957 : spdk_bit_array_load_mask(ctx->bs->used_blobids, ctx->mask->mask);
# # # # #
# # # #
# ]
4346 [ # # # # ]: 957 : spdk_free(ctx->mask);
4347 : :
4348 : 957 : bs_load_complete(ctx);
4349 : 218 : }
4350 : :
4351 : : static void
4352 : 957 : bs_load_used_clusters_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4353 : : {
4354 : 957 : struct spdk_bs_load_ctx *ctx = cb_arg;
4355 : : uint64_t lba, lba_count, mask_size;
4356 : : int rc;
4357 : :
4358 [ - + ]: 957 : if (bserrno != 0) {
4359 : 0 : bs_load_ctx_fail(ctx, bserrno);
4360 : 0 : return;
4361 : : }
4362 : :
4363 : : /* The type must be correct */
4364 [ + + # # : 957 : assert(ctx->mask->type == SPDK_MD_MASK_TYPE_USED_CLUSTERS);
# # # # #
# # # ]
4365 : : /* The length of the mask (in bits) must not be greater than the length of the buffer (converted to bits) */
4366 [ + + # # : 957 : assert(ctx->mask->length <= (ctx->super->used_cluster_mask_len * sizeof(
# # # # #
# # # # #
# # # # #
# ]
4367 : : struct spdk_blob_md_page) * 8));
4368 : : /*
4369 : : * The length of the mask must be equal to or larger than the total number of clusters. It may be
4370 : : * larger than the total number of clusters due to a failure spdk_bs_grow.
4371 : : */
4372 [ + + # # : 957 : assert(ctx->mask->length >= ctx->bs->total_clusters);
# # # # #
# # # # #
# # # # #
# ]
4373 [ + + # # : 957 : if (ctx->mask->length > ctx->bs->total_clusters) {
# # # # #
# # # # #
# # # # ]
4374 : 20 : SPDK_WARNLOG("Shrink the used_custers mask length to total_clusters");
4375 [ # # # # : 20 : ctx->mask->length = ctx->bs->total_clusters;
# # # # #
# # # # #
# # ]
4376 : 5 : }
4377 : :
4378 [ # # # # : 957 : rc = spdk_bit_array_resize(&ctx->used_clusters, ctx->mask->length);
# # # # #
# ]
4379 [ + + ]: 957 : if (rc < 0) {
4380 [ # # # # ]: 0 : spdk_free(ctx->mask);
4381 : 0 : bs_load_ctx_fail(ctx, rc);
4382 : 0 : return;
4383 : : }
4384 : :
4385 [ # # # # : 957 : spdk_bit_array_load_mask(ctx->used_clusters, ctx->mask->mask);
# # # # #
# ]
4386 [ # # # # : 957 : ctx->bs->num_free_clusters = spdk_bit_array_count_clear(ctx->used_clusters);
# # # # #
# # # ]
4387 [ - + # # : 957 : assert(ctx->bs->num_free_clusters <= ctx->bs->total_clusters);
# # # # #
# # # # #
# # # # #
# ]
4388 : :
4389 [ # # # # ]: 957 : spdk_free(ctx->mask);
4390 : :
4391 : : /* Read the used blobids mask */
4392 [ # # # # : 957 : mask_size = ctx->super->used_blobid_mask_len * ctx->super->md_page_size;
# # # # #
# # # # #
# # ]
4393 [ # # # # ]: 957 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL, SPDK_ENV_NUMA_ID_ANY,
4394 : : SPDK_MALLOC_DMA);
4395 [ + + # # : 957 : if (!ctx->mask) {
# # ]
4396 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4397 : 0 : return;
4398 : : }
4399 [ # # # # : 957 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_start);
# # # # #
# # # ]
4400 [ # # # # : 957 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_blobid_mask_len);
# # # # #
# # # ]
4401 [ # # # # ]: 1175 : bs_sequence_read_dev(seq, ctx->mask, lba, lba_count,
4402 : 218 : bs_load_used_blobids_cpl, ctx);
4403 : 218 : }
4404 : :
4405 : : static void
4406 : 977 : bs_load_used_pages_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4407 : : {
4408 : 977 : struct spdk_bs_load_ctx *ctx = cb_arg;
4409 : : uint64_t lba, lba_count, mask_size;
4410 : : int rc;
4411 : :
4412 [ + + ]: 977 : if (bserrno != 0) {
4413 : 20 : bs_load_ctx_fail(ctx, bserrno);
4414 : 20 : return;
4415 : : }
4416 : :
4417 : : /* The type must be correct */
4418 [ + + # # : 957 : assert(ctx->mask->type == SPDK_MD_MASK_TYPE_USED_PAGES);
# # # # #
# # # ]
4419 : : /* The length of the mask (in bits) must not be greater than the length of the buffer (converted to bits) */
4420 [ + + # # : 957 : assert(ctx->mask->length <= (ctx->super->used_page_mask_len * ctx->super->md_page_size *
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
4421 : : 8));
4422 : : /* The length of the mask must be exactly equal to the size (in pages) of the metadata region */
4423 [ + + # # : 957 : if (ctx->mask->length != ctx->super->md_len) {
# # # # #
# # # # #
# # # # ]
4424 [ # # # # : 0 : SPDK_ERRLOG("mismatched md_len in used_pages mask: "
# # # # #
# # # # #
# # ]
4425 : : "mask->length=%" PRIu32 " super->md_len=%" PRIu32 "\n",
4426 : : ctx->mask->length, ctx->super->md_len);
4427 [ # # ]: 0 : assert(false);
4428 : : }
4429 : :
4430 [ # # # # : 957 : rc = spdk_bit_array_resize(&ctx->bs->used_md_pages, ctx->mask->length);
# # # # #
# # # #
# ]
4431 [ + + ]: 957 : if (rc < 0) {
4432 : 0 : bs_load_ctx_fail(ctx, rc);
4433 : 0 : return;
4434 : : }
4435 : :
4436 [ # # # # : 957 : spdk_bit_array_load_mask(ctx->bs->used_md_pages, ctx->mask->mask);
# # # # #
# # # #
# ]
4437 [ # # # # ]: 957 : spdk_free(ctx->mask);
4438 : :
4439 : : /* Read the used clusters mask */
4440 [ # # # # : 957 : mask_size = ctx->super->used_cluster_mask_len * ctx->super->md_page_size;
# # # # #
# # # # #
# # ]
4441 [ # # # # ]: 957 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL, SPDK_ENV_NUMA_ID_ANY,
4442 : : SPDK_MALLOC_DMA);
4443 [ - + # # : 957 : if (!ctx->mask) {
# # ]
4444 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4445 : 0 : return;
4446 : : }
4447 [ # # # # : 957 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
# # # # #
# # # ]
4448 [ # # # # : 957 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
# # # # #
# # # ]
4449 [ # # # # ]: 1175 : bs_sequence_read_dev(seq, ctx->mask, lba, lba_count,
4450 : 218 : bs_load_used_clusters_cpl, ctx);
4451 : 223 : }
4452 : :
4453 : : static void
4454 : 997 : bs_load_read_used_pages(struct spdk_bs_load_ctx *ctx)
4455 : : {
4456 : : uint64_t lba, lba_count, mask_size;
4457 : :
4458 : : /* Read the used pages mask */
4459 [ # # # # : 997 : mask_size = ctx->super->used_page_mask_len * ctx->super->md_page_size;
# # # # #
# # # # #
# # ]
4460 [ # # # # ]: 997 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL,
4461 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
4462 [ + + # # : 997 : if (!ctx->mask) {
# # ]
4463 : 20 : bs_load_ctx_fail(ctx, -ENOMEM);
4464 : 20 : return;
4465 : : }
4466 : :
4467 [ # # # # : 977 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_start);
# # # # #
# # # ]
4468 [ # # # # : 977 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_page_mask_len);
# # # # #
# # # ]
4469 [ # # # # : 1200 : bs_sequence_read_dev(ctx->seq, ctx->mask, lba, lba_count,
# # # # ]
4470 : 223 : bs_load_used_pages_cpl, ctx);
4471 : 228 : }
4472 : :
4473 : : static int
4474 : 1317 : bs_load_replay_md_parse_page(struct spdk_bs_load_ctx *ctx, struct spdk_blob_md_page *page)
4475 : : {
4476 [ # # # # ]: 1317 : struct spdk_blob_store *bs = ctx->bs;
4477 : : struct spdk_blob_md_descriptor *desc;
4478 : 1317 : size_t cur_desc = 0;
4479 : :
4480 [ # # ]: 1317 : desc = (struct spdk_blob_md_descriptor *)page->descriptors;
4481 [ + + ]: 3830 : while (cur_desc < sizeof(page->descriptors)) {
4482 [ + + # # : 3830 : if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_PADDING) {
# # ]
4483 [ + + # # : 1217 : if (desc->length == 0) {
# # ]
4484 : : /* If padding and length are 0, this terminates the page */
4485 : 1217 : break;
4486 : : }
4487 [ + + # # : 2613 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE) {
# # ]
4488 : : struct spdk_blob_md_descriptor_extent_rle *desc_extent_rle;
4489 : : unsigned int i, j;
4490 : 272 : unsigned int cluster_count = 0;
4491 : : uint32_t cluster_idx;
4492 : :
4493 : 272 : desc_extent_rle = (struct spdk_blob_md_descriptor_extent_rle *)desc;
4494 : :
4495 [ + + # # : 544 : for (i = 0; i < desc_extent_rle->length / sizeof(desc_extent_rle->extents[0]); i++) {
# # # # ]
4496 [ + + # # : 3312 : for (j = 0; j < desc_extent_rle->extents[i].length; j++) {
# # # # #
# ]
4497 [ # # # # : 3040 : cluster_idx = desc_extent_rle->extents[i].cluster_idx;
# # # # ]
4498 : : /*
4499 : : * cluster_idx = 0 means an unallocated cluster - don't mark that
4500 : : * in the used cluster map.
4501 : : */
4502 [ + + ]: 3040 : if (cluster_idx != 0) {
4503 : 2160 : SPDK_NOTICELOG("Recover: cluster %" PRIu32 "\n", cluster_idx + j);
4504 [ # # # # ]: 2160 : spdk_bit_array_set(ctx->used_clusters, cluster_idx + j);
4505 [ + + # # : 2160 : if (bs->num_free_clusters == 0) {
# # ]
4506 : 0 : return -ENOSPC;
4507 : : }
4508 [ # # ]: 2160 : bs->num_free_clusters--;
4509 : 540 : }
4510 : 3040 : cluster_count++;
4511 : 760 : }
4512 : 68 : }
4513 [ + + ]: 272 : if (cluster_count == 0) {
4514 : 0 : return -EINVAL;
4515 : : }
4516 [ + + # # : 2409 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE) {
# # ]
4517 : : struct spdk_blob_md_descriptor_extent_page *desc_extent;
4518 : : uint32_t i;
4519 : 321 : uint32_t cluster_count = 0;
4520 : : uint32_t cluster_idx;
4521 : : size_t cluster_idx_length;
4522 : :
4523 : 321 : desc_extent = (struct spdk_blob_md_descriptor_extent_page *)desc;
4524 [ # # # # ]: 321 : cluster_idx_length = desc_extent->length - sizeof(desc_extent->start_cluster_idx);
4525 : :
4526 [ + - - + : 321 : if (desc_extent->length <= sizeof(desc_extent->start_cluster_idx) ||
# # # # ]
4527 [ - + ]: 321 : (cluster_idx_length % sizeof(desc_extent->cluster_idx[0]) != 0)) {
4528 : 0 : return -EINVAL;
4529 : : }
4530 : :
4531 [ + + # # ]: 4955 : for (i = 0; i < cluster_idx_length / sizeof(desc_extent->cluster_idx[0]); i++) {
4532 [ # # # # : 4634 : cluster_idx = desc_extent->cluster_idx[i];
# # ]
4533 : : /*
4534 : : * cluster_idx = 0 means an unallocated cluster - don't mark that
4535 : : * in the used cluster map.
4536 : : */
4537 [ + + ]: 4634 : if (cluster_idx != 0) {
4538 [ + + # # : 3868 : if (cluster_idx < desc_extent->start_cluster_idx &&
# # # # ]
4539 [ - + # # ]: 1 : cluster_idx >= desc_extent->start_cluster_idx + cluster_count) {
4540 : 0 : return -EINVAL;
4541 : : }
4542 [ # # # # ]: 3868 : spdk_bit_array_set(ctx->used_clusters, cluster_idx);
4543 [ + + # # : 3868 : if (bs->num_free_clusters == 0) {
# # ]
4544 : 0 : return -ENOSPC;
4545 : : }
4546 [ # # ]: 3868 : bs->num_free_clusters--;
4547 : 900 : }
4548 : 4634 : cluster_count++;
4549 : 900 : }
4550 : :
4551 [ + + ]: 321 : if (cluster_count == 0) {
4552 : 0 : return -EINVAL;
4553 : : }
4554 [ + + # # : 2098 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR) {
# # ]
4555 : : /* Skip this item */
4556 [ + + # # : 1703 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL) {
# # ]
4557 : : /* Skip this item */
4558 [ + + # # : 1380 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_FLAGS) {
# # ]
4559 : : /* Skip this item */
4560 [ + - # # : 703 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_TABLE) {
# # ]
4561 : : struct spdk_blob_md_descriptor_extent_table *desc_extent_table;
4562 [ # # # # ]: 508 : uint32_t num_extent_pages = ctx->num_extent_pages;
4563 : : uint32_t i;
4564 : : size_t extent_pages_length;
4565 : : void *tmp;
4566 : :
4567 : 508 : desc_extent_table = (struct spdk_blob_md_descriptor_extent_table *)desc;
4568 [ # # # # ]: 508 : extent_pages_length = desc_extent_table->length - sizeof(desc_extent_table->num_clusters);
4569 : :
4570 [ + - - + : 508 : if (desc_extent_table->length == 0 ||
# # # # ]
4571 [ - + ]: 508 : (extent_pages_length % sizeof(desc_extent_table->extent_page[0]) != 0)) {
4572 : 0 : return -EINVAL;
4573 : : }
4574 : :
4575 [ + + # # ]: 986 : for (i = 0; i < extent_pages_length / sizeof(desc_extent_table->extent_page[0]); i++) {
4576 [ + + # # : 478 : if (desc_extent_table->extent_page[i].page_idx != 0) {
# # # # #
# ]
4577 [ + + # # : 321 : if (desc_extent_table->extent_page[i].num_pages != 1) {
# # # # #
# ]
4578 : 0 : return -EINVAL;
4579 : : }
4580 : 321 : num_extent_pages += 1;
4581 : 78 : }
4582 : 117 : }
4583 : :
4584 [ + + ]: 508 : if (num_extent_pages > 0) {
4585 [ # # # # ]: 320 : tmp = realloc(ctx->extent_page_num, num_extent_pages * sizeof(uint32_t));
4586 [ + + ]: 320 : if (tmp == NULL) {
4587 : 0 : return -ENOMEM;
4588 : : }
4589 [ # # # # ]: 320 : ctx->extent_page_num = tmp;
4590 : :
4591 : : /* Extent table entries contain md page numbers for extent pages.
4592 : : * Zeroes represent unallocated extent pages, those are run-length-encoded.
4593 : : */
4594 [ + + # # ]: 642 : for (i = 0; i < extent_pages_length / sizeof(desc_extent_table->extent_page[0]); i++) {
4595 [ + + # # : 322 : if (desc_extent_table->extent_page[i].page_idx != 0) {
# # # # #
# ]
4596 [ # # # # : 321 : ctx->extent_page_num[ctx->num_extent_pages] = desc_extent_table->extent_page[i].page_idx;
# # # # #
# # # # #
# # # # #
# ]
4597 [ # # # # ]: 321 : ctx->num_extent_pages += 1;
4598 : 78 : }
4599 : 78 : }
4600 : 78 : }
4601 : 123 : } else {
4602 : : /* Error */
4603 : 0 : return -EINVAL;
4604 : : }
4605 : : /* Advance to the next descriptor */
4606 [ # # # # ]: 2613 : cur_desc += sizeof(*desc) + desc->length;
4607 [ + + ]: 2613 : if (cur_desc + sizeof(*desc) > sizeof(page->descriptors)) {
4608 : 100 : break;
4609 : : }
4610 [ # # ]: 2513 : desc = (struct spdk_blob_md_descriptor *)((uintptr_t)page->descriptors + cur_desc);
4611 : : }
4612 : 1317 : return 0;
4613 : 323 : }
4614 : :
4615 : : static bool
4616 : 33437 : bs_load_cur_extent_page_valid(struct spdk_blob_md_page *page)
4617 : : {
4618 : : uint32_t crc;
4619 [ # # ]: 33437 : struct spdk_blob_md_descriptor *desc = (struct spdk_blob_md_descriptor *)page->descriptors;
4620 : : size_t desc_len;
4621 : :
4622 : 33437 : crc = blob_md_page_calc_crc(page);
4623 [ - + # # : 33437 : if (crc != page->crc) {
# # ]
4624 : 0 : return false;
4625 : : }
4626 : :
4627 : : /* Extent page should always be of sequence num 0. */
4628 [ + + # # : 33437 : if (page->sequence_num != 0) {
# # ]
4629 : 220 : return false;
4630 : : }
4631 : :
4632 : : /* Descriptor type must be EXTENT_PAGE. */
4633 [ + + # # : 33217 : if (desc->type != SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE) {
# # ]
4634 : 796 : return false;
4635 : : }
4636 : :
4637 : : /* Descriptor length cannot exceed the page. */
4638 [ # # # # ]: 32421 : desc_len = sizeof(*desc) + desc->length;
4639 [ - + ]: 32421 : if (desc_len > sizeof(page->descriptors)) {
4640 : 0 : return false;
4641 : : }
4642 : :
4643 : : /* It has to be the only descriptor in the page. */
4644 [ + + ]: 32421 : if (desc_len + sizeof(*desc) <= sizeof(page->descriptors)) {
4645 [ # # ]: 32421 : desc = (struct spdk_blob_md_descriptor *)((uintptr_t)page->descriptors + desc_len);
4646 [ + + # # : 32421 : if (desc->length != 0) {
# # ]
4647 : 0 : return false;
4648 : : }
4649 : 1645 : }
4650 : :
4651 : 32421 : return true;
4652 : 1895 : }
4653 : :
4654 : : static bool
4655 : 36445 : bs_load_cur_md_page_valid(struct spdk_bs_load_ctx *ctx)
4656 : : {
4657 : : uint32_t crc;
4658 [ # # # # ]: 36445 : struct spdk_blob_md_page *page = ctx->page;
4659 : :
4660 : 36445 : crc = blob_md_page_calc_crc(page);
4661 [ + + # # : 36445 : if (crc != page->crc) {
# # ]
4662 : 35321 : return false;
4663 : : }
4664 : :
4665 : : /* First page of a sequence should match the blobid. */
4666 [ + + + + : 1124 : if (page->sequence_num == 0 &&
# # # # ]
4667 [ + + # # : 904 : bs_page_to_blobid(ctx->cur_page) != page->id) {
# # # # ]
4668 : 108 : return false;
4669 : : }
4670 [ + + # # ]: 1016 : assert(bs_load_cur_extent_page_valid(page) == false);
4671 : :
4672 : 1016 : return true;
4673 : 8531 : }
4674 : :
4675 : : static void bs_load_replay_cur_md_page(struct spdk_bs_load_ctx *ctx);
4676 : :
4677 : : static void
4678 : 544 : bs_load_write_used_clusters_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4679 : : {
4680 : 544 : struct spdk_bs_load_ctx *ctx = cb_arg;
4681 : :
4682 [ # # # # ]: 544 : spdk_free(ctx->mask);
4683 [ # # # # ]: 544 : ctx->mask = NULL;
4684 : :
4685 [ - + ]: 544 : if (bserrno != 0) {
4686 : 0 : bs_load_ctx_fail(ctx, bserrno);
4687 : 0 : return;
4688 : : }
4689 : :
4690 : 544 : bs_load_complete(ctx);
4691 : 134 : }
4692 : :
4693 : : static void
4694 : 544 : bs_load_write_used_blobids_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4695 : : {
4696 : 544 : struct spdk_bs_load_ctx *ctx = cb_arg;
4697 : :
4698 [ # # # # ]: 544 : spdk_free(ctx->mask);
4699 [ # # # # ]: 544 : ctx->mask = NULL;
4700 : :
4701 [ - + ]: 544 : if (bserrno != 0) {
4702 : 0 : bs_load_ctx_fail(ctx, bserrno);
4703 : 0 : return;
4704 : : }
4705 : :
4706 : 544 : bs_write_used_clusters(seq, ctx, bs_load_write_used_clusters_cpl);
4707 : 134 : }
4708 : :
4709 : : static void
4710 : 544 : bs_load_write_used_pages_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4711 : : {
4712 : 544 : struct spdk_bs_load_ctx *ctx = cb_arg;
4713 : :
4714 [ # # # # ]: 544 : spdk_free(ctx->mask);
4715 [ # # # # ]: 544 : ctx->mask = NULL;
4716 : :
4717 [ - + ]: 544 : if (bserrno != 0) {
4718 : 0 : bs_load_ctx_fail(ctx, bserrno);
4719 : 0 : return;
4720 : : }
4721 : :
4722 : 544 : bs_write_used_blobids(seq, ctx, bs_load_write_used_blobids_cpl);
4723 : 134 : }
4724 : :
4725 : : static void
4726 : 544 : bs_load_write_used_md(struct spdk_bs_load_ctx *ctx)
4727 : : {
4728 [ # # # # ]: 544 : bs_write_used_md(ctx->seq, ctx, bs_load_write_used_pages_cpl);
4729 : 544 : }
4730 : :
4731 : : static void
4732 : 36245 : bs_load_replay_md_chain_cpl(struct spdk_bs_load_ctx *ctx)
4733 : : {
4734 : : uint64_t num_md_clusters;
4735 : : uint64_t i;
4736 : :
4737 [ # # # # ]: 36245 : ctx->in_page_chain = false;
4738 : :
4739 : 8481 : do {
4740 [ # # ]: 36634 : ctx->page_index++;
4741 [ + + # # : 36634 : } while (spdk_bit_array_get(ctx->bs->used_md_pages, ctx->page_index) == true);
# # # # #
# # # #
# ]
4742 : :
4743 [ + + # # : 36245 : if (ctx->page_index < ctx->super->md_len) {
# # # # #
# # # #
# ]
4744 [ # # # # : 35701 : ctx->cur_page = ctx->page_index;
# # # # ]
4745 : 35701 : bs_load_replay_cur_md_page(ctx);
4746 : 8347 : } else {
4747 : : /* Claim all of the clusters used by the metadata */
4748 : 544 : num_md_clusters = spdk_divide_round_up(
4749 [ # # # # : 954 : ctx->super->md_start + ctx->super->md_len, ctx->bs->pages_per_cluster);
# # # # #
# # # # #
# # # # #
# # # #
# ]
4750 [ + + ]: 2533 : for (i = 0; i < num_md_clusters; i++) {
4751 [ # # # # ]: 1989 : spdk_bit_array_set(ctx->used_clusters, i);
4752 : 495 : }
4753 [ # # # # : 544 : ctx->bs->num_free_clusters -= num_md_clusters;
# # # # ]
4754 [ # # # # ]: 544 : spdk_free(ctx->page);
4755 : 544 : bs_load_write_used_md(ctx);
4756 : : }
4757 : 36245 : }
4758 : :
4759 : : static void
4760 : 320 : bs_load_replay_extent_page_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4761 : : {
4762 : 320 : struct spdk_bs_load_ctx *ctx = cb_arg;
4763 : : uint32_t page_num;
4764 : : uint64_t i;
4765 : :
4766 [ - + ]: 320 : if (bserrno != 0) {
4767 [ # # # # ]: 0 : spdk_free(ctx->extent_pages);
4768 : 0 : bs_load_ctx_fail(ctx, bserrno);
4769 : 0 : return;
4770 : : }
4771 : :
4772 [ + + # # : 641 : for (i = 0; i < ctx->num_extent_pages; i++) {
# # ]
4773 : : /* Extent pages are only read when present within in chain md.
4774 : : * Integrity of md is not right if that page was not a valid extent page. */
4775 [ + + # # : 321 : if (bs_load_cur_extent_page_valid(&ctx->extent_pages[i]) != true) {
# # # # ]
4776 [ # # # # ]: 0 : spdk_free(ctx->extent_pages);
4777 : 0 : bs_load_ctx_fail(ctx, -EILSEQ);
4778 : 0 : return;
4779 : : }
4780 : :
4781 [ # # # # : 321 : page_num = ctx->extent_page_num[i];
# # # # ]
4782 [ # # # # : 321 : spdk_bit_array_set(ctx->bs->used_md_pages, page_num);
# # # # ]
4783 [ - + # # : 321 : if (bs_load_replay_md_parse_page(ctx, &ctx->extent_pages[i])) {
# # # # ]
4784 [ # # # # ]: 0 : spdk_free(ctx->extent_pages);
4785 : 0 : bs_load_ctx_fail(ctx, -EILSEQ);
4786 : 0 : return;
4787 : : }
4788 : 78 : }
4789 : :
4790 [ # # # # ]: 320 : spdk_free(ctx->extent_pages);
4791 [ # # # # ]: 320 : free(ctx->extent_page_num);
4792 [ # # # # ]: 320 : ctx->extent_page_num = NULL;
4793 [ # # # # ]: 320 : ctx->num_extent_pages = 0;
4794 : :
4795 : 320 : bs_load_replay_md_chain_cpl(ctx);
4796 : 78 : }
4797 : :
4798 : : static void
4799 : 320 : bs_load_replay_extent_pages(struct spdk_bs_load_ctx *ctx)
4800 : : {
4801 : : spdk_bs_batch_t *batch;
4802 : : uint32_t page;
4803 : : uint64_t lba;
4804 : : uint64_t i;
4805 : :
4806 [ # # # # : 320 : ctx->extent_pages = spdk_zmalloc(ctx->super->md_page_size * ctx->num_extent_pages, 0,
# # # # #
# # # # #
# # ]
4807 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
4808 [ + + # # : 320 : if (!ctx->extent_pages) {
# # ]
4809 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4810 : 0 : return;
4811 : : }
4812 : :
4813 [ # # # # ]: 320 : batch = bs_sequence_to_batch(ctx->seq, bs_load_replay_extent_page_cpl, ctx);
4814 : :
4815 [ + + # # : 641 : for (i = 0; i < ctx->num_extent_pages; i++) {
# # ]
4816 [ # # # # : 321 : page = ctx->extent_page_num[i];
# # # # ]
4817 [ + + # # : 321 : assert(page < ctx->super->md_len);
# # # # #
# # # ]
4818 [ # # # # ]: 321 : lba = bs_md_page_to_lba(ctx->bs, page);
4819 [ # # # # : 399 : bs_batch_read_dev(batch, &ctx->extent_pages[i], lba,
# # ]
4820 [ # # # # : 321 : bs_byte_to_lba(ctx->bs, ctx->super->md_page_size));
# # # # #
# # # ]
4821 : 78 : }
4822 : :
4823 : 320 : bs_batch_close(batch);
4824 : 78 : }
4825 : :
4826 : : static void
4827 : 36445 : bs_load_replay_md_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4828 : : {
4829 : 36445 : struct spdk_bs_load_ctx *ctx = cb_arg;
4830 : : uint32_t page_num;
4831 : : struct spdk_blob_md_page *page;
4832 : :
4833 [ - + ]: 36445 : if (bserrno != 0) {
4834 : 0 : bs_load_ctx_fail(ctx, bserrno);
4835 : 0 : return;
4836 : : }
4837 : :
4838 [ # # # # ]: 36445 : page_num = ctx->cur_page;
4839 [ # # # # ]: 36445 : page = ctx->page;
4840 [ + + ]: 36445 : if (bs_load_cur_md_page_valid(ctx) == true) {
4841 [ + + + + : 1016 : if (page->sequence_num == 0 || ctx->in_page_chain == true) {
+ + # # #
# # # #
# ]
4842 [ # # # # : 996 : spdk_spin_lock(&ctx->bs->used_lock);
# # ]
4843 [ # # # # ]: 996 : bs_claim_md_page(ctx->bs, page_num);
4844 [ # # # # : 996 : spdk_spin_unlock(&ctx->bs->used_lock);
# # ]
4845 [ + + # # : 996 : if (page->sequence_num == 0) {
# # ]
4846 : 796 : SPDK_NOTICELOG("Recover: blob 0x%" PRIx32 "\n", page_num);
4847 [ # # # # : 796 : spdk_bit_array_set(ctx->bs->used_blobids, page_num);
# # # # ]
4848 : 195 : }
4849 [ - + ]: 996 : if (bs_load_replay_md_parse_page(ctx, page)) {
4850 : 0 : bs_load_ctx_fail(ctx, -EILSEQ);
4851 : 0 : return;
4852 : : }
4853 [ + + # # : 996 : if (page->next != SPDK_INVALID_MD_PAGE) {
# # ]
4854 [ # # # # ]: 200 : ctx->in_page_chain = true;
4855 [ # # # # : 200 : ctx->cur_page = page->next;
# # # # ]
4856 : 200 : bs_load_replay_cur_md_page(ctx);
4857 : 200 : return;
4858 : : }
4859 [ + + # # : 796 : if (ctx->num_extent_pages != 0) {
# # ]
4860 : 320 : bs_load_replay_extent_pages(ctx);
4861 : 320 : return;
4862 : : }
4863 : 117 : }
4864 : 122 : }
4865 : 35925 : bs_load_replay_md_chain_cpl(ctx);
4866 : 8531 : }
4867 : :
4868 : : static void
4869 : 36445 : bs_load_replay_cur_md_page(struct spdk_bs_load_ctx *ctx)
4870 : : {
4871 : : uint64_t lba;
4872 : :
4873 [ + + # # : 36445 : assert(ctx->cur_page < ctx->super->md_len);
# # # # #
# # # # #
# # ]
4874 [ # # # # : 36445 : lba = bs_md_page_to_lba(ctx->bs, ctx->cur_page);
# # # # ]
4875 [ # # # # : 44976 : bs_sequence_read_dev(ctx->seq, ctx->page, lba,
# # # # ]
4876 [ # # # # : 36445 : bs_byte_to_lba(ctx->bs, ctx->super->md_page_size),
# # # # #
# # # ]
4877 : 8531 : bs_load_replay_md_cpl, ctx);
4878 : 36445 : }
4879 : :
4880 : : static void
4881 : 544 : bs_load_replay_md(struct spdk_bs_load_ctx *ctx)
4882 : : {
4883 [ # # # # ]: 544 : ctx->page_index = 0;
4884 [ # # # # ]: 544 : ctx->cur_page = 0;
4885 [ # # # # : 544 : ctx->page = spdk_zmalloc(ctx->bs->md_page_size, 0,
# # # # #
# # # ]
4886 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
4887 [ - + # # : 544 : if (!ctx->page) {
# # ]
4888 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4889 : 0 : return;
4890 : : }
4891 : 544 : bs_load_replay_cur_md_page(ctx);
4892 : 134 : }
4893 : :
4894 : : static void
4895 : 544 : bs_recover(struct spdk_bs_load_ctx *ctx)
4896 : : {
4897 : : int rc;
4898 : :
4899 : 544 : SPDK_NOTICELOG("Performing recovery on blobstore\n");
4900 [ # # # # : 544 : rc = spdk_bit_array_resize(&ctx->bs->used_md_pages, ctx->super->md_len);
# # # # #
# # # #
# ]
4901 [ + + ]: 544 : if (rc < 0) {
4902 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4903 : 0 : return;
4904 : : }
4905 : :
4906 [ # # # # : 544 : rc = spdk_bit_array_resize(&ctx->bs->used_blobids, ctx->super->md_len);
# # # # #
# # # #
# ]
4907 [ + + ]: 544 : if (rc < 0) {
4908 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4909 : 0 : return;
4910 : : }
4911 : :
4912 [ # # # # : 544 : rc = spdk_bit_array_resize(&ctx->used_clusters, ctx->bs->total_clusters);
# # # # #
# ]
4913 [ + + ]: 544 : if (rc < 0) {
4914 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4915 : 0 : return;
4916 : : }
4917 : :
4918 [ # # # # : 544 : rc = spdk_bit_array_resize(&ctx->bs->open_blobids, ctx->super->md_len);
# # # # #
# # # #
# ]
4919 [ - + ]: 544 : if (rc < 0) {
4920 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
4921 : 0 : return;
4922 : : }
4923 : :
4924 [ # # # # : 544 : ctx->bs->num_free_clusters = ctx->bs->total_clusters;
# # # # #
# # # # #
# # ]
4925 : 544 : bs_load_replay_md(ctx);
4926 : 134 : }
4927 : :
4928 : : static int
4929 : 1521 : bs_parse_super(struct spdk_bs_load_ctx *ctx)
4930 : : {
4931 : : int rc;
4932 : :
4933 [ + + # # : 1521 : if (ctx->super->size == 0) {
# # # # #
# ]
4934 [ # # # # : 40 : ctx->super->size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
4935 : 10 : }
4936 : :
4937 [ + + # # : 1521 : if (ctx->super->io_unit_size == 0) {
# # # # #
# ]
4938 [ # # # # : 40 : ctx->super->io_unit_size = SPDK_BS_PAGE_SIZE;
# # # # ]
4939 : 10 : }
4940 [ + + # # : 1521 : if (ctx->super->md_page_size == 0) {
# # # # #
# ]
4941 [ # # # # : 20 : ctx->super->md_page_size = SPDK_BS_PAGE_SIZE;
# # # # ]
4942 : 5 : }
4943 : :
4944 [ # # # # : 1521 : ctx->bs->clean = 1;
# # # # ]
4945 [ # # # # : 1521 : ctx->bs->cluster_sz = ctx->super->cluster_size;
# # # # #
# # # # #
# # ]
4946 [ - + # # : 1521 : ctx->bs->total_clusters = ctx->super->size / ctx->super->cluster_size;
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
4947 [ # # # # : 1521 : ctx->bs->io_unit_size = ctx->super->io_unit_size;
# # # # #
# # # # #
# # ]
4948 [ # # # # : 1521 : ctx->bs->md_page_size = ctx->super->md_page_size;
# # # # #
# # # # #
# # ]
4949 [ # # # # ]: 1521 : bs_init_per_cluster_fields(ctx->bs);
4950 [ # # # # : 1521 : rc = spdk_bit_array_resize(&ctx->used_clusters, ctx->bs->total_clusters);
# # # # #
# ]
4951 [ + + ]: 1521 : if (rc < 0) {
4952 : 0 : return -ENOMEM;
4953 : : }
4954 [ # # # # : 1521 : ctx->bs->md_start = ctx->super->md_start;
# # # # #
# # # # #
# # ]
4955 [ # # # # : 1521 : ctx->bs->md_len = ctx->super->md_len;
# # # # #
# # # # #
# # ]
4956 [ # # # # : 1521 : rc = spdk_bit_array_resize(&ctx->bs->open_blobids, ctx->bs->md_len);
# # # # #
# # # #
# ]
4957 [ - + ]: 1521 : if (rc < 0) {
4958 : 0 : return -ENOMEM;
4959 : : }
4960 : :
4961 [ # # # # : 4206 : ctx->bs->total_data_clusters = ctx->bs->total_clusters - spdk_divide_round_up(
# # # # #
# # # # #
# # ]
4962 [ # # # # : 2685 : ctx->bs->md_start + ctx->bs->md_len, ctx->bs->pages_per_cluster);
# # # # #
# # # # #
# # # # #
# # # #
# ]
4963 [ # # # # : 1521 : ctx->bs->super_blob = ctx->super->super_blob;
# # # # #
# # # # #
# # ]
4964 [ # # # # : 1521 : memcpy(&ctx->bs->bstype, &ctx->super->bstype, sizeof(ctx->super->bstype));
# # # # #
# # # # #
# # ]
4965 : :
4966 : 1521 : return 0;
4967 : 357 : }
4968 : :
4969 : : static void
4970 : 7442 : bs_load_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
4971 : : {
4972 : 7442 : struct spdk_bs_load_ctx *ctx = cb_arg;
4973 : : int rc;
4974 : :
4975 [ + - + - : 7442 : rc = bs_super_validate(ctx->super, ctx->bs);
+ - + - ]
4976 [ + + ]: 7442 : if (rc != 0) {
4977 : 5921 : bs_load_ctx_fail(ctx, rc);
4978 : 5921 : return;
4979 : : }
4980 : :
4981 : 1521 : rc = bs_parse_super(ctx);
4982 [ + + ]: 1521 : if (rc < 0) {
4983 : 0 : bs_load_ctx_fail(ctx, rc);
4984 : 0 : return;
4985 : : }
4986 : :
4987 [ + + + + : 1521 : if (ctx->super->used_blobid_mask_len == 0 || ctx->super->clean == 0 || ctx->force_recover) {
- + - + #
# # # # #
# # # # #
# # # # #
# # # # ]
4988 : 544 : bs_recover(ctx);
4989 : 134 : } else {
4990 : 977 : bs_load_read_used_pages(ctx);
4991 : : }
4992 : 669 : }
4993 : :
4994 : : static inline int
4995 : 7781 : bs_opts_copy(struct spdk_bs_opts *src, struct spdk_bs_opts *dst)
4996 : : {
4997 : :
4998 [ + + + - : 7781 : if (!src->opts_size) {
+ - ]
4999 : 0 : SPDK_ERRLOG("opts_size should not be zero value\n");
5000 : 0 : return -1;
5001 : : }
5002 : :
5003 : : #define FIELD_OK(field) \
5004 : : offsetof(struct spdk_bs_opts, field) + sizeof(src->field) <= src->opts_size
5005 : :
5006 : : #define SET_FIELD(field) \
5007 : : if (FIELD_OK(field)) { \
5008 : : dst->field = src->field; \
5009 : : } \
5010 : :
5011 [ + - + - : 7781 : SET_FIELD(cluster_sz);
- + - + -
+ - + -
+ ]
5012 [ + - + - : 7781 : SET_FIELD(num_md_pages);
- + - + -
+ - + -
+ ]
5013 [ + - + - : 7781 : SET_FIELD(max_md_ops);
- + - + -
+ - + -
+ ]
5014 [ + - + - : 7781 : SET_FIELD(max_channel_ops);
- + - + -
+ - + -
+ ]
5015 [ + - + - : 7781 : SET_FIELD(clear_method);
- + - + -
+ - + -
+ ]
5016 : :
5017 [ + - + - : 7781 : if (FIELD_OK(bstype)) {
- + ]
5018 [ - + - + : 7781 : memcpy(&dst->bstype, &src->bstype, sizeof(dst->bstype));
- + - + ]
5019 : 683 : }
5020 [ + - + - : 7781 : SET_FIELD(md_page_size);
- + - + -
+ - + -
+ ]
5021 [ + - + - : 7781 : SET_FIELD(iter_cb_fn);
- + - + -
+ - + -
+ ]
5022 [ + - + - : 7781 : SET_FIELD(iter_cb_arg);
- + - + -
+ - + -
+ ]
5023 [ + - + - : 7781 : SET_FIELD(force_recover);
- + - + -
+ - + -
+ ]
5024 [ + - + - : 7781 : SET_FIELD(esnap_bs_dev_create);
- + - + -
+ - + -
+ ]
5025 [ + - + - : 7781 : SET_FIELD(esnap_ctx);
- + - + -
+ - + -
+ ]
5026 : :
5027 [ + - + - : 7781 : dst->opts_size = src->opts_size;
+ - + - ]
5028 : :
5029 : : /* You should not remove this statement, but need to update the assert statement
5030 : : * if you add a new field, and also add a corresponding SET_FIELD statement */
5031 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_opts) == 88, "Incorrect size");
5032 : :
5033 : : #undef FIELD_OK
5034 : : #undef SET_FIELD
5035 : :
5036 : 7781 : return 0;
5037 : 683 : }
5038 : :
5039 : : void
5040 : 7603 : spdk_bs_load(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
5041 : : spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
5042 : : {
5043 : 6915 : struct spdk_blob_store *bs;
5044 : 6915 : struct spdk_bs_cpl cpl;
5045 : 6915 : struct spdk_bs_load_ctx *ctx;
5046 : 7603 : struct spdk_bs_opts opts = {};
5047 : : int err;
5048 : :
5049 [ + + + + : 7603 : SPDK_DEBUGLOG(blob, "Loading blobstore from dev %p\n", dev);
+ - ]
5050 : :
5051 [ + + + + : 7603 : if ((dev->phys_blocklen % dev->blocklen) != 0) {
+ - + - +
- - + ]
5052 [ + + - + : 20 : SPDK_DEBUGLOG(blob, "unsupported dev block length of %d\n", dev->blocklen);
# # # # #
# ]
5053 [ # # # # : 20 : dev->destroy(dev);
# # # # ]
5054 [ # # # # ]: 20 : cb_fn(cb_arg, NULL, -EINVAL);
5055 : 20 : return;
5056 : : }
5057 : :
5058 : 7583 : spdk_bs_opts_init(&opts, sizeof(opts));
5059 [ + + ]: 7583 : if (o) {
5060 [ + + ]: 6636 : if (bs_opts_copy(o, &opts)) {
5061 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
5062 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -EINVAL);
5063 : 0 : return;
5064 : : }
5065 : 449 : }
5066 : :
5067 [ + + + + ]: 7583 : if (opts.max_md_ops == 0 || opts.max_channel_ops == 0) {
5068 [ # # # # : 40 : dev->destroy(dev);
# # # # ]
5069 [ # # # # ]: 40 : cb_fn(cb_arg, NULL, -EINVAL);
5070 : 40 : return;
5071 : : }
5072 : :
5073 : 7543 : err = bs_alloc(dev, &opts, &bs, &ctx);
5074 [ + + ]: 7543 : if (err) {
5075 [ + - + - : 101 : dev->destroy(dev);
- + + - ]
5076 [ - + + - ]: 101 : cb_fn(cb_arg, NULL, err);
5077 : 101 : return;
5078 : : }
5079 : :
5080 : 7442 : cpl.type = SPDK_BS_CPL_TYPE_BS_HANDLE;
5081 [ + - + - : 7442 : cpl.u.bs_handle.cb_fn = cb_fn;
+ - ]
5082 [ + - + - : 7442 : cpl.u.bs_handle.cb_arg = cb_arg;
+ - ]
5083 [ + - + - : 7442 : cpl.u.bs_handle.bs = bs;
+ - ]
5084 : :
5085 [ + - + - : 7442 : ctx->seq = bs_sequence_start_bs(bs->md_channel, &cpl);
+ - + - ]
5086 [ + + + - : 7442 : if (!ctx->seq) {
- + ]
5087 [ # # # # ]: 0 : spdk_free(ctx->super);
5088 : 0 : free(ctx);
5089 : 0 : bs_free(bs);
5090 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
5091 : 0 : return;
5092 : : }
5093 : :
5094 : : /* Read the super block */
5095 [ + - + - : 8066 : bs_sequence_read_dev(ctx->seq, ctx->super, bs_page_to_lba(bs, 0),
+ - + - ]
5096 : 7442 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
5097 : 669 : bs_load_super_cpl, ctx);
5098 : 688 : }
5099 : :
5100 : : /* END spdk_bs_load */
5101 : :
5102 : : /* START spdk_bs_dump */
5103 : :
5104 : : static void
5105 : 0 : bs_dump_finish(spdk_bs_sequence_t *seq, struct spdk_bs_load_ctx *ctx, int bserrno)
5106 : : {
5107 [ # # # # ]: 0 : spdk_free(ctx->super);
5108 : :
5109 : : /*
5110 : : * We need to defer calling bs_call_cpl() until after
5111 : : * dev destruction, so tuck these away for later use.
5112 : : */
5113 [ # # # # : 0 : ctx->bs->unload_err = bserrno;
# # # # ]
5114 [ # # # # : 0 : memcpy(&ctx->bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
# # # # #
# # # ]
5115 [ # # # # : 0 : seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
# # ]
5116 : :
5117 : 0 : bs_sequence_finish(seq, 0);
5118 [ # # # # ]: 0 : bs_free(ctx->bs);
5119 : 0 : free(ctx);
5120 : 0 : }
5121 : :
5122 : : static void
5123 : 0 : bs_dump_print_xattr(struct spdk_bs_load_ctx *ctx, struct spdk_blob_md_descriptor *desc)
5124 : : {
5125 : : struct spdk_blob_md_descriptor_xattr *desc_xattr;
5126 : : uint32_t i;
5127 : : const char *type;
5128 : :
5129 : 0 : desc_xattr = (struct spdk_blob_md_descriptor_xattr *)desc;
5130 : :
5131 [ # # # # : 0 : if (desc_xattr->length !=
# # ]
5132 : 0 : sizeof(desc_xattr->name_length) + sizeof(desc_xattr->value_length) +
5133 [ # # # # : 0 : desc_xattr->name_length + desc_xattr->value_length) {
# # # # #
# ]
5134 : 0 : }
5135 : :
5136 [ # # # # : 0 : memcpy(ctx->xattr_name, desc_xattr->name, desc_xattr->name_length);
# # # # #
# # # ]
5137 [ # # # # : 0 : ctx->xattr_name[desc_xattr->name_length] = '\0';
# # # # #
# ]
5138 [ # # # # : 0 : if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR) {
# # ]
5139 : 0 : type = "XATTR";
5140 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL) {
# # ]
5141 : 0 : type = "XATTR_INTERNAL";
5142 : 0 : } else {
5143 [ # # ]: 0 : assert(false);
5144 : : type = "XATTR_?";
5145 : : }
5146 [ # # # # : 0 : fprintf(ctx->fp, "%s: name = \"%s\"\n", type, ctx->xattr_name);
# # ]
5147 [ # # # # ]: 0 : fprintf(ctx->fp, " value = \"");
5148 [ # # # # : 0 : ctx->print_xattr_fn(ctx->fp, ctx->super->bstype.bstype, ctx->xattr_name,
# # # # #
# # # # #
# # # # #
# # # ]
5149 [ # # # # : 0 : (void *)((uintptr_t)desc_xattr->name + desc_xattr->name_length),
# # ]
5150 [ # # # # ]: 0 : desc_xattr->value_length);
5151 [ # # # # ]: 0 : fprintf(ctx->fp, "\"\n");
5152 [ # # # # : 0 : for (i = 0; i < desc_xattr->value_length; i++) {
# # ]
5153 [ # # # # ]: 0 : if (i % 16 == 0) {
5154 [ # # # # ]: 0 : fprintf(ctx->fp, " ");
5155 : 0 : }
5156 [ # # # # : 0 : fprintf(ctx->fp, "%02" PRIx8 " ", *((uint8_t *)desc_xattr->name + desc_xattr->name_length + i));
# # # # #
# # # # #
# # ]
5157 [ # # # # ]: 0 : if ((i + 1) % 16 == 0) {
5158 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5159 : 0 : }
5160 : 0 : }
5161 [ # # # # ]: 0 : if (i % 16 != 0) {
5162 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5163 : 0 : }
5164 : 0 : }
5165 : :
5166 : : struct type_flag_desc {
5167 : : uint64_t mask;
5168 : : uint64_t val;
5169 : : const char *name;
5170 : : };
5171 : :
5172 : : static void
5173 : 0 : bs_dump_print_type_bits(struct spdk_bs_load_ctx *ctx, uint64_t flags,
5174 : : struct type_flag_desc *desc, size_t numflags)
5175 : : {
5176 : 0 : uint64_t covered = 0;
5177 : : size_t i;
5178 : :
5179 [ # # ]: 0 : for (i = 0; i < numflags; i++) {
5180 [ # # # # : 0 : if ((desc[i].mask & flags) != desc[i].val) {
# # # # #
# # # #
# ]
5181 : 0 : continue;
5182 : : }
5183 [ # # # # : 0 : fprintf(ctx->fp, "\t\t 0x%016" PRIx64 " %s", desc[i].val, desc[i].name);
# # # # #
# # # # #
# # ]
5184 [ # # # # : 0 : if (desc[i].mask != desc[i].val) {
# # # # #
# # # #
# ]
5185 [ # # # # ]: 0 : fprintf(ctx->fp, " (mask 0x%" PRIx64 " value 0x%" PRIx64 ")",
5186 [ # # # # : 0 : desc[i].mask, desc[i].val);
# # # # #
# # # ]
5187 : 0 : }
5188 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5189 [ # # # # : 0 : covered |= desc[i].mask;
# # ]
5190 : 0 : }
5191 [ # # ]: 0 : if ((flags & ~covered) != 0) {
5192 [ # # # # ]: 0 : fprintf(ctx->fp, "\t\t 0x%016" PRIx64 " Unknown\n", flags & ~covered);
5193 : 0 : }
5194 : 0 : }
5195 : :
5196 : : static void
5197 : 0 : bs_dump_print_type_flags(struct spdk_bs_load_ctx *ctx, struct spdk_blob_md_descriptor *desc)
5198 : : {
5199 : : struct spdk_blob_md_descriptor_flags *type_desc;
5200 : : #define ADD_FLAG(f) { f, f, #f }
5201 : : #define ADD_MASK_VAL(m, v) { m, v, #v }
5202 : : static struct type_flag_desc invalid[] = {
5203 : : ADD_FLAG(SPDK_BLOB_THIN_PROV),
5204 : : ADD_FLAG(SPDK_BLOB_INTERNAL_XATTR),
5205 : : ADD_FLAG(SPDK_BLOB_EXTENT_TABLE),
5206 : : };
5207 : : static struct type_flag_desc data_ro[] = {
5208 : : ADD_FLAG(SPDK_BLOB_READ_ONLY),
5209 : : };
5210 : : static struct type_flag_desc md_ro[] = {
5211 : : ADD_MASK_VAL(SPDK_BLOB_MD_RO_FLAGS_MASK, BLOB_CLEAR_WITH_DEFAULT),
5212 : : ADD_MASK_VAL(SPDK_BLOB_MD_RO_FLAGS_MASK, BLOB_CLEAR_WITH_NONE),
5213 : : ADD_MASK_VAL(SPDK_BLOB_MD_RO_FLAGS_MASK, BLOB_CLEAR_WITH_UNMAP),
5214 : : ADD_MASK_VAL(SPDK_BLOB_MD_RO_FLAGS_MASK, BLOB_CLEAR_WITH_WRITE_ZEROES),
5215 : : };
5216 : : #undef ADD_FLAG
5217 : : #undef ADD_MASK_VAL
5218 : :
5219 : 0 : type_desc = (struct spdk_blob_md_descriptor_flags *)desc;
5220 [ # # # # ]: 0 : fprintf(ctx->fp, "Flags:\n");
5221 [ # # # # : 0 : fprintf(ctx->fp, "\tinvalid: 0x%016" PRIx64 "\n", type_desc->invalid_flags);
# # # # ]
5222 [ # # # # ]: 0 : bs_dump_print_type_bits(ctx, type_desc->invalid_flags, invalid,
5223 : : SPDK_COUNTOF(invalid));
5224 [ # # # # : 0 : fprintf(ctx->fp, "\tdata_ro: 0x%016" PRIx64 "\n", type_desc->data_ro_flags);
# # # # ]
5225 [ # # # # ]: 0 : bs_dump_print_type_bits(ctx, type_desc->data_ro_flags, data_ro,
5226 : : SPDK_COUNTOF(data_ro));
5227 [ # # # # : 0 : fprintf(ctx->fp, "\t md_ro: 0x%016" PRIx64 "\n", type_desc->md_ro_flags);
# # # # ]
5228 [ # # # # ]: 0 : bs_dump_print_type_bits(ctx, type_desc->md_ro_flags, md_ro,
5229 : : SPDK_COUNTOF(md_ro));
5230 : 0 : }
5231 : :
5232 : : static void
5233 : 0 : bs_dump_print_extent_table(struct spdk_bs_load_ctx *ctx, struct spdk_blob_md_descriptor *desc)
5234 : : {
5235 : : struct spdk_blob_md_descriptor_extent_table *et_desc;
5236 : : uint64_t num_extent_pages;
5237 : : uint32_t et_idx;
5238 : :
5239 : 0 : et_desc = (struct spdk_blob_md_descriptor_extent_table *)desc;
5240 [ # # # # : 0 : num_extent_pages = (et_desc->length - sizeof(et_desc->num_clusters)) /
# # ]
5241 : : sizeof(et_desc->extent_page[0]);
5242 : :
5243 [ # # # # ]: 0 : fprintf(ctx->fp, "Extent table:\n");
5244 [ # # ]: 0 : for (et_idx = 0; et_idx < num_extent_pages; et_idx++) {
5245 [ # # # # : 0 : if (et_desc->extent_page[et_idx].page_idx == 0) {
# # # # #
# ]
5246 : : /* Zeroes represent unallocated extent pages. */
5247 : 0 : continue;
5248 : : }
5249 [ # # # # ]: 0 : fprintf(ctx->fp, "\tExtent page: %5" PRIu32 " length %3" PRIu32
5250 [ # # # # : 0 : " at LBA %" PRIu64 "\n", et_desc->extent_page[et_idx].page_idx,
# # # # ]
5251 [ # # # # : 0 : et_desc->extent_page[et_idx].num_pages,
# # # # ]
5252 [ # # # # : 0 : bs_md_page_to_lba(ctx->bs, et_desc->extent_page[et_idx].page_idx));
# # # # #
# # # ]
5253 : 0 : }
5254 : 0 : }
5255 : :
5256 : : static void
5257 : 0 : bs_dump_print_md_page(struct spdk_bs_load_ctx *ctx)
5258 : : {
5259 [ # # # # ]: 0 : uint32_t page_idx = ctx->cur_page;
5260 [ # # # # ]: 0 : struct spdk_blob_md_page *page = ctx->page;
5261 : : struct spdk_blob_md_descriptor *desc;
5262 : 0 : size_t cur_desc = 0;
5263 : : uint32_t crc;
5264 : :
5265 [ # # # # ]: 0 : fprintf(ctx->fp, "=========\n");
5266 [ # # # # ]: 0 : fprintf(ctx->fp, "Metadata Page Index: %" PRIu32 " (0x%" PRIx32 ")\n", page_idx, page_idx);
5267 [ # # # # : 0 : fprintf(ctx->fp, "Start LBA: %" PRIu64 "\n", bs_md_page_to_lba(ctx->bs, page_idx));
# # # # ]
5268 [ # # # # : 0 : fprintf(ctx->fp, "Blob ID: 0x%" PRIx64 "\n", page->id);
# # # # ]
5269 [ # # # # : 0 : fprintf(ctx->fp, "Sequence: %" PRIu32 "\n", page->sequence_num);
# # # # ]
5270 [ # # # # : 0 : if (page->next == SPDK_INVALID_MD_PAGE) {
# # ]
5271 [ # # # # ]: 0 : fprintf(ctx->fp, "Next: None\n");
5272 : 0 : } else {
5273 [ # # # # : 0 : fprintf(ctx->fp, "Next: %" PRIu32 "\n", page->next);
# # # # ]
5274 : : }
5275 [ # # # # : 0 : fprintf(ctx->fp, "In used bit array%s:", ctx->super->clean ? "" : " (not clean: dubious)");
# # # # #
# # # ]
5276 [ # # # # : 0 : if (spdk_bit_array_get(ctx->bs->used_md_pages, page_idx)) {
# # # # #
# ]
5277 [ # # # # ]: 0 : fprintf(ctx->fp, " md");
5278 : 0 : }
5279 [ # # # # : 0 : if (spdk_bit_array_get(ctx->bs->used_blobids, page_idx)) {
# # # # #
# ]
5280 [ # # # # ]: 0 : fprintf(ctx->fp, " blob");
5281 : 0 : }
5282 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5283 : :
5284 : 0 : crc = blob_md_page_calc_crc(page);
5285 [ # # # # : 0 : fprintf(ctx->fp, "CRC: 0x%" PRIx32 " (%s)\n", page->crc, crc == page->crc ? "OK" : "Mismatch");
# # # # #
# # # ]
5286 : :
5287 [ # # ]: 0 : desc = (struct spdk_blob_md_descriptor *)page->descriptors;
5288 [ # # ]: 0 : while (cur_desc < sizeof(page->descriptors)) {
5289 [ # # # # : 0 : if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_PADDING) {
# # ]
5290 [ # # # # : 0 : if (desc->length == 0) {
# # ]
5291 : : /* If padding and length are 0, this terminates the page */
5292 : 0 : break;
5293 : : }
5294 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE) {
# # ]
5295 : : struct spdk_blob_md_descriptor_extent_rle *desc_extent_rle;
5296 : : unsigned int i;
5297 : :
5298 : 0 : desc_extent_rle = (struct spdk_blob_md_descriptor_extent_rle *)desc;
5299 : :
5300 [ # # # # : 0 : for (i = 0; i < desc_extent_rle->length / sizeof(desc_extent_rle->extents[0]); i++) {
# # # # ]
5301 [ # # # # : 0 : if (desc_extent_rle->extents[i].cluster_idx != 0) {
# # # # #
# ]
5302 [ # # # # ]: 0 : fprintf(ctx->fp, "Allocated Extent - Start: %" PRIu32,
5303 [ # # # # : 0 : desc_extent_rle->extents[i].cluster_idx);
# # # # ]
5304 : 0 : } else {
5305 [ # # # # ]: 0 : fprintf(ctx->fp, "Unallocated Extent - ");
5306 : : }
5307 [ # # # # : 0 : fprintf(ctx->fp, " Length: %" PRIu32, desc_extent_rle->extents[i].length);
# # # # #
# # # ]
5308 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5309 : 0 : }
5310 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE) {
# # ]
5311 : : struct spdk_blob_md_descriptor_extent_page *desc_extent;
5312 : : unsigned int i;
5313 : :
5314 : 0 : desc_extent = (struct spdk_blob_md_descriptor_extent_page *)desc;
5315 : :
5316 [ # # # # : 0 : for (i = 0; i < desc_extent->length / sizeof(desc_extent->cluster_idx[0]); i++) {
# # # # ]
5317 [ # # # # : 0 : if (desc_extent->cluster_idx[i] != 0) {
# # # # ]
5318 [ # # # # ]: 0 : fprintf(ctx->fp, "Allocated Extent - Start: %" PRIu32,
5319 [ # # # # : 0 : desc_extent->cluster_idx[i]);
# # ]
5320 : 0 : } else {
5321 [ # # # # ]: 0 : fprintf(ctx->fp, "Unallocated Extent");
5322 : : }
5323 [ # # # # ]: 0 : fprintf(ctx->fp, "\n");
5324 : 0 : }
5325 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR) {
# # ]
5326 : 0 : bs_dump_print_xattr(ctx, desc);
5327 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL) {
# # ]
5328 : 0 : bs_dump_print_xattr(ctx, desc);
5329 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_FLAGS) {
# # ]
5330 : 0 : bs_dump_print_type_flags(ctx, desc);
5331 [ # # # # : 0 : } else if (desc->type == SPDK_MD_DESCRIPTOR_TYPE_EXTENT_TABLE) {
# # ]
5332 : 0 : bs_dump_print_extent_table(ctx, desc);
5333 : 0 : } else {
5334 : : /* Error */
5335 [ # # # # : 0 : fprintf(ctx->fp, "Unknown descriptor type %" PRIu8 "\n", desc->type);
# # # # ]
5336 : : }
5337 : : /* Advance to the next descriptor */
5338 [ # # # # ]: 0 : cur_desc += sizeof(*desc) + desc->length;
5339 [ # # ]: 0 : if (cur_desc + sizeof(*desc) > sizeof(page->descriptors)) {
5340 : 0 : break;
5341 : : }
5342 [ # # ]: 0 : desc = (struct spdk_blob_md_descriptor *)((uintptr_t)page->descriptors + cur_desc);
5343 : : }
5344 : 0 : }
5345 : :
5346 : : static void
5347 : 0 : bs_dump_read_md_page_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5348 : : {
5349 : 0 : struct spdk_bs_load_ctx *ctx = cb_arg;
5350 : :
5351 [ # # ]: 0 : if (bserrno != 0) {
5352 : 0 : bs_dump_finish(seq, ctx, bserrno);
5353 : 0 : return;
5354 : : }
5355 : :
5356 [ # # # # : 0 : if (ctx->page->id != 0) {
# # # # #
# ]
5357 : 0 : bs_dump_print_md_page(ctx);
5358 : 0 : }
5359 : :
5360 [ # # ]: 0 : ctx->cur_page++;
5361 : :
5362 [ # # # # : 0 : if (ctx->cur_page < ctx->super->md_len) {
# # # # #
# # # #
# ]
5363 : 0 : bs_dump_read_md_page(seq, ctx);
5364 : 0 : } else {
5365 [ # # # # ]: 0 : spdk_free(ctx->page);
5366 : 0 : bs_dump_finish(seq, ctx, 0);
5367 : : }
5368 : 0 : }
5369 : :
5370 : : static void
5371 : 0 : bs_dump_read_md_page(spdk_bs_sequence_t *seq, void *cb_arg)
5372 : : {
5373 : 0 : struct spdk_bs_load_ctx *ctx = cb_arg;
5374 : : uint64_t lba;
5375 : :
5376 [ # # # # : 0 : assert(ctx->cur_page < ctx->super->md_len);
# # # # #
# # # # #
# # ]
5377 [ # # # # : 0 : lba = bs_page_to_lba(ctx->bs, ctx->super->md_start + ctx->cur_page);
# # # # #
# # # # #
# # ]
5378 [ # # # # ]: 0 : bs_sequence_read_dev(seq, ctx->page, lba,
5379 [ # # # # : 0 : bs_byte_to_lba(ctx->bs, ctx->super->md_page_size),
# # # # #
# # # ]
5380 : 0 : bs_dump_read_md_page_cpl, ctx);
5381 : 0 : }
5382 : :
5383 : : static void
5384 : 0 : bs_dump_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5385 : : {
5386 : 0 : struct spdk_bs_load_ctx *ctx = cb_arg;
5387 : : int rc;
5388 : :
5389 [ # # # # : 0 : fprintf(ctx->fp, "Signature: \"%.8s\" ", ctx->super->signature);
# # # # #
# ]
5390 [ # # # # : 0 : if (memcmp(ctx->super->signature, SPDK_BS_SUPER_BLOCK_SIG,
# # # # #
# # # #
# ]
5391 : 0 : sizeof(ctx->super->signature)) != 0) {
5392 [ # # # # ]: 0 : fprintf(ctx->fp, "(Mismatch)\n");
5393 : 0 : bs_dump_finish(seq, ctx, bserrno);
5394 : 0 : return;
5395 : : } else {
5396 [ # # # # ]: 0 : fprintf(ctx->fp, "(OK)\n");
5397 : : }
5398 [ # # # # : 0 : fprintf(ctx->fp, "Version: %" PRIu32 "\n", ctx->super->version);
# # # # #
# # # ]
5399 [ # # # # : 0 : fprintf(ctx->fp, "CRC: 0x%x (%s)\n", ctx->super->crc,
# # # # #
# # # ]
5400 [ # # # # : 0 : (ctx->super->crc == blob_md_page_calc_crc(ctx->super)) ? "OK" : "Mismatch");
# # # # #
# # # ]
5401 [ # # # # : 0 : fprintf(ctx->fp, "Blobstore Type: %.*s\n", SPDK_BLOBSTORE_TYPE_LENGTH, ctx->super->bstype.bstype);
# # # # #
# # # ]
5402 [ # # # # : 0 : fprintf(ctx->fp, "Cluster Size: %" PRIu32 "\n", ctx->super->cluster_size);
# # # # #
# # # ]
5403 [ # # # # ]: 0 : fprintf(ctx->fp, "Super Blob ID: ");
5404 [ # # # # : 0 : if (ctx->super->super_blob == SPDK_BLOBID_INVALID) {
# # # # #
# ]
5405 [ # # # # ]: 0 : fprintf(ctx->fp, "(None)\n");
5406 : 0 : } else {
5407 [ # # # # : 0 : fprintf(ctx->fp, "0x%" PRIx64 "\n", ctx->super->super_blob);
# # # # #
# # # ]
5408 : : }
5409 [ # # # # : 0 : fprintf(ctx->fp, "Clean: %" PRIu32 "\n", ctx->super->clean);
# # # # #
# # # ]
5410 [ # # # # : 0 : fprintf(ctx->fp, "Used Metadata Page Mask Start: %" PRIu32 "\n", ctx->super->used_page_mask_start);
# # # # #
# # # ]
5411 [ # # # # : 0 : fprintf(ctx->fp, "Used Metadata Page Mask Length: %" PRIu32 "\n", ctx->super->used_page_mask_len);
# # # # #
# # # ]
5412 [ # # # # : 0 : fprintf(ctx->fp, "Used Cluster Mask Start: %" PRIu32 "\n", ctx->super->used_cluster_mask_start);
# # # # #
# # # ]
5413 [ # # # # : 0 : fprintf(ctx->fp, "Used Cluster Mask Length: %" PRIu32 "\n", ctx->super->used_cluster_mask_len);
# # # # #
# # # ]
5414 [ # # # # : 0 : fprintf(ctx->fp, "Used Blob ID Mask Start: %" PRIu32 "\n", ctx->super->used_blobid_mask_start);
# # # # #
# # # ]
5415 [ # # # # : 0 : fprintf(ctx->fp, "Used Blob ID Mask Length: %" PRIu32 "\n", ctx->super->used_blobid_mask_len);
# # # # #
# # # ]
5416 [ # # # # : 0 : fprintf(ctx->fp, "Metadata Start: %" PRIu32 "\n", ctx->super->md_start);
# # # # #
# # # ]
5417 [ # # # # : 0 : fprintf(ctx->fp, "Metadata Length: %" PRIu32 "\n", ctx->super->md_len);
# # # # #
# # # ]
5418 : :
5419 [ # # # # ]: 0 : ctx->cur_page = 0;
5420 [ # # # # : 0 : ctx->page = spdk_zmalloc(ctx->super->md_page_size, 0,
# # # # #
# # # ]
5421 : : NULL, SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
5422 [ # # # # : 0 : if (!ctx->page) {
# # ]
5423 : 0 : bs_dump_finish(seq, ctx, -ENOMEM);
5424 : 0 : return;
5425 : : }
5426 : :
5427 : 0 : rc = bs_parse_super(ctx);
5428 [ # # ]: 0 : if (rc < 0) {
5429 : 0 : bs_load_ctx_fail(ctx, rc);
5430 : 0 : return;
5431 : : }
5432 : :
5433 : 0 : bs_load_read_used_pages(ctx);
5434 : 0 : }
5435 : :
5436 : : void
5437 : 0 : spdk_bs_dump(struct spdk_bs_dev *dev, FILE *fp, spdk_bs_dump_print_xattr print_xattr_fn,
5438 : : spdk_bs_op_complete cb_fn, void *cb_arg)
5439 : : {
5440 : 0 : struct spdk_blob_store *bs;
5441 : 0 : struct spdk_bs_cpl cpl;
5442 : 0 : struct spdk_bs_load_ctx *ctx;
5443 : 0 : struct spdk_bs_opts opts = {};
5444 : : int err;
5445 : :
5446 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Dumping blobstore from dev %p\n", dev);
# # ]
5447 : :
5448 : 0 : spdk_bs_opts_init(&opts, sizeof(opts));
5449 : :
5450 : 0 : err = bs_alloc(dev, &opts, &bs, &ctx);
5451 [ # # ]: 0 : if (err) {
5452 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
5453 [ # # # # ]: 0 : cb_fn(cb_arg, err);
5454 : 0 : return;
5455 : : }
5456 : :
5457 [ # # # # ]: 0 : ctx->dumping = true;
5458 [ # # # # ]: 0 : ctx->fp = fp;
5459 [ # # # # ]: 0 : ctx->print_xattr_fn = print_xattr_fn;
5460 : :
5461 : 0 : cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
5462 [ # # # # : 0 : cpl.u.bs_basic.cb_fn = cb_fn;
# # ]
5463 [ # # # # : 0 : cpl.u.bs_basic.cb_arg = cb_arg;
# # ]
5464 : :
5465 [ # # # # : 0 : ctx->seq = bs_sequence_start_bs(bs->md_channel, &cpl);
# # # # ]
5466 [ # # # # : 0 : if (!ctx->seq) {
# # ]
5467 [ # # # # ]: 0 : spdk_free(ctx->super);
5468 : 0 : free(ctx);
5469 : 0 : bs_free(bs);
5470 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5471 : 0 : return;
5472 : : }
5473 : :
5474 : : /* Read the super block */
5475 [ # # # # : 0 : bs_sequence_read_dev(ctx->seq, ctx->super, bs_page_to_lba(bs, 0),
# # # # ]
5476 : 0 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
5477 : 0 : bs_dump_super_cpl, ctx);
5478 : 0 : }
5479 : :
5480 : : /* END spdk_bs_dump */
5481 : :
5482 : : /* START spdk_bs_init */
5483 : :
5484 : : static void
5485 : 2583 : bs_init_persist_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5486 : : {
5487 : 2583 : struct spdk_bs_load_ctx *ctx = cb_arg;
5488 : :
5489 [ # # # # : 2583 : ctx->bs->used_clusters = spdk_bit_pool_create_from_array(ctx->used_clusters);
# # # # #
# # # ]
5490 [ # # # # ]: 2583 : spdk_free(ctx->super);
5491 : 2583 : free(ctx);
5492 : :
5493 : 2583 : bs_sequence_finish(seq, bserrno);
5494 : 2583 : }
5495 : :
5496 : : static void
5497 : 2583 : bs_init_trim_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5498 : : {
5499 : 2583 : struct spdk_bs_load_ctx *ctx = cb_arg;
5500 : :
5501 : : /* Write super block */
5502 [ # # # # : 3176 : bs_sequence_write_dev(seq, ctx->super, bs_page_to_lba(ctx->bs, 0),
# # # # ]
5503 [ # # # # ]: 2583 : bs_byte_to_lba(ctx->bs, sizeof(*ctx->super)),
5504 : 593 : bs_init_persist_super_cpl, ctx);
5505 : 2583 : }
5506 : :
5507 : : void
5508 : 2663 : spdk_bs_init(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
5509 : : spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
5510 : : {
5511 : 2050 : struct spdk_bs_load_ctx *ctx;
5512 : 2050 : struct spdk_blob_store *bs;
5513 : 2050 : struct spdk_bs_cpl cpl;
5514 : : spdk_bs_sequence_t *seq;
5515 : : spdk_bs_batch_t *batch;
5516 : : uint64_t num_md_lba;
5517 : : uint64_t num_md_pages;
5518 : : uint64_t num_md_clusters;
5519 : : uint64_t max_used_cluster_mask_len;
5520 : : uint32_t i;
5521 : 2663 : struct spdk_bs_opts opts = {};
5522 : : int rc;
5523 : : uint64_t lba, lba_count;
5524 : :
5525 [ + + - + : 2663 : SPDK_DEBUGLOG(blob, "Initializing blobstore on dev %p\n", dev);
# # ]
5526 [ + + + + : 2663 : if ((dev->phys_blocklen % dev->blocklen) != 0) {
# # # # #
# # # ]
5527 [ # # # # ]: 20 : SPDK_ERRLOG("unsupported dev block length of %d\n",
5528 : : dev->blocklen);
5529 [ # # # # : 20 : dev->destroy(dev);
# # # # ]
5530 [ # # # # ]: 20 : cb_fn(cb_arg, NULL, -EINVAL);
5531 : 20 : return;
5532 : : }
5533 : :
5534 : 2643 : spdk_bs_opts_init(&opts, sizeof(opts));
5535 [ + + ]: 2643 : if (o) {
5536 [ - + ]: 1125 : if (bs_opts_copy(o, &opts)) {
5537 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
5538 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -EINVAL);
5539 : 0 : return;
5540 : : }
5541 : 229 : }
5542 : :
5543 [ + + ]: 2643 : if (bs_opts_verify(&opts) != 0) {
5544 [ # # # # : 40 : dev->destroy(dev);
# # # # ]
5545 [ # # # # ]: 40 : cb_fn(cb_arg, NULL, -EINVAL);
5546 : 40 : return;
5547 : : }
5548 : :
5549 : 2603 : rc = bs_alloc(dev, &opts, &bs, &ctx);
5550 [ - + ]: 2603 : if (rc) {
5551 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
5552 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, rc);
5553 : 0 : return;
5554 : : }
5555 : :
5556 [ + + ]: 2603 : if (opts.num_md_pages == SPDK_BLOB_OPTS_NUM_MD_PAGES) {
5557 : : /* By default, allocate 1 page per cluster.
5558 : : * Technically, this over-allocates metadata
5559 : : * because more metadata will reduce the number
5560 : : * of usable clusters. This can be addressed with
5561 : : * more complex math in the future.
5562 : : */
5563 [ # # # # : 2353 : bs->md_len = bs->total_clusters;
# # # # ]
5564 : 587 : } else {
5565 [ # # # # ]: 250 : bs->md_len = opts.num_md_pages;
5566 : : }
5567 [ # # # # : 2603 : rc = spdk_bit_array_resize(&bs->used_md_pages, bs->md_len);
# # ]
5568 [ + + ]: 2603 : if (rc < 0) {
5569 [ # # # # ]: 0 : spdk_free(ctx->super);
5570 : 0 : free(ctx);
5571 : 0 : bs_free(bs);
5572 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
5573 : 0 : return;
5574 : : }
5575 : :
5576 [ # # # # : 2603 : rc = spdk_bit_array_resize(&bs->used_blobids, bs->md_len);
# # ]
5577 [ + + ]: 2603 : if (rc < 0) {
5578 [ # # # # ]: 0 : spdk_free(ctx->super);
5579 : 0 : free(ctx);
5580 : 0 : bs_free(bs);
5581 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
5582 : 0 : return;
5583 : : }
5584 : :
5585 [ # # # # : 2603 : rc = spdk_bit_array_resize(&bs->open_blobids, bs->md_len);
# # ]
5586 [ + + ]: 2603 : if (rc < 0) {
5587 [ # # # # ]: 0 : spdk_free(ctx->super);
5588 : 0 : free(ctx);
5589 : 0 : bs_free(bs);
5590 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
5591 : 0 : return;
5592 : : }
5593 : :
5594 [ - + - + : 2603 : memcpy(ctx->super->signature, SPDK_BS_SUPER_BLOCK_SIG,
# # # # #
# ]
5595 : : sizeof(ctx->super->signature));
5596 [ # # # # : 2603 : ctx->super->version = SPDK_BS_VERSION;
# # # # ]
5597 [ # # # # : 2603 : ctx->super->length = sizeof(*ctx->super);
# # # # ]
5598 [ # # # # : 2603 : ctx->super->super_blob = bs->super_blob;
# # # # #
# # # ]
5599 [ # # # # : 2603 : ctx->super->clean = 0;
# # # # ]
5600 [ # # # # : 2603 : ctx->super->cluster_size = bs->cluster_sz;
# # # # #
# # # ]
5601 [ # # # # : 2603 : ctx->super->io_unit_size = bs->io_unit_size;
# # # # #
# # # ]
5602 [ # # # # : 2603 : ctx->super->md_page_size = bs->md_page_size;
# # # # #
# # # ]
5603 [ # # # # : 2603 : memcpy(&ctx->super->bstype, &bs->bstype, sizeof(bs->bstype));
# # # # #
# # # ]
5604 : :
5605 : : /* Calculate how many pages the metadata consumes at the front
5606 : : * of the disk.
5607 : : */
5608 : :
5609 : : /* The super block uses 1 page */
5610 : 2603 : num_md_pages = 1;
5611 : :
5612 : : /* The used_md_pages mask requires 1 bit per metadata page, rounded
5613 : : * up to the nearest page, plus a header.
5614 : : */
5615 [ # # # # : 2603 : ctx->super->used_page_mask_start = num_md_pages;
# # # # ]
5616 [ # # # # : 3201 : ctx->super->used_page_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
# # # # ]
5617 [ # # # # ]: 2603 : spdk_divide_round_up(bs->md_len, 8),
5618 [ # # # # : 2603 : ctx->super->md_page_size);
# # # # ]
5619 [ # # # # : 2603 : num_md_pages += ctx->super->used_page_mask_len;
# # # # ]
5620 : :
5621 : : /* The used_clusters mask requires 1 bit per cluster, rounded
5622 : : * up to the nearest page, plus a header.
5623 : : */
5624 [ # # # # : 2603 : ctx->super->used_cluster_mask_start = num_md_pages;
# # # # ]
5625 [ # # # # : 3201 : ctx->super->used_cluster_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
# # # # ]
5626 [ # # # # ]: 2603 : spdk_divide_round_up(bs->total_clusters, 8),
5627 [ # # # # : 2603 : ctx->super->md_page_size);
# # # # ]
5628 : : /* The blobstore might be extended, then the used_cluster bitmap will need more space.
5629 : : * Here we calculate the max clusters we can support according to the
5630 : : * num_md_pages (bs->md_len).
5631 : : */
5632 : 3201 : max_used_cluster_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
5633 [ # # # # ]: 2603 : spdk_divide_round_up(bs->md_len, 8),
5634 [ # # # # : 2603 : ctx->super->md_page_size);
# # # # ]
5635 [ - + # # : 2603 : max_used_cluster_mask_len = spdk_max(max_used_cluster_mask_len,
# # # # #
# # # # #
# # # # ]
5636 : : ctx->super->used_cluster_mask_len);
5637 : 2603 : num_md_pages += max_used_cluster_mask_len;
5638 : :
5639 : : /* The used_blobids mask requires 1 bit per metadata page, rounded
5640 : : * up to the nearest page, plus a header.
5641 : : */
5642 [ # # # # : 2603 : ctx->super->used_blobid_mask_start = num_md_pages;
# # # # ]
5643 [ # # # # : 3201 : ctx->super->used_blobid_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
# # # # ]
5644 [ # # # # ]: 2603 : spdk_divide_round_up(bs->md_len, 8),
5645 [ # # # # : 2603 : ctx->super->md_page_size);
# # # # ]
5646 [ # # # # : 2603 : num_md_pages += ctx->super->used_blobid_mask_len;
# # # # ]
5647 : :
5648 : : /* The metadata region size was chosen above */
5649 [ # # # # : 2603 : ctx->super->md_start = bs->md_start = num_md_pages;
# # # # #
# # # ]
5650 [ # # # # : 2603 : ctx->super->md_len = bs->md_len;
# # # # #
# # # ]
5651 [ # # # # ]: 2603 : num_md_pages += bs->md_len;
5652 : :
5653 : 2603 : num_md_lba = bs_page_to_lba(bs, num_md_pages);
5654 : :
5655 [ # # # # : 2603 : ctx->super->size = dev->blockcnt * dev->blocklen;
# # # # #
# # # # #
# # ]
5656 : :
5657 [ # # # # : 2603 : ctx->super->crc = blob_md_page_calc_crc(ctx->super);
# # # # #
# # # ]
5658 : :
5659 [ # # # # ]: 2603 : num_md_clusters = spdk_divide_round_up(num_md_pages, bs->pages_per_cluster);
5660 [ + + # # : 2603 : if (num_md_clusters > bs->total_clusters) {
# # ]
5661 : 20 : SPDK_ERRLOG("Blobstore metadata cannot use more clusters than is available, "
5662 : : "please decrease number of pages reserved for metadata "
5663 : : "or increase cluster size.\n");
5664 [ # # # # ]: 20 : spdk_free(ctx->super);
5665 [ # # ]: 20 : spdk_bit_array_free(&ctx->used_clusters);
5666 : 20 : free(ctx);
5667 : 20 : bs_free(bs);
5668 [ # # # # ]: 20 : cb_fn(cb_arg, NULL, -ENOMEM);
5669 : 20 : return;
5670 : : }
5671 : : /* Claim all of the clusters used by the metadata */
5672 [ + + ]: 403282 : for (i = 0; i < num_md_clusters; i++) {
5673 [ # # # # ]: 400699 : spdk_bit_array_set(ctx->used_clusters, i);
5674 : 78787 : }
5675 : :
5676 [ # # # # ]: 2583 : bs->num_free_clusters -= num_md_clusters;
5677 [ # # # # : 2583 : bs->total_data_clusters = bs->num_free_clusters;
# # # # ]
5678 : :
5679 : 2583 : cpl.type = SPDK_BS_CPL_TYPE_BS_HANDLE;
5680 [ # # # # : 2583 : cpl.u.bs_handle.cb_fn = cb_fn;
# # ]
5681 [ # # # # : 2583 : cpl.u.bs_handle.cb_arg = cb_arg;
# # ]
5682 [ # # # # : 2583 : cpl.u.bs_handle.bs = bs;
# # ]
5683 : :
5684 [ # # # # ]: 2583 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
5685 [ + + ]: 2583 : if (!seq) {
5686 [ # # # # ]: 0 : spdk_free(ctx->super);
5687 : 0 : free(ctx);
5688 : 0 : bs_free(bs);
5689 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
5690 : 0 : return;
5691 : : }
5692 : :
5693 : 2583 : batch = bs_sequence_to_batch(seq, bs_init_trim_cpl, ctx);
5694 : :
5695 : : /* Clear metadata space */
5696 : 2583 : bs_batch_write_zeroes_dev(batch, 0, num_md_lba);
5697 : :
5698 : 2583 : lba = num_md_lba;
5699 [ # # # # : 2583 : lba_count = ctx->bs->dev->blockcnt - lba;
# # # # #
# # # ]
5700 [ + + + + ]: 2583 : switch (opts.clear_method) {
5701 : 1898 : case BS_CLEAR_WITH_UNMAP:
5702 : : /* Trim data clusters */
5703 : 2471 : bs_batch_unmap_dev(batch, lba, lba_count);
5704 : 2471 : break;
5705 : 1 : case BS_CLEAR_WITH_WRITE_ZEROES:
5706 : : /* Write_zeroes to data clusters */
5707 : 1 : bs_batch_write_zeroes_dev(batch, lba, lba_count);
5708 : 1 : break;
5709 : 111 : case BS_CLEAR_WITH_NONE:
5710 : : default:
5711 : 111 : break;
5712 : : }
5713 : :
5714 : 2583 : bs_batch_close(batch);
5715 : 613 : }
5716 : :
5717 : : /* END spdk_bs_init */
5718 : :
5719 : : /* START spdk_bs_destroy */
5720 : :
5721 : : static void
5722 : 186 : bs_destroy_trim_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5723 : : {
5724 : 186 : struct spdk_bs_load_ctx *ctx = cb_arg;
5725 [ # # # # ]: 186 : struct spdk_blob_store *bs = ctx->bs;
5726 : :
5727 : 186 : free(ctx);
5728 : :
5729 [ + + ]: 186 : if (bserrno != 0) {
5730 : 20 : bs_sequence_finish(seq, bserrno);
5731 : 20 : return;
5732 : : }
5733 : :
5734 : : /*
5735 : : * We need to defer calling bs_call_cpl() until after
5736 : : * dev destruction, so tuck these away for later use.
5737 : : */
5738 [ # # # # ]: 166 : bs->unload_err = bserrno;
5739 [ - + - + : 166 : memcpy(&bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
# # # # ]
5740 [ # # # # : 166 : seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
# # ]
5741 : 166 : bs_sequence_finish(seq, bserrno);
5742 : :
5743 : 166 : bs_free(bs);
5744 : 11 : }
5745 : :
5746 : : void
5747 : 186 : spdk_bs_destroy(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn,
5748 : : void *cb_arg)
5749 : : {
5750 : 175 : struct spdk_bs_cpl cpl;
5751 : : spdk_bs_sequence_t *seq;
5752 : : struct spdk_bs_load_ctx *ctx;
5753 : :
5754 [ + + - + : 186 : SPDK_DEBUGLOG(blob, "Destroying blobstore\n");
# # ]
5755 : :
5756 [ - + # # : 186 : if (!RB_EMPTY(&bs->open_blobs)) {
# # # # ]
5757 : 0 : SPDK_ERRLOG("Blobstore still has open blobs\n");
5758 [ # # # # ]: 0 : cb_fn(cb_arg, -EBUSY);
5759 : 0 : return;
5760 : : }
5761 : :
5762 : 186 : cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
5763 [ # # # # : 186 : cpl.u.bs_basic.cb_fn = cb_fn;
# # ]
5764 [ # # # # : 186 : cpl.u.bs_basic.cb_arg = cb_arg;
# # ]
5765 : :
5766 : 186 : ctx = calloc(1, sizeof(*ctx));
5767 [ + + ]: 186 : if (!ctx) {
5768 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5769 : 0 : return;
5770 : : }
5771 : :
5772 [ # # # # ]: 186 : ctx->bs = bs;
5773 : :
5774 [ # # # # ]: 186 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
5775 [ - + ]: 186 : if (!seq) {
5776 : 0 : free(ctx);
5777 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5778 : 0 : return;
5779 : : }
5780 : :
5781 : : /* Write zeroes to the super block */
5782 : 197 : bs_sequence_write_zeroes_dev(seq,
5783 : 11 : bs_page_to_lba(bs, 0),
5784 : 11 : bs_byte_to_lba(bs, sizeof(struct spdk_bs_super_block)),
5785 : 11 : bs_destroy_trim_cpl, ctx);
5786 : 11 : }
5787 : :
5788 : : /* END spdk_bs_destroy */
5789 : :
5790 : : /* START spdk_bs_unload */
5791 : :
5792 : : static void
5793 : 3482 : bs_unload_finish(struct spdk_bs_load_ctx *ctx, int bserrno)
5794 : : {
5795 [ # # # # ]: 3482 : spdk_bs_sequence_t *seq = ctx->seq;
5796 [ # # # # ]: 3482 : struct spdk_blob_store *bs = ctx->bs;
5797 : :
5798 [ # # # # ]: 3482 : spdk_free(ctx->super);
5799 : 3482 : free(ctx);
5800 : :
5801 [ + + ]: 3482 : if (bserrno != 0) {
5802 : 40 : bs_sequence_finish(seq, bserrno);
5803 : 40 : return;
5804 : : }
5805 : :
5806 : : /*
5807 : : * We need to defer calling bs_call_cpl() until after
5808 : : * dev destruction, so tuck these away for later use.
5809 : : */
5810 [ # # # # ]: 3442 : bs->unload_err = bserrno;
5811 [ - + - + : 3442 : memcpy(&bs->unload_cpl, &seq->cpl, sizeof(struct spdk_bs_cpl));
# # # # ]
5812 [ # # # # : 3442 : seq->cpl.type = SPDK_BS_CPL_TYPE_NONE;
# # ]
5813 : 3442 : bs_sequence_finish(seq, bserrno);
5814 : :
5815 : 3442 : bs_free(bs);
5816 : 830 : }
5817 : :
5818 : : static void
5819 : 3442 : bs_unload_write_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5820 : : {
5821 : 3442 : struct spdk_bs_load_ctx *ctx = cb_arg;
5822 : :
5823 : 3442 : bs_unload_finish(ctx, bserrno);
5824 : 3442 : }
5825 : :
5826 : : static void
5827 : 3442 : bs_unload_write_used_clusters_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5828 : : {
5829 : 3442 : struct spdk_bs_load_ctx *ctx = cb_arg;
5830 : :
5831 [ # # # # ]: 3442 : spdk_free(ctx->mask);
5832 [ # # # # ]: 3442 : ctx->mask = NULL;
5833 : :
5834 [ - + ]: 3442 : if (bserrno != 0) {
5835 : 0 : bs_unload_finish(ctx, bserrno);
5836 : 0 : return;
5837 : : }
5838 : :
5839 [ # # # # : 3442 : ctx->super->clean = 1;
# # # # ]
5840 : :
5841 [ # # # # : 3442 : bs_write_super(seq, ctx->bs, ctx->super, bs_unload_write_super_cpl, ctx);
# # # # ]
5842 : 820 : }
5843 : :
5844 : : static void
5845 : 3442 : bs_unload_write_used_blobids_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5846 : : {
5847 : 3442 : struct spdk_bs_load_ctx *ctx = cb_arg;
5848 : :
5849 [ # # # # ]: 3442 : spdk_free(ctx->mask);
5850 [ # # # # ]: 3442 : ctx->mask = NULL;
5851 : :
5852 [ - + ]: 3442 : if (bserrno != 0) {
5853 : 0 : bs_unload_finish(ctx, bserrno);
5854 : 0 : return;
5855 : : }
5856 : :
5857 : 3442 : bs_write_used_clusters(seq, ctx, bs_unload_write_used_clusters_cpl);
5858 : 820 : }
5859 : :
5860 : : static void
5861 : 3482 : bs_unload_write_used_pages_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5862 : : {
5863 : 3482 : struct spdk_bs_load_ctx *ctx = cb_arg;
5864 : :
5865 [ # # # # ]: 3482 : spdk_free(ctx->mask);
5866 [ # # # # ]: 3482 : ctx->mask = NULL;
5867 : :
5868 [ + + ]: 3482 : if (bserrno != 0) {
5869 : 40 : bs_unload_finish(ctx, bserrno);
5870 : 40 : return;
5871 : : }
5872 : :
5873 : 3442 : bs_write_used_blobids(seq, ctx, bs_unload_write_used_blobids_cpl);
5874 : 830 : }
5875 : :
5876 : : static void
5877 : 3482 : bs_unload_read_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5878 : : {
5879 : 3482 : struct spdk_bs_load_ctx *ctx = cb_arg;
5880 : : int rc;
5881 : :
5882 [ - + ]: 3482 : if (bserrno != 0) {
5883 : 0 : bs_unload_finish(ctx, bserrno);
5884 : 0 : return;
5885 : : }
5886 : :
5887 [ # # # # : 3482 : rc = bs_super_validate(ctx->super, ctx->bs);
# # # # ]
5888 [ + + ]: 3482 : if (rc != 0) {
5889 : 0 : bs_unload_finish(ctx, rc);
5890 : 0 : return;
5891 : : }
5892 : :
5893 : 3482 : bs_write_used_md(seq, cb_arg, bs_unload_write_used_pages_cpl);
5894 : 830 : }
5895 : :
5896 : : void
5897 : 3538 : spdk_bs_unload(struct spdk_blob_store *bs, spdk_bs_op_complete cb_fn, void *cb_arg)
5898 : : {
5899 : 2698 : struct spdk_bs_cpl cpl;
5900 : : struct spdk_bs_load_ctx *ctx;
5901 : :
5902 [ + + - + : 3538 : SPDK_DEBUGLOG(blob, "Syncing blobstore\n");
# # ]
5903 : :
5904 : : /*
5905 : : * If external snapshot channels are being destroyed while the blobstore is unloaded, the
5906 : : * unload is deferred until after the channel destruction completes.
5907 : : */
5908 [ + + # # : 3538 : if (bs->esnap_channels_unloading != 0) {
# # ]
5909 [ + + # # : 36 : if (bs->esnap_unload_cb_fn != NULL) {
# # ]
5910 : 0 : SPDK_ERRLOG("Blobstore unload in progress\n");
5911 [ # # # # ]: 0 : cb_fn(cb_arg, -EBUSY);
5912 : 0 : return;
5913 : : }
5914 [ + + - + : 36 : SPDK_DEBUGLOG(blob_esnap, "Blobstore unload deferred: %" PRIu32
# # # # #
# ]
5915 : : " esnap clones are unloading\n", bs->esnap_channels_unloading);
5916 [ # # # # ]: 36 : bs->esnap_unload_cb_fn = cb_fn;
5917 [ # # # # ]: 36 : bs->esnap_unload_cb_arg = cb_arg;
5918 : 36 : return;
5919 : : }
5920 [ + + # # : 3502 : if (bs->esnap_unload_cb_fn != NULL) {
# # ]
5921 [ + + - + : 36 : SPDK_DEBUGLOG(blob_esnap, "Blobstore deferred unload progressing\n");
# # ]
5922 [ + + # # : 36 : assert(bs->esnap_unload_cb_fn == cb_fn);
# # # # ]
5923 [ - + # # : 36 : assert(bs->esnap_unload_cb_arg == cb_arg);
# # # # ]
5924 [ # # # # ]: 36 : bs->esnap_unload_cb_fn = NULL;
5925 [ # # # # ]: 36 : bs->esnap_unload_cb_arg = NULL;
5926 : 5 : }
5927 : :
5928 [ + + # # : 3502 : if (!RB_EMPTY(&bs->open_blobs)) {
# # # # ]
5929 : 20 : SPDK_ERRLOG("Blobstore still has open blobs\n");
5930 [ # # # # ]: 20 : cb_fn(cb_arg, -EBUSY);
5931 : 20 : return;
5932 : : }
5933 : :
5934 : 3482 : ctx = calloc(1, sizeof(*ctx));
5935 [ + + ]: 3482 : if (!ctx) {
5936 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5937 : 0 : return;
5938 : : }
5939 : :
5940 [ # # # # ]: 3482 : ctx->bs = bs;
5941 : :
5942 [ # # # # ]: 3482 : ctx->super = spdk_zmalloc(sizeof(*ctx->super), 0x1000, NULL,
5943 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
5944 [ + + # # : 3482 : if (!ctx->super) {
# # ]
5945 : 0 : free(ctx);
5946 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5947 : 0 : return;
5948 : : }
5949 : :
5950 : 3482 : cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
5951 [ # # # # : 3482 : cpl.u.bs_basic.cb_fn = cb_fn;
# # ]
5952 [ # # # # : 3482 : cpl.u.bs_basic.cb_arg = cb_arg;
# # ]
5953 : :
5954 [ # # # # : 3482 : ctx->seq = bs_sequence_start_bs(bs->md_channel, &cpl);
# # # # ]
5955 [ + + # # : 3482 : if (!ctx->seq) {
# # ]
5956 [ # # # # ]: 0 : spdk_free(ctx->super);
5957 : 0 : free(ctx);
5958 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
5959 : 0 : return;
5960 : : }
5961 : :
5962 : : /* Read super block */
5963 [ # # # # : 4312 : bs_sequence_read_dev(ctx->seq, ctx->super, bs_page_to_lba(bs, 0),
# # # # ]
5964 : 3482 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
5965 : 830 : bs_unload_read_super_cpl, ctx);
5966 : 840 : }
5967 : :
5968 : : /* END spdk_bs_unload */
5969 : :
5970 : : /* START spdk_bs_set_super */
5971 : :
5972 : : struct spdk_bs_set_super_ctx {
5973 : : struct spdk_blob_store *bs;
5974 : : struct spdk_bs_super_block *super;
5975 : : };
5976 : :
5977 : : static void
5978 : 252 : bs_set_super_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5979 : : {
5980 : 252 : struct spdk_bs_set_super_ctx *ctx = cb_arg;
5981 : :
5982 [ - + ]: 252 : if (bserrno != 0) {
5983 : 0 : SPDK_ERRLOG("Unable to write to super block of blobstore\n");
5984 : 0 : }
5985 : :
5986 [ # # # # ]: 252 : spdk_free(ctx->super);
5987 : :
5988 : 252 : bs_sequence_finish(seq, bserrno);
5989 : :
5990 : 252 : free(ctx);
5991 : 252 : }
5992 : :
5993 : : static void
5994 : 252 : bs_set_super_read_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
5995 : : {
5996 : 252 : struct spdk_bs_set_super_ctx *ctx = cb_arg;
5997 : : int rc;
5998 : :
5999 [ - + ]: 252 : if (bserrno != 0) {
6000 : 0 : SPDK_ERRLOG("Unable to read super block of blobstore\n");
6001 [ # # # # ]: 0 : spdk_free(ctx->super);
6002 : 0 : bs_sequence_finish(seq, bserrno);
6003 : 0 : free(ctx);
6004 : 0 : return;
6005 : : }
6006 : :
6007 [ # # # # : 252 : rc = bs_super_validate(ctx->super, ctx->bs);
# # # # ]
6008 [ + + ]: 252 : if (rc != 0) {
6009 : 0 : SPDK_ERRLOG("Not a valid super block\n");
6010 [ # # # # ]: 0 : spdk_free(ctx->super);
6011 : 0 : bs_sequence_finish(seq, rc);
6012 : 0 : free(ctx);
6013 : 0 : return;
6014 : : }
6015 : :
6016 [ # # # # : 252 : bs_write_super(seq, ctx->bs, ctx->super, bs_set_super_write_cpl, ctx);
# # # # ]
6017 : 11 : }
6018 : :
6019 : : void
6020 : 252 : spdk_bs_set_super(struct spdk_blob_store *bs, spdk_blob_id blobid,
6021 : : spdk_bs_op_complete cb_fn, void *cb_arg)
6022 : : {
6023 : 241 : struct spdk_bs_cpl cpl;
6024 : : spdk_bs_sequence_t *seq;
6025 : : struct spdk_bs_set_super_ctx *ctx;
6026 : :
6027 [ + + - + : 252 : SPDK_DEBUGLOG(blob, "Setting super blob id on blobstore\n");
# # ]
6028 : :
6029 : 252 : ctx = calloc(1, sizeof(*ctx));
6030 [ + + ]: 252 : if (!ctx) {
6031 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
6032 : 0 : return;
6033 : : }
6034 : :
6035 [ # # # # ]: 252 : ctx->bs = bs;
6036 : :
6037 [ # # # # ]: 252 : ctx->super = spdk_zmalloc(sizeof(*ctx->super), 0x1000, NULL,
6038 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
6039 [ + + # # : 252 : if (!ctx->super) {
# # ]
6040 : 0 : free(ctx);
6041 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
6042 : 0 : return;
6043 : : }
6044 : :
6045 : 252 : cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
6046 [ # # # # : 252 : cpl.u.bs_basic.cb_fn = cb_fn;
# # ]
6047 [ # # # # : 252 : cpl.u.bs_basic.cb_arg = cb_arg;
# # ]
6048 : :
6049 [ # # # # ]: 252 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
6050 [ - + ]: 252 : if (!seq) {
6051 [ # # # # ]: 0 : spdk_free(ctx->super);
6052 : 0 : free(ctx);
6053 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
6054 : 0 : return;
6055 : : }
6056 : :
6057 [ # # # # ]: 252 : bs->super_blob = blobid;
6058 : :
6059 : : /* Read super block */
6060 [ # # # # ]: 263 : bs_sequence_read_dev(seq, ctx->super, bs_page_to_lba(bs, 0),
6061 : 252 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
6062 : 11 : bs_set_super_read_cpl, ctx);
6063 : 11 : }
6064 : :
6065 : : /* END spdk_bs_set_super */
6066 : :
6067 : : void
6068 : 139 : spdk_bs_get_super(struct spdk_blob_store *bs,
6069 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6070 : : {
6071 [ + + # # : 139 : if (bs->super_blob == SPDK_BLOBID_INVALID) {
# # ]
6072 [ # # # # ]: 20 : cb_fn(cb_arg, SPDK_BLOBID_INVALID, -ENOENT);
6073 : 5 : } else {
6074 [ # # # # : 119 : cb_fn(cb_arg, bs->super_blob, 0);
# # # # ]
6075 : : }
6076 : 139 : }
6077 : :
6078 : : uint64_t
6079 : 3122 : spdk_bs_get_cluster_size(struct spdk_blob_store *bs)
6080 : : {
6081 [ # # # # ]: 3122 : return bs->cluster_sz;
6082 : : }
6083 : :
6084 : : uint64_t
6085 : 467 : spdk_bs_get_page_size(struct spdk_blob_store *bs)
6086 : : {
6087 [ # # # # ]: 467 : return bs->md_page_size;
6088 : : }
6089 : :
6090 : : uint64_t
6091 : 4704151 : spdk_bs_get_io_unit_size(struct spdk_blob_store *bs)
6092 : : {
6093 [ # # # # ]: 4704151 : return bs->io_unit_size;
6094 : : }
6095 : :
6096 : : uint64_t
6097 : 3025 : spdk_bs_free_cluster_count(struct spdk_blob_store *bs)
6098 : : {
6099 [ # # # # ]: 3025 : return bs->num_free_clusters;
6100 : : }
6101 : :
6102 : : uint64_t
6103 : 998 : spdk_bs_total_data_cluster_count(struct spdk_blob_store *bs)
6104 : : {
6105 [ # # # # ]: 998 : return bs->total_data_clusters;
6106 : : }
6107 : :
6108 : : static int
6109 : 10065 : bs_register_md_thread(struct spdk_blob_store *bs)
6110 : : {
6111 [ + - + - ]: 10065 : bs->md_channel = spdk_get_io_channel(bs);
6112 [ + + + - : 10065 : if (!bs->md_channel) {
+ - ]
6113 : 0 : SPDK_ERRLOG("Failed to get IO channel.\n");
6114 : 0 : return -1;
6115 : : }
6116 : :
6117 : 10065 : return 0;
6118 : 1272 : }
6119 : :
6120 : : static int
6121 : 10065 : bs_unregister_md_thread(struct spdk_blob_store *bs)
6122 : : {
6123 [ + - + - ]: 10065 : spdk_put_io_channel(bs->md_channel);
6124 : :
6125 : 10065 : return 0;
6126 : : }
6127 : :
6128 : : spdk_blob_id
6129 : 9286 : spdk_blob_get_id(struct spdk_blob *blob)
6130 : : {
6131 [ + + # # ]: 9286 : assert(blob != NULL);
6132 : :
6133 [ # # # # ]: 9286 : return blob->id;
6134 : : }
6135 : :
6136 : : uint64_t
6137 : 153 : spdk_blob_get_num_io_units(struct spdk_blob *blob)
6138 : : {
6139 [ + + # # ]: 153 : assert(blob != NULL);
6140 : :
6141 [ # # # # : 153 : return bs_cluster_to_io_unit(blob->bs, blob->active.num_clusters);
# # # # #
# ]
6142 : : }
6143 : :
6144 : : uint64_t
6145 : 905471 : spdk_blob_get_num_clusters(struct spdk_blob *blob)
6146 : : {
6147 [ + + # # ]: 905471 : assert(blob != NULL);
6148 : :
6149 [ # # # # : 905471 : return blob->active.num_clusters;
# # ]
6150 : : }
6151 : :
6152 : : uint64_t
6153 : 2979 : spdk_blob_get_num_allocated_clusters(struct spdk_blob *blob)
6154 : : {
6155 [ + + # # ]: 2979 : assert(blob != NULL);
6156 : :
6157 [ # # # # : 2979 : return blob->active.num_allocated_clusters;
# # ]
6158 : : }
6159 : :
6160 : : static uint64_t
6161 : 150 : blob_find_io_unit(struct spdk_blob *blob, uint64_t offset, bool is_allocated)
6162 : : {
6163 : 150 : uint64_t blob_io_unit_num = spdk_blob_get_num_io_units(blob);
6164 : :
6165 [ + + ]: 295 : while (offset < blob_io_unit_num) {
6166 [ + + # # ]: 270 : if (bs_io_unit_is_allocated(blob, offset) == is_allocated) {
6167 : 125 : return offset;
6168 : : }
6169 : :
6170 : 145 : offset += bs_num_io_units_to_cluster_boundary(blob, offset);
6171 : : }
6172 : :
6173 : 25 : return UINT64_MAX;
6174 : 30 : }
6175 : :
6176 : : uint64_t
6177 : 75 : spdk_blob_get_next_allocated_io_unit(struct spdk_blob *blob, uint64_t offset)
6178 : : {
6179 : 75 : return blob_find_io_unit(blob, offset, true);
6180 : : }
6181 : :
6182 : : uint64_t
6183 : 75 : spdk_blob_get_next_unallocated_io_unit(struct spdk_blob *blob, uint64_t offset)
6184 : : {
6185 : 75 : return blob_find_io_unit(blob, offset, false);
6186 : : }
6187 : :
6188 : : /* START spdk_bs_create_blob */
6189 : :
6190 : : static void
6191 : 12224 : bs_create_blob_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
6192 : : {
6193 : 12224 : struct spdk_blob *blob = cb_arg;
6194 [ # # # # ]: 12224 : uint32_t page_idx = bs_blobid_to_page(blob->id);
6195 : :
6196 [ - + ]: 12224 : if (bserrno != 0) {
6197 [ # # # # : 0 : spdk_spin_lock(&blob->bs->used_lock);
# # ]
6198 [ # # # # : 0 : spdk_bit_array_clear(blob->bs->used_blobids, page_idx);
# # # # ]
6199 [ # # # # ]: 0 : bs_release_md_page(blob->bs, page_idx);
6200 [ # # # # : 0 : spdk_spin_unlock(&blob->bs->used_lock);
# # ]
6201 : 0 : }
6202 : :
6203 : 12224 : blob_free(blob);
6204 : :
6205 : 12224 : bs_sequence_finish(seq, bserrno);
6206 : 12224 : }
6207 : :
6208 : : static int
6209 : 24552 : blob_set_xattrs(struct spdk_blob *blob, const struct spdk_blob_xattr_opts *xattrs,
6210 : : bool internal)
6211 : : {
6212 : : uint64_t i;
6213 : 24552 : size_t value_len = 0;
6214 : : int rc;
6215 : 24552 : const void *value = NULL;
6216 [ + + + + : 24552 : if (xattrs->count > 0 && xattrs->get_value == NULL) {
# # # # #
# # # ]
6217 : 40 : return -EINVAL;
6218 : : }
6219 [ + + # # : 27285 : for (i = 0; i < xattrs->count; i++) {
# # ]
6220 [ # # # # : 2793 : xattrs->get_value(xattrs->ctx, xattrs->names[i], &value, &value_len);
# # # # #
# # # # #
# # # # #
# ]
6221 [ + + - + ]: 2793 : if (value == NULL || value_len == 0) {
6222 : 20 : return -EINVAL;
6223 : : }
6224 [ # # # # : 2773 : rc = blob_set_xattr(blob, xattrs->names[i], value, value_len, internal);
# # # # #
# ]
6225 [ + + ]: 2773 : if (rc < 0) {
6226 : 0 : return rc;
6227 : : }
6228 : 406 : }
6229 : 24492 : return 0;
6230 : 4727 : }
6231 : :
6232 : : static void
6233 : 9882 : blob_opts_copy(const struct spdk_blob_opts *src, struct spdk_blob_opts *dst)
6234 : : {
6235 : : #define FIELD_OK(field) \
6236 : : offsetof(struct spdk_blob_opts, field) + sizeof(src->field) <= src->opts_size
6237 : :
6238 : : #define SET_FIELD(field) \
6239 : : if (FIELD_OK(field)) { \
6240 : : dst->field = src->field; \
6241 : : } \
6242 : :
6243 [ + + # # : 9882 : SET_FIELD(num_clusters);
# # # # #
# # # #
# ]
6244 [ + + - + : 9882 : SET_FIELD(thin_provision);
# # # # #
# # # # #
# # ]
6245 [ + + # # : 9882 : SET_FIELD(clear_method);
# # # # #
# # # #
# ]
6246 : :
6247 [ + + # # : 9882 : if (FIELD_OK(xattrs)) {
# # ]
6248 [ - + - + : 9882 : memcpy(&dst->xattrs, &src->xattrs, sizeof(src->xattrs));
# # # # ]
6249 : 2334 : }
6250 : :
6251 [ + + - + : 9882 : SET_FIELD(use_extent_table);
# # # # #
# # # # #
# # ]
6252 [ + + # # : 9882 : SET_FIELD(esnap_id);
# # # # #
# # # #
# ]
6253 [ + + # # : 9882 : SET_FIELD(esnap_id_len);
# # # # #
# # # #
# ]
6254 : :
6255 [ # # # # : 9882 : dst->opts_size = src->opts_size;
# # # # ]
6256 : :
6257 : : /* You should not remove this statement, but need to update the assert statement
6258 : : * if you add a new field, and also add a corresponding SET_FIELD statement */
6259 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_blob_opts) == 80, "Incorrect size");
6260 : :
6261 : : #undef FIELD_OK
6262 : : #undef SET_FIELD
6263 : 9882 : }
6264 : :
6265 : : static void
6266 : 12306 : bs_create_blob(struct spdk_blob_store *bs,
6267 : : const struct spdk_blob_opts *opts,
6268 : : const struct spdk_blob_xattr_opts *internal_xattrs,
6269 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6270 : : {
6271 : : struct spdk_blob *blob;
6272 : : uint32_t page_idx;
6273 : 9935 : struct spdk_bs_cpl cpl;
6274 : 9935 : struct spdk_blob_opts opts_local;
6275 : 9935 : struct spdk_blob_xattr_opts internal_xattrs_default;
6276 : : spdk_bs_sequence_t *seq;
6277 : : spdk_blob_id id;
6278 : : int rc;
6279 : :
6280 [ + + # # : 12306 : assert(spdk_get_thread() == bs->md_thread);
# # # # ]
6281 : :
6282 [ # # ]: 12306 : spdk_spin_lock(&bs->used_lock);
6283 [ # # # # ]: 12306 : page_idx = spdk_bit_array_find_first_clear(bs->used_md_pages, 0);
6284 [ + + ]: 12306 : if (page_idx == UINT32_MAX) {
6285 [ # # ]: 0 : spdk_spin_unlock(&bs->used_lock);
6286 [ # # # # ]: 0 : cb_fn(cb_arg, 0, -ENOMEM);
6287 : 0 : return;
6288 : : }
6289 [ # # # # ]: 12306 : spdk_bit_array_set(bs->used_blobids, page_idx);
6290 : 12306 : bs_claim_md_page(bs, page_idx);
6291 [ # # ]: 12306 : spdk_spin_unlock(&bs->used_lock);
6292 : :
6293 : 12306 : id = bs_page_to_blobid(page_idx);
6294 : :
6295 [ + + - + : 12306 : SPDK_DEBUGLOG(blob, "Creating blob with id 0x%" PRIx64 " at page %u\n", id, page_idx);
# # ]
6296 : :
6297 : 12306 : spdk_blob_opts_init(&opts_local, sizeof(opts_local));
6298 [ + + ]: 12306 : if (opts) {
6299 : 9882 : blob_opts_copy(opts, &opts_local);
6300 : 2334 : }
6301 : :
6302 : 12306 : blob = blob_alloc(bs, id);
6303 [ + + ]: 12306 : if (!blob) {
6304 : 0 : rc = -ENOMEM;
6305 : 0 : goto error;
6306 : : }
6307 : :
6308 [ - + # # : 12306 : blob->use_extent_table = opts_local.use_extent_table;
# # # # ]
6309 [ + + + + : 12306 : if (blob->use_extent_table) {
# # # # ]
6310 [ # # # # : 8602 : blob->invalid_flags |= SPDK_BLOB_EXTENT_TABLE;
# # ]
6311 : 1445 : }
6312 : :
6313 [ + + ]: 12306 : if (!internal_xattrs) {
6314 : 10877 : blob_xattrs_init(&internal_xattrs_default);
6315 : 10877 : internal_xattrs = &internal_xattrs_default;
6316 : 2028 : }
6317 : :
6318 : 12306 : rc = blob_set_xattrs(blob, &opts_local.xattrs, false);
6319 [ + + ]: 12306 : if (rc < 0) {
6320 : 60 : goto error;
6321 : : }
6322 : :
6323 : 12246 : rc = blob_set_xattrs(blob, internal_xattrs, true);
6324 [ + + ]: 12246 : if (rc < 0) {
6325 : 0 : goto error;
6326 : : }
6327 : :
6328 [ + + + + : 12246 : if (opts_local.thin_provision) {
# # ]
6329 : 1921 : blob_set_thin_provision(blob);
6330 : 449 : }
6331 : :
6332 [ # # ]: 12246 : blob_set_clear_method(blob, opts_local.clear_method);
6333 : :
6334 [ + + # # ]: 12246 : if (opts_local.esnap_id != NULL) {
6335 [ - + # # ]: 310 : if (opts_local.esnap_id_len > UINT16_MAX) {
6336 [ # # ]: 0 : SPDK_ERRLOG("esnap id length %" PRIu64 "is too long\n",
6337 : : opts_local.esnap_id_len);
6338 : 0 : rc = -EINVAL;
6339 : 0 : goto error;
6340 : :
6341 : : }
6342 : 310 : blob_set_thin_provision(blob);
6343 [ # # # # : 310 : blob->invalid_flags |= SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
6344 : 385 : rc = blob_set_xattr(blob, BLOB_EXTERNAL_SNAPSHOT_ID,
6345 [ # # # # ]: 310 : opts_local.esnap_id, opts_local.esnap_id_len, true);
6346 [ - + ]: 310 : if (rc != 0) {
6347 : 0 : goto error;
6348 : : }
6349 : 75 : }
6350 : :
6351 : 12246 : rc = blob_resize(blob, opts_local.num_clusters);
6352 [ + + ]: 12246 : if (rc < 0) {
6353 : 22 : goto error;
6354 : : }
6355 : 12224 : cpl.type = SPDK_BS_CPL_TYPE_BLOBID;
6356 [ # # # # : 12224 : cpl.u.blobid.cb_fn = cb_fn;
# # ]
6357 [ # # # # : 12224 : cpl.u.blobid.cb_arg = cb_arg;
# # ]
6358 [ # # # # : 12224 : cpl.u.blobid.blobid = blob->id;
# # # # #
# ]
6359 : :
6360 [ # # # # ]: 12224 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
6361 [ - + ]: 12224 : if (!seq) {
6362 : 0 : rc = -ENOMEM;
6363 : 0 : goto error;
6364 : : }
6365 : :
6366 : 12224 : blob_persist(seq, blob, bs_create_blob_cpl, blob);
6367 : 12224 : return;
6368 : :
6369 : 62 : error:
6370 : 82 : SPDK_ERRLOG("Failed to create blob: %s, size in clusters/size: %lu (clusters)\n",
6371 : : spdk_strerror(rc), opts_local.num_clusters);
6372 [ + + ]: 82 : if (blob != NULL) {
6373 : 82 : blob_free(blob);
6374 : 20 : }
6375 [ # # ]: 82 : spdk_spin_lock(&bs->used_lock);
6376 [ # # # # ]: 82 : spdk_bit_array_clear(bs->used_blobids, page_idx);
6377 : 82 : bs_release_md_page(bs, page_idx);
6378 [ # # ]: 82 : spdk_spin_unlock(&bs->used_lock);
6379 [ # # # # ]: 82 : cb_fn(cb_arg, 0, rc);
6380 : 2371 : }
6381 : :
6382 : : void
6383 : 2344 : spdk_bs_create_blob(struct spdk_blob_store *bs,
6384 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6385 : : {
6386 : 2344 : bs_create_blob(bs, NULL, NULL, cb_fn, cb_arg);
6387 : 2344 : }
6388 : :
6389 : : void
6390 : 8493 : spdk_bs_create_blob_ext(struct spdk_blob_store *bs, const struct spdk_blob_opts *opts,
6391 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6392 : : {
6393 : 8493 : bs_create_blob(bs, opts, NULL, cb_fn, cb_arg);
6394 : 8493 : }
6395 : :
6396 : : /* END spdk_bs_create_blob */
6397 : :
6398 : : /* START blob_cleanup */
6399 : :
6400 : : struct spdk_clone_snapshot_ctx {
6401 : : struct spdk_bs_cpl cpl;
6402 : : int bserrno;
6403 : : bool frozen;
6404 : :
6405 : : struct spdk_io_channel *channel;
6406 : :
6407 : : /* Current cluster for inflate operation */
6408 : : uint64_t cluster;
6409 : :
6410 : : /* For inflation force allocation of all unallocated clusters and remove
6411 : : * thin-provisioning. Otherwise only decouple parent and keep clone thin. */
6412 : : bool allocate_all;
6413 : :
6414 : : struct {
6415 : : spdk_blob_id id;
6416 : : struct spdk_blob *blob;
6417 : : bool md_ro;
6418 : : } original;
6419 : : struct {
6420 : : spdk_blob_id id;
6421 : : struct spdk_blob *blob;
6422 : : } new;
6423 : :
6424 : : /* xattrs specified for snapshot/clones only. They have no impact on
6425 : : * the original blobs xattrs. */
6426 : : const struct spdk_blob_xattr_opts *xattrs;
6427 : : };
6428 : :
6429 : : static void
6430 : 1795 : bs_clone_snapshot_cleanup_finish(void *cb_arg, int bserrno)
6431 : : {
6432 : 1795 : struct spdk_clone_snapshot_ctx *ctx = cb_arg;
6433 [ # # ]: 1795 : struct spdk_bs_cpl *cpl = &ctx->cpl;
6434 : :
6435 [ + + ]: 1795 : if (bserrno != 0) {
6436 [ - + # # : 32 : if (ctx->bserrno != 0) {
# # ]
6437 : 0 : SPDK_ERRLOG("Cleanup error %d\n", bserrno);
6438 : 0 : } else {
6439 [ # # # # ]: 32 : ctx->bserrno = bserrno;
6440 : : }
6441 : 8 : }
6442 : :
6443 [ + + + # : 1795 : switch (cpl->type) {
# # # ]
6444 : 1128 : case SPDK_BS_CPL_TYPE_BLOBID:
6445 [ # # # # : 1484 : cpl->u.blobid.cb_fn(cpl->u.blobid.cb_arg, cpl->u.blobid.blobid, ctx->bserrno);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
6446 : 1484 : break;
6447 : 236 : case SPDK_BS_CPL_TYPE_BLOB_BASIC:
6448 [ # # # # : 311 : cpl->u.blob_basic.cb_fn(cpl->u.blob_basic.cb_arg, ctx->bserrno);
# # # # #
# # # # #
# # # # #
# # # #
# ]
6449 : 311 : break;
6450 : 0 : default:
6451 [ # # ]: 0 : SPDK_UNREACHABLE();
6452 : : break;
6453 : : }
6454 : :
6455 : 1795 : free(ctx);
6456 : 1795 : }
6457 : :
6458 : : static void
6459 : 1720 : bs_snapshot_unfreeze_cpl(void *cb_arg, int bserrno)
6460 : : {
6461 : 1720 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6462 [ # # # # : 1720 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6463 : :
6464 [ + + ]: 1720 : if (bserrno != 0) {
6465 [ # # # # : 0 : if (ctx->bserrno != 0) {
# # ]
6466 : 0 : SPDK_ERRLOG("Unfreeze error %d\n", bserrno);
6467 : 0 : } else {
6468 [ # # # # ]: 0 : ctx->bserrno = bserrno;
6469 : : }
6470 : 0 : }
6471 : :
6472 [ # # # # : 1720 : ctx->original.id = origblob->id;
# # # # #
# ]
6473 [ # # # # ]: 1720 : origblob->locked_operation_in_progress = false;
6474 : :
6475 : : /* Revert md_ro to original state */
6476 [ - + # # : 1720 : origblob->md_ro = ctx->original.md_ro;
# # # # #
# # # ]
6477 : :
6478 : 1720 : spdk_blob_close(origblob, bs_clone_snapshot_cleanup_finish, ctx);
6479 : 1720 : }
6480 : :
6481 : : static void
6482 : 1720 : bs_clone_snapshot_origblob_cleanup(void *cb_arg, int bserrno)
6483 : : {
6484 : 1720 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6485 [ # # # # : 1720 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6486 : :
6487 [ + + ]: 1720 : if (bserrno != 0) {
6488 [ + + # # : 121 : if (ctx->bserrno != 0) {
# # ]
6489 : 20 : SPDK_ERRLOG("Cleanup error %d\n", bserrno);
6490 : 5 : } else {
6491 [ # # # # ]: 101 : ctx->bserrno = bserrno;
6492 : : }
6493 : 30 : }
6494 : :
6495 [ + + + + : 1720 : if (ctx->frozen) {
# # # # ]
6496 : : /* Unfreeze any outstanding I/O */
6497 : 1104 : blob_unfreeze_io(origblob, bs_snapshot_unfreeze_cpl, ctx);
6498 : 267 : } else {
6499 : 616 : bs_snapshot_unfreeze_cpl(ctx, 0);
6500 : : }
6501 : :
6502 : 1720 : }
6503 : :
6504 : : static void
6505 : 20 : bs_clone_snapshot_newblob_cleanup(struct spdk_clone_snapshot_ctx *ctx, int bserrno)
6506 : : {
6507 [ # # # # : 20 : struct spdk_blob *newblob = ctx->new.blob;
# # ]
6508 : :
6509 [ + + ]: 20 : if (bserrno != 0) {
6510 [ + + # # : 20 : if (ctx->bserrno != 0) {
# # ]
6511 : 0 : SPDK_ERRLOG("Cleanup error %d\n", bserrno);
6512 : 0 : } else {
6513 [ # # # # ]: 20 : ctx->bserrno = bserrno;
6514 : : }
6515 : 5 : }
6516 : :
6517 [ # # # # : 20 : ctx->new.id = newblob->id;
# # # # #
# ]
6518 : 20 : spdk_blob_close(newblob, bs_clone_snapshot_origblob_cleanup, ctx);
6519 : 20 : }
6520 : :
6521 : : /* END blob_cleanup */
6522 : :
6523 : : /* START spdk_bs_create_snapshot */
6524 : :
6525 : : static void
6526 : 1144 : bs_snapshot_swap_cluster_maps(struct spdk_blob *blob1, struct spdk_blob *blob2)
6527 : : {
6528 : : uint64_t *cluster_temp;
6529 : : uint64_t num_allocated_clusters_temp;
6530 : : uint32_t *extent_page_temp;
6531 : :
6532 [ # # # # : 1144 : cluster_temp = blob1->active.clusters;
# # ]
6533 [ # # # # : 1144 : blob1->active.clusters = blob2->active.clusters;
# # # # #
# # # ]
6534 [ # # # # : 1144 : blob2->active.clusters = cluster_temp;
# # ]
6535 : :
6536 [ # # # # : 1144 : num_allocated_clusters_temp = blob1->active.num_allocated_clusters;
# # ]
6537 [ # # # # : 1144 : blob1->active.num_allocated_clusters = blob2->active.num_allocated_clusters;
# # # # #
# # # ]
6538 [ # # # # : 1144 : blob2->active.num_allocated_clusters = num_allocated_clusters_temp;
# # ]
6539 : :
6540 [ # # # # : 1144 : extent_page_temp = blob1->active.extent_pages;
# # ]
6541 [ # # # # : 1144 : blob1->active.extent_pages = blob2->active.extent_pages;
# # # # #
# # # ]
6542 [ # # # # : 1144 : blob2->active.extent_pages = extent_page_temp;
# # ]
6543 : 1144 : }
6544 : :
6545 : : /* Copies an internal xattr */
6546 : : static int
6547 : 108 : bs_snapshot_copy_xattr(struct spdk_blob *toblob, struct spdk_blob *fromblob, const char *name)
6548 : : {
6549 : 108 : const void *val = NULL;
6550 : 83 : size_t len;
6551 : : int bserrno;
6552 : :
6553 : 108 : bserrno = blob_get_xattr_value(fromblob, name, &val, &len, true);
6554 [ - + ]: 108 : if (bserrno != 0) {
6555 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " missing %s XATTR\n", fromblob->id, name);
6556 : 0 : return bserrno;
6557 : : }
6558 : :
6559 : 108 : bserrno = blob_set_xattr(toblob, name, val, len, true);
6560 [ + + ]: 108 : if (bserrno != 0) {
6561 [ # # # # ]: 0 : SPDK_ERRLOG("could not set %s XATTR on blob 0x%" PRIx64 "\n",
6562 : : name, toblob->id);
6563 : 0 : return bserrno;
6564 : : }
6565 : 108 : return 0;
6566 : 25 : }
6567 : :
6568 : : static void
6569 : 1084 : bs_snapshot_origblob_sync_cpl(void *cb_arg, int bserrno)
6570 : : {
6571 : 1084 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6572 [ # # # # : 1084 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6573 [ # # # # : 1084 : struct spdk_blob *newblob = ctx->new.blob;
# # ]
6574 : :
6575 [ + + ]: 1084 : if (bserrno != 0) {
6576 : 20 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6577 [ + + ]: 20 : if (blob_is_esnap_clone(newblob)) {
6578 : 0 : bs_snapshot_copy_xattr(origblob, newblob, BLOB_EXTERNAL_SNAPSHOT_ID);
6579 [ # # # # : 0 : origblob->invalid_flags |= SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
6580 : 0 : }
6581 : 20 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6582 : 20 : return;
6583 : : }
6584 : :
6585 : : /* Remove metadata descriptor SNAPSHOT_IN_PROGRESS */
6586 : 1064 : bserrno = blob_remove_xattr(newblob, SNAPSHOT_IN_PROGRESS, true);
6587 [ + + ]: 1064 : if (bserrno != 0) {
6588 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6589 : 0 : return;
6590 : : }
6591 : :
6592 [ # # # # : 1064 : bs_blob_list_add(ctx->original.blob);
# # ]
6593 : :
6594 : 1064 : spdk_blob_set_read_only(newblob);
6595 : :
6596 : : /* sync snapshot metadata */
6597 : 1064 : spdk_blob_sync_md(newblob, bs_clone_snapshot_origblob_cleanup, ctx);
6598 : 262 : }
6599 : :
6600 : : static void
6601 : 1104 : bs_snapshot_newblob_sync_cpl(void *cb_arg, int bserrno)
6602 : : {
6603 : 1104 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6604 [ # # # # : 1104 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6605 [ # # # # : 1104 : struct spdk_blob *newblob = ctx->new.blob;
# # ]
6606 : :
6607 [ + + ]: 1104 : if (bserrno != 0) {
6608 : : /* return cluster map back to original */
6609 : 20 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6610 : :
6611 : : /* Newblob md sync failed. Valid clusters are only present in origblob.
6612 : : * Since I/O is frozen on origblob, not changes to zeroed out cluster map should have occurred.
6613 : : * Newblob needs to be reverted to thin_provisioned state at creation to properly close. */
6614 : 20 : blob_set_thin_provision(newblob);
6615 [ + + # # : 20 : assert(spdk_mem_all_zero(newblob->active.clusters,
# # # # #
# # # # #
# # ]
6616 : : newblob->active.num_clusters * sizeof(*newblob->active.clusters)));
6617 [ + + # # : 20 : assert(spdk_mem_all_zero(newblob->active.extent_pages,
# # # # #
# # # # #
# # ]
6618 : : newblob->active.num_extent_pages * sizeof(*newblob->active.extent_pages)));
6619 : :
6620 : 20 : bs_clone_snapshot_newblob_cleanup(ctx, bserrno);
6621 : 20 : return;
6622 : : }
6623 : :
6624 : : /* Set internal xattr for snapshot id */
6625 [ # # ]: 1084 : bserrno = blob_set_xattr(origblob, BLOB_SNAPSHOT, &newblob->id, sizeof(spdk_blob_id), true);
6626 [ - + ]: 1084 : if (bserrno != 0) {
6627 : : /* return cluster map back to original */
6628 : 0 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6629 : 0 : blob_set_thin_provision(newblob);
6630 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, bserrno);
6631 : 0 : return;
6632 : : }
6633 : :
6634 : : /* Create new back_bs_dev for snapshot */
6635 [ # # # # ]: 1084 : origblob->back_bs_dev = bs_create_blob_bs_dev(newblob);
6636 [ + + # # : 1084 : if (origblob->back_bs_dev == NULL) {
# # ]
6637 : : /* return cluster map back to original */
6638 : 0 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6639 : 0 : blob_set_thin_provision(newblob);
6640 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, -EINVAL);
6641 : 0 : return;
6642 : : }
6643 : :
6644 : : /* Remove the xattr that references an external snapshot */
6645 [ + + ]: 1084 : if (blob_is_esnap_clone(origblob)) {
6646 [ # # # # : 64 : origblob->invalid_flags &= ~SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
6647 : 64 : bserrno = blob_remove_xattr(origblob, BLOB_EXTERNAL_SNAPSHOT_ID, true);
6648 [ - + ]: 64 : if (bserrno != 0) {
6649 [ # # ]: 0 : if (bserrno == -ENOENT) {
6650 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " has no " BLOB_EXTERNAL_SNAPSHOT_ID
6651 : : " xattr to remove\n", origblob->id);
6652 [ # # ]: 0 : assert(false);
6653 : : } else {
6654 : : /* return cluster map back to original */
6655 : 0 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6656 : 0 : blob_set_thin_provision(newblob);
6657 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, bserrno);
6658 : 0 : return;
6659 : : }
6660 : : }
6661 : 15 : }
6662 : :
6663 : 1084 : bs_blob_list_remove(origblob);
6664 [ # # # # : 1084 : origblob->parent_id = newblob->id;
# # # # ]
6665 : : /* set clone blob as thin provisioned */
6666 : 1084 : blob_set_thin_provision(origblob);
6667 : :
6668 : 1084 : bs_blob_list_add(newblob);
6669 : :
6670 : : /* sync clone metadata */
6671 : 1084 : spdk_blob_sync_md(origblob, bs_snapshot_origblob_sync_cpl, ctx);
6672 : 267 : }
6673 : :
6674 : : static void
6675 : 1104 : bs_snapshot_freeze_cpl(void *cb_arg, int rc)
6676 : : {
6677 : 1104 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6678 [ # # # # : 1104 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6679 [ # # # # : 1104 : struct spdk_blob *newblob = ctx->new.blob;
# # ]
6680 : : int bserrno;
6681 : :
6682 [ - + ]: 1104 : if (rc != 0) {
6683 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, rc);
6684 : 0 : return;
6685 : : }
6686 : :
6687 [ # # # # ]: 1104 : ctx->frozen = true;
6688 : :
6689 [ + + ]: 1104 : if (blob_is_esnap_clone(origblob)) {
6690 : : /* Clean up any channels associated with the original blob id because future IO will
6691 : : * perform IO using the snapshot blob_id.
6692 : : */
6693 : 64 : blob_esnap_destroy_bs_dev_channels(origblob, false, NULL, NULL);
6694 : 15 : }
6695 [ + + # # : 1104 : if (newblob->back_bs_dev) {
# # ]
6696 : 1104 : blob_back_bs_destroy(newblob);
6697 : 267 : }
6698 : : /* set new back_bs_dev for snapshot */
6699 [ # # # # : 1104 : newblob->back_bs_dev = origblob->back_bs_dev;
# # # # ]
6700 : : /* Set invalid flags from origblob */
6701 [ # # # # : 1104 : newblob->invalid_flags = origblob->invalid_flags;
# # # # ]
6702 : :
6703 : : /* inherit parent from original blob if set */
6704 [ # # # # : 1104 : newblob->parent_id = origblob->parent_id;
# # # # ]
6705 [ + + + # : 1104 : switch (origblob->parent_id) {
# # # ]
6706 : 49 : case SPDK_BLOBID_EXTERNAL_SNAPSHOT:
6707 : 64 : bserrno = bs_snapshot_copy_xattr(newblob, origblob, BLOB_EXTERNAL_SNAPSHOT_ID);
6708 [ + + ]: 64 : if (bserrno != 0) {
6709 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, bserrno);
6710 : 0 : return;
6711 : : }
6712 : 64 : break;
6713 : 588 : case SPDK_BLOBID_INVALID:
6714 : 775 : break;
6715 : 200 : default:
6716 : : /* Set internal xattr for snapshot id */
6717 : 330 : bserrno = blob_set_xattr(newblob, BLOB_SNAPSHOT,
6718 [ # # ]: 265 : &origblob->parent_id, sizeof(spdk_blob_id), true);
6719 [ + + ]: 265 : if (bserrno != 0) {
6720 : 0 : bs_clone_snapshot_newblob_cleanup(ctx, bserrno);
6721 : 0 : return;
6722 : : }
6723 : 65 : }
6724 : :
6725 : : /* swap cluster maps */
6726 : 1104 : bs_snapshot_swap_cluster_maps(newblob, origblob);
6727 : :
6728 : : /* Set the clear method on the new blob to match the original. */
6729 [ # # # # ]: 1104 : blob_set_clear_method(newblob, origblob->clear_method);
6730 : :
6731 : : /* sync snapshot metadata */
6732 : 1104 : spdk_blob_sync_md(newblob, bs_snapshot_newblob_sync_cpl, ctx);
6733 : 267 : }
6734 : :
6735 : : static void
6736 : 1124 : bs_snapshot_newblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
6737 : : {
6738 : 1124 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6739 [ # # # # : 1124 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6740 : 1124 : struct spdk_blob *newblob = _blob;
6741 : :
6742 [ + + ]: 1124 : if (bserrno != 0) {
6743 : 20 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6744 : 20 : return;
6745 : : }
6746 : :
6747 [ # # # # : 1104 : ctx->new.blob = newblob;
# # ]
6748 [ + + # # ]: 1104 : assert(spdk_blob_is_thin_provisioned(newblob));
6749 [ + + # # : 1104 : assert(spdk_mem_all_zero(newblob->active.clusters,
# # # # #
# # # # #
# # ]
6750 : : newblob->active.num_clusters * sizeof(*newblob->active.clusters)));
6751 [ + + # # : 1104 : assert(spdk_mem_all_zero(newblob->active.extent_pages,
# # # # #
# # # # #
# # ]
6752 : : newblob->active.num_extent_pages * sizeof(*newblob->active.extent_pages)));
6753 : :
6754 : 1104 : blob_freeze_io(origblob, bs_snapshot_freeze_cpl, ctx);
6755 : 272 : }
6756 : :
6757 : : static void
6758 : 1144 : bs_snapshot_newblob_create_cpl(void *cb_arg, spdk_blob_id blobid, int bserrno)
6759 : : {
6760 : 1144 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6761 [ # # # # : 1144 : struct spdk_blob *origblob = ctx->original.blob;
# # ]
6762 : :
6763 [ + + ]: 1144 : if (bserrno != 0) {
6764 : 20 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6765 : 20 : return;
6766 : : }
6767 : :
6768 [ # # # # : 1124 : ctx->new.id = blobid;
# # ]
6769 [ # # # # : 1124 : ctx->cpl.u.blobid.blobid = blobid;
# # # # #
# ]
6770 : :
6771 [ # # # # : 1124 : spdk_bs_open_blob(origblob->bs, ctx->new.id, bs_snapshot_newblob_open_cpl, ctx);
# # # # #
# ]
6772 : 277 : }
6773 : :
6774 : :
6775 : : static void
6776 : 1144 : bs_xattr_snapshot(void *arg, const char *name,
6777 : : const void **value, size_t *value_len)
6778 : : {
6779 [ + + - + : 1144 : assert(strncmp(name, SNAPSHOT_IN_PROGRESS, sizeof(SNAPSHOT_IN_PROGRESS)) == 0);
# # # # ]
6780 : :
6781 : 1144 : struct spdk_blob *blob = (struct spdk_blob *)arg;
6782 [ # # # # ]: 1144 : *value = &blob->id;
6783 [ # # ]: 1144 : *value_len = sizeof(blob->id);
6784 : 1144 : }
6785 : :
6786 : : static void
6787 : 1197 : bs_snapshot_origblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
6788 : : {
6789 : 1197 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6790 : 907 : struct spdk_blob_opts opts;
6791 : 907 : struct spdk_blob_xattr_opts internal_xattrs;
6792 : 1197 : char *xattrs_names[] = { SNAPSHOT_IN_PROGRESS };
6793 : :
6794 [ + + ]: 1197 : if (bserrno != 0) {
6795 : 32 : bs_clone_snapshot_cleanup_finish(ctx, bserrno);
6796 : 32 : return;
6797 : : }
6798 : :
6799 [ # # # # : 1165 : ctx->original.blob = _blob;
# # ]
6800 : :
6801 [ + + + + : 1165 : if (_blob->data_ro || _blob->md_ro) {
- + - + #
# # # # #
# # ]
6802 [ + + - + : 21 : SPDK_DEBUGLOG(blob, "Cannot create snapshot from read only blob with id 0x%"
# # # # #
# ]
6803 : : PRIx64 "\n", _blob->id);
6804 [ # # # # ]: 21 : ctx->bserrno = -EINVAL;
6805 : 21 : spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
6806 : 21 : return;
6807 : : }
6808 : :
6809 [ - + - + : 1144 : if (_blob->locked_operation_in_progress) {
# # # # ]
6810 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Cannot create snapshot - another operation in progress\n");
# # ]
6811 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
6812 : 0 : spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
6813 : 0 : return;
6814 : : }
6815 : :
6816 [ # # # # ]: 1144 : _blob->locked_operation_in_progress = true;
6817 : :
6818 : 1144 : spdk_blob_opts_init(&opts, sizeof(opts));
6819 : 1144 : blob_xattrs_init(&internal_xattrs);
6820 : :
6821 : : /* Change the size of new blob to the same as in original blob,
6822 : : * but do not allocate clusters */
6823 [ # # ]: 1144 : opts.thin_provision = true;
6824 : 1144 : opts.num_clusters = spdk_blob_get_num_clusters(_blob);
6825 [ - + # # : 1144 : opts.use_extent_table = _blob->use_extent_table;
# # # # ]
6826 : :
6827 : : /* If there are any xattrs specified for snapshot, set them now */
6828 [ + + # # : 1144 : if (ctx->xattrs) {
# # ]
6829 [ - + - + : 60 : memcpy(&opts.xattrs, ctx->xattrs, sizeof(*ctx->xattrs));
# # # # ]
6830 : 6 : }
6831 : : /* Set internal xattr SNAPSHOT_IN_PROGRESS */
6832 : 1144 : internal_xattrs.count = 1;
6833 [ # # ]: 1144 : internal_xattrs.ctx = _blob;
6834 [ # # ]: 1144 : internal_xattrs.names = xattrs_names;
6835 [ # # ]: 1144 : internal_xattrs.get_value = bs_xattr_snapshot;
6836 : :
6837 [ # # # # ]: 1421 : bs_create_blob(_blob->bs, &opts, &internal_xattrs,
6838 : 277 : bs_snapshot_newblob_create_cpl, ctx);
6839 : 290 : }
6840 : :
6841 : : void
6842 : 1197 : spdk_bs_create_snapshot(struct spdk_blob_store *bs, spdk_blob_id blobid,
6843 : : const struct spdk_blob_xattr_opts *snapshot_xattrs,
6844 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6845 : : {
6846 : 1197 : struct spdk_clone_snapshot_ctx *ctx = calloc(1, sizeof(*ctx));
6847 : :
6848 [ - + ]: 1197 : if (!ctx) {
6849 [ # # # # ]: 0 : cb_fn(cb_arg, SPDK_BLOBID_INVALID, -ENOMEM);
6850 : 0 : return;
6851 : : }
6852 [ # # # # : 1197 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BLOBID;
# # ]
6853 [ # # # # : 1197 : ctx->cpl.u.blobid.cb_fn = cb_fn;
# # # # #
# ]
6854 [ # # # # : 1197 : ctx->cpl.u.blobid.cb_arg = cb_arg;
# # # # #
# ]
6855 [ # # # # : 1197 : ctx->cpl.u.blobid.blobid = SPDK_BLOBID_INVALID;
# # # # #
# ]
6856 [ # # # # ]: 1197 : ctx->bserrno = 0;
6857 [ # # # # ]: 1197 : ctx->frozen = false;
6858 [ # # # # : 1197 : ctx->original.id = blobid;
# # ]
6859 [ # # # # ]: 1197 : ctx->xattrs = snapshot_xattrs;
6860 : :
6861 [ # # # # : 1197 : spdk_bs_open_blob(bs, ctx->original.id, bs_snapshot_origblob_open_cpl, ctx);
# # ]
6862 : 290 : }
6863 : : /* END spdk_bs_create_snapshot */
6864 : :
6865 : : /* START spdk_bs_create_clone */
6866 : :
6867 : : static void
6868 : 265 : bs_xattr_clone(void *arg, const char *name,
6869 : : const void **value, size_t *value_len)
6870 : : {
6871 [ + + - + : 265 : assert(strncmp(name, BLOB_SNAPSHOT, sizeof(BLOB_SNAPSHOT)) == 0);
# # # # ]
6872 : :
6873 : 265 : struct spdk_blob *blob = (struct spdk_blob *)arg;
6874 [ # # # # ]: 265 : *value = &blob->id;
6875 [ # # ]: 265 : *value_len = sizeof(blob->id);
6876 : 265 : }
6877 : :
6878 : : static void
6879 : 265 : bs_clone_newblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
6880 : : {
6881 : 265 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6882 : 265 : struct spdk_blob *clone = _blob;
6883 : :
6884 [ # # # # : 265 : ctx->new.blob = clone;
# # ]
6885 : 265 : bs_blob_list_add(clone);
6886 : :
6887 : 265 : spdk_blob_close(clone, bs_clone_snapshot_origblob_cleanup, ctx);
6888 : 265 : }
6889 : :
6890 : : static void
6891 : 265 : bs_clone_newblob_create_cpl(void *cb_arg, spdk_blob_id blobid, int bserrno)
6892 : : {
6893 : 265 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6894 : :
6895 [ # # # # : 265 : ctx->cpl.u.blobid.blobid = blobid;
# # # # #
# ]
6896 [ # # # # : 265 : spdk_bs_open_blob(ctx->original.blob->bs, blobid, bs_clone_newblob_open_cpl, ctx);
# # # # #
# ]
6897 : 265 : }
6898 : :
6899 : : static void
6900 : 287 : bs_clone_origblob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
6901 : : {
6902 : 287 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6903 : 221 : struct spdk_blob_opts opts;
6904 : 221 : struct spdk_blob_xattr_opts internal_xattrs;
6905 : 287 : char *xattr_names[] = { BLOB_SNAPSHOT };
6906 : :
6907 [ - + ]: 287 : if (bserrno != 0) {
6908 : 0 : bs_clone_snapshot_cleanup_finish(ctx, bserrno);
6909 : 0 : return;
6910 : : }
6911 : :
6912 [ # # # # : 287 : ctx->original.blob = _blob;
# # ]
6913 [ - + # # : 287 : ctx->original.md_ro = _blob->md_ro;
# # # # #
# # # ]
6914 : :
6915 [ + + + + : 287 : if (!_blob->data_ro || !_blob->md_ro) {
- + - + #
# # # # #
# # ]
6916 [ + + - + : 22 : SPDK_DEBUGLOG(blob, "Clone not from read-only blob\n");
# # ]
6917 [ # # # # ]: 22 : ctx->bserrno = -EINVAL;
6918 : 22 : spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
6919 : 22 : return;
6920 : : }
6921 : :
6922 [ - + - + : 265 : if (_blob->locked_operation_in_progress) {
# # # # ]
6923 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Cannot create clone - another operation in progress\n");
# # ]
6924 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
6925 : 0 : spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
6926 : 0 : return;
6927 : : }
6928 : :
6929 [ # # # # ]: 265 : _blob->locked_operation_in_progress = true;
6930 : :
6931 : 265 : spdk_blob_opts_init(&opts, sizeof(opts));
6932 : 265 : blob_xattrs_init(&internal_xattrs);
6933 : :
6934 [ # # ]: 265 : opts.thin_provision = true;
6935 : 265 : opts.num_clusters = spdk_blob_get_num_clusters(_blob);
6936 [ - + # # : 265 : opts.use_extent_table = _blob->use_extent_table;
# # # # ]
6937 [ + + # # : 265 : if (ctx->xattrs) {
# # ]
6938 [ - + - + : 45 : memcpy(&opts.xattrs, ctx->xattrs, sizeof(*ctx->xattrs));
# # # # ]
6939 : 6 : }
6940 : :
6941 : : /* Set internal xattr BLOB_SNAPSHOT */
6942 : 265 : internal_xattrs.count = 1;
6943 [ # # ]: 265 : internal_xattrs.ctx = _blob;
6944 [ # # ]: 265 : internal_xattrs.names = xattr_names;
6945 [ # # ]: 265 : internal_xattrs.get_value = bs_xattr_clone;
6946 : :
6947 [ # # # # ]: 326 : bs_create_blob(_blob->bs, &opts, &internal_xattrs,
6948 : 61 : bs_clone_newblob_create_cpl, ctx);
6949 : 66 : }
6950 : :
6951 : : void
6952 : 287 : spdk_bs_create_clone(struct spdk_blob_store *bs, spdk_blob_id blobid,
6953 : : const struct spdk_blob_xattr_opts *clone_xattrs,
6954 : : spdk_blob_op_with_id_complete cb_fn, void *cb_arg)
6955 : : {
6956 : 287 : struct spdk_clone_snapshot_ctx *ctx = calloc(1, sizeof(*ctx));
6957 : :
6958 [ - + ]: 287 : if (!ctx) {
6959 [ # # # # ]: 0 : cb_fn(cb_arg, SPDK_BLOBID_INVALID, -ENOMEM);
6960 : 0 : return;
6961 : : }
6962 : :
6963 [ # # # # : 287 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BLOBID;
# # ]
6964 [ # # # # : 287 : ctx->cpl.u.blobid.cb_fn = cb_fn;
# # # # #
# ]
6965 [ # # # # : 287 : ctx->cpl.u.blobid.cb_arg = cb_arg;
# # # # #
# ]
6966 [ # # # # : 287 : ctx->cpl.u.blobid.blobid = SPDK_BLOBID_INVALID;
# # # # #
# ]
6967 [ # # # # ]: 287 : ctx->bserrno = 0;
6968 [ # # # # ]: 287 : ctx->xattrs = clone_xattrs;
6969 [ # # # # : 287 : ctx->original.id = blobid;
# # ]
6970 : :
6971 [ # # # # : 287 : spdk_bs_open_blob(bs, ctx->original.id, bs_clone_origblob_open_cpl, ctx);
# # ]
6972 : 66 : }
6973 : :
6974 : : /* END spdk_bs_create_clone */
6975 : :
6976 : : /* START spdk_bs_inflate_blob */
6977 : :
6978 : : static void
6979 : 61 : bs_inflate_blob_set_parent_cpl(void *cb_arg, struct spdk_blob *_parent, int bserrno)
6980 : : {
6981 : 61 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
6982 [ # # # # : 61 : struct spdk_blob *_blob = ctx->original.blob;
# # ]
6983 : :
6984 [ - + ]: 61 : if (bserrno != 0) {
6985 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6986 : 0 : return;
6987 : : }
6988 : :
6989 : : /* Temporarily override md_ro flag for MD modification */
6990 [ # # # # ]: 61 : _blob->md_ro = false;
6991 : :
6992 [ # # ]: 61 : bserrno = blob_set_xattr(_blob, BLOB_SNAPSHOT, &_parent->id, sizeof(spdk_blob_id), true);
6993 [ - + ]: 61 : if (bserrno != 0) {
6994 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
6995 : 0 : return;
6996 : : }
6997 : :
6998 [ + + # # ]: 61 : assert(_parent != NULL);
6999 : :
7000 : 61 : bs_blob_list_remove(_blob);
7001 [ # # # # : 61 : _blob->parent_id = _parent->id;
# # # # ]
7002 : :
7003 : 61 : blob_back_bs_destroy(_blob);
7004 [ # # # # ]: 61 : _blob->back_bs_dev = bs_create_blob_bs_dev(_parent);
7005 : 61 : bs_blob_list_add(_blob);
7006 : :
7007 : 61 : spdk_blob_sync_md(_blob, bs_clone_snapshot_origblob_cleanup, ctx);
7008 : 15 : }
7009 : :
7010 : : static void
7011 : 290 : bs_inflate_blob_done(struct spdk_clone_snapshot_ctx *ctx)
7012 : : {
7013 [ # # # # : 290 : struct spdk_blob *_blob = ctx->original.blob;
# # ]
7014 : : struct spdk_blob *_parent;
7015 : :
7016 [ + + + + : 290 : if (ctx->allocate_all) {
# # # # ]
7017 : : /* remove thin provisioning */
7018 : 168 : bs_blob_list_remove(_blob);
7019 [ + + # # : 168 : if (_blob->parent_id == SPDK_BLOBID_EXTERNAL_SNAPSHOT) {
# # ]
7020 : 40 : blob_remove_xattr(_blob, BLOB_EXTERNAL_SNAPSHOT_ID, true);
7021 [ # # # # : 40 : _blob->invalid_flags &= ~SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
7022 : 10 : } else {
7023 : 128 : blob_remove_xattr(_blob, BLOB_SNAPSHOT, true);
7024 : : }
7025 [ # # # # : 168 : _blob->invalid_flags = _blob->invalid_flags & ~SPDK_BLOB_THIN_PROV;
# # # # #
# ]
7026 : 168 : blob_back_bs_destroy(_blob);
7027 [ # # # # ]: 168 : _blob->parent_id = SPDK_BLOBID_INVALID;
7028 : 40 : } else {
7029 : : /* For now, esnap clones always have allocate_all set. */
7030 [ - + # # ]: 122 : assert(!blob_is_esnap_clone(_blob));
7031 : :
7032 [ # # # # : 122 : _parent = ((struct spdk_blob_bs_dev *)(_blob->back_bs_dev))->blob;
# # # # ]
7033 [ + + # # : 122 : if (_parent->parent_id != SPDK_BLOBID_INVALID) {
# # ]
7034 : : /* We must change the parent of the inflated blob */
7035 [ # # # # : 76 : spdk_bs_open_blob(_blob->bs, _parent->parent_id,
# # # # ]
7036 : 15 : bs_inflate_blob_set_parent_cpl, ctx);
7037 : 61 : return;
7038 : : }
7039 : :
7040 : 61 : bs_blob_list_remove(_blob);
7041 [ # # # # ]: 61 : _blob->parent_id = SPDK_BLOBID_INVALID;
7042 : 61 : blob_back_bs_destroy(_blob);
7043 [ # # # # ]: 61 : _blob->back_bs_dev = bs_create_zeroes_dev();
7044 : : }
7045 : :
7046 : : /* Temporarily override md_ro flag for MD modification */
7047 [ # # # # ]: 229 : _blob->md_ro = false;
7048 : 229 : blob_remove_xattr(_blob, BLOB_SNAPSHOT, true);
7049 [ # # # # ]: 229 : _blob->state = SPDK_BLOB_STATE_DIRTY;
7050 : :
7051 : 229 : spdk_blob_sync_md(_blob, bs_clone_snapshot_origblob_cleanup, ctx);
7052 : 70 : }
7053 : :
7054 : : /* Check if cluster needs allocation */
7055 : : static inline bool
7056 : 6104 : bs_cluster_needs_allocation(struct spdk_blob *blob, uint64_t cluster, bool allocate_all)
7057 : : {
7058 : : struct spdk_blob_bs_dev *b;
7059 : :
7060 [ + + # # ]: 6104 : assert(blob != NULL);
7061 : :
7062 [ + + # # : 6104 : if (blob->active.clusters[cluster] != 0) {
# # # # #
# # # ]
7063 : : /* Cluster is already allocated */
7064 : 170 : return false;
7065 : : }
7066 : :
7067 [ + + # # : 5934 : if (blob->parent_id == SPDK_BLOBID_INVALID) {
# # ]
7068 : : /* Blob have no parent blob */
7069 [ # # ]: 400 : return allocate_all;
7070 : : }
7071 : :
7072 [ + + # # : 5534 : if (blob->parent_id == SPDK_BLOBID_EXTERNAL_SNAPSHOT) {
# # ]
7073 : 320 : return true;
7074 : : }
7075 : :
7076 [ # # # # ]: 5214 : b = (struct spdk_blob_bs_dev *)blob->back_bs_dev;
7077 [ + + + + : 5214 : return (allocate_all || b->blob->active.clusters[cluster] != 0);
# # # # #
# # # # #
# # # # ]
7078 : 1500 : }
7079 : :
7080 : : static void
7081 : 2593 : bs_inflate_blob_touch_next(void *cb_arg, int bserrno)
7082 : : {
7083 : 2593 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
7084 [ # # # # : 2593 : struct spdk_blob *_blob = ctx->original.blob;
# # ]
7085 : 1958 : struct spdk_bs_cpl cpl;
7086 : : spdk_bs_user_op_t *op;
7087 : : uint64_t offset;
7088 : :
7089 [ - + ]: 2593 : if (bserrno != 0) {
7090 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, bserrno);
7091 : 0 : return;
7092 : : }
7093 : :
7094 [ + + # # : 3342 : for (; ctx->cluster < _blob->active.num_clusters; ctx->cluster++) {
# # # # #
# # # #
# ]
7095 [ + + + + : 3052 : if (bs_cluster_needs_allocation(_blob, ctx->cluster, ctx->allocate_all)) {
# # # # #
# # # ]
7096 : 2303 : break;
7097 : : }
7098 : 185 : }
7099 : :
7100 [ + + # # : 2593 : if (ctx->cluster < _blob->active.num_clusters) {
# # # # #
# # # ]
7101 [ # # # # : 2303 : offset = bs_cluster_to_lba(_blob->bs, ctx->cluster);
# # # # ]
7102 : :
7103 : : /* We may safely increment a cluster before copying */
7104 [ # # ]: 2303 : ctx->cluster++;
7105 : :
7106 : : /* Use a dummy 0B read as a context for cluster copy */
7107 : 2303 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
7108 [ # # # # : 2303 : cpl.u.blob_basic.cb_fn = bs_inflate_blob_touch_next;
# # ]
7109 [ # # # # : 2303 : cpl.u.blob_basic.cb_arg = ctx;
# # ]
7110 : :
7111 [ # # # # ]: 2868 : op = bs_user_op_alloc(ctx->channel, &cpl, SPDK_BLOB_READ, _blob,
7112 : 565 : NULL, 0, offset, 0);
7113 [ - + ]: 2303 : if (!op) {
7114 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, -ENOMEM);
7115 : 0 : return;
7116 : : }
7117 : :
7118 [ # # # # ]: 2303 : bs_allocate_and_copy_cluster(_blob, ctx->channel, offset, op);
7119 : 565 : } else {
7120 : 290 : bs_inflate_blob_done(ctx);
7121 : : }
7122 : 635 : }
7123 : :
7124 : : static void
7125 : 311 : bs_inflate_blob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
7126 : : {
7127 : 311 : struct spdk_clone_snapshot_ctx *ctx = (struct spdk_clone_snapshot_ctx *)cb_arg;
7128 : : uint64_t clusters_needed;
7129 : : uint64_t i;
7130 : :
7131 [ - + ]: 311 : if (bserrno != 0) {
7132 : 0 : bs_clone_snapshot_cleanup_finish(ctx, bserrno);
7133 : 0 : return;
7134 : : }
7135 : :
7136 [ # # # # : 311 : ctx->original.blob = _blob;
# # ]
7137 [ - + # # : 311 : ctx->original.md_ro = _blob->md_ro;
# # # # #
# # # ]
7138 : :
7139 [ - + - + : 311 : if (_blob->locked_operation_in_progress) {
# # # # ]
7140 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Cannot inflate blob - another operation in progress\n");
# # ]
7141 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
7142 : 0 : spdk_blob_close(_blob, bs_clone_snapshot_cleanup_finish, ctx);
7143 : 0 : return;
7144 : : }
7145 : :
7146 [ # # # # ]: 311 : _blob->locked_operation_in_progress = true;
7147 : :
7148 [ + + + # : 311 : switch (_blob->parent_id) {
# # # ]
7149 : 31 : case SPDK_BLOBID_INVALID:
7150 [ + + + + : 41 : if (!ctx->allocate_all) {
# # # # ]
7151 : : /* This blob has no parent, so we cannot decouple it. */
7152 : 21 : SPDK_ERRLOG("Cannot decouple parent of blob with no parent.\n");
7153 : 21 : bs_clone_snapshot_origblob_cleanup(ctx, -EINVAL);
7154 : 21 : return;
7155 : : }
7156 : 20 : break;
7157 : 30 : case SPDK_BLOBID_EXTERNAL_SNAPSHOT:
7158 : : /*
7159 : : * It would be better to rely on back_bs_dev->is_zeroes(), to determine which
7160 : : * clusters require allocation. Until there is a blobstore consumer that
7161 : : * uses esnaps with an spdk_bs_dev that implements a useful is_zeroes() it is not
7162 : : * worth the effort.
7163 : : */
7164 [ # # # # ]: 40 : ctx->allocate_all = true;
7165 : 40 : break;
7166 : 175 : default:
7167 : 230 : break;
7168 : : }
7169 : :
7170 [ + + ]: 290 : if (spdk_blob_is_thin_provisioned(_blob) == false) {
7171 : : /* This is not thin provisioned blob. No need to inflate. */
7172 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, 0);
7173 : 0 : return;
7174 : : }
7175 : :
7176 : : /* Do two passes - one to verify that we can obtain enough clusters
7177 : : * and another to actually claim them.
7178 : : */
7179 : 290 : clusters_needed = 0;
7180 [ + + # # : 3342 : for (i = 0; i < _blob->active.num_clusters; i++) {
# # # # ]
7181 [ + + + + : 3052 : if (bs_cluster_needs_allocation(_blob, i, ctx->allocate_all)) {
# # # # ]
7182 : 2303 : clusters_needed++;
7183 : 565 : }
7184 : 750 : }
7185 : :
7186 [ - + # # : 290 : if (clusters_needed > _blob->bs->num_free_clusters) {
# # # # #
# ]
7187 : : /* Not enough free clusters. Cannot satisfy the request. */
7188 : 0 : bs_clone_snapshot_origblob_cleanup(ctx, -ENOSPC);
7189 : 0 : return;
7190 : : }
7191 : :
7192 [ # # # # ]: 290 : ctx->cluster = 0;
7193 : 290 : bs_inflate_blob_touch_next(ctx, 0);
7194 : 75 : }
7195 : :
7196 : : static void
7197 : 311 : bs_inflate_blob(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
7198 : : spdk_blob_id blobid, bool allocate_all, spdk_blob_op_complete cb_fn, void *cb_arg)
7199 : : {
7200 : 311 : struct spdk_clone_snapshot_ctx *ctx = calloc(1, sizeof(*ctx));
7201 : :
7202 [ - + ]: 311 : if (!ctx) {
7203 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
7204 : 0 : return;
7205 : : }
7206 [ # # # # : 311 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
# # ]
7207 [ # # # # : 311 : ctx->cpl.u.bs_basic.cb_fn = cb_fn;
# # # # #
# ]
7208 [ # # # # : 311 : ctx->cpl.u.bs_basic.cb_arg = cb_arg;
# # # # #
# ]
7209 [ # # # # ]: 311 : ctx->bserrno = 0;
7210 [ # # # # : 311 : ctx->original.id = blobid;
# # ]
7211 [ # # # # ]: 311 : ctx->channel = channel;
7212 [ # # # # : 311 : ctx->allocate_all = allocate_all;
# # ]
7213 : :
7214 [ # # # # : 311 : spdk_bs_open_blob(bs, ctx->original.id, bs_inflate_blob_open_cpl, ctx);
# # ]
7215 : 75 : }
7216 : :
7217 : : void
7218 : 148 : spdk_bs_inflate_blob(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
7219 : : spdk_blob_id blobid, spdk_blob_op_complete cb_fn, void *cb_arg)
7220 : : {
7221 : 148 : bs_inflate_blob(bs, channel, blobid, true, cb_fn, cb_arg);
7222 : 148 : }
7223 : :
7224 : : void
7225 : 163 : spdk_bs_blob_decouple_parent(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
7226 : : spdk_blob_id blobid, spdk_blob_op_complete cb_fn, void *cb_arg)
7227 : : {
7228 : 163 : bs_inflate_blob(bs, channel, blobid, false, cb_fn, cb_arg);
7229 : 163 : }
7230 : : /* END spdk_bs_inflate_blob */
7231 : :
7232 : : /* START spdk_bs_blob_shallow_copy */
7233 : :
7234 : : struct shallow_copy_ctx {
7235 : : struct spdk_bs_cpl cpl;
7236 : : int bserrno;
7237 : :
7238 : : /* Blob source for copy */
7239 : : struct spdk_blob_store *bs;
7240 : : spdk_blob_id blobid;
7241 : : struct spdk_blob *blob;
7242 : : struct spdk_io_channel *blob_channel;
7243 : :
7244 : : /* Destination device for copy */
7245 : : struct spdk_bs_dev *ext_dev;
7246 : : struct spdk_io_channel *ext_channel;
7247 : :
7248 : : /* Current cluster for copy operation */
7249 : : uint64_t cluster;
7250 : :
7251 : : /* Buffer for blob reading */
7252 : : uint8_t *read_buff;
7253 : :
7254 : : /* Struct for external device writing */
7255 : : struct spdk_bs_dev_cb_args ext_args;
7256 : :
7257 : : /* Actual number of copied clusters */
7258 : : uint64_t copied_clusters_count;
7259 : :
7260 : : /* Status callback for updates about the ongoing operation */
7261 : : spdk_blob_shallow_copy_status status_cb;
7262 : :
7263 : : /* Argument passed to function status_cb */
7264 : : void *status_cb_arg;
7265 : : };
7266 : :
7267 : : static void
7268 : 81 : bs_shallow_copy_cleanup_finish(void *cb_arg, int bserrno)
7269 : : {
7270 : 81 : struct shallow_copy_ctx *ctx = cb_arg;
7271 [ # # ]: 81 : struct spdk_bs_cpl *cpl = &ctx->cpl;
7272 : :
7273 [ - + ]: 81 : if (bserrno != 0) {
7274 [ # # # # : 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, cleanup error %d\n", ctx->blob->id, bserrno);
# # # # ]
7275 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7276 : 0 : }
7277 : :
7278 [ # # # # : 81 : ctx->ext_dev->destroy_channel(ctx->ext_dev, ctx->ext_channel);
# # # # #
# # # # #
# # # # #
# ]
7279 [ # # # # ]: 81 : spdk_free(ctx->read_buff);
7280 : :
7281 [ # # # # : 81 : cpl->u.blob_basic.cb_fn(cpl->u.blob_basic.cb_arg, ctx->bserrno);
# # # # #
# # # # #
# # # # #
# # # #
# ]
7282 : :
7283 : 81 : free(ctx);
7284 : 81 : }
7285 : :
7286 : : static void
7287 : 42 : bs_shallow_copy_bdev_write_cpl(struct spdk_io_channel *channel, void *cb_arg, int bserrno)
7288 : : {
7289 : 42 : struct shallow_copy_ctx *ctx = cb_arg;
7290 [ # # # # ]: 42 : struct spdk_blob *_blob = ctx->blob;
7291 : :
7292 [ - + ]: 42 : if (bserrno != 0) {
7293 [ # # # # : 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, ext dev write error %d\n", ctx->blob->id, bserrno);
# # # # ]
7294 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7295 [ # # # # ]: 0 : _blob->locked_operation_in_progress = false;
7296 : 0 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7297 : 0 : return;
7298 : : }
7299 : :
7300 [ # # ]: 42 : ctx->cluster++;
7301 [ + - # # : 42 : if (ctx->status_cb) {
# # ]
7302 [ # # ]: 42 : ctx->copied_clusters_count++;
7303 [ # # # # : 42 : ctx->status_cb(ctx->copied_clusters_count, ctx->status_cb_arg);
# # # # #
# # # # #
# # ]
7304 : 10 : }
7305 : :
7306 : 42 : bs_shallow_copy_cluster_find_next(ctx);
7307 : 10 : }
7308 : :
7309 : : static void
7310 : 42 : bs_shallow_copy_blob_read_cpl(void *cb_arg, int bserrno)
7311 : : {
7312 : 42 : struct shallow_copy_ctx *ctx = cb_arg;
7313 [ # # # # ]: 42 : struct spdk_bs_dev *ext_dev = ctx->ext_dev;
7314 [ # # # # ]: 42 : struct spdk_blob *_blob = ctx->blob;
7315 : :
7316 [ - + ]: 42 : if (bserrno != 0) {
7317 [ # # # # : 0 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, blob read error %d\n", ctx->blob->id, bserrno);
# # # # ]
7318 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7319 [ # # # # ]: 0 : _blob->locked_operation_in_progress = false;
7320 : 0 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7321 : 0 : return;
7322 : : }
7323 : :
7324 [ # # # # : 42 : ctx->ext_args.channel = ctx->ext_channel;
# # # # #
# ]
7325 [ # # # # : 42 : ctx->ext_args.cb_fn = bs_shallow_copy_bdev_write_cpl;
# # ]
7326 [ # # # # : 42 : ctx->ext_args.cb_arg = ctx;
# # ]
7327 : :
7328 [ # # # # : 84 : ext_dev->write(ext_dev, ctx->ext_channel, ctx->read_buff,
# # # # #
# # # # #
# # ]
7329 [ # # # # : 42 : bs_cluster_to_lba(_blob->bs, ctx->cluster),
# # # # ]
7330 [ # # # # : 42 : bs_dev_byte_to_lba(_blob->bs->dev, _blob->bs->cluster_sz),
# # # # #
# # # # #
# # ]
7331 [ # # ]: 10 : &ctx->ext_args);
7332 : 10 : }
7333 : :
7334 : : static void
7335 : 63 : bs_shallow_copy_cluster_find_next(void *cb_arg)
7336 : : {
7337 : 63 : struct shallow_copy_ctx *ctx = cb_arg;
7338 [ # # # # ]: 63 : struct spdk_blob *_blob = ctx->blob;
7339 : :
7340 [ + + # # : 105 : while (ctx->cluster < _blob->active.num_clusters) {
# # # # #
# # # ]
7341 [ + + # # : 84 : if (_blob->active.clusters[ctx->cluster] != 0) {
# # # # #
# # # # #
# # ]
7342 : 42 : break;
7343 : : }
7344 : :
7345 [ # # ]: 42 : ctx->cluster++;
7346 : : }
7347 : :
7348 [ + + # # : 63 : if (ctx->cluster < _blob->active.num_clusters) {
# # # # #
# # # ]
7349 [ # # # # : 84 : blob_request_submit_op_single(ctx->blob_channel, _blob, ctx->read_buff,
# # # # ]
7350 [ # # # # : 42 : bs_cluster_to_lba(_blob->bs, ctx->cluster),
# # # # ]
7351 [ # # # # : 42 : bs_dev_byte_to_lba(_blob->bs->dev, _blob->bs->cluster_sz),
# # # # #
# # # # #
# # ]
7352 : 10 : bs_shallow_copy_blob_read_cpl, ctx, SPDK_BLOB_READ);
7353 : 10 : } else {
7354 [ # # # # ]: 21 : _blob->locked_operation_in_progress = false;
7355 : 21 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7356 : : }
7357 : 63 : }
7358 : :
7359 : : static void
7360 : 81 : bs_shallow_copy_blob_open_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
7361 : : {
7362 : 81 : struct shallow_copy_ctx *ctx = cb_arg;
7363 [ # # # # ]: 81 : struct spdk_bs_dev *ext_dev = ctx->ext_dev;
7364 : : uint32_t blob_block_size;
7365 : : uint64_t blob_total_size;
7366 : :
7367 [ - + ]: 81 : if (bserrno != 0) {
7368 : 0 : SPDK_ERRLOG("Shallow copy blob open error %d\n", bserrno);
7369 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7370 : 0 : bs_shallow_copy_cleanup_finish(ctx, 0);
7371 : 0 : return;
7372 : : }
7373 : :
7374 [ + + ]: 81 : if (!spdk_blob_is_read_only(_blob)) {
7375 [ # # # # ]: 20 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, blob must be read only\n", _blob->id);
7376 [ # # # # ]: 20 : ctx->bserrno = -EPERM;
7377 : 20 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7378 : 20 : return;
7379 : : }
7380 : :
7381 [ # # # # : 61 : blob_block_size = _blob->bs->dev->blocklen;
# # # # #
# # # ]
7382 [ # # # # ]: 61 : blob_total_size = spdk_blob_get_num_clusters(_blob) * spdk_bs_get_cluster_size(_blob->bs);
7383 : :
7384 [ + + # # : 61 : if (blob_total_size > ext_dev->blockcnt * ext_dev->blocklen) {
# # # # #
# ]
7385 [ # # # # ]: 20 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, external device must have at least blob size\n",
7386 : : _blob->id);
7387 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7388 : 20 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7389 : 20 : return;
7390 : : }
7391 : :
7392 [ + + + + : 41 : if (blob_block_size % ext_dev->blocklen != 0) {
# # # # ]
7393 [ # # # # ]: 20 : SPDK_ERRLOG("blob 0x%" PRIx64 " shallow copy, external device block size is not compatible with \
7394 : : blobstore block size\n", _blob->id);
7395 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7396 : 20 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7397 : 20 : return;
7398 : : }
7399 : :
7400 [ # # # # ]: 21 : ctx->blob = _blob;
7401 : :
7402 [ - + - + : 21 : if (_blob->locked_operation_in_progress) {
# # # # ]
7403 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "blob 0x%" PRIx64 " shallow copy - another operation in progress\n", _blob->id);
# # # # #
# ]
7404 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
7405 : 0 : spdk_blob_close(_blob, bs_shallow_copy_cleanup_finish, ctx);
7406 : 0 : return;
7407 : : }
7408 : :
7409 [ # # # # ]: 21 : _blob->locked_operation_in_progress = true;
7410 : :
7411 [ # # # # ]: 21 : ctx->cluster = 0;
7412 : 21 : bs_shallow_copy_cluster_find_next(ctx);
7413 : 20 : }
7414 : :
7415 : : int
7416 : 81 : spdk_bs_blob_shallow_copy(struct spdk_blob_store *bs, struct spdk_io_channel *channel,
7417 : : spdk_blob_id blobid, struct spdk_bs_dev *ext_dev,
7418 : : spdk_blob_shallow_copy_status status_cb_fn, void *status_cb_arg,
7419 : : spdk_blob_op_complete cb_fn, void *cb_arg)
7420 : : {
7421 : : struct shallow_copy_ctx *ctx;
7422 : : struct spdk_io_channel *ext_channel;
7423 : :
7424 : 81 : ctx = calloc(1, sizeof(*ctx));
7425 [ + + ]: 81 : if (!ctx) {
7426 : 0 : return -ENOMEM;
7427 : : }
7428 : :
7429 [ # # # # ]: 81 : ctx->bs = bs;
7430 [ # # # # ]: 81 : ctx->blobid = blobid;
7431 [ # # # # : 81 : ctx->cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
# # ]
7432 [ # # # # : 81 : ctx->cpl.u.bs_basic.cb_fn = cb_fn;
# # # # #
# ]
7433 [ # # # # : 81 : ctx->cpl.u.bs_basic.cb_arg = cb_arg;
# # # # #
# ]
7434 [ # # # # ]: 81 : ctx->bserrno = 0;
7435 [ # # # # ]: 81 : ctx->blob_channel = channel;
7436 [ # # # # ]: 81 : ctx->status_cb = status_cb_fn;
7437 [ # # # # ]: 81 : ctx->status_cb_arg = status_cb_arg;
7438 [ # # # # : 81 : ctx->read_buff = spdk_malloc(bs->cluster_sz, bs->dev->blocklen, NULL,
# # # # #
# # # # #
# # ]
7439 : : SPDK_ENV_LCORE_ID_ANY, SPDK_MALLOC_DMA);
7440 [ + + # # : 81 : if (!ctx->read_buff) {
# # ]
7441 : 0 : free(ctx);
7442 : 0 : return -ENOMEM;
7443 : : }
7444 : :
7445 [ # # # # : 81 : ext_channel = ext_dev->create_channel(ext_dev);
# # # # ]
7446 [ - + ]: 81 : if (!ext_channel) {
7447 [ # # # # ]: 0 : spdk_free(ctx->read_buff);
7448 : 0 : free(ctx);
7449 : 0 : return -ENOMEM;
7450 : : }
7451 [ # # # # ]: 81 : ctx->ext_dev = ext_dev;
7452 [ # # # # ]: 81 : ctx->ext_channel = ext_channel;
7453 : :
7454 [ # # # # : 81 : spdk_bs_open_blob(ctx->bs, ctx->blobid, bs_shallow_copy_blob_open_cpl, ctx);
# # # # ]
7455 : :
7456 : 81 : return 0;
7457 : 20 : }
7458 : : /* END spdk_bs_blob_shallow_copy */
7459 : :
7460 : : /* START spdk_bs_blob_set_parent */
7461 : :
7462 : : struct set_parent_ctx {
7463 : : struct spdk_blob_store *bs;
7464 : : int bserrno;
7465 : : spdk_bs_op_complete cb_fn;
7466 : : void *cb_arg;
7467 : :
7468 : : struct spdk_blob *blob;
7469 : : bool blob_md_ro;
7470 : :
7471 : : struct blob_parent parent;
7472 : : };
7473 : :
7474 : : static void
7475 : 124 : bs_set_parent_cleanup_finish(void *cb_arg, int bserrno)
7476 : : {
7477 : 124 : struct set_parent_ctx *ctx = cb_arg;
7478 : :
7479 [ + + # # ]: 124 : assert(ctx != NULL);
7480 : :
7481 [ + + ]: 124 : if (bserrno != 0) {
7482 : 0 : SPDK_ERRLOG("blob set parent finish error %d\n", bserrno);
7483 [ # # # # : 0 : if (ctx->bserrno == 0) {
# # ]
7484 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7485 : 0 : }
7486 : 0 : }
7487 : :
7488 [ # # # # : 124 : ctx->cb_fn(ctx->cb_arg, ctx->bserrno);
# # # # #
# # # # #
# # ]
7489 : :
7490 : 124 : free(ctx);
7491 : 124 : }
7492 : :
7493 : : static void
7494 : 103 : bs_set_parent_close_snapshot(void *cb_arg, int bserrno)
7495 : : {
7496 : 103 : struct set_parent_ctx *ctx = cb_arg;
7497 : :
7498 [ + + # # : 103 : if (ctx->bserrno != 0) {
# # ]
7499 [ # # # # : 40 : spdk_blob_close(ctx->parent.u.snapshot.blob, bs_set_parent_cleanup_finish, ctx);
# # # # #
# ]
7500 : 40 : return;
7501 : : }
7502 : :
7503 [ - + ]: 63 : if (bserrno != 0) {
7504 : 0 : SPDK_ERRLOG("blob close error %d\n", bserrno);
7505 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7506 : 0 : }
7507 : :
7508 [ # # # # ]: 63 : bs_set_parent_cleanup_finish(ctx, ctx->bserrno);
7509 : 25 : }
7510 : :
7511 : : static void
7512 : 63 : bs_set_parent_close_blob(void *cb_arg, int bserrno)
7513 : : {
7514 : 63 : struct set_parent_ctx *ctx = cb_arg;
7515 [ # # # # ]: 63 : struct spdk_blob *blob = ctx->blob;
7516 [ # # # # : 63 : struct spdk_blob *snapshot = ctx->parent.u.snapshot.blob;
# # # # #
# ]
7517 : :
7518 [ - + - - : 63 : if (bserrno != 0 && ctx->bserrno == 0) {
# # # # ]
7519 : 0 : SPDK_ERRLOG("error %d in metadata sync\n", bserrno);
7520 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7521 : 0 : }
7522 : :
7523 : : /* Revert md_ro to original state */
7524 [ - + # # : 63 : blob->md_ro = ctx->blob_md_ro;
# # # # #
# ]
7525 : :
7526 [ # # # # ]: 63 : blob->locked_operation_in_progress = false;
7527 [ # # # # ]: 63 : snapshot->locked_operation_in_progress = false;
7528 : :
7529 : 63 : spdk_blob_close(blob, bs_set_parent_close_snapshot, ctx);
7530 : 63 : }
7531 : :
7532 : : static void
7533 : 63 : bs_set_parent_set_back_bs_dev_done(void *cb_arg, int bserrno)
7534 : : {
7535 : 63 : struct set_parent_ctx *ctx = cb_arg;
7536 [ # # # # ]: 63 : struct spdk_blob *blob = ctx->blob;
7537 : :
7538 [ - + ]: 63 : if (bserrno != 0) {
7539 : 0 : SPDK_ERRLOG("error %d setting back_bs_dev\n", bserrno);
7540 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7541 : 0 : bs_set_parent_close_blob(ctx, bserrno);
7542 : 0 : return;
7543 : : }
7544 : :
7545 : 63 : spdk_blob_sync_md(blob, bs_set_parent_close_blob, ctx);
7546 : 15 : }
7547 : :
7548 : : static int
7549 : 63 : bs_set_parent_refs(struct spdk_blob *blob, struct blob_parent *parent)
7550 : : {
7551 : : int rc;
7552 : :
7553 : 63 : bs_blob_list_remove(blob);
7554 : :
7555 [ # # # # : 63 : rc = blob_set_xattr(blob, BLOB_SNAPSHOT, &parent->u.snapshot.id, sizeof(spdk_blob_id), true);
# # ]
7556 [ - + ]: 63 : if (rc != 0) {
7557 : 0 : SPDK_ERRLOG("error %d setting snapshot xattr\n", rc);
7558 : 0 : return rc;
7559 : : }
7560 [ # # # # : 63 : blob->parent_id = parent->u.snapshot.id;
# # # # #
# # # ]
7561 : :
7562 [ + + ]: 63 : if (blob_is_esnap_clone(blob)) {
7563 : : /* Remove the xattr that references the external snapshot */
7564 [ # # # # : 21 : blob->invalid_flags &= ~SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
7565 : 21 : blob_remove_xattr(blob, BLOB_EXTERNAL_SNAPSHOT_ID, true);
7566 : 5 : }
7567 : :
7568 : 63 : bs_blob_list_add(blob);
7569 : :
7570 : 63 : return 0;
7571 : 15 : }
7572 : :
7573 : : static void
7574 : 104 : bs_set_parent_snapshot_open_cpl(void *cb_arg, struct spdk_blob *snapshot, int bserrno)
7575 : : {
7576 : 104 : struct set_parent_ctx *ctx = cb_arg;
7577 [ # # # # ]: 104 : struct spdk_blob *blob = ctx->blob;
7578 : : struct spdk_bs_dev *back_bs_dev;
7579 : :
7580 [ + + ]: 104 : if (bserrno != 0) {
7581 : 1 : SPDK_ERRLOG("snapshot open error %d\n", bserrno);
7582 [ # # # # ]: 1 : ctx->bserrno = bserrno;
7583 : 1 : spdk_blob_close(blob, bs_set_parent_cleanup_finish, ctx);
7584 : 1 : return;
7585 : : }
7586 : :
7587 [ # # # # : 103 : ctx->parent.u.snapshot.blob = snapshot;
# # # # #
# ]
7588 [ # # # # : 103 : ctx->parent.u.snapshot.id = snapshot->id;
# # # # #
# # # #
# ]
7589 : :
7590 [ + + ]: 103 : if (!spdk_blob_is_snapshot(snapshot)) {
7591 : 20 : SPDK_ERRLOG("parent blob is not a snapshot\n");
7592 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7593 : 20 : spdk_blob_close(blob, bs_set_parent_close_snapshot, ctx);
7594 : 20 : return;
7595 : : }
7596 : :
7597 [ + + # # : 83 : if (blob->active.num_clusters != snapshot->active.num_clusters) {
# # # # #
# # # #
# ]
7598 : 20 : SPDK_ERRLOG("parent blob has a number of clusters different from child's ones\n");
7599 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7600 : 20 : spdk_blob_close(blob, bs_set_parent_close_snapshot, ctx);
7601 : 20 : return;
7602 : : }
7603 : :
7604 [ + + + - : 63 : if (blob->locked_operation_in_progress || snapshot->locked_operation_in_progress) {
- + - + #
# # # # #
# # ]
7605 : 0 : SPDK_ERRLOG("cannot set parent of blob, another operation in progress\n");
7606 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
7607 : 0 : spdk_blob_close(blob, bs_set_parent_close_snapshot, ctx);
7608 : 0 : return;
7609 : : }
7610 : :
7611 [ # # # # ]: 63 : blob->locked_operation_in_progress = true;
7612 [ # # # # ]: 63 : snapshot->locked_operation_in_progress = true;
7613 : :
7614 : : /* Temporarily override md_ro flag for MD modification */
7615 [ # # # # ]: 63 : blob->md_ro = false;
7616 : :
7617 : 63 : back_bs_dev = bs_create_blob_bs_dev(snapshot);
7618 : :
7619 [ # # ]: 78 : blob_set_back_bs_dev(blob, back_bs_dev, bs_set_parent_refs, &ctx->parent,
7620 : : bs_set_parent_set_back_bs_dev_done,
7621 : 15 : ctx);
7622 : 25 : }
7623 : :
7624 : : static void
7625 : 124 : bs_set_parent_blob_open_cpl(void *cb_arg, struct spdk_blob *blob, int bserrno)
7626 : : {
7627 : 124 : struct set_parent_ctx *ctx = cb_arg;
7628 : :
7629 [ - + ]: 124 : if (bserrno != 0) {
7630 : 0 : SPDK_ERRLOG("blob open error %d\n", bserrno);
7631 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7632 : 0 : bs_set_parent_cleanup_finish(ctx, 0);
7633 : 0 : return;
7634 : : }
7635 : :
7636 [ + + ]: 124 : if (!spdk_blob_is_thin_provisioned(blob)) {
7637 : 20 : SPDK_ERRLOG("blob is not thin-provisioned\n");
7638 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7639 : 20 : spdk_blob_close(blob, bs_set_parent_cleanup_finish, ctx);
7640 : 20 : return;
7641 : : }
7642 : :
7643 [ # # # # ]: 104 : ctx->blob = blob;
7644 [ - + # # : 104 : ctx->blob_md_ro = blob->md_ro;
# # # # #
# ]
7645 : :
7646 [ # # # # : 104 : spdk_bs_open_blob(ctx->bs, ctx->parent.u.snapshot.id, bs_set_parent_snapshot_open_cpl, ctx);
# # # # #
# # # #
# ]
7647 : 30 : }
7648 : :
7649 : : void
7650 : 187 : spdk_bs_blob_set_parent(struct spdk_blob_store *bs, spdk_blob_id blob_id,
7651 : : spdk_blob_id snapshot_id, spdk_blob_op_complete cb_fn, void *cb_arg)
7652 : : {
7653 : : struct set_parent_ctx *ctx;
7654 : :
7655 [ + + ]: 187 : if (snapshot_id == SPDK_BLOBID_INVALID) {
7656 : 20 : SPDK_ERRLOG("snapshot id not valid\n");
7657 [ # # # # ]: 20 : cb_fn(cb_arg, -EINVAL);
7658 : 20 : return;
7659 : : }
7660 : :
7661 [ + + ]: 167 : if (blob_id == snapshot_id) {
7662 : 20 : SPDK_ERRLOG("blob id and snapshot id cannot be the same\n");
7663 [ # # # # ]: 20 : cb_fn(cb_arg, -EINVAL);
7664 : 20 : return;
7665 : : }
7666 : :
7667 [ + + ]: 147 : if (spdk_blob_get_parent_snapshot(bs, blob_id) == snapshot_id) {
7668 : 23 : SPDK_NOTICELOG("snapshot is already the parent of blob\n");
7669 [ # # # # ]: 23 : cb_fn(cb_arg, -EEXIST);
7670 : 23 : return;
7671 : : }
7672 : :
7673 : 124 : ctx = calloc(1, sizeof(*ctx));
7674 [ - + ]: 124 : if (!ctx) {
7675 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
7676 : 0 : return;
7677 : : }
7678 : :
7679 [ # # # # ]: 124 : ctx->bs = bs;
7680 [ # # # # : 124 : ctx->parent.u.snapshot.id = snapshot_id;
# # # # #
# ]
7681 [ # # # # ]: 124 : ctx->cb_fn = cb_fn;
7682 [ # # # # ]: 124 : ctx->cb_arg = cb_arg;
7683 [ # # # # ]: 124 : ctx->bserrno = 0;
7684 : :
7685 : 124 : spdk_bs_open_blob(bs, blob_id, bs_set_parent_blob_open_cpl, ctx);
7686 : 45 : }
7687 : : /* END spdk_bs_blob_set_parent */
7688 : :
7689 : : /* START spdk_bs_blob_set_external_parent */
7690 : :
7691 : : static void
7692 : 86 : bs_set_external_parent_cleanup_finish(void *cb_arg, int bserrno)
7693 : : {
7694 : 86 : struct set_parent_ctx *ctx = cb_arg;
7695 : :
7696 [ + + ]: 86 : if (bserrno != 0) {
7697 : 0 : SPDK_ERRLOG("blob set external parent finish error %d\n", bserrno);
7698 [ # # # # : 0 : if (ctx->bserrno == 0) {
# # ]
7699 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7700 : 0 : }
7701 : 0 : }
7702 : :
7703 [ # # # # : 86 : ctx->cb_fn(ctx->cb_arg, ctx->bserrno);
# # # # #
# # # # #
# # ]
7704 : :
7705 [ # # # # : 86 : free(ctx->parent.u.esnap.id);
# # # # #
# ]
7706 : 86 : free(ctx);
7707 : 86 : }
7708 : :
7709 : : static void
7710 : 43 : bs_set_external_parent_close_blob(void *cb_arg, int bserrno)
7711 : : {
7712 : 43 : struct set_parent_ctx *ctx = cb_arg;
7713 [ # # # # ]: 43 : struct spdk_blob *blob = ctx->blob;
7714 : :
7715 [ - + - - : 43 : if (bserrno != 0 && ctx->bserrno == 0) {
# # # # ]
7716 : 0 : SPDK_ERRLOG("error %d in metadata sync\n", bserrno);
7717 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7718 : 0 : }
7719 : :
7720 : : /* Revert md_ro to original state */
7721 [ - + # # : 43 : blob->md_ro = ctx->blob_md_ro;
# # # # #
# ]
7722 : :
7723 [ # # # # ]: 43 : blob->locked_operation_in_progress = false;
7724 : :
7725 : 43 : spdk_blob_close(blob, bs_set_external_parent_cleanup_finish, ctx);
7726 : 43 : }
7727 : :
7728 : : static void
7729 : 43 : bs_set_external_parent_unfrozen(void *cb_arg, int bserrno)
7730 : : {
7731 : 43 : struct set_parent_ctx *ctx = cb_arg;
7732 [ # # # # ]: 43 : struct spdk_blob *blob = ctx->blob;
7733 : :
7734 [ - + ]: 43 : if (bserrno != 0) {
7735 : 0 : SPDK_ERRLOG("error %d setting back_bs_dev\n", bserrno);
7736 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7737 : 0 : bs_set_external_parent_close_blob(ctx, bserrno);
7738 : 0 : return;
7739 : : }
7740 : :
7741 : 43 : spdk_blob_sync_md(blob, bs_set_external_parent_close_blob, ctx);
7742 : 10 : }
7743 : :
7744 : : static int
7745 : 43 : bs_set_external_parent_refs(struct spdk_blob *blob, struct blob_parent *parent)
7746 : : {
7747 : : int rc;
7748 : :
7749 : 43 : bs_blob_list_remove(blob);
7750 : :
7751 [ + + ]: 43 : if (spdk_blob_is_clone(blob)) {
7752 : : /* Remove the xattr that references the snapshot */
7753 [ # # # # ]: 0 : blob->parent_id = SPDK_BLOBID_INVALID;
7754 : 0 : blob_remove_xattr(blob, BLOB_SNAPSHOT, true);
7755 : 0 : }
7756 : :
7757 [ # # # # : 53 : rc = blob_set_xattr(blob, BLOB_EXTERNAL_SNAPSHOT_ID, parent->u.esnap.id,
# # # # ]
7758 [ # # # # : 43 : parent->u.esnap.id_len, true);
# # # # ]
7759 [ + + ]: 43 : if (rc != 0) {
7760 : 0 : SPDK_ERRLOG("error %d setting external snapshot xattr\n", rc);
7761 : 0 : return rc;
7762 : : }
7763 [ # # # # : 43 : blob->invalid_flags |= SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # ]
7764 [ # # # # ]: 43 : blob->parent_id = SPDK_BLOBID_EXTERNAL_SNAPSHOT;
7765 : :
7766 : 43 : bs_blob_list_add(blob);
7767 : :
7768 : 43 : return 0;
7769 : 10 : }
7770 : :
7771 : : static void
7772 : 86 : bs_set_external_parent_blob_open_cpl(void *cb_arg, struct spdk_blob *blob, int bserrno)
7773 : : {
7774 : 86 : struct set_parent_ctx *ctx = cb_arg;
7775 : 66 : const void *esnap_id;
7776 : 66 : size_t esnap_id_len;
7777 : : int rc;
7778 : :
7779 [ - + ]: 86 : if (bserrno != 0) {
7780 : 0 : SPDK_ERRLOG("blob open error %d\n", bserrno);
7781 [ # # # # ]: 0 : ctx->bserrno = bserrno;
7782 : 0 : bs_set_parent_cleanup_finish(ctx, 0);
7783 : 0 : return;
7784 : : }
7785 : :
7786 [ # # # # ]: 86 : ctx->blob = blob;
7787 [ - + # # : 86 : ctx->blob_md_ro = blob->md_ro;
# # # # #
# ]
7788 : :
7789 : 86 : rc = spdk_blob_get_esnap_id(blob, &esnap_id, &esnap_id_len);
7790 [ + + + - : 86 : if (rc == 0 && esnap_id != NULL && esnap_id_len == ctx->parent.u.esnap.id_len &&
+ - + - #
# # # # #
# # # # ]
7791 [ - + - + : 24 : memcmp(esnap_id, ctx->parent.u.esnap.id, esnap_id_len) == 0) {
+ + # # #
# # # #
# ]
7792 : 23 : SPDK_ERRLOG("external snapshot is already the parent of blob\n");
7793 [ # # # # ]: 23 : ctx->bserrno = -EEXIST;
7794 : 23 : goto error;
7795 : : }
7796 : :
7797 [ + + ]: 63 : if (!spdk_blob_is_thin_provisioned(blob)) {
7798 : 20 : SPDK_ERRLOG("blob is not thin-provisioned\n");
7799 [ # # # # ]: 20 : ctx->bserrno = -EINVAL;
7800 : 20 : goto error;
7801 : : }
7802 : :
7803 [ - + - + : 43 : if (blob->locked_operation_in_progress) {
# # # # ]
7804 : 0 : SPDK_ERRLOG("cannot set external parent of blob, another operation in progress\n");
7805 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
7806 : 0 : goto error;
7807 : : }
7808 : :
7809 [ # # # # ]: 43 : blob->locked_operation_in_progress = true;
7810 : :
7811 : : /* Temporarily override md_ro flag for MD modification */
7812 [ # # # # ]: 43 : blob->md_ro = false;
7813 : :
7814 [ # # # # : 53 : blob_set_back_bs_dev(blob, ctx->parent.u.esnap.back_bs_dev, bs_set_external_parent_refs,
# # # # #
# ]
7815 [ # # ]: 10 : &ctx->parent, bs_set_external_parent_unfrozen, ctx);
7816 : 43 : return;
7817 : :
7818 : 33 : error:
7819 : 43 : spdk_blob_close(blob, bs_set_external_parent_cleanup_finish, ctx);
7820 : 20 : }
7821 : :
7822 : : void
7823 : 126 : spdk_bs_blob_set_external_parent(struct spdk_blob_store *bs, spdk_blob_id blob_id,
7824 : : struct spdk_bs_dev *esnap_bs_dev, const void *esnap_id,
7825 : : uint32_t esnap_id_len, spdk_blob_op_complete cb_fn, void *cb_arg)
7826 : : {
7827 : : struct set_parent_ctx *ctx;
7828 : : uint64_t esnap_dev_size, cluster_sz;
7829 : :
7830 [ + + - + : 126 : if (sizeof(blob_id) == esnap_id_len && memcmp(&blob_id, esnap_id, sizeof(blob_id)) == 0) {
+ - # # ]
7831 : 20 : SPDK_ERRLOG("blob id and external snapshot id cannot be the same\n");
7832 [ # # # # ]: 20 : cb_fn(cb_arg, -EINVAL);
7833 : 20 : return;
7834 : : }
7835 : :
7836 [ # # # # : 106 : esnap_dev_size = esnap_bs_dev->blockcnt * esnap_bs_dev->blocklen;
# # # # ]
7837 : 106 : cluster_sz = spdk_bs_get_cluster_size(bs);
7838 [ + + + + ]: 106 : if ((esnap_dev_size % cluster_sz) != 0) {
7839 : 20 : SPDK_ERRLOG("Esnap device size %" PRIu64 " is not an integer multiple of "
7840 : : "cluster size %" PRIu64 "\n", esnap_dev_size, cluster_sz);
7841 [ # # # # ]: 20 : cb_fn(cb_arg, -EINVAL);
7842 : 20 : return;
7843 : : }
7844 : :
7845 : 86 : ctx = calloc(1, sizeof(*ctx));
7846 [ + + ]: 86 : if (!ctx) {
7847 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
7848 : 0 : return;
7849 : : }
7850 : :
7851 [ # # # # : 86 : ctx->parent.u.esnap.id = calloc(1, esnap_id_len);
# # # # #
# ]
7852 [ - + # # : 86 : if (!ctx->parent.u.esnap.id) {
# # # # #
# # # ]
7853 : 0 : free(ctx);
7854 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
7855 : 0 : return;
7856 : : }
7857 : :
7858 [ # # # # ]: 86 : ctx->bs = bs;
7859 [ # # # # : 86 : ctx->parent.u.esnap.back_bs_dev = esnap_bs_dev;
# # # # #
# ]
7860 [ - + - + : 86 : memcpy(ctx->parent.u.esnap.id, esnap_id, esnap_id_len);
# # # # #
# # # #
# ]
7861 [ # # # # : 86 : ctx->parent.u.esnap.id_len = esnap_id_len;
# # # # #
# ]
7862 [ # # # # ]: 86 : ctx->cb_fn = cb_fn;
7863 [ # # # # ]: 86 : ctx->cb_arg = cb_arg;
7864 [ # # # # ]: 86 : ctx->bserrno = 0;
7865 : :
7866 : 86 : spdk_bs_open_blob(bs, blob_id, bs_set_external_parent_blob_open_cpl, ctx);
7867 : 30 : }
7868 : : /* END spdk_bs_blob_set_external_parent */
7869 : :
7870 : : /* START spdk_blob_resize */
7871 : : struct spdk_bs_resize_ctx {
7872 : : spdk_blob_op_complete cb_fn;
7873 : : void *cb_arg;
7874 : : struct spdk_blob *blob;
7875 : : uint64_t sz;
7876 : : int rc;
7877 : : };
7878 : :
7879 : : static void
7880 : 112466 : bs_resize_unfreeze_cpl(void *cb_arg, int rc)
7881 : : {
7882 : 112466 : struct spdk_bs_resize_ctx *ctx = (struct spdk_bs_resize_ctx *)cb_arg;
7883 : :
7884 [ - + ]: 112466 : if (rc != 0) {
7885 : 0 : SPDK_ERRLOG("Unfreeze failed, rc=%d\n", rc);
7886 : 0 : }
7887 : :
7888 [ + + # # : 112466 : if (ctx->rc != 0) {
# # ]
7889 [ # # # # ]: 21 : SPDK_ERRLOG("Unfreeze failed, ctx->rc=%d\n", ctx->rc);
7890 [ # # # # ]: 21 : rc = ctx->rc;
7891 : 5 : }
7892 : :
7893 [ # # # # : 112466 : ctx->blob->locked_operation_in_progress = false;
# # # # ]
7894 : :
7895 [ # # # # : 112466 : ctx->cb_fn(ctx->cb_arg, rc);
# # # # #
# # # ]
7896 : 112466 : free(ctx);
7897 : 112466 : }
7898 : :
7899 : : static void
7900 : 112466 : bs_resize_freeze_cpl(void *cb_arg, int rc)
7901 : : {
7902 : 112466 : struct spdk_bs_resize_ctx *ctx = (struct spdk_bs_resize_ctx *)cb_arg;
7903 : :
7904 [ - + ]: 112466 : if (rc != 0) {
7905 [ # # # # : 0 : ctx->blob->locked_operation_in_progress = false;
# # # # ]
7906 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, rc);
# # # # #
# # # ]
7907 : 0 : free(ctx);
7908 : 0 : return;
7909 : : }
7910 : :
7911 [ # # # # : 112466 : ctx->rc = blob_resize(ctx->blob, ctx->sz);
# # # # #
# # # ]
7912 : :
7913 [ # # # # ]: 112466 : blob_unfreeze_io(ctx->blob, bs_resize_unfreeze_cpl, ctx);
7914 : 252 : }
7915 : :
7916 : : void
7917 : 112534 : spdk_blob_resize(struct spdk_blob *blob, uint64_t sz, spdk_blob_op_complete cb_fn, void *cb_arg)
7918 : : {
7919 : : struct spdk_bs_resize_ctx *ctx;
7920 : :
7921 : 112534 : blob_verify_md_op(blob);
7922 : :
7923 [ + + - + : 112534 : SPDK_DEBUGLOG(blob, "Resizing blob 0x%" PRIx64 " to %" PRIu64 " clusters\n", blob->id, sz);
# # # # #
# ]
7924 : :
7925 [ + + + + : 112534 : if (blob->md_ro) {
# # # # ]
7926 [ # # # # ]: 20 : cb_fn(cb_arg, -EPERM);
7927 : 20 : return;
7928 : : }
7929 : :
7930 [ + + # # : 112514 : if (sz == blob->active.num_clusters) {
# # # # ]
7931 [ # # # # ]: 48 : cb_fn(cb_arg, 0);
7932 : 48 : return;
7933 : : }
7934 : :
7935 [ - + - + : 112466 : if (blob->locked_operation_in_progress) {
# # # # ]
7936 [ # # # # ]: 0 : cb_fn(cb_arg, -EBUSY);
7937 : 0 : return;
7938 : : }
7939 : :
7940 : 112466 : ctx = calloc(1, sizeof(*ctx));
7941 [ - + ]: 112466 : if (!ctx) {
7942 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
7943 : 0 : return;
7944 : : }
7945 : :
7946 [ # # # # ]: 112466 : blob->locked_operation_in_progress = true;
7947 [ # # # # ]: 112466 : ctx->cb_fn = cb_fn;
7948 [ # # # # ]: 112466 : ctx->cb_arg = cb_arg;
7949 [ # # # # ]: 112466 : ctx->blob = blob;
7950 [ # # # # ]: 112466 : ctx->sz = sz;
7951 : 112466 : blob_freeze_io(blob, bs_resize_freeze_cpl, ctx);
7952 : 269 : }
7953 : :
7954 : : /* END spdk_blob_resize */
7955 : :
7956 : :
7957 : : /* START spdk_bs_delete_blob */
7958 : :
7959 : : static void
7960 : 8602 : bs_delete_close_cpl(void *cb_arg, int bserrno)
7961 : : {
7962 : 8602 : spdk_bs_sequence_t *seq = cb_arg;
7963 : :
7964 : 8602 : bs_sequence_finish(seq, bserrno);
7965 : 8602 : }
7966 : :
7967 : : static void
7968 : 8602 : bs_delete_persist_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
7969 : : {
7970 : 8602 : struct spdk_blob *blob = cb_arg;
7971 : :
7972 [ - + ]: 8602 : if (bserrno != 0) {
7973 : : /*
7974 : : * We already removed this blob from the blobstore tailq, so
7975 : : * we need to free it here since this is the last reference
7976 : : * to it.
7977 : : */
7978 : 0 : blob_free(blob);
7979 : 0 : bs_delete_close_cpl(seq, bserrno);
7980 : 0 : return;
7981 : : }
7982 : :
7983 : : /*
7984 : : * This will immediately decrement the ref_count and call
7985 : : * the completion routine since the metadata state is clean.
7986 : : * By calling spdk_blob_close, we reduce the number of call
7987 : : * points into code that touches the blob->open_ref count
7988 : : * and the blobstore's blob list.
7989 : : */
7990 : 8602 : spdk_blob_close(blob, bs_delete_close_cpl, seq);
7991 : 1867 : }
7992 : :
7993 : : struct delete_snapshot_ctx {
7994 : : struct spdk_blob_list *parent_snapshot_entry;
7995 : : struct spdk_blob *snapshot;
7996 : : struct spdk_blob_md_page *page;
7997 : : bool snapshot_md_ro;
7998 : : struct spdk_blob *clone;
7999 : : bool clone_md_ro;
8000 : : spdk_blob_op_with_handle_complete cb_fn;
8001 : : void *cb_arg;
8002 : : int bserrno;
8003 : : uint32_t next_extent_page;
8004 : : };
8005 : :
8006 : : static void
8007 : 560 : delete_blob_cleanup_finish(void *cb_arg, int bserrno)
8008 : : {
8009 : 560 : struct delete_snapshot_ctx *ctx = cb_arg;
8010 : :
8011 [ + + ]: 560 : if (bserrno != 0) {
8012 : 0 : SPDK_ERRLOG("Snapshot cleanup error %d\n", bserrno);
8013 : 0 : }
8014 : :
8015 [ + + # # ]: 560 : assert(ctx != NULL);
8016 : :
8017 [ - + - - : 560 : if (bserrno != 0 && ctx->bserrno == 0) {
# # # # ]
8018 [ # # # # ]: 0 : ctx->bserrno = bserrno;
8019 : 0 : }
8020 : :
8021 [ # # # # : 560 : ctx->cb_fn(ctx->cb_arg, ctx->snapshot, ctx->bserrno);
# # # # #
# # # # #
# # # # #
# ]
8022 [ # # # # ]: 560 : spdk_free(ctx->page);
8023 : 560 : free(ctx);
8024 : 560 : }
8025 : :
8026 : : static void
8027 : 112 : delete_snapshot_cleanup_snapshot(void *cb_arg, int bserrno)
8028 : : {
8029 : 112 : struct delete_snapshot_ctx *ctx = cb_arg;
8030 : :
8031 [ - + ]: 112 : if (bserrno != 0) {
8032 [ # # # # ]: 0 : ctx->bserrno = bserrno;
8033 : 0 : SPDK_ERRLOG("Clone cleanup error %d\n", bserrno);
8034 : 0 : }
8035 : :
8036 [ + + # # : 112 : if (ctx->bserrno != 0) {
# # ]
8037 [ + + # # : 112 : assert(blob_lookup(ctx->snapshot->bs, ctx->snapshot->id) == NULL);
# # # # #
# # # # #
# # # # #
# ]
8038 [ # # # # : 112 : RB_INSERT(spdk_blob_tree, &ctx->snapshot->bs->open_blobs, ctx->snapshot);
# # # # #
# # # #
# ]
8039 [ # # # # : 112 : spdk_bit_array_set(ctx->snapshot->bs->open_blobids, ctx->snapshot->id);
# # # # #
# # # # #
# # # # #
# ]
8040 : 28 : }
8041 : :
8042 [ # # # # : 112 : ctx->snapshot->locked_operation_in_progress = false;
# # # # ]
8043 [ - + # # : 112 : ctx->snapshot->md_ro = ctx->snapshot_md_ro;
# # # # #
# # # #
# ]
8044 : :
8045 [ # # # # ]: 112 : spdk_blob_close(ctx->snapshot, delete_blob_cleanup_finish, ctx);
8046 : 112 : }
8047 : :
8048 : : static void
8049 : 60 : delete_snapshot_cleanup_clone(void *cb_arg, int bserrno)
8050 : : {
8051 : 60 : struct delete_snapshot_ctx *ctx = cb_arg;
8052 : :
8053 [ # # # # : 60 : ctx->clone->locked_operation_in_progress = false;
# # # # ]
8054 [ - + # # : 60 : ctx->clone->md_ro = ctx->clone_md_ro;
# # # # #
# # # #
# ]
8055 : :
8056 [ # # # # ]: 60 : spdk_blob_close(ctx->clone, delete_snapshot_cleanup_snapshot, ctx);
8057 : 60 : }
8058 : :
8059 : : static void
8060 : 248 : delete_snapshot_unfreeze_cpl(void *cb_arg, int bserrno)
8061 : : {
8062 : 248 : struct delete_snapshot_ctx *ctx = cb_arg;
8063 : :
8064 [ - + ]: 248 : if (bserrno) {
8065 [ # # # # ]: 0 : ctx->bserrno = bserrno;
8066 : 0 : delete_snapshot_cleanup_clone(ctx, 0);
8067 : 0 : return;
8068 : : }
8069 : :
8070 [ # # # # : 248 : ctx->clone->locked_operation_in_progress = false;
# # # # ]
8071 [ # # # # ]: 248 : spdk_blob_close(ctx->clone, delete_blob_cleanup_finish, ctx);
8072 : 60 : }
8073 : :
8074 : : static void
8075 : 268 : delete_snapshot_sync_snapshot_cpl(void *cb_arg, int bserrno)
8076 : : {
8077 : 268 : struct delete_snapshot_ctx *ctx = cb_arg;
8078 : 268 : struct spdk_blob_list *parent_snapshot_entry = NULL;
8079 : 268 : struct spdk_blob_list *snapshot_entry = NULL;
8080 : 268 : struct spdk_blob_list *clone_entry = NULL;
8081 : 268 : struct spdk_blob_list *snapshot_clone_entry = NULL;
8082 : :
8083 [ + + ]: 268 : if (bserrno) {
8084 : 20 : SPDK_ERRLOG("Failed to sync MD on blob\n");
8085 [ # # # # ]: 20 : ctx->bserrno = bserrno;
8086 : 20 : delete_snapshot_cleanup_clone(ctx, 0);
8087 : 20 : return;
8088 : : }
8089 : :
8090 : : /* Get snapshot entry for the snapshot we want to remove */
8091 [ # # # # : 248 : snapshot_entry = bs_get_snapshot_entry(ctx->snapshot->bs, ctx->snapshot->id);
# # # # #
# # # # #
# # ]
8092 : :
8093 [ + + # # ]: 248 : assert(snapshot_entry != NULL);
8094 : :
8095 : : /* Remove clone entry in this snapshot (at this point there can be only one clone) */
8096 [ # # # # : 248 : clone_entry = TAILQ_FIRST(&snapshot_entry->clones);
# # ]
8097 [ + + # # ]: 248 : assert(clone_entry != NULL);
8098 [ - + # # : 248 : TAILQ_REMOVE(&snapshot_entry->clones, clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
8099 [ # # ]: 248 : snapshot_entry->clone_count--;
8100 [ + + # # : 248 : assert(TAILQ_EMPTY(&snapshot_entry->clones));
# # # # #
# ]
8101 : :
8102 [ + + # # : 248 : switch (ctx->snapshot->parent_id) {
# # # # #
# ]
8103 : 157 : case SPDK_BLOBID_INVALID:
8104 : : case SPDK_BLOBID_EXTERNAL_SNAPSHOT:
8105 : : /* No parent snapshot - just remove clone entry */
8106 : 207 : free(clone_entry);
8107 : 207 : break;
8108 : 31 : default:
8109 : : /* This snapshot is at the same time a clone of another snapshot - we need to
8110 : : * update parent snapshot (remove current clone, add new one inherited from
8111 : : * the snapshot that is being removed) */
8112 : :
8113 : : /* Get snapshot entry for parent snapshot and clone entry within that snapshot for
8114 : : * snapshot that we are removing */
8115 [ # # # # ]: 41 : blob_get_snapshot_and_clone_entries(ctx->snapshot, &parent_snapshot_entry,
8116 : : &snapshot_clone_entry);
8117 : :
8118 : : /* Switch clone entry in parent snapshot */
8119 [ # # # # : 41 : TAILQ_INSERT_TAIL(&parent_snapshot_entry->clones, clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
8120 [ + - # # : 41 : TAILQ_REMOVE(&parent_snapshot_entry->clones, snapshot_clone_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
8121 : 41 : free(snapshot_clone_entry);
8122 : 10 : }
8123 : :
8124 : : /* Restore md_ro flags */
8125 [ - + # # : 248 : ctx->clone->md_ro = ctx->clone_md_ro;
# # # # #
# # # #
# ]
8126 [ - + # # : 248 : ctx->snapshot->md_ro = ctx->snapshot_md_ro;
# # # # #
# # # #
# ]
8127 : :
8128 [ # # # # ]: 248 : blob_unfreeze_io(ctx->clone, delete_snapshot_unfreeze_cpl, ctx);
8129 : 65 : }
8130 : :
8131 : : static void
8132 : 288 : delete_snapshot_sync_clone_cpl(void *cb_arg, int bserrno)
8133 : : {
8134 : 288 : struct delete_snapshot_ctx *ctx = cb_arg;
8135 : : uint64_t i;
8136 : :
8137 [ # # # # : 288 : ctx->snapshot->md_ro = false;
# # # # ]
8138 : :
8139 [ + + ]: 288 : if (bserrno) {
8140 : 20 : SPDK_ERRLOG("Failed to sync MD on clone\n");
8141 [ # # # # ]: 20 : ctx->bserrno = bserrno;
8142 : :
8143 : : /* Restore snapshot to previous state */
8144 [ # # # # ]: 20 : bserrno = blob_remove_xattr(ctx->snapshot, SNAPSHOT_PENDING_REMOVAL, true);
8145 [ + + ]: 20 : if (bserrno != 0) {
8146 : 0 : delete_snapshot_cleanup_clone(ctx, bserrno);
8147 : 0 : return;
8148 : : }
8149 : :
8150 [ # # # # ]: 20 : spdk_blob_sync_md(ctx->snapshot, delete_snapshot_cleanup_clone, ctx);
8151 : 20 : return;
8152 : : }
8153 : :
8154 : : /* Clear cluster map entries for snapshot */
8155 [ + + + + : 2993 : for (i = 0; i < ctx->snapshot->active.num_clusters && i < ctx->clone->active.num_clusters; i++) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
8156 [ + + # # : 2725 : if (ctx->clone->active.clusters[i] == ctx->snapshot->active.clusters[i]) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
8157 [ + + # # : 2669 : if (ctx->snapshot->active.clusters[i] != 0) {
# # # # #
# # # # #
# # ]
8158 [ # # # # : 1653 : ctx->snapshot->active.num_allocated_clusters--;
# # # # ]
8159 : 410 : }
8160 [ # # # # : 2669 : ctx->snapshot->active.clusters[i] = 0;
# # # # #
# # # #
# ]
8161 : 615 : }
8162 : 625 : }
8163 [ + + + + : 471 : for (i = 0; i < ctx->snapshot->active.num_extent_pages &&
# # # # #
# # # #
# ]
8164 [ + - # # : 328 : i < ctx->clone->active.num_extent_pages; i++) {
# # # # #
# ]
8165 [ + + # # : 164 : if (ctx->clone->active.extent_pages[i] == ctx->snapshot->active.extent_pages[i]) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
8166 [ # # # # : 148 : ctx->snapshot->active.extent_pages[i] = 0;
# # # # #
# # # #
# ]
8167 : 36 : }
8168 : 39 : }
8169 : :
8170 [ # # # # ]: 268 : blob_set_thin_provision(ctx->snapshot);
8171 [ # # # # : 268 : ctx->snapshot->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
8172 : :
8173 [ + + # # : 268 : if (ctx->parent_snapshot_entry != NULL) {
# # ]
8174 [ # # # # : 41 : ctx->snapshot->back_bs_dev = NULL;
# # # # ]
8175 : 10 : }
8176 : :
8177 [ # # # # ]: 268 : spdk_blob_sync_md(ctx->snapshot, delete_snapshot_sync_snapshot_cpl, ctx);
8178 : 70 : }
8179 : :
8180 : : static void
8181 : 288 : delete_snapshot_update_extent_pages_cpl(struct delete_snapshot_ctx *ctx)
8182 : : {
8183 : : int bserrno;
8184 : :
8185 : : /* Delete old backing bs_dev from clone (related to snapshot that will be removed) */
8186 [ # # # # ]: 288 : blob_back_bs_destroy(ctx->clone);
8187 : :
8188 : : /* Set/remove snapshot xattr and switch parent ID and backing bs_dev on clone... */
8189 [ + + # # : 288 : if (ctx->snapshot->parent_id == SPDK_BLOBID_EXTERNAL_SNAPSHOT) {
# # # # #
# ]
8190 [ # # # # : 44 : bserrno = bs_snapshot_copy_xattr(ctx->clone, ctx->snapshot,
# # # # ]
8191 : : BLOB_EXTERNAL_SNAPSHOT_ID);
8192 [ - + ]: 44 : if (bserrno != 0) {
8193 [ # # # # ]: 0 : ctx->bserrno = bserrno;
8194 : :
8195 : : /* Restore snapshot to previous state */
8196 [ # # # # ]: 0 : bserrno = blob_remove_xattr(ctx->snapshot, SNAPSHOT_PENDING_REMOVAL, true);
8197 [ # # ]: 0 : if (bserrno != 0) {
8198 : 0 : delete_snapshot_cleanup_clone(ctx, bserrno);
8199 : 0 : return;
8200 : : }
8201 : :
8202 [ # # # # ]: 0 : spdk_blob_sync_md(ctx->snapshot, delete_snapshot_cleanup_clone, ctx);
8203 : 0 : return;
8204 : : }
8205 [ # # # # : 44 : ctx->clone->parent_id = SPDK_BLOBID_EXTERNAL_SNAPSHOT;
# # # # ]
8206 [ # # # # : 44 : ctx->clone->back_bs_dev = ctx->snapshot->back_bs_dev;
# # # # #
# # # # #
# # ]
8207 : : /* Do not delete the external snapshot along with this snapshot */
8208 [ # # # # : 44 : ctx->snapshot->back_bs_dev = NULL;
# # # # ]
8209 [ # # # # : 44 : ctx->clone->invalid_flags |= SPDK_BLOB_EXTERNAL_SNAPSHOT;
# # # # #
# ]
8210 [ + + # # : 254 : } else if (ctx->parent_snapshot_entry != NULL) {
# # ]
8211 : : /* ...to parent snapshot */
8212 [ # # # # : 41 : ctx->clone->parent_id = ctx->parent_snapshot_entry->id;
# # # # #
# # # # #
# # ]
8213 [ # # # # : 41 : ctx->clone->back_bs_dev = ctx->snapshot->back_bs_dev;
# # # # #
# # # # #
# # ]
8214 [ # # # # : 41 : blob_set_xattr(ctx->clone, BLOB_SNAPSHOT, &ctx->parent_snapshot_entry->id,
# # # # #
# ]
8215 : : sizeof(spdk_blob_id),
8216 : : true);
8217 : 10 : } else {
8218 : : /* ...to blobid invalid and zeroes dev */
8219 [ # # # # : 203 : ctx->clone->parent_id = SPDK_BLOBID_INVALID;
# # # # ]
8220 [ # # # # : 203 : ctx->clone->back_bs_dev = bs_create_zeroes_dev();
# # # # ]
8221 [ # # # # ]: 203 : blob_remove_xattr(ctx->clone, BLOB_SNAPSHOT, true);
8222 : : }
8223 : :
8224 [ # # # # ]: 288 : spdk_blob_sync_md(ctx->clone, delete_snapshot_sync_clone_cpl, ctx);
8225 : 70 : }
8226 : :
8227 : : static void
8228 : 304 : delete_snapshot_update_extent_pages(void *cb_arg, int bserrno)
8229 : : {
8230 : 304 : struct delete_snapshot_ctx *ctx = cb_arg;
8231 : : uint32_t *extent_page;
8232 : : uint64_t i;
8233 : :
8234 [ + + + + : 506 : for (i = ctx->next_extent_page; i < ctx->snapshot->active.num_extent_pages &&
# # # # #
# # # # #
# # # # ]
8235 [ + - # # : 336 : i < ctx->clone->active.num_extent_pages; i++) {
# # # # #
# ]
8236 [ + + # # : 176 : if (ctx->snapshot->active.extent_pages[i] == 0) {
# # # # #
# # # # #
# # ]
8237 : : /* No extent page to use from snapshot */
8238 : 52 : continue;
8239 : : }
8240 : :
8241 [ # # # # : 124 : extent_page = &ctx->clone->active.extent_pages[i];
# # # # #
# # # ]
8242 [ + + # # ]: 124 : if (*extent_page == 0) {
8243 : : /* Copy extent page from snapshot when clone did not have a matching one */
8244 [ # # # # : 108 : *extent_page = ctx->snapshot->active.extent_pages[i];
# # # # #
# # # # #
# # ]
8245 : 108 : continue;
8246 : : }
8247 : :
8248 : : /* Clone and snapshot both contain partially filled matching extent pages.
8249 : : * Update the clone extent page in place with cluster map containing the mix of both. */
8250 [ # # # # ]: 16 : ctx->next_extent_page = i + 1;
8251 [ - + # # : 16 : memset(ctx->page, 0, SPDK_BS_PAGE_SIZE);
# # ]
8252 : :
8253 [ # # # # : 19 : blob_write_extent_page(ctx->clone, *extent_page, i * SPDK_EXTENTS_PER_EP, ctx->page,
# # # # #
# # # ]
8254 : 3 : delete_snapshot_update_extent_pages, ctx);
8255 : 16 : return;
8256 : : }
8257 : 288 : delete_snapshot_update_extent_pages_cpl(ctx);
8258 : 73 : }
8259 : :
8260 : : static void
8261 : 308 : delete_snapshot_sync_snapshot_xattr_cpl(void *cb_arg, int bserrno)
8262 : : {
8263 : 308 : struct delete_snapshot_ctx *ctx = cb_arg;
8264 : : uint64_t i;
8265 : :
8266 : : /* Temporarily override md_ro flag for clone for MD modification */
8267 [ - + # # : 308 : ctx->clone_md_ro = ctx->clone->md_ro;
# # # # #
# # # #
# ]
8268 [ # # # # : 308 : ctx->clone->md_ro = false;
# # # # ]
8269 : :
8270 [ + + ]: 308 : if (bserrno) {
8271 : 20 : SPDK_ERRLOG("Failed to sync MD with xattr on blob\n");
8272 [ # # # # ]: 20 : ctx->bserrno = bserrno;
8273 : 20 : delete_snapshot_cleanup_clone(ctx, 0);
8274 : 20 : return;
8275 : : }
8276 : :
8277 : : /* Copy snapshot map to clone map (only unallocated clusters in clone) */
8278 [ + + + + : 3213 : for (i = 0; i < ctx->snapshot->active.num_clusters && i < ctx->clone->active.num_clusters; i++) {
# # # # #
# # # # #
# # # # #
# # # #
# ]
8279 [ + + # # : 2925 : if (ctx->clone->active.clusters[i] == 0) {
# # # # #
# # # # #
# # ]
8280 [ # # # # : 2869 : ctx->clone->active.clusters[i] = ctx->snapshot->active.clusters[i];
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
8281 [ + + # # : 2869 : if (ctx->clone->active.clusters[i] != 0) {
# # # # #
# # # # #
# # ]
8282 [ # # # # : 1853 : ctx->clone->active.num_allocated_clusters++;
# # # # ]
8283 : 460 : }
8284 : 665 : }
8285 : 675 : }
8286 [ # # # # ]: 288 : ctx->next_extent_page = 0;
8287 : 288 : delete_snapshot_update_extent_pages(ctx, 0);
8288 : 75 : }
8289 : :
8290 : : static void
8291 : 44 : delete_snapshot_esnap_channels_destroyed_cb(void *cb_arg, struct spdk_blob *blob, int bserrno)
8292 : : {
8293 : 44 : struct delete_snapshot_ctx *ctx = cb_arg;
8294 : :
8295 [ - + ]: 44 : if (bserrno != 0) {
8296 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": failed to destroy esnap channels: %d\n",
8297 : : blob->id, bserrno);
8298 : : /* That error should not stop us from syncing metadata. */
8299 : 0 : }
8300 : :
8301 [ # # # # ]: 44 : spdk_blob_sync_md(ctx->snapshot, delete_snapshot_sync_snapshot_xattr_cpl, ctx);
8302 : 44 : }
8303 : :
8304 : : static void
8305 : 308 : delete_snapshot_freeze_io_cb(void *cb_arg, int bserrno)
8306 : : {
8307 : 308 : struct delete_snapshot_ctx *ctx = cb_arg;
8308 : :
8309 [ - + ]: 308 : if (bserrno) {
8310 : 0 : SPDK_ERRLOG("Failed to freeze I/O on clone\n");
8311 [ # # # # ]: 0 : ctx->bserrno = bserrno;
8312 : 0 : delete_snapshot_cleanup_clone(ctx, 0);
8313 : 0 : return;
8314 : : }
8315 : :
8316 : : /* Temporarily override md_ro flag for snapshot for MD modification */
8317 [ - + # # : 308 : ctx->snapshot_md_ro = ctx->snapshot->md_ro;
# # # # #
# # # #
# ]
8318 [ # # # # : 308 : ctx->snapshot->md_ro = false;
# # # # ]
8319 : :
8320 : : /* Mark blob as pending for removal for power failure safety, use clone id for recovery */
8321 [ # # # # : 308 : ctx->bserrno = blob_set_xattr(ctx->snapshot, SNAPSHOT_PENDING_REMOVAL, &ctx->clone->id,
# # # # #
# # # #
# ]
8322 : : sizeof(spdk_blob_id), true);
8323 [ - + # # : 308 : if (ctx->bserrno != 0) {
# # ]
8324 : 0 : delete_snapshot_cleanup_clone(ctx, 0);
8325 : 0 : return;
8326 : : }
8327 : :
8328 [ + + # # : 308 : if (blob_is_esnap_clone(ctx->snapshot)) {
# # ]
8329 [ # # # # ]: 54 : blob_esnap_destroy_bs_dev_channels(ctx->snapshot, false,
8330 : : delete_snapshot_esnap_channels_destroyed_cb,
8331 : 10 : ctx);
8332 : 44 : return;
8333 : : }
8334 : :
8335 [ # # # # ]: 264 : spdk_blob_sync_md(ctx->snapshot, delete_snapshot_sync_snapshot_xattr_cpl, ctx);
8336 : 75 : }
8337 : :
8338 : : static void
8339 : 360 : delete_snapshot_open_clone_cb(void *cb_arg, struct spdk_blob *clone, int bserrno)
8340 : : {
8341 : 360 : struct delete_snapshot_ctx *ctx = cb_arg;
8342 : :
8343 [ + + ]: 360 : if (bserrno) {
8344 : 52 : SPDK_ERRLOG("Failed to open clone\n");
8345 [ # # # # ]: 52 : ctx->bserrno = bserrno;
8346 : 52 : delete_snapshot_cleanup_snapshot(ctx, 0);
8347 : 52 : return;
8348 : : }
8349 : :
8350 [ # # # # ]: 308 : ctx->clone = clone;
8351 : :
8352 [ - + - + : 308 : if (clone->locked_operation_in_progress) {
# # # # ]
8353 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Cannot remove blob - another operation in progress on its clone\n");
# # ]
8354 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
8355 [ # # # # ]: 0 : spdk_blob_close(ctx->clone, delete_snapshot_cleanup_snapshot, ctx);
8356 : 0 : return;
8357 : : }
8358 : :
8359 [ # # # # ]: 308 : clone->locked_operation_in_progress = true;
8360 : :
8361 : 308 : blob_freeze_io(clone, delete_snapshot_freeze_io_cb, ctx);
8362 : 88 : }
8363 : :
8364 : : static void
8365 : 360 : update_clone_on_snapshot_deletion(struct spdk_blob *snapshot, struct delete_snapshot_ctx *ctx)
8366 : : {
8367 : 360 : struct spdk_blob_list *snapshot_entry = NULL;
8368 : 360 : struct spdk_blob_list *clone_entry = NULL;
8369 : 360 : struct spdk_blob_list *snapshot_clone_entry = NULL;
8370 : :
8371 : : /* Get snapshot entry for the snapshot we want to remove */
8372 [ # # # # : 360 : snapshot_entry = bs_get_snapshot_entry(snapshot->bs, snapshot->id);
# # # # ]
8373 : :
8374 [ + + # # ]: 360 : assert(snapshot_entry != NULL);
8375 : :
8376 : : /* Get clone of the snapshot (at this point there can be only one clone) */
8377 [ # # # # : 360 : clone_entry = TAILQ_FIRST(&snapshot_entry->clones);
# # ]
8378 [ + + # # : 360 : assert(snapshot_entry->clone_count == 1);
# # # # ]
8379 [ + + # # ]: 360 : assert(clone_entry != NULL);
8380 : :
8381 : : /* Get snapshot entry for parent snapshot and clone entry within that snapshot for
8382 : : * snapshot that we are removing */
8383 [ # # ]: 360 : blob_get_snapshot_and_clone_entries(snapshot, &ctx->parent_snapshot_entry,
8384 : : &snapshot_clone_entry);
8385 : :
8386 [ # # # # : 360 : spdk_bs_open_blob(snapshot->bs, clone_entry->id, delete_snapshot_open_clone_cb, ctx);
# # # # ]
8387 : 360 : }
8388 : :
8389 : : static void
8390 : 8914 : bs_delete_blob_finish(void *cb_arg, struct spdk_blob *blob, int bserrno)
8391 : : {
8392 : 8914 : spdk_bs_sequence_t *seq = cb_arg;
8393 : 8914 : struct spdk_blob_list *snapshot_entry = NULL;
8394 : : uint32_t page_num;
8395 : :
8396 [ + + ]: 8914 : if (bserrno) {
8397 : 312 : SPDK_ERRLOG("Failed to remove blob\n");
8398 : 312 : bs_sequence_finish(seq, bserrno);
8399 : 312 : return;
8400 : : }
8401 : :
8402 : : /* Remove snapshot from the list */
8403 [ # # # # : 8602 : snapshot_entry = bs_get_snapshot_entry(blob->bs, blob->id);
# # # # ]
8404 [ + + ]: 8602 : if (snapshot_entry != NULL) {
8405 [ + + # # : 759 : TAILQ_REMOVE(&blob->bs->snapshots, snapshot_entry, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
8406 : 759 : free(snapshot_entry);
8407 : 181 : }
8408 : :
8409 [ # # # # ]: 8602 : page_num = bs_blobid_to_page(blob->id);
8410 [ # # # # : 8602 : spdk_bit_array_clear(blob->bs->used_blobids, page_num);
# # # # ]
8411 [ # # # # ]: 8602 : blob->state = SPDK_BLOB_STATE_DIRTY;
8412 [ # # # # : 8602 : blob->active.num_pages = 0;
# # ]
8413 : 8602 : blob_resize(blob, 0);
8414 : :
8415 : 8602 : blob_persist(seq, blob, bs_delete_persist_cpl, blob);
8416 : 1945 : }
8417 : :
8418 : : static int
8419 : 8914 : bs_is_blob_deletable(struct spdk_blob *blob, bool *update_clone)
8420 : : {
8421 : 8914 : struct spdk_blob_list *snapshot_entry = NULL;
8422 : 8914 : struct spdk_blob_list *clone_entry = NULL;
8423 : 8914 : struct spdk_blob *clone = NULL;
8424 : 8914 : bool has_one_clone = false;
8425 : :
8426 : : /* Check if this is a snapshot with clones */
8427 [ # # # # : 8914 : snapshot_entry = bs_get_snapshot_entry(blob->bs, blob->id);
# # # # ]
8428 [ + + ]: 8914 : if (snapshot_entry != NULL) {
8429 [ + + # # : 1011 : if (snapshot_entry->clone_count > 1) {
# # ]
8430 : 120 : SPDK_ERRLOG("Cannot remove snapshot with more than one clone\n");
8431 : 120 : return -EBUSY;
8432 [ + + # # : 891 : } else if (snapshot_entry->clone_count == 1) {
# # ]
8433 : 360 : has_one_clone = true;
8434 : 88 : }
8435 : 214 : }
8436 : :
8437 : : /* Check if someone has this blob open (besides this delete context):
8438 : : * - open_ref = 1 - only this context opened blob, so it is ok to remove it
8439 : : * - open_ref <= 2 && has_one_clone = true - clone is holding snapshot
8440 : : * and that is ok, because we will update it accordingly */
8441 [ + + + + : 8794 : if (blob->open_ref <= 2 && has_one_clone) {
# # # # #
# ]
8442 [ # # # # : 360 : clone_entry = TAILQ_FIRST(&snapshot_entry->clones);
# # ]
8443 [ - + # # ]: 360 : assert(clone_entry != NULL);
8444 [ # # # # : 360 : clone = blob_lookup(blob->bs, clone_entry->id);
# # # # ]
8445 : :
8446 [ + + + + : 360 : if (blob->open_ref == 2 && clone == NULL) {
# # # # ]
8447 : : /* Clone is closed and someone else opened this blob */
8448 : 0 : SPDK_ERRLOG("Cannot remove snapshot because it is open\n");
8449 : 0 : return -EBUSY;
8450 : : }
8451 : :
8452 [ # # ]: 360 : *update_clone = true;
8453 : 360 : return 0;
8454 : : }
8455 : :
8456 [ + + # # : 8434 : if (blob->open_ref > 1) {
# # ]
8457 : 80 : SPDK_ERRLOG("Cannot remove snapshot because it is open\n");
8458 : 80 : return -EBUSY;
8459 : : }
8460 : :
8461 [ + + # # : 8354 : assert(has_one_clone == false);
# # ]
8462 [ # # ]: 8354 : *update_clone = false;
8463 : 8354 : return 0;
8464 : 1945 : }
8465 : :
8466 : : static void
8467 : 0 : bs_delete_enomem_close_cpl(void *cb_arg, int bserrno)
8468 : : {
8469 : 0 : spdk_bs_sequence_t *seq = cb_arg;
8470 : :
8471 : 0 : bs_sequence_finish(seq, -ENOMEM);
8472 : 0 : }
8473 : :
8474 : : static void
8475 : 8966 : bs_delete_open_cpl(void *cb_arg, struct spdk_blob *blob, int bserrno)
8476 : : {
8477 : 8966 : spdk_bs_sequence_t *seq = cb_arg;
8478 : : struct delete_snapshot_ctx *ctx;
8479 : 8966 : bool update_clone = false;
8480 : :
8481 [ + + ]: 8966 : if (bserrno != 0) {
8482 : 52 : bs_sequence_finish(seq, bserrno);
8483 : 52 : return;
8484 : : }
8485 : :
8486 : 8914 : blob_verify_md_op(blob);
8487 : :
8488 : 8914 : ctx = calloc(1, sizeof(*ctx));
8489 [ + + ]: 8914 : if (ctx == NULL) {
8490 : 0 : spdk_blob_close(blob, bs_delete_enomem_close_cpl, seq);
8491 : 0 : return;
8492 : : }
8493 : :
8494 [ # # # # ]: 8914 : ctx->snapshot = blob;
8495 [ # # # # ]: 8914 : ctx->cb_fn = bs_delete_blob_finish;
8496 [ # # # # ]: 8914 : ctx->cb_arg = seq;
8497 : :
8498 : : /* Check if blob can be removed and if it is a snapshot with clone on top of it */
8499 [ # # # # ]: 8914 : ctx->bserrno = bs_is_blob_deletable(blob, &update_clone);
8500 [ + + # # : 8914 : if (ctx->bserrno) {
# # ]
8501 : 200 : spdk_blob_close(blob, delete_blob_cleanup_finish, ctx);
8502 : 200 : return;
8503 : : }
8504 : :
8505 [ - + - + : 8714 : if (blob->locked_operation_in_progress) {
# # # # ]
8506 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "Cannot remove blob - another operation in progress\n");
# # ]
8507 [ # # # # ]: 0 : ctx->bserrno = -EBUSY;
8508 : 0 : spdk_blob_close(blob, delete_blob_cleanup_finish, ctx);
8509 : 0 : return;
8510 : : }
8511 : :
8512 [ # # # # ]: 8714 : blob->locked_operation_in_progress = true;
8513 : :
8514 : : /*
8515 : : * Remove the blob from the blob_store list now, to ensure it does not
8516 : : * get returned after this point by blob_lookup().
8517 : : */
8518 [ # # # # : 8714 : spdk_bit_array_clear(blob->bs->open_blobids, blob->id);
# # # # #
# # # ]
8519 [ # # # # : 8714 : RB_REMOVE(spdk_blob_tree, &blob->bs->open_blobs, blob);
# # ]
8520 : :
8521 [ + + + + ]: 8714 : if (update_clone) {
8522 [ # # # # : 360 : ctx->page = spdk_zmalloc(blob->bs->md_page_size, 0, NULL, SPDK_ENV_NUMA_ID_ANY,
# # # # #
# # # ]
8523 : : SPDK_MALLOC_DMA);
8524 [ - + # # : 360 : if (!ctx->page) {
# # ]
8525 [ # # # # ]: 0 : ctx->bserrno = -ENOMEM;
8526 : 0 : spdk_blob_close(blob, delete_blob_cleanup_finish, ctx);
8527 : 0 : return;
8528 : : }
8529 : : /* This blob is a snapshot with active clone - update clone first */
8530 : 360 : update_clone_on_snapshot_deletion(blob, ctx);
8531 : 88 : } else {
8532 : : /* This blob does not have any clones - just remove it */
8533 : 8354 : bs_blob_list_remove(blob);
8534 : 8354 : bs_delete_blob_finish(seq, blob, 0);
8535 : 8354 : free(ctx);
8536 : : }
8537 : 1958 : }
8538 : :
8539 : : void
8540 : 8966 : spdk_bs_delete_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
8541 : : spdk_blob_op_complete cb_fn, void *cb_arg)
8542 : : {
8543 : 7008 : struct spdk_bs_cpl cpl;
8544 : : spdk_bs_sequence_t *seq;
8545 : :
8546 [ + + - + : 8966 : SPDK_DEBUGLOG(blob, "Deleting blob 0x%" PRIx64 "\n", blobid);
# # ]
8547 : :
8548 [ + + # # : 8966 : assert(spdk_get_thread() == bs->md_thread);
# # # # ]
8549 : :
8550 : 8966 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
8551 [ # # # # : 8966 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
8552 [ # # # # : 8966 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
8553 : :
8554 [ # # # # ]: 8966 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
8555 [ + + ]: 8966 : if (!seq) {
8556 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
8557 : 0 : return;
8558 : : }
8559 : :
8560 : 8966 : spdk_bs_open_blob(bs, blobid, bs_delete_open_cpl, seq);
8561 : 1958 : }
8562 : :
8563 : : /* END spdk_bs_delete_blob */
8564 : :
8565 : : /* START spdk_bs_open_blob */
8566 : :
8567 : : static void
8568 : 36005 : bs_open_blob_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
8569 : : {
8570 : 36005 : struct spdk_blob *blob = cb_arg;
8571 : : struct spdk_blob *existing;
8572 : :
8573 [ + + ]: 36005 : if (bserrno != 0) {
8574 : 328 : blob_free(blob);
8575 [ # # # # : 328 : seq->cpl.u.blob_handle.blob = NULL;
# # # # #
# ]
8576 : 328 : bs_sequence_finish(seq, bserrno);
8577 : 328 : return;
8578 : : }
8579 : :
8580 [ # # # # : 35677 : existing = blob_lookup(blob->bs, blob->id);
# # # # ]
8581 [ + + ]: 35677 : if (existing) {
8582 : 35 : blob_free(blob);
8583 [ # # ]: 35 : existing->open_ref++;
8584 [ # # # # : 35 : seq->cpl.u.blob_handle.blob = existing;
# # # # #
# ]
8585 : 35 : bs_sequence_finish(seq, 0);
8586 : 35 : return;
8587 : : }
8588 : :
8589 [ # # ]: 35642 : blob->open_ref++;
8590 : :
8591 [ # # # # : 35642 : spdk_bit_array_set(blob->bs->open_blobids, blob->id);
# # # # #
# # # ]
8592 [ # # # # : 35642 : RB_INSERT(spdk_blob_tree, &blob->bs->open_blobs, blob);
# # ]
8593 : :
8594 : 35642 : bs_sequence_finish(seq, bserrno);
8595 : 4373 : }
8596 : :
8597 : : static inline void
8598 : 646 : blob_open_opts_copy(const struct spdk_blob_open_opts *src, struct spdk_blob_open_opts *dst)
8599 : : {
8600 : : #define FIELD_OK(field) \
8601 : : offsetof(struct spdk_blob_open_opts, field) + sizeof(src->field) <= src->opts_size
8602 : :
8603 : : #define SET_FIELD(field) \
8604 : : if (FIELD_OK(field)) { \
8605 : : dst->field = src->field; \
8606 : : } \
8607 : :
8608 [ + + # # : 646 : SET_FIELD(clear_method);
# # # # #
# # # #
# ]
8609 [ + + # # : 646 : SET_FIELD(esnap_ctx);
# # # # #
# # # #
# ]
8610 : :
8611 [ # # # # : 646 : dst->opts_size = src->opts_size;
# # # # ]
8612 : :
8613 : : /* You should not remove this statement, but need to update the assert statement
8614 : : * if you add a new field, and also add a corresponding SET_FIELD statement */
8615 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_blob_open_opts) == 24, "Incorrect size");
8616 : :
8617 : : #undef FIELD_OK
8618 : : #undef SET_FIELD
8619 : 646 : }
8620 : :
8621 : : static void
8622 : 40304 : bs_open_blob(struct spdk_blob_store *bs,
8623 : : spdk_blob_id blobid,
8624 : : struct spdk_blob_open_opts *opts,
8625 : : spdk_blob_op_with_handle_complete cb_fn,
8626 : : void *cb_arg)
8627 : : {
8628 : : struct spdk_blob *blob;
8629 : 34912 : struct spdk_bs_cpl cpl;
8630 : 34912 : struct spdk_blob_open_opts opts_local;
8631 : : spdk_bs_sequence_t *seq;
8632 : : uint32_t page_num;
8633 : :
8634 [ + + - + : 40304 : SPDK_DEBUGLOG(blob, "Opening blob 0x%" PRIx64 "\n", blobid);
# # ]
8635 [ + + # # : 40304 : assert(spdk_get_thread() == bs->md_thread);
# # # # ]
8636 : :
8637 : 40304 : page_num = bs_blobid_to_page(blobid);
8638 [ + + # # : 40304 : if (spdk_bit_array_get(bs->used_blobids, page_num) == false) {
# # ]
8639 : : /* Invalid blobid */
8640 [ # # # # ]: 241 : cb_fn(cb_arg, NULL, -ENOENT);
8641 : 241 : return;
8642 : : }
8643 : :
8644 : 40063 : blob = blob_lookup(bs, blobid);
8645 [ + + ]: 40063 : if (blob) {
8646 [ # # ]: 4058 : blob->open_ref++;
8647 [ # # # # ]: 4058 : cb_fn(cb_arg, blob, 0);
8648 : 4058 : return;
8649 : : }
8650 : :
8651 : 36005 : blob = blob_alloc(bs, blobid);
8652 [ + + ]: 36005 : if (!blob) {
8653 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
8654 : 0 : return;
8655 : : }
8656 : :
8657 : 36005 : spdk_blob_open_opts_init(&opts_local, sizeof(opts_local));
8658 [ + + ]: 36005 : if (opts) {
8659 : 646 : blob_open_opts_copy(opts, &opts_local);
8660 : 12 : }
8661 : :
8662 [ # # # # ]: 36005 : blob->clear_method = opts_local.clear_method;
8663 : :
8664 : 36005 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_HANDLE;
8665 [ # # # # : 36005 : cpl.u.blob_handle.cb_fn = cb_fn;
# # ]
8666 [ # # # # : 36005 : cpl.u.blob_handle.cb_arg = cb_arg;
# # ]
8667 [ # # # # : 36005 : cpl.u.blob_handle.blob = blob;
# # ]
8668 [ # # # # : 36005 : cpl.u.blob_handle.esnap_ctx = opts_local.esnap_ctx;
# # # # ]
8669 : :
8670 [ # # # # ]: 36005 : seq = bs_sequence_start_bs(bs->md_channel, &cpl);
8671 [ + + ]: 36005 : if (!seq) {
8672 : 0 : blob_free(blob);
8673 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
8674 : 0 : return;
8675 : : }
8676 : :
8677 : 36005 : blob_load(seq, blob, bs_open_blob_cpl, blob);
8678 : 5392 : }
8679 : :
8680 : : void
8681 : 39618 : spdk_bs_open_blob(struct spdk_blob_store *bs, spdk_blob_id blobid,
8682 : : spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
8683 : : {
8684 : 39618 : bs_open_blob(bs, blobid, NULL, cb_fn, cb_arg);
8685 : 39618 : }
8686 : :
8687 : : void
8688 : 686 : spdk_bs_open_blob_ext(struct spdk_blob_store *bs, spdk_blob_id blobid,
8689 : : struct spdk_blob_open_opts *opts, spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
8690 : : {
8691 : 686 : bs_open_blob(bs, blobid, opts, cb_fn, cb_arg);
8692 : 686 : }
8693 : :
8694 : : /* END spdk_bs_open_blob */
8695 : :
8696 : : /* START spdk_blob_set_read_only */
8697 : : int
8698 : 1228 : spdk_blob_set_read_only(struct spdk_blob *blob)
8699 : : {
8700 : 1228 : blob_verify_md_op(blob);
8701 : :
8702 [ # # # # : 1228 : blob->data_ro_flags |= SPDK_BLOB_READ_ONLY;
# # ]
8703 : :
8704 [ # # # # ]: 1228 : blob->state = SPDK_BLOB_STATE_DIRTY;
8705 : 1228 : return 0;
8706 : : }
8707 : : /* END spdk_blob_set_read_only */
8708 : :
8709 : : /* START spdk_blob_sync_md */
8710 : :
8711 : : static void
8712 : 161758 : blob_sync_md_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
8713 : : {
8714 : 161758 : struct spdk_blob *blob = cb_arg;
8715 : :
8716 [ + - + + : 161758 : if (bserrno == 0 && (blob->data_ro_flags & SPDK_BLOB_READ_ONLY)) {
# # # # #
# ]
8717 [ # # # # ]: 2049 : blob->data_ro = true;
8718 [ # # # # ]: 2049 : blob->md_ro = true;
8719 : 498 : }
8720 : :
8721 : 161758 : bs_sequence_finish(seq, bserrno);
8722 : 161758 : }
8723 : :
8724 : : static void
8725 : 161758 : blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
8726 : : {
8727 : 159827 : struct spdk_bs_cpl cpl;
8728 : : spdk_bs_sequence_t *seq;
8729 : :
8730 : 161758 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
8731 [ # # # # : 161758 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
8732 [ # # # # : 161758 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
8733 : :
8734 [ # # # # : 161758 : seq = bs_sequence_start_bs(blob->bs->md_channel, &cpl);
# # # # ]
8735 [ - + ]: 161758 : if (!seq) {
8736 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
8737 : 0 : return;
8738 : : }
8739 : :
8740 : 161758 : blob_persist(seq, blob, blob_sync_md_cpl, blob);
8741 : 1931 : }
8742 : :
8743 : : void
8744 : 158549 : spdk_blob_sync_md(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
8745 : : {
8746 : 158549 : blob_verify_md_op(blob);
8747 : :
8748 [ + + - + : 158549 : SPDK_DEBUGLOG(blob, "Syncing blob 0x%" PRIx64 "\n", blob->id);
# # # # #
# ]
8749 : :
8750 [ + + + + : 158549 : if (blob->md_ro) {
# # # # ]
8751 [ - + # # : 20 : assert(blob->state == SPDK_BLOB_STATE_CLEAN);
# # # # ]
8752 [ # # # # ]: 20 : cb_fn(cb_arg, 0);
8753 : 20 : return;
8754 : : }
8755 : :
8756 : 158529 : blob_sync_md(blob, cb_fn, cb_arg);
8757 : 1374 : }
8758 : :
8759 : : /* END spdk_blob_sync_md */
8760 : :
8761 : : struct spdk_blob_cluster_op_ctx {
8762 : : struct spdk_thread *thread;
8763 : : struct spdk_blob *blob;
8764 : : uint32_t cluster_num; /* cluster index in blob */
8765 : : uint32_t cluster; /* cluster on disk */
8766 : : uint32_t extent_page; /* extent page on disk */
8767 : : struct spdk_blob_md_page *page; /* preallocated extent page */
8768 : : int rc;
8769 : : spdk_blob_op_complete cb_fn;
8770 : : void *cb_arg;
8771 : : };
8772 : :
8773 : : static void
8774 : 36731 : blob_op_cluster_msg_cpl(void *arg)
8775 : : {
8776 : 36731 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8777 : :
8778 [ # # # # : 36731 : ctx->cb_fn(ctx->cb_arg, ctx->rc);
# # # # #
# # # # #
# # ]
8779 : 36731 : free(ctx);
8780 : 36731 : }
8781 : :
8782 : : static void
8783 : 36539 : blob_op_cluster_msg_cb(void *arg, int bserrno)
8784 : : {
8785 : 36539 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8786 : :
8787 [ # # # # ]: 36539 : ctx->rc = bserrno;
8788 [ # # # # ]: 36539 : spdk_thread_send_msg(ctx->thread, blob_op_cluster_msg_cpl, ctx);
8789 : 36539 : }
8790 : :
8791 : : static void
8792 : 1485 : blob_insert_new_ep_cb(void *arg, int bserrno)
8793 : : {
8794 : 1485 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8795 : : uint32_t *extent_page;
8796 : :
8797 [ # # # # : 1485 : extent_page = bs_cluster_to_extent_page(ctx->blob, ctx->cluster_num);
# # # # ]
8798 [ # # # # : 1485 : *extent_page = ctx->extent_page;
# # ]
8799 [ # # # # : 1485 : ctx->blob->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
8800 [ # # # # ]: 1485 : blob_sync_md(ctx->blob, blob_op_cluster_msg_cb, ctx);
8801 : 1485 : }
8802 : :
8803 : : struct spdk_blob_write_extent_page_ctx {
8804 : : struct spdk_blob_store *bs;
8805 : :
8806 : : uint32_t extent;
8807 : : struct spdk_blob_md_page *page;
8808 : : };
8809 : :
8810 : : static void
8811 : 156 : blob_free_cluster_msg_cb(void *arg, int bserrno)
8812 : : {
8813 : 156 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8814 : :
8815 [ # # # # : 156 : spdk_spin_lock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8816 [ # # # # : 156 : bs_release_cluster(ctx->blob->bs, ctx->cluster);
# # # # #
# # # ]
8817 [ # # # # : 156 : spdk_spin_unlock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8818 : :
8819 [ # # # # ]: 156 : ctx->rc = bserrno;
8820 [ # # # # ]: 156 : spdk_thread_send_msg(ctx->thread, blob_op_cluster_msg_cpl, ctx);
8821 : 156 : }
8822 : :
8823 : : static void
8824 : 156 : blob_free_cluster_update_ep_cb(void *arg, int bserrno)
8825 : : {
8826 : 156 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8827 : :
8828 [ + - - + : 156 : if (bserrno != 0 || ctx->blob->bs->clean == 0) {
+ - # # #
# # # # #
# # # # ]
8829 : 156 : blob_free_cluster_msg_cb(ctx, bserrno);
8830 : 156 : return;
8831 : : }
8832 : :
8833 [ # # # # : 0 : ctx->blob->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
8834 [ # # # # ]: 0 : blob_sync_md(ctx->blob, blob_free_cluster_msg_cb, ctx);
8835 : 39 : }
8836 : :
8837 : : static void
8838 : 0 : blob_free_cluster_free_ep_cb(void *arg, int bserrno)
8839 : : {
8840 : 0 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8841 : :
8842 [ # # # # : 0 : spdk_spin_lock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8843 [ # # # # : 0 : assert(spdk_bit_array_get(ctx->blob->bs->used_md_pages, ctx->extent_page) == true);
# # # # #
# # # # #
# # # # #
# ]
8844 [ # # # # : 0 : bs_release_md_page(ctx->blob->bs, ctx->extent_page);
# # # # #
# # # ]
8845 [ # # # # : 0 : spdk_spin_unlock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8846 [ # # # # : 0 : ctx->blob->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
8847 [ # # # # ]: 0 : blob_sync_md(ctx->blob, blob_free_cluster_msg_cb, ctx);
8848 : 0 : }
8849 : :
8850 : : static void
8851 : 34927 : blob_persist_extent_page_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
8852 : : {
8853 : 34927 : struct spdk_blob_write_extent_page_ctx *ctx = cb_arg;
8854 : :
8855 : 34927 : free(ctx);
8856 : 34927 : bs_sequence_finish(seq, bserrno);
8857 : 34927 : }
8858 : :
8859 : : static void
8860 : 34927 : blob_write_extent_page_ready(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
8861 : : {
8862 : 34927 : struct spdk_blob_write_extent_page_ctx *ctx = cb_arg;
8863 : :
8864 [ - + ]: 34927 : if (bserrno != 0) {
8865 : 0 : blob_persist_extent_page_cpl(seq, ctx, bserrno);
8866 : 0 : return;
8867 : : }
8868 [ # # # # : 35584 : bs_sequence_write_dev(seq, ctx->page, bs_md_page_to_lba(ctx->bs, ctx->extent),
# # # # #
# # # ]
8869 [ # # # # : 34927 : bs_byte_to_lba(ctx->bs, ctx->bs->md_page_size),
# # # # #
# # # ]
8870 : 657 : blob_persist_extent_page_cpl, ctx);
8871 : 657 : }
8872 : :
8873 : : static void
8874 : 34927 : blob_write_extent_page(struct spdk_blob *blob, uint32_t extent, uint64_t cluster_num,
8875 : : struct spdk_blob_md_page *page, spdk_blob_op_complete cb_fn, void *cb_arg)
8876 : : {
8877 : : struct spdk_blob_write_extent_page_ctx *ctx;
8878 : : spdk_bs_sequence_t *seq;
8879 : 34270 : struct spdk_bs_cpl cpl;
8880 : :
8881 : 34927 : ctx = calloc(1, sizeof(*ctx));
8882 [ + + ]: 34927 : if (!ctx) {
8883 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
8884 : 0 : return;
8885 : : }
8886 [ # # # # : 34927 : ctx->bs = blob->bs;
# # # # ]
8887 [ # # # # ]: 34927 : ctx->extent = extent;
8888 [ # # # # ]: 34927 : ctx->page = page;
8889 : :
8890 : 34927 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
8891 [ # # # # : 34927 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
8892 [ # # # # : 34927 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
8893 : :
8894 [ # # # # : 34927 : seq = bs_sequence_start_bs(blob->bs->md_channel, &cpl);
# # # # ]
8895 [ + + ]: 34927 : if (!seq) {
8896 : 0 : free(ctx);
8897 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
8898 : 0 : return;
8899 : : }
8900 : :
8901 [ + + # # ]: 34927 : assert(page);
8902 [ # # # # ]: 34927 : page->next = SPDK_INVALID_MD_PAGE;
8903 [ # # # # : 34927 : page->id = blob->id;
# # # # ]
8904 [ # # # # ]: 34927 : page->sequence_num = 0;
8905 : :
8906 : 34927 : blob_serialize_extent_page(blob, cluster_num, page);
8907 : :
8908 [ # # # # ]: 34927 : page->crc = blob_md_page_calc_crc(page);
8909 : :
8910 [ - + # # : 34927 : assert(spdk_bit_array_get(blob->bs->used_md_pages, extent) == true);
# # # # #
# # # ]
8911 : :
8912 [ # # # # ]: 34927 : bs_mark_dirty(seq, blob->bs, blob_write_extent_page_ready, ctx);
8913 : 657 : }
8914 : :
8915 : : static void
8916 : 36431 : blob_insert_cluster_msg(void *arg)
8917 : : {
8918 : 36431 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8919 : : uint32_t *extent_page;
8920 : :
8921 [ # # # # : 36431 : ctx->rc = blob_insert_cluster(ctx->blob, ctx->cluster_num, ctx->cluster);
# # # # #
# # # # #
# # ]
8922 [ + + # # : 36431 : if (ctx->rc != 0) {
# # ]
8923 [ # # # # ]: 36 : spdk_thread_send_msg(ctx->thread, blob_op_cluster_msg_cpl, ctx);
8924 : 36 : return;
8925 : : }
8926 : :
8927 [ + + + + : 36395 : if (ctx->blob->use_extent_table == false) {
# # # # #
# # # ]
8928 : : /* Extent table is not used, proceed with sync of md that will only use extents_rle. */
8929 [ # # # # : 1640 : ctx->blob->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
8930 [ # # # # ]: 1640 : blob_sync_md(ctx->blob, blob_op_cluster_msg_cb, ctx);
8931 : 1640 : return;
8932 : : }
8933 : :
8934 [ # # # # : 34755 : extent_page = bs_cluster_to_extent_page(ctx->blob, ctx->cluster_num);
# # # # ]
8935 [ + + # # ]: 34755 : if (*extent_page == 0) {
8936 : : /* Extent page requires allocation.
8937 : : * It was already claimed in the used_md_pages map and placed in ctx. */
8938 [ + + # # : 1485 : assert(ctx->extent_page != 0);
# # # # ]
8939 [ - + # # : 1485 : assert(spdk_bit_array_get(ctx->blob->bs->used_md_pages, ctx->extent_page) == true);
# # # # #
# # # # #
# # # # #
# ]
8940 [ # # # # : 1611 : blob_write_extent_page(ctx->blob, ctx->extent_page, ctx->cluster_num, ctx->page,
# # # # #
# # # # #
# # ]
8941 : 126 : blob_insert_new_ep_cb, ctx);
8942 : 126 : } else {
8943 : : /* It is possible for original thread to allocate extent page for
8944 : : * different cluster in the same extent page. In such case proceed with
8945 : : * updating the existing extent page, but release the additional one. */
8946 [ + + # # : 33270 : if (ctx->extent_page != 0) {
# # ]
8947 [ # # # # : 5 : spdk_spin_lock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8948 [ - + # # : 5 : assert(spdk_bit_array_get(ctx->blob->bs->used_md_pages, ctx->extent_page) == true);
# # # # #
# # # # #
# # # # #
# ]
8949 [ # # # # : 5 : bs_release_md_page(ctx->blob->bs, ctx->extent_page);
# # # # #
# # # ]
8950 [ # # # # : 5 : spdk_spin_unlock(&ctx->blob->bs->used_lock);
# # # # #
# ]
8951 [ # # # # ]: 5 : ctx->extent_page = 0;
8952 : 0 : }
8953 : : /* Extent page already allocated.
8954 : : * Every cluster allocation, requires just an update of single extent page. */
8955 [ # # # # : 33759 : blob_write_extent_page(ctx->blob, *extent_page, ctx->cluster_num, ctx->page,
# # # # #
# # # #
# ]
8956 : 489 : blob_op_cluster_msg_cb, ctx);
8957 : : }
8958 : 1030 : }
8959 : :
8960 : : static void
8961 : 36431 : blob_insert_cluster_on_md_thread(struct spdk_blob *blob, uint32_t cluster_num,
8962 : : uint64_t cluster, uint32_t extent_page, struct spdk_blob_md_page *page,
8963 : : spdk_blob_op_complete cb_fn, void *cb_arg)
8964 : : {
8965 : : struct spdk_blob_cluster_op_ctx *ctx;
8966 : :
8967 : 36431 : ctx = calloc(1, sizeof(*ctx));
8968 [ - + ]: 36431 : if (ctx == NULL) {
8969 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
8970 : 0 : return;
8971 : : }
8972 : :
8973 [ # # # # ]: 36431 : ctx->thread = spdk_get_thread();
8974 [ # # # # ]: 36431 : ctx->blob = blob;
8975 [ # # # # ]: 36431 : ctx->cluster_num = cluster_num;
8976 [ # # # # ]: 36431 : ctx->cluster = cluster;
8977 [ # # # # ]: 36431 : ctx->extent_page = extent_page;
8978 [ # # # # ]: 36431 : ctx->page = page;
8979 [ # # # # ]: 36431 : ctx->cb_fn = cb_fn;
8980 [ # # # # ]: 36431 : ctx->cb_arg = cb_arg;
8981 : :
8982 [ # # # # : 36431 : spdk_thread_send_msg(blob->bs->md_thread, blob_insert_cluster_msg, ctx);
# # # # ]
8983 : 1030 : }
8984 : :
8985 : : static void
8986 : 300 : blob_free_cluster_msg(void *arg)
8987 : : {
8988 : 300 : struct spdk_blob_cluster_op_ctx *ctx = arg;
8989 : : uint32_t *extent_page;
8990 : : uint32_t start_cluster_idx;
8991 : 300 : bool free_extent_page = true;
8992 : : size_t i;
8993 : :
8994 [ # # # # : 300 : ctx->cluster = bs_lba_to_cluster(ctx->blob->bs, ctx->blob->active.clusters[ctx->cluster_num]);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
8995 : :
8996 : : /* There were concurrent unmaps to the same cluster, only release the cluster on the first one */
8997 [ + + # # : 300 : if (ctx->cluster == 0) {
# # ]
8998 : 40 : blob_op_cluster_msg_cb(ctx, 0);
8999 : 40 : return;
9000 : : }
9001 : :
9002 [ # # # # : 260 : ctx->blob->active.clusters[ctx->cluster_num] = 0;
# # # # #
# # # # #
# # # # ]
9003 [ + - # # : 260 : if (ctx->cluster != 0) {
# # ]
9004 [ # # # # : 260 : ctx->blob->active.num_allocated_clusters--;
# # # # ]
9005 : 65 : }
9006 : :
9007 [ + + + + : 260 : if (ctx->blob->use_extent_table == false) {
# # # # #
# # # ]
9008 : : /* Extent table is not used, proceed with sync of md that will only use extents_rle. */
9009 [ # # # # : 104 : spdk_spin_lock(&ctx->blob->bs->used_lock);
# # # # #
# ]
9010 [ # # # # : 104 : bs_release_cluster(ctx->blob->bs, ctx->cluster);
# # # # #
# # # ]
9011 [ # # # # : 104 : spdk_spin_unlock(&ctx->blob->bs->used_lock);
# # # # #
# ]
9012 [ # # # # : 104 : ctx->blob->state = SPDK_BLOB_STATE_DIRTY;
# # # # ]
9013 [ # # # # ]: 104 : blob_sync_md(ctx->blob, blob_op_cluster_msg_cb, ctx);
9014 : 104 : return;
9015 : : }
9016 : :
9017 [ # # # # : 156 : extent_page = bs_cluster_to_extent_page(ctx->blob, ctx->cluster_num);
# # # # ]
9018 : :
9019 : : /* There shouldn't be parallel release operations on same cluster */
9020 [ + + # # : 156 : assert(*extent_page == ctx->extent_page);
# # # # #
# ]
9021 : :
9022 [ - + # # : 156 : start_cluster_idx = (ctx->cluster_num / SPDK_EXTENTS_PER_EP) * SPDK_EXTENTS_PER_EP;
# # # # #
# ]
9023 [ + + # # ]: 288 : for (i = 0; i < SPDK_EXTENTS_PER_EP; ++i) {
9024 [ + + # # : 288 : if (ctx->blob->active.clusters[start_cluster_idx + i] != 0) {
# # # # #
# # # # #
# # ]
9025 : 156 : free_extent_page = false;
9026 : 156 : break;
9027 : : }
9028 : 33 : }
9029 : :
9030 [ - + # # ]: 156 : if (free_extent_page) {
9031 [ # # # # : 0 : assert(ctx->extent_page != 0);
# # # # ]
9032 [ # # # # : 0 : assert(spdk_bit_array_get(ctx->blob->bs->used_md_pages, ctx->extent_page) == true);
# # # # #
# # # # #
# # # # #
# ]
9033 [ # # # # : 0 : ctx->blob->active.extent_pages[bs_cluster_to_extent_table_id(ctx->cluster_num)] = 0;
# # # # #
# # # # #
# # # # ]
9034 [ # # # # : 0 : blob_write_extent_page(ctx->blob, ctx->extent_page, ctx->cluster_num, ctx->page,
# # # # #
# # # # #
# # ]
9035 : 0 : blob_free_cluster_free_ep_cb, ctx);
9036 : 0 : } else {
9037 [ # # # # : 195 : blob_write_extent_page(ctx->blob, *extent_page, ctx->cluster_num, ctx->page,
# # # # #
# # # #
# ]
9038 : 39 : blob_free_cluster_update_ep_cb, ctx);
9039 : : }
9040 : 75 : }
9041 : :
9042 : :
9043 : : static void
9044 : 300 : blob_free_cluster_on_md_thread(struct spdk_blob *blob, uint32_t cluster_num, uint32_t extent_page,
9045 : : struct spdk_blob_md_page *page, spdk_blob_op_complete cb_fn, void *cb_arg)
9046 : : {
9047 : : struct spdk_blob_cluster_op_ctx *ctx;
9048 : :
9049 : 300 : ctx = calloc(1, sizeof(*ctx));
9050 [ - + ]: 300 : if (ctx == NULL) {
9051 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
9052 : 0 : return;
9053 : : }
9054 : :
9055 [ # # # # ]: 300 : ctx->thread = spdk_get_thread();
9056 [ # # # # ]: 300 : ctx->blob = blob;
9057 [ # # # # ]: 300 : ctx->cluster_num = cluster_num;
9058 [ # # # # ]: 300 : ctx->extent_page = extent_page;
9059 [ # # # # ]: 300 : ctx->page = page;
9060 [ # # # # ]: 300 : ctx->cb_fn = cb_fn;
9061 [ # # # # ]: 300 : ctx->cb_arg = cb_arg;
9062 : :
9063 [ # # # # : 300 : spdk_thread_send_msg(blob->bs->md_thread, blob_free_cluster_msg, ctx);
# # # # ]
9064 : 75 : }
9065 : :
9066 : : /* START spdk_blob_close */
9067 : :
9068 : : static void
9069 : 39735 : blob_close_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9070 : : {
9071 : 39735 : struct spdk_blob *blob = cb_arg;
9072 : :
9073 [ + + ]: 39735 : if (bserrno == 0) {
9074 [ # # ]: 39735 : blob->open_ref--;
9075 [ + + # # : 39735 : if (blob->open_ref == 0) {
# # ]
9076 : : /*
9077 : : * Blobs with active.num_pages == 0 are deleted blobs.
9078 : : * these blobs are removed from the blob_store list
9079 : : * when the deletion process starts - so don't try to
9080 : : * remove them again.
9081 : : */
9082 [ + + # # : 35642 : if (blob->active.num_pages > 0) {
# # # # ]
9083 [ # # # # : 27040 : spdk_bit_array_clear(blob->bs->open_blobids, blob->id);
# # # # #
# # # ]
9084 [ # # # # : 27040 : RB_REMOVE(spdk_blob_tree, &blob->bs->open_blobs, blob);
# # ]
9085 : 2417 : }
9086 : 35642 : blob_free(blob);
9087 : 4284 : }
9088 : 5250 : }
9089 : :
9090 : 39735 : bs_sequence_finish(seq, bserrno);
9091 : 39735 : }
9092 : :
9093 : : static void
9094 : 638 : blob_close_esnap_done(void *cb_arg, struct spdk_blob *blob, int bserrno)
9095 : : {
9096 : 638 : spdk_bs_sequence_t *seq = cb_arg;
9097 : :
9098 [ + + ]: 638 : if (bserrno != 0) {
9099 [ # # # # : 0 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": close failed with error %d\n",
# # # # #
# ]
9100 : : blob->id, bserrno);
9101 : 0 : bs_sequence_finish(seq, bserrno);
9102 : 0 : return;
9103 : : }
9104 : :
9105 [ + + - + : 638 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": closed, syncing metadata on thread %s\n",
# # # # #
# ]
9106 : : blob->id, spdk_thread_get_name(spdk_get_thread()));
9107 : :
9108 : : /* Sync metadata */
9109 : 638 : blob_persist(seq, blob, blob_close_cpl, blob);
9110 : 140 : }
9111 : :
9112 : : void
9113 : 39735 : spdk_blob_close(struct spdk_blob *blob, spdk_blob_op_complete cb_fn, void *cb_arg)
9114 : : {
9115 : 34485 : struct spdk_bs_cpl cpl;
9116 : : spdk_bs_sequence_t *seq;
9117 : :
9118 : 39735 : blob_verify_md_op(blob);
9119 : :
9120 [ + + - + : 39735 : SPDK_DEBUGLOG(blob, "Closing blob 0x%" PRIx64 "\n", blob->id);
# # # # #
# ]
9121 : :
9122 [ + + # # : 39735 : if (blob->open_ref == 0) {
# # ]
9123 [ # # # # ]: 0 : cb_fn(cb_arg, -EBADF);
9124 : 0 : return;
9125 : : }
9126 : :
9127 : 39735 : cpl.type = SPDK_BS_CPL_TYPE_BLOB_BASIC;
9128 [ # # # # : 39735 : cpl.u.blob_basic.cb_fn = cb_fn;
# # ]
9129 [ # # # # : 39735 : cpl.u.blob_basic.cb_arg = cb_arg;
# # ]
9130 : :
9131 [ # # # # : 39735 : seq = bs_sequence_start_bs(blob->bs->md_channel, &cpl);
# # # # ]
9132 [ + + ]: 39735 : if (!seq) {
9133 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
9134 : 0 : return;
9135 : : }
9136 : :
9137 [ + + + + : 39735 : if (blob->open_ref == 1 && blob_is_esnap_clone(blob)) {
# # # # ]
9138 : 638 : blob_esnap_destroy_bs_dev_channels(blob, false, blob_close_esnap_done, seq);
9139 : 638 : return;
9140 : : }
9141 : :
9142 : : /* Sync metadata */
9143 : 39097 : blob_persist(seq, blob, blob_close_cpl, blob);
9144 : 5250 : }
9145 : :
9146 : : /* END spdk_blob_close */
9147 : :
9148 : 2438 : struct spdk_io_channel *spdk_bs_alloc_io_channel(struct spdk_blob_store *bs)
9149 : : {
9150 : 2438 : return spdk_get_io_channel(bs);
9151 : : }
9152 : :
9153 : : void
9154 : 1152 : spdk_bs_free_io_channel(struct spdk_io_channel *channel)
9155 : : {
9156 : 1152 : blob_esnap_destroy_bs_channel(spdk_io_channel_get_ctx(channel));
9157 : 1152 : spdk_put_io_channel(channel);
9158 : 1152 : }
9159 : :
9160 : : void
9161 : 213085 : spdk_blob_io_unmap(struct spdk_blob *blob, struct spdk_io_channel *channel,
9162 : : uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg)
9163 : : {
9164 : 213085 : blob_request_submit_op(blob, channel, NULL, offset, length, cb_fn, cb_arg,
9165 : : SPDK_BLOB_UNMAP);
9166 : 213085 : }
9167 : :
9168 : : void
9169 : 2472 : spdk_blob_io_write_zeroes(struct spdk_blob *blob, struct spdk_io_channel *channel,
9170 : : uint64_t offset, uint64_t length, spdk_blob_op_complete cb_fn, void *cb_arg)
9171 : : {
9172 : 2472 : blob_request_submit_op(blob, channel, NULL, offset, length, cb_fn, cb_arg,
9173 : : SPDK_BLOB_WRITE_ZEROES);
9174 : 2472 : }
9175 : :
9176 : : void
9177 : 806543 : spdk_blob_io_write(struct spdk_blob *blob, struct spdk_io_channel *channel,
9178 : : void *payload, uint64_t offset, uint64_t length,
9179 : : spdk_blob_op_complete cb_fn, void *cb_arg)
9180 : : {
9181 : 806543 : blob_request_submit_op(blob, channel, payload, offset, length, cb_fn, cb_arg,
9182 : : SPDK_BLOB_WRITE);
9183 : 806543 : }
9184 : :
9185 : : void
9186 : 4110743 : spdk_blob_io_read(struct spdk_blob *blob, struct spdk_io_channel *channel,
9187 : : void *payload, uint64_t offset, uint64_t length,
9188 : : spdk_blob_op_complete cb_fn, void *cb_arg)
9189 : : {
9190 : 4110743 : blob_request_submit_op(blob, channel, payload, offset, length, cb_fn, cb_arg,
9191 : : SPDK_BLOB_READ);
9192 : 4110743 : }
9193 : :
9194 : : void
9195 : 700 : spdk_blob_io_writev(struct spdk_blob *blob, struct spdk_io_channel *channel,
9196 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
9197 : : spdk_blob_op_complete cb_fn, void *cb_arg)
9198 : : {
9199 : 700 : blob_request_submit_rw_iov(blob, channel, iov, iovcnt, offset, length, cb_fn, cb_arg, false, NULL);
9200 : 700 : }
9201 : :
9202 : : void
9203 : 6620 : spdk_blob_io_readv(struct spdk_blob *blob, struct spdk_io_channel *channel,
9204 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
9205 : : spdk_blob_op_complete cb_fn, void *cb_arg)
9206 : : {
9207 : 6620 : blob_request_submit_rw_iov(blob, channel, iov, iovcnt, offset, length, cb_fn, cb_arg, true, NULL);
9208 : 6620 : }
9209 : :
9210 : : void
9211 : 9856276 : spdk_blob_io_writev_ext(struct spdk_blob *blob, struct spdk_io_channel *channel,
9212 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
9213 : : spdk_blob_op_complete cb_fn, void *cb_arg, struct spdk_blob_ext_io_opts *io_opts)
9214 : : {
9215 : 9856536 : blob_request_submit_rw_iov(blob, channel, iov, iovcnt, offset, length, cb_fn, cb_arg, false,
9216 : 260 : io_opts);
9217 : 9856276 : }
9218 : :
9219 : : void
9220 : 8418911 : spdk_blob_io_readv_ext(struct spdk_blob *blob, struct spdk_io_channel *channel,
9221 : : struct iovec *iov, int iovcnt, uint64_t offset, uint64_t length,
9222 : : spdk_blob_op_complete cb_fn, void *cb_arg, struct spdk_blob_ext_io_opts *io_opts)
9223 : : {
9224 : 8421049 : blob_request_submit_rw_iov(blob, channel, iov, iovcnt, offset, length, cb_fn, cb_arg, true,
9225 : 2138 : io_opts);
9226 : 8418911 : }
9227 : :
9228 : : struct spdk_bs_iter_ctx {
9229 : : int64_t page_num;
9230 : : struct spdk_blob_store *bs;
9231 : :
9232 : : spdk_blob_op_with_handle_complete cb_fn;
9233 : : void *cb_arg;
9234 : : };
9235 : :
9236 : : static void
9237 : 19969 : bs_iter_cpl(void *cb_arg, struct spdk_blob *_blob, int bserrno)
9238 : : {
9239 : 19969 : struct spdk_bs_iter_ctx *ctx = cb_arg;
9240 [ # # # # ]: 19969 : struct spdk_blob_store *bs = ctx->bs;
9241 : : spdk_blob_id id;
9242 : :
9243 [ + + ]: 19969 : if (bserrno == 0) {
9244 [ # # # # : 9205 : ctx->cb_fn(ctx->cb_arg, _blob, bserrno);
# # # # #
# # # ]
9245 : 9205 : free(ctx);
9246 : 9205 : return;
9247 : : }
9248 : :
9249 [ # # # # ]: 10764 : ctx->page_num++;
9250 [ # # # # : 10764 : ctx->page_num = spdk_bit_array_find_first_set(bs->used_blobids, ctx->page_num);
# # # # #
# # # ]
9251 [ + + # # : 10764 : if (ctx->page_num >= spdk_bit_array_capacity(bs->used_blobids)) {
# # # # #
# ]
9252 [ # # # # : 1519 : ctx->cb_fn(ctx->cb_arg, NULL, -ENOENT);
# # # # #
# # # ]
9253 : 1519 : free(ctx);
9254 : 1519 : return;
9255 : : }
9256 : :
9257 [ # # # # ]: 9245 : id = bs_page_to_blobid(ctx->page_num);
9258 : :
9259 : 9245 : spdk_bs_open_blob(bs, id, bs_iter_cpl, ctx);
9260 : 1482 : }
9261 : :
9262 : : void
9263 : 1639 : spdk_bs_iter_first(struct spdk_blob_store *bs,
9264 : : spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
9265 : : {
9266 : : struct spdk_bs_iter_ctx *ctx;
9267 : :
9268 : 1639 : ctx = calloc(1, sizeof(*ctx));
9269 [ - + ]: 1639 : if (!ctx) {
9270 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
9271 : 0 : return;
9272 : : }
9273 : :
9274 [ # # # # ]: 1639 : ctx->page_num = -1;
9275 [ # # # # ]: 1639 : ctx->bs = bs;
9276 [ # # # # ]: 1639 : ctx->cb_fn = cb_fn;
9277 [ # # # # ]: 1639 : ctx->cb_arg = cb_arg;
9278 : :
9279 : 1639 : bs_iter_cpl(ctx, NULL, -1);
9280 : 368 : }
9281 : :
9282 : : static void
9283 : 9085 : bs_iter_close_cpl(void *cb_arg, int bserrno)
9284 : : {
9285 : 9085 : struct spdk_bs_iter_ctx *ctx = cb_arg;
9286 : :
9287 : 9085 : bs_iter_cpl(ctx, NULL, -1);
9288 : 9085 : }
9289 : :
9290 : : void
9291 : 9085 : spdk_bs_iter_next(struct spdk_blob_store *bs, struct spdk_blob *blob,
9292 : : spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
9293 : : {
9294 : : struct spdk_bs_iter_ctx *ctx;
9295 : :
9296 [ + + # # ]: 9085 : assert(blob != NULL);
9297 : :
9298 : 9085 : ctx = calloc(1, sizeof(*ctx));
9299 [ + + ]: 9085 : if (!ctx) {
9300 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
9301 : 0 : return;
9302 : : }
9303 : :
9304 [ # # # # : 9085 : ctx->page_num = bs_blobid_to_page(blob->id);
# # # # ]
9305 [ # # # # ]: 9085 : ctx->bs = bs;
9306 [ # # # # ]: 9085 : ctx->cb_fn = cb_fn;
9307 [ # # # # ]: 9085 : ctx->cb_arg = cb_arg;
9308 : :
9309 : : /* Close the existing blob */
9310 : 9085 : spdk_blob_close(blob, bs_iter_close_cpl, ctx);
9311 : 537 : }
9312 : :
9313 : : static int
9314 : 54713 : blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value,
9315 : : uint16_t value_len, bool internal)
9316 : : {
9317 : : struct spdk_xattr_tailq *xattrs;
9318 : : struct spdk_xattr *xattr;
9319 : : size_t desc_size;
9320 : : void *tmp;
9321 : :
9322 : 54713 : blob_verify_md_op(blob);
9323 : :
9324 [ + + + + : 54713 : if (blob->md_ro) {
# # # # ]
9325 : 20 : return -EPERM;
9326 : : }
9327 : :
9328 [ - + ]: 54693 : desc_size = sizeof(struct spdk_blob_md_descriptor_xattr) + strlen(name) + value_len;
9329 [ + + ]: 54693 : if (desc_size > SPDK_BS_MAX_DESC_SIZE) {
9330 [ + + - + : 20 : SPDK_DEBUGLOG(blob, "Xattr '%s' of size %zu does not fix into single page %zu\n", name,
# # ]
9331 : : desc_size, SPDK_BS_MAX_DESC_SIZE);
9332 : 20 : return -ENOMEM;
9333 : : }
9334 : :
9335 [ + + # # ]: 54673 : if (internal) {
9336 [ # # ]: 3812 : xattrs = &blob->xattrs_internal;
9337 [ # # # # : 3812 : blob->invalid_flags |= SPDK_BLOB_INTERNAL_XATTR;
# # ]
9338 : 920 : } else {
9339 [ # # ]: 50861 : xattrs = &blob->xattrs;
9340 : : }
9341 : :
9342 [ + + # # : 102773 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
9343 [ + + - + : 92816 : if (!strcmp(name, xattr->name)) {
+ + # # #
# ]
9344 : 44716 : tmp = malloc(value_len);
9345 [ + + ]: 44716 : if (!tmp) {
9346 : 0 : return -ENOMEM;
9347 : : }
9348 : :
9349 [ # # # # ]: 44716 : free(xattr->value);
9350 [ # # # # ]: 44716 : xattr->value_len = value_len;
9351 [ # # # # ]: 44716 : xattr->value = tmp;
9352 [ - + - + : 44716 : memcpy(xattr->value, value, value_len);
# # # # ]
9353 : :
9354 [ # # # # ]: 44716 : blob->state = SPDK_BLOB_STATE_DIRTY;
9355 : :
9356 : 44716 : return 0;
9357 : : }
9358 : 275 : }
9359 : :
9360 : 9957 : xattr = calloc(1, sizeof(*xattr));
9361 [ + + ]: 9957 : if (!xattr) {
9362 : 0 : return -ENOMEM;
9363 : : }
9364 : :
9365 [ - + # # : 9957 : xattr->name = strdup(name);
# # ]
9366 [ + + # # : 9957 : if (!xattr->name) {
# # ]
9367 : 0 : free(xattr);
9368 : 0 : return -ENOMEM;
9369 : : }
9370 : :
9371 [ # # # # ]: 9957 : xattr->value_len = value_len;
9372 [ # # # # ]: 9957 : xattr->value = malloc(value_len);
9373 [ - + # # : 9957 : if (!xattr->value) {
# # ]
9374 [ # # # # ]: 0 : free(xattr->name);
9375 : 0 : free(xattr);
9376 : 0 : return -ENOMEM;
9377 : : }
9378 [ - + - + : 9957 : memcpy(xattr->value, value, value_len);
# # # # ]
9379 [ # # # # : 9957 : TAILQ_INSERT_TAIL(xattrs, xattr, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
9380 : :
9381 [ # # # # ]: 9957 : blob->state = SPDK_BLOB_STATE_DIRTY;
9382 : :
9383 : 9957 : return 0;
9384 : 1191 : }
9385 : :
9386 : : int
9387 : 49597 : spdk_blob_set_xattr(struct spdk_blob *blob, const char *name, const void *value,
9388 : : uint16_t value_len)
9389 : : {
9390 : 49597 : return blob_set_xattr(blob, name, value, value_len, false);
9391 : : }
9392 : :
9393 : : static int
9394 : 2110 : blob_remove_xattr(struct spdk_blob *blob, const char *name, bool internal)
9395 : : {
9396 : : struct spdk_xattr_tailq *xattrs;
9397 : : struct spdk_xattr *xattr;
9398 : :
9399 : 2110 : blob_verify_md_op(blob);
9400 : :
9401 [ + + + + : 2110 : if (blob->md_ro) {
# # # # ]
9402 : 20 : return -EPERM;
9403 : : }
9404 [ + + # # : 2090 : xattrs = internal ? &blob->xattrs_internal : &blob->xattrs;
# # # # ]
9405 : :
9406 [ + + # # : 2151 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
9407 [ + + - + : 1883 : if (!strcmp(name, xattr->name)) {
+ + # # #
# ]
9408 [ + + # # : 1822 : TAILQ_REMOVE(xattrs, xattr, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
9409 [ # # # # ]: 1822 : free(xattr->value);
9410 [ # # # # ]: 1822 : free(xattr->name);
9411 : 1822 : free(xattr);
9412 : :
9413 [ + + + + : 1822 : if (internal && TAILQ_EMPTY(&blob->xattrs_internal)) {
# # # # #
# # # ]
9414 [ # # # # : 1267 : blob->invalid_flags &= ~SPDK_BLOB_INTERNAL_XATTR;
# # ]
9415 : 307 : }
9416 [ # # # # ]: 1822 : blob->state = SPDK_BLOB_STATE_DIRTY;
9417 : :
9418 : 1822 : return 0;
9419 : : }
9420 : 15 : }
9421 : :
9422 : 268 : return -ENOENT;
9423 : 512 : }
9424 : :
9425 : : int
9426 : 181 : spdk_blob_remove_xattr(struct spdk_blob *blob, const char *name)
9427 : : {
9428 : 181 : return blob_remove_xattr(blob, name, false);
9429 : : }
9430 : :
9431 : : static int
9432 : 41551 : blob_get_xattr_value(struct spdk_blob *blob, const char *name,
9433 : : const void **value, size_t *value_len, bool internal)
9434 : : {
9435 : : struct spdk_xattr *xattr;
9436 : : struct spdk_xattr_tailq *xattrs;
9437 : :
9438 [ + + # # : 41551 : xattrs = internal ? &blob->xattrs_internal : &blob->xattrs;
# # # # ]
9439 : :
9440 [ + + # # : 60637 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
9441 [ + + - + : 33934 : if (!strcmp(name, xattr->name)) {
+ + # # #
# ]
9442 [ # # # # : 14848 : *value = xattr->value;
# # ]
9443 [ # # # # : 14848 : *value_len = xattr->value_len;
# # ]
9444 : 14848 : return 0;
9445 : : }
9446 : 794 : }
9447 : 26703 : return -ENOENT;
9448 : 2888 : }
9449 : :
9450 : : int
9451 : 16789 : spdk_blob_get_xattr_value(struct spdk_blob *blob, const char *name,
9452 : : const void **value, size_t *value_len)
9453 : : {
9454 : 16789 : blob_verify_md_op(blob);
9455 : :
9456 : 16789 : return blob_get_xattr_value(blob, name, value, value_len, false);
9457 : : }
9458 : :
9459 : : struct spdk_xattr_names {
9460 : : uint32_t count;
9461 : : const char *names[0];
9462 : : };
9463 : :
9464 : : static int
9465 : 21 : blob_get_xattr_names(struct spdk_xattr_tailq *xattrs, struct spdk_xattr_names **names)
9466 : : {
9467 : : struct spdk_xattr *xattr;
9468 : 21 : int count = 0;
9469 : :
9470 [ + + # # : 62 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
9471 [ # # ]: 41 : count++;
9472 : 10 : }
9473 : :
9474 [ # # ]: 21 : *names = calloc(1, sizeof(struct spdk_xattr_names) + count * sizeof(char *));
9475 [ - + # # ]: 21 : if (*names == NULL) {
9476 : 0 : return -ENOMEM;
9477 : : }
9478 : :
9479 [ + + # # : 62 : TAILQ_FOREACH(xattr, xattrs, link) {
# # # # #
# # # ]
9480 [ # # # # : 41 : (*names)->names[(*names)->count++] = xattr->name;
# # # # #
# # # # #
# # ]
9481 : 10 : }
9482 : :
9483 : 21 : return 0;
9484 : 5 : }
9485 : :
9486 : : int
9487 : 21 : spdk_blob_get_xattr_names(struct spdk_blob *blob, struct spdk_xattr_names **names)
9488 : : {
9489 : 21 : blob_verify_md_op(blob);
9490 : :
9491 [ # # ]: 21 : return blob_get_xattr_names(&blob->xattrs, names);
9492 : : }
9493 : :
9494 : : uint32_t
9495 : 23 : spdk_xattr_names_get_count(struct spdk_xattr_names *names)
9496 : : {
9497 [ + + # # ]: 23 : assert(names != NULL);
9498 : :
9499 [ # # # # ]: 23 : return names->count;
9500 : : }
9501 : :
9502 : : const char *
9503 : 42 : spdk_xattr_names_get_name(struct spdk_xattr_names *names, uint32_t index)
9504 : : {
9505 [ - + # # : 42 : if (index >= names->count) {
# # ]
9506 : 0 : return NULL;
9507 : : }
9508 : :
9509 [ # # # # : 42 : return names->names[index];
# # ]
9510 : 10 : }
9511 : :
9512 : : void
9513 : 21 : spdk_xattr_names_free(struct spdk_xattr_names *names)
9514 : : {
9515 : 21 : free(names);
9516 : 21 : }
9517 : :
9518 : : struct spdk_bs_type
9519 : 19 : spdk_bs_get_bstype(struct spdk_blob_store *bs)
9520 : : {
9521 [ # # ]: 19 : return bs->bstype;
9522 : : }
9523 : :
9524 : : void
9525 : 0 : spdk_bs_set_bstype(struct spdk_blob_store *bs, struct spdk_bs_type bstype)
9526 : : {
9527 [ # # # # : 0 : memcpy(&bs->bstype, &bstype, sizeof(bstype));
# # ]
9528 : 0 : }
9529 : :
9530 : : bool
9531 : 16212 : spdk_blob_is_read_only(struct spdk_blob *blob)
9532 : : {
9533 [ + + # # ]: 16212 : assert(blob != NULL);
9534 [ + + + + : 16212 : return (blob->data_ro || blob->md_ro);
- + - + #
# # # #
# ]
9535 : : }
9536 : :
9537 : : bool
9538 : 2887 : spdk_blob_is_snapshot(struct spdk_blob *blob)
9539 : : {
9540 : : struct spdk_blob_list *snapshot_entry;
9541 : :
9542 [ + + # # ]: 2887 : assert(blob != NULL);
9543 : :
9544 [ # # # # : 2887 : snapshot_entry = bs_get_snapshot_entry(blob->bs, blob->id);
# # # # ]
9545 [ + + ]: 2887 : if (snapshot_entry == NULL) {
9546 : 2686 : return false;
9547 : : }
9548 : :
9549 : 201 : return true;
9550 : 73 : }
9551 : :
9552 : : bool
9553 : 2967 : spdk_blob_is_clone(struct spdk_blob *blob)
9554 : : {
9555 [ + + # # ]: 2967 : assert(blob != NULL);
9556 : :
9557 [ + + + + : 2967 : if (blob->parent_id != SPDK_BLOBID_INVALID &&
# # # # ]
9558 [ + + # # ]: 428 : blob->parent_id != SPDK_BLOBID_EXTERNAL_SNAPSHOT) {
9559 [ - + # # ]: 308 : assert(spdk_blob_is_thin_provisioned(blob));
9560 : 308 : return true;
9561 : : }
9562 : :
9563 : 2659 : return false;
9564 : 93 : }
9565 : :
9566 : : bool
9567 : 2615408 : spdk_blob_is_thin_provisioned(struct spdk_blob *blob)
9568 : : {
9569 [ + + # # ]: 2615408 : assert(blob != NULL);
9570 [ # # # # : 2615408 : return !!(blob->invalid_flags & SPDK_BLOB_THIN_PROV);
# # ]
9571 : : }
9572 : :
9573 : : bool
9574 : 23314439 : spdk_blob_is_esnap_clone(const struct spdk_blob *blob)
9575 : : {
9576 : 23314439 : return blob_is_esnap_clone(blob);
9577 : : }
9578 : :
9579 : : static void
9580 : 35805 : blob_update_clear_method(struct spdk_blob *blob)
9581 : : {
9582 : : enum blob_clear_method stored_cm;
9583 : :
9584 [ + + # # ]: 35805 : assert(blob != NULL);
9585 : :
9586 : : /* If BLOB_CLEAR_WITH_DEFAULT was passed in, use the setting stored
9587 : : * in metadata previously. If something other than the default was
9588 : : * specified, ignore stored value and used what was passed in.
9589 : : */
9590 [ # # # # : 35805 : stored_cm = ((blob->md_ro_flags & SPDK_BLOB_CLEAR_METHOD) >> SPDK_BLOB_CLEAR_METHOD_SHIFT);
# # # # ]
9591 : :
9592 [ + + # # : 35805 : if (blob->clear_method == BLOB_CLEAR_WITH_DEFAULT) {
# # ]
9593 [ # # # # ]: 35802 : blob->clear_method = stored_cm;
9594 [ - + # # : 4326 : } else if (blob->clear_method != stored_cm) {
# # ]
9595 [ # # # # ]: 0 : SPDK_WARNLOG("Using passed in clear method 0x%x instead of stored value of 0x%x\n",
9596 : : blob->clear_method, stored_cm);
9597 : 0 : }
9598 : 35805 : }
9599 : :
9600 : : spdk_blob_id
9601 : 1352 : spdk_blob_get_parent_snapshot(struct spdk_blob_store *bs, spdk_blob_id blob_id)
9602 : : {
9603 : 1352 : struct spdk_blob_list *snapshot_entry = NULL;
9604 : 1352 : struct spdk_blob_list *clone_entry = NULL;
9605 : :
9606 [ + + # # : 2538 : TAILQ_FOREACH(snapshot_entry, &bs->snapshots, link) {
# # # # #
# # # #
# ]
9607 [ + + # # : 3750 : TAILQ_FOREACH(clone_entry, &snapshot_entry->clones, link) {
# # # # #
# # # #
# ]
9608 [ + + # # : 2564 : if (clone_entry->id == blob_id) {
# # ]
9609 [ # # # # ]: 897 : return snapshot_entry->id;
9610 : : }
9611 : 411 : }
9612 : 295 : }
9613 : :
9614 : 455 : return SPDK_BLOBID_INVALID;
9615 : 326 : }
9616 : :
9617 : : int
9618 : 1771 : spdk_blob_get_clones(struct spdk_blob_store *bs, spdk_blob_id blobid, spdk_blob_id *ids,
9619 : : size_t *count)
9620 : : {
9621 : : struct spdk_blob_list *snapshot_entry, *clone_entry;
9622 : : size_t n;
9623 : :
9624 : 1771 : snapshot_entry = bs_get_snapshot_entry(bs, blobid);
9625 [ + + ]: 1771 : if (snapshot_entry == NULL) {
9626 [ # # ]: 765 : *count = 0;
9627 : 765 : return 0;
9628 : : }
9629 : :
9630 [ + + + + : 1006 : if (ids == NULL || *count < snapshot_entry->clone_count) {
# # # # #
# ]
9631 [ # # # # : 130 : *count = snapshot_entry->clone_count;
# # ]
9632 : 130 : return -ENOMEM;
9633 : : }
9634 [ # # # # : 876 : *count = snapshot_entry->clone_count;
# # ]
9635 : :
9636 : 876 : n = 0;
9637 [ + + # # : 1832 : TAILQ_FOREACH(clone_entry, &snapshot_entry->clones, link) {
# # # # #
# # # #
# ]
9638 [ # # # # : 956 : ids[n++] = clone_entry->id;
# # # # ]
9639 : 228 : }
9640 : :
9641 : 876 : return 0;
9642 : 257 : }
9643 : :
9644 : : static void
9645 : 20 : bs_load_grow_continue(struct spdk_bs_load_ctx *ctx)
9646 : : {
9647 : : int rc;
9648 : :
9649 [ + + # # : 20 : if (ctx->super->size == 0) {
# # # # #
# ]
9650 [ # # # # : 0 : ctx->super->size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
9651 : 0 : }
9652 : :
9653 [ + + # # : 20 : if (ctx->super->io_unit_size == 0) {
# # # # #
# ]
9654 [ # # # # : 0 : ctx->super->io_unit_size = SPDK_BS_PAGE_SIZE;
# # # # ]
9655 : 0 : }
9656 [ + + # # : 20 : if (ctx->super->md_page_size == 0) {
# # # # #
# ]
9657 [ # # # # : 0 : ctx->super->md_page_size = SPDK_BS_PAGE_SIZE;
# # # # ]
9658 : 0 : }
9659 : :
9660 : : /* Parse the super block */
9661 [ # # # # : 20 : ctx->bs->clean = 1;
# # # # ]
9662 [ # # # # : 20 : ctx->bs->cluster_sz = ctx->super->cluster_size;
# # # # #
# # # # #
# # ]
9663 [ - + # # : 20 : ctx->bs->total_clusters = ctx->super->size / ctx->super->cluster_size;
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
9664 [ # # # # : 20 : ctx->bs->md_page_size = ctx->super->md_page_size;
# # # # #
# # # # #
# # ]
9665 [ # # # # : 20 : ctx->bs->io_unit_size = ctx->super->io_unit_size;
# # # # #
# # # # #
# # ]
9666 [ # # # # ]: 20 : bs_init_per_cluster_fields(ctx->bs);
9667 [ # # # # : 20 : rc = spdk_bit_array_resize(&ctx->used_clusters, ctx->bs->total_clusters);
# # # # #
# ]
9668 [ + + ]: 20 : if (rc < 0) {
9669 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
9670 : 0 : return;
9671 : : }
9672 [ # # # # : 20 : ctx->bs->md_start = ctx->super->md_start;
# # # # #
# # # # #
# # ]
9673 [ # # # # : 20 : ctx->bs->md_len = ctx->super->md_len;
# # # # #
# # # # #
# # ]
9674 [ # # # # : 20 : rc = spdk_bit_array_resize(&ctx->bs->open_blobids, ctx->bs->md_len);
# # # # #
# # # #
# ]
9675 [ + + ]: 20 : if (rc < 0) {
9676 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
9677 : 0 : return;
9678 : : }
9679 : :
9680 [ # # # # : 55 : ctx->bs->total_data_clusters = ctx->bs->total_clusters - spdk_divide_round_up(
# # # # #
# # # # #
# # ]
9681 [ # # # # : 35 : ctx->bs->md_start + ctx->bs->md_len, ctx->bs->pages_per_cluster);
# # # # #
# # # # #
# # # # #
# # # #
# ]
9682 [ # # # # : 20 : ctx->bs->super_blob = ctx->super->super_blob;
# # # # #
# # # # #
# # ]
9683 [ # # # # : 20 : memcpy(&ctx->bs->bstype, &ctx->super->bstype, sizeof(ctx->super->bstype));
# # # # #
# # # # #
# # ]
9684 : :
9685 [ + - + + : 20 : if (ctx->super->used_blobid_mask_len == 0 || ctx->super->clean == 0) {
# # # # #
# # # # #
# # # # #
# ]
9686 : 0 : SPDK_ERRLOG("Can not grow an unclean blobstore, please load it normally to clean it.\n");
9687 : 0 : bs_load_ctx_fail(ctx, -EIO);
9688 : 0 : return;
9689 : : } else {
9690 : 20 : bs_load_read_used_pages(ctx);
9691 : : }
9692 : 5 : }
9693 : :
9694 : : static void
9695 : 20 : bs_load_grow_super_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9696 : : {
9697 : 20 : struct spdk_bs_load_ctx *ctx = cb_arg;
9698 : :
9699 [ - + ]: 20 : if (bserrno != 0) {
9700 : 0 : bs_load_ctx_fail(ctx, bserrno);
9701 : 0 : return;
9702 : : }
9703 : 20 : bs_load_grow_continue(ctx);
9704 : 5 : }
9705 : :
9706 : : static void
9707 : 20 : bs_load_grow_used_clusters_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9708 : : {
9709 : 20 : struct spdk_bs_load_ctx *ctx = cb_arg;
9710 : :
9711 [ - + ]: 20 : if (bserrno != 0) {
9712 : 0 : bs_load_ctx_fail(ctx, bserrno);
9713 : 0 : return;
9714 : : }
9715 : :
9716 [ # # # # ]: 20 : spdk_free(ctx->mask);
9717 : :
9718 [ # # # # : 25 : bs_sequence_write_dev(ctx->seq, ctx->super, bs_page_to_lba(ctx->bs, 0),
# # # # #
# # # ]
9719 [ # # # # ]: 20 : bs_byte_to_lba(ctx->bs, sizeof(*ctx->super)),
9720 : 5 : bs_load_grow_super_write_cpl, ctx);
9721 : 5 : }
9722 : :
9723 : : static void
9724 : 20 : bs_load_grow_used_clusters_read_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9725 : : {
9726 : 20 : struct spdk_bs_load_ctx *ctx = cb_arg;
9727 : : uint64_t lba, lba_count;
9728 : : uint64_t dev_size;
9729 : : uint64_t total_clusters;
9730 : :
9731 [ - + ]: 20 : if (bserrno != 0) {
9732 : 0 : bs_load_ctx_fail(ctx, bserrno);
9733 : 0 : return;
9734 : : }
9735 : :
9736 : : /* The type must be correct */
9737 [ + + # # : 20 : assert(ctx->mask->type == SPDK_MD_MASK_TYPE_USED_CLUSTERS);
# # # # #
# # # ]
9738 : : /* The length of the mask (in bits) must not be greater than the length of the buffer (converted to bits) */
9739 [ - + # # : 20 : assert(ctx->mask->length <= (ctx->super->used_cluster_mask_len * sizeof(
# # # # #
# # # # #
# # # # #
# ]
9740 : : struct spdk_blob_md_page) * 8));
9741 [ # # # # : 20 : dev_size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # #
# ]
9742 [ - + # # : 20 : total_clusters = dev_size / ctx->super->cluster_size;
# # # # #
# ]
9743 [ # # # # : 20 : ctx->mask->length = total_clusters;
# # # # ]
9744 : :
9745 [ # # # # : 20 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
# # # # #
# # # ]
9746 [ # # # # : 20 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
# # # # #
# # # ]
9747 [ # # # # : 25 : bs_sequence_write_dev(ctx->seq, ctx->mask, lba, lba_count,
# # # # ]
9748 : 5 : bs_load_grow_used_clusters_write_cpl, ctx);
9749 : 5 : }
9750 : :
9751 : : static void
9752 : 20 : bs_load_try_to_grow(struct spdk_bs_load_ctx *ctx)
9753 : : {
9754 : : uint64_t dev_size, total_clusters, used_cluster_mask_len, max_used_cluster_mask;
9755 : : uint64_t lba, lba_count, mask_size;
9756 : :
9757 [ # # # # : 20 : dev_size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # #
# ]
9758 [ - + # # : 20 : total_clusters = dev_size / ctx->super->cluster_size;
# # # # #
# ]
9759 : 25 : used_cluster_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
9760 : 20 : spdk_divide_round_up(total_clusters, 8),
9761 [ # # # # : 20 : ctx->super->md_page_size);
# # # # ]
9762 [ # # # # : 20 : max_used_cluster_mask = ctx->super->used_blobid_mask_start - ctx->super->used_cluster_mask_start;
# # # # #
# # # # #
# # ]
9763 : : /* No necessary to grow or no space to grow */
9764 [ + - - + : 20 : if (ctx->super->size >= dev_size || used_cluster_mask_len > max_used_cluster_mask) {
# # # # #
# # # ]
9765 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "No grow\n");
# # ]
9766 : 0 : bs_load_grow_continue(ctx);
9767 : 0 : return;
9768 : : }
9769 : :
9770 [ + + - + : 20 : SPDK_DEBUGLOG(blob, "Resize blobstore\n");
# # ]
9771 : :
9772 [ # # # # : 20 : ctx->super->size = dev_size;
# # # # ]
9773 [ # # # # : 20 : ctx->super->used_cluster_mask_len = used_cluster_mask_len;
# # # # ]
9774 [ # # # # : 20 : ctx->super->crc = blob_md_page_calc_crc(ctx->super);
# # # # #
# # # ]
9775 : :
9776 [ # # # # : 20 : mask_size = used_cluster_mask_len * ctx->super->md_page_size;
# # # # ]
9777 [ # # # # ]: 20 : ctx->mask = spdk_zmalloc(mask_size, 0x1000, NULL, SPDK_ENV_NUMA_ID_ANY,
9778 : : SPDK_MALLOC_DMA);
9779 [ - + # # : 20 : if (!ctx->mask) {
# # ]
9780 : 0 : bs_load_ctx_fail(ctx, -ENOMEM);
9781 : 0 : return;
9782 : : }
9783 [ # # # # : 20 : lba = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_start);
# # # # #
# # # ]
9784 [ # # # # : 20 : lba_count = bs_page_to_lba(ctx->bs, ctx->super->used_cluster_mask_len);
# # # # #
# # # ]
9785 [ # # # # : 25 : bs_sequence_read_dev(ctx->seq, ctx->mask, lba, lba_count,
# # # # ]
9786 : 5 : bs_load_grow_used_clusters_read_cpl, ctx);
9787 : 5 : }
9788 : :
9789 : : static void
9790 : 20 : bs_grow_load_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9791 : : {
9792 : 20 : struct spdk_bs_load_ctx *ctx = cb_arg;
9793 : : int rc;
9794 : :
9795 [ # # # # : 20 : rc = bs_super_validate(ctx->super, ctx->bs);
# # # # ]
9796 [ - + ]: 20 : if (rc != 0) {
9797 : 0 : bs_load_ctx_fail(ctx, rc);
9798 : 0 : return;
9799 : : }
9800 : :
9801 : 20 : bs_load_try_to_grow(ctx);
9802 : 5 : }
9803 : :
9804 : : struct spdk_bs_grow_ctx {
9805 : : struct spdk_blob_store *bs;
9806 : : struct spdk_bs_super_block *super;
9807 : :
9808 : : struct spdk_bit_pool *new_used_clusters;
9809 : : struct spdk_bs_md_mask *new_used_clusters_mask;
9810 : :
9811 : : spdk_bs_sequence_t *seq;
9812 : : };
9813 : :
9814 : : static void
9815 : 162 : bs_grow_live_done(struct spdk_bs_grow_ctx *ctx, int bserrno)
9816 : : {
9817 [ + + ]: 162 : if (bserrno != 0) {
9818 [ # # ]: 40 : spdk_bit_pool_free(&ctx->new_used_clusters);
9819 : 10 : }
9820 : :
9821 [ # # # # ]: 162 : bs_sequence_finish(ctx->seq, bserrno);
9822 [ # # # # ]: 162 : free(ctx->new_used_clusters_mask);
9823 [ # # # # ]: 162 : spdk_free(ctx->super);
9824 : 162 : free(ctx);
9825 : 162 : }
9826 : :
9827 : : static void
9828 : 42 : bs_grow_live_super_write_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9829 : : {
9830 : 42 : struct spdk_bs_grow_ctx *ctx = cb_arg;
9831 [ # # # # ]: 42 : struct spdk_blob_store *bs = ctx->bs;
9832 : : uint64_t total_clusters;
9833 : :
9834 [ - + ]: 42 : if (bserrno != 0) {
9835 : 0 : bs_grow_live_done(ctx, bserrno);
9836 : 0 : return;
9837 : : }
9838 : :
9839 : : /*
9840 : : * Blobstore is not clean until unload, for now only the super block is up to date.
9841 : : * This is similar to state right after blobstore init, when bs_write_used_md() didn't
9842 : : * yet execute.
9843 : : * When cleanly unloaded, the used md pages will be written out.
9844 : : * In case of unclean shutdown, loading blobstore will go through recovery path correctly
9845 : : * filling out the used_clusters with new size and writing it out.
9846 : : */
9847 [ # # # # ]: 42 : bs->clean = 0;
9848 : :
9849 : : /* Reverting the super->size past this point is complex, avoid any error paths
9850 : : * that require to do so. */
9851 [ # # ]: 42 : spdk_spin_lock(&bs->used_lock);
9852 : :
9853 [ - + # # : 42 : total_clusters = ctx->super->size / ctx->super->cluster_size;
# # # # #
# # # # #
# # # # ]
9854 : :
9855 [ + + # # : 42 : assert(total_clusters >= spdk_bit_pool_capacity(bs->used_clusters));
# # # # ]
9856 [ # # # # : 42 : spdk_bit_pool_store_mask(bs->used_clusters, ctx->new_used_clusters_mask);
# # # # ]
9857 : :
9858 [ + + # # : 42 : assert(total_clusters == spdk_bit_pool_capacity(ctx->new_used_clusters));
# # # # ]
9859 [ # # # # : 42 : spdk_bit_pool_load_mask(ctx->new_used_clusters, ctx->new_used_clusters_mask);
# # # # ]
9860 : :
9861 [ # # ]: 42 : spdk_bit_pool_free(&bs->used_clusters);
9862 [ # # # # : 42 : bs->used_clusters = ctx->new_used_clusters;
# # # # ]
9863 : :
9864 [ # # # # ]: 42 : bs->total_clusters = total_clusters;
9865 [ # # # # : 84 : bs->total_data_clusters = bs->total_clusters - spdk_divide_round_up(
# # # # ]
9866 [ # # # # : 42 : bs->md_start + bs->md_len, bs->pages_per_cluster);
# # # # #
# # # ]
9867 : :
9868 [ # # # # : 42 : bs->num_free_clusters = spdk_bit_pool_count_free(bs->used_clusters);
# # # # ]
9869 [ + + # # : 42 : assert(ctx->bs->num_free_clusters <= ctx->bs->total_clusters);
# # # # #
# # # # #
# # # # #
# ]
9870 [ # # ]: 42 : spdk_spin_unlock(&bs->used_lock);
9871 : :
9872 : 42 : bs_grow_live_done(ctx, 0);
9873 : 10 : }
9874 : :
9875 : : static void
9876 : 162 : bs_grow_live_load_super_cpl(spdk_bs_sequence_t *seq, void *cb_arg, int bserrno)
9877 : : {
9878 : 162 : struct spdk_bs_grow_ctx *ctx = cb_arg;
9879 : : uint64_t dev_size, total_clusters, used_cluster_mask_len, max_used_cluster_mask;
9880 : : int rc;
9881 : :
9882 [ - + ]: 162 : if (bserrno != 0) {
9883 : 0 : bs_grow_live_done(ctx, bserrno);
9884 : 0 : return;
9885 : : }
9886 : :
9887 [ # # # # : 162 : rc = bs_super_validate(ctx->super, ctx->bs);
# # # # ]
9888 [ + + ]: 162 : if (rc != 0) {
9889 : 20 : bs_grow_live_done(ctx, rc);
9890 : 20 : return;
9891 : : }
9892 : :
9893 [ # # # # : 142 : dev_size = ctx->bs->dev->blockcnt * ctx->bs->dev->blocklen;
# # # # #
# # # # #
# # # # #
# # # #
# ]
9894 [ - + # # : 142 : total_clusters = dev_size / ctx->super->cluster_size;
# # # # #
# ]
9895 : 177 : used_cluster_mask_len = spdk_divide_round_up(sizeof(struct spdk_bs_md_mask) +
9896 : 142 : spdk_divide_round_up(total_clusters, 8),
9897 [ # # # # : 142 : ctx->super->md_page_size);
# # # # ]
9898 [ # # # # : 142 : max_used_cluster_mask = ctx->super->used_blobid_mask_start - ctx->super->used_cluster_mask_start;
# # # # #
# # # # #
# # ]
9899 : : /* Only checking dev_size. Since it can change, but total_clusters remain the same. */
9900 [ + + # # : 142 : if (dev_size == ctx->super->size) {
# # # # #
# ]
9901 [ + + - + : 80 : SPDK_DEBUGLOG(blob, "No need to grow blobstore\n");
# # ]
9902 : 80 : bs_grow_live_done(ctx, 0);
9903 : 80 : return;
9904 : : }
9905 : : /*
9906 : : * Blobstore cannot be shrunk, so check before if:
9907 : : * - new size of the device is smaller than size in super_block
9908 : : * - new total number of clusters is smaller than used_clusters bit_pool
9909 : : * - there is enough space in metadata for used_cluster_mask to be written out
9910 : : */
9911 [ + - + + : 77 : if (dev_size < ctx->super->size ||
# # # # #
# # # ]
9912 [ + - + + : 62 : total_clusters < spdk_bit_pool_capacity(ctx->bs->used_clusters) ||
# # # # #
# ]
9913 : 15 : used_cluster_mask_len > max_used_cluster_mask) {
9914 [ + + - + : 20 : SPDK_DEBUGLOG(blob, "No space to grow blobstore\n");
# # ]
9915 : 20 : bs_grow_live_done(ctx, -ENOSPC);
9916 : 20 : return;
9917 : : }
9918 : :
9919 [ + + - + : 42 : SPDK_DEBUGLOG(blob, "Resizing blobstore\n");
# # ]
9920 : :
9921 [ # # # # ]: 42 : ctx->new_used_clusters_mask = calloc(1, total_clusters);
9922 [ + + # # : 42 : if (!ctx->new_used_clusters_mask) {
# # ]
9923 : 0 : bs_grow_live_done(ctx, -ENOMEM);
9924 : 0 : return;
9925 : : }
9926 [ # # # # ]: 42 : ctx->new_used_clusters = spdk_bit_pool_create(total_clusters);
9927 [ - + # # : 42 : if (!ctx->new_used_clusters) {
# # ]
9928 : 0 : bs_grow_live_done(ctx, -ENOMEM);
9929 : 0 : return;
9930 : : }
9931 : :
9932 [ # # # # : 42 : ctx->super->clean = 0;
# # # # ]
9933 [ # # # # : 42 : ctx->super->size = dev_size;
# # # # ]
9934 [ # # # # : 42 : ctx->super->used_cluster_mask_len = used_cluster_mask_len;
# # # # ]
9935 [ # # # # : 42 : bs_write_super(seq, ctx->bs, ctx->super, bs_grow_live_super_write_cpl, ctx);
# # # # ]
9936 : 40 : }
9937 : :
9938 : : void
9939 : 162 : spdk_bs_grow_live(struct spdk_blob_store *bs,
9940 : : spdk_bs_op_complete cb_fn, void *cb_arg)
9941 : : {
9942 : 122 : struct spdk_bs_cpl cpl;
9943 : : struct spdk_bs_grow_ctx *ctx;
9944 : :
9945 [ + + # # : 162 : assert(spdk_get_thread() == bs->md_thread);
# # # # ]
9946 : :
9947 [ + + - + : 162 : SPDK_DEBUGLOG(blob, "Growing blobstore on dev %p\n", bs->dev);
# # # # #
# ]
9948 : :
9949 : 162 : cpl.type = SPDK_BS_CPL_TYPE_BS_BASIC;
9950 [ # # # # : 162 : cpl.u.bs_basic.cb_fn = cb_fn;
# # ]
9951 [ # # # # : 162 : cpl.u.bs_basic.cb_arg = cb_arg;
# # ]
9952 : :
9953 : 162 : ctx = calloc(1, sizeof(struct spdk_bs_grow_ctx));
9954 [ + + ]: 162 : if (!ctx) {
9955 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
9956 : 0 : return;
9957 : : }
9958 [ # # # # ]: 162 : ctx->bs = bs;
9959 : :
9960 [ # # # # ]: 162 : ctx->super = spdk_zmalloc(sizeof(*ctx->super), 0x1000, NULL,
9961 : : SPDK_ENV_NUMA_ID_ANY, SPDK_MALLOC_DMA);
9962 [ + + # # : 162 : if (!ctx->super) {
# # ]
9963 : 0 : free(ctx);
9964 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
9965 : 0 : return;
9966 : : }
9967 : :
9968 [ # # # # : 162 : ctx->seq = bs_sequence_start_bs(bs->md_channel, &cpl);
# # # # ]
9969 [ + + # # : 162 : if (!ctx->seq) {
# # ]
9970 [ # # # # ]: 0 : spdk_free(ctx->super);
9971 : 0 : free(ctx);
9972 [ # # # # ]: 0 : cb_fn(cb_arg, -ENOMEM);
9973 : 0 : return;
9974 : : }
9975 : :
9976 : : /* Read the super block */
9977 [ # # # # : 202 : bs_sequence_read_dev(ctx->seq, ctx->super, bs_page_to_lba(bs, 0),
# # # # ]
9978 : 162 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
9979 : 40 : bs_grow_live_load_super_cpl, ctx);
9980 : 40 : }
9981 : :
9982 : : void
9983 : 20 : spdk_bs_grow(struct spdk_bs_dev *dev, struct spdk_bs_opts *o,
9984 : : spdk_bs_op_with_handle_complete cb_fn, void *cb_arg)
9985 : : {
9986 : 15 : struct spdk_blob_store *bs;
9987 : 15 : struct spdk_bs_cpl cpl;
9988 : 15 : struct spdk_bs_load_ctx *ctx;
9989 : 20 : struct spdk_bs_opts opts = {};
9990 : : int err;
9991 : :
9992 [ + + - + : 20 : SPDK_DEBUGLOG(blob, "Loading blobstore from dev %p\n", dev);
# # ]
9993 : :
9994 [ - + - + : 20 : if ((dev->phys_blocklen % dev->blocklen) != 0) {
# # # # #
# # # ]
9995 [ # # # # : 0 : SPDK_DEBUGLOG(blob, "unsupported dev block length of %d\n", dev->blocklen);
# # # # #
# ]
9996 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
9997 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -EINVAL);
9998 : 0 : return;
9999 : : }
10000 : :
10001 : 20 : spdk_bs_opts_init(&opts, sizeof(opts));
10002 [ + + ]: 20 : if (o) {
10003 [ + + ]: 20 : if (bs_opts_copy(o, &opts)) {
10004 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
10005 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -EINVAL);
10006 : 0 : return;
10007 : : }
10008 : 5 : }
10009 : :
10010 [ + - - + ]: 20 : if (opts.max_md_ops == 0 || opts.max_channel_ops == 0) {
10011 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
10012 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -EINVAL);
10013 : 0 : return;
10014 : : }
10015 : :
10016 : 20 : err = bs_alloc(dev, &opts, &bs, &ctx);
10017 [ - + ]: 20 : if (err) {
10018 [ # # # # : 0 : dev->destroy(dev);
# # # # ]
10019 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, err);
10020 : 0 : return;
10021 : : }
10022 : :
10023 : 20 : cpl.type = SPDK_BS_CPL_TYPE_BS_HANDLE;
10024 [ # # # # : 20 : cpl.u.bs_handle.cb_fn = cb_fn;
# # ]
10025 [ # # # # : 20 : cpl.u.bs_handle.cb_arg = cb_arg;
# # ]
10026 [ # # # # : 20 : cpl.u.bs_handle.bs = bs;
# # ]
10027 : :
10028 [ # # # # : 20 : ctx->seq = bs_sequence_start_bs(bs->md_channel, &cpl);
# # # # ]
10029 [ - + # # : 20 : if (!ctx->seq) {
# # ]
10030 [ # # # # ]: 0 : spdk_free(ctx->super);
10031 : 0 : free(ctx);
10032 : 0 : bs_free(bs);
10033 [ # # # # ]: 0 : cb_fn(cb_arg, NULL, -ENOMEM);
10034 : 0 : return;
10035 : : }
10036 : :
10037 : : /* Read the super block */
10038 [ # # # # : 25 : bs_sequence_read_dev(ctx->seq, ctx->super, bs_page_to_lba(bs, 0),
# # # # ]
10039 : 20 : bs_byte_to_lba(bs, sizeof(*ctx->super)),
10040 : 5 : bs_grow_load_super_cpl, ctx);
10041 : 5 : }
10042 : :
10043 : : int
10044 : 149 : spdk_blob_get_esnap_id(struct spdk_blob *blob, const void **id, size_t *len)
10045 : : {
10046 [ + + ]: 149 : if (!blob_is_esnap_clone(blob)) {
10047 : 62 : return -EINVAL;
10048 : : }
10049 : :
10050 : 87 : return blob_get_xattr_value(blob, BLOB_EXTERNAL_SNAPSHOT_ID, id, len, true);
10051 : 30 : }
10052 : :
10053 : : struct spdk_io_channel *
10054 : 83703 : blob_esnap_get_io_channel(struct spdk_io_channel *ch, struct spdk_blob *blob)
10055 : : {
10056 : 83703 : struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(ch);
10057 [ # # # # ]: 83703 : struct spdk_bs_dev *bs_dev = blob->back_bs_dev;
10058 : 83703 : struct blob_esnap_channel find = {};
10059 : : struct blob_esnap_channel *esnap_channel, *existing;
10060 : :
10061 [ # # # # : 83703 : find.blob_id = blob->id;
# # ]
10062 [ # # ]: 83703 : esnap_channel = RB_FIND(blob_esnap_channel_tree, &bs_channel->esnap_channels, &find);
10063 [ + + ]: 83703 : if (spdk_likely(esnap_channel != NULL)) {
10064 [ + + - + : 83462 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": using cached channel on thread %s\n",
# # # # #
# ]
10065 : : blob->id, spdk_thread_get_name(spdk_get_thread()));
10066 [ # # # # ]: 83462 : return esnap_channel->channel;
10067 : : }
10068 : :
10069 [ + + - + : 241 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": allocating channel on thread %s\n",
# # # # #
# ]
10070 : : blob->id, spdk_thread_get_name(spdk_get_thread()));
10071 : :
10072 : 241 : esnap_channel = calloc(1, sizeof(*esnap_channel));
10073 [ + + ]: 241 : if (esnap_channel == NULL) {
10074 [ # # ]: 0 : SPDK_NOTICELOG("blob 0x%" PRIx64 " channel allocation failed: no memory\n",
10075 : : find.blob_id);
10076 : 0 : return NULL;
10077 : : }
10078 [ # # # # : 241 : esnap_channel->channel = bs_dev->create_channel(bs_dev);
# # # # #
# # # ]
10079 [ + + # # : 241 : if (esnap_channel->channel == NULL) {
# # ]
10080 [ # # # # ]: 0 : SPDK_NOTICELOG("blob 0x%" PRIx64 " back channel allocation failed\n", blob->id);
10081 : 0 : free(esnap_channel);
10082 : 0 : return NULL;
10083 : : }
10084 [ # # # # : 241 : esnap_channel->blob_id = find.blob_id;
# # ]
10085 [ # # ]: 241 : existing = RB_INSERT(blob_esnap_channel_tree, &bs_channel->esnap_channels, esnap_channel);
10086 [ - + ]: 241 : if (spdk_unlikely(existing != NULL)) {
10087 : : /*
10088 : : * This should be unreachable: all modifications to this tree happen on this thread.
10089 : : */
10090 [ # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 "lost race to allocate a channel\n", find.blob_id);
10091 [ # # ]: 0 : assert(false);
10092 : :
10093 : : bs_dev->destroy_channel(bs_dev, esnap_channel->channel);
10094 : : free(esnap_channel);
10095 : :
10096 : : return existing->channel;
10097 : : }
10098 : :
10099 [ # # # # ]: 241 : return esnap_channel->channel;
10100 : 17482 : }
10101 : :
10102 : : static int
10103 : 83583 : blob_esnap_channel_compare(struct blob_esnap_channel *c1, struct blob_esnap_channel *c2)
10104 : : {
10105 [ + + # # : 83583 : return (c1->blob_id < c2->blob_id ? -1 : c1->blob_id > c2->blob_id);
# # # # #
# # # # #
# # # # ]
10106 : : }
10107 : :
10108 : : struct blob_esnap_destroy_ctx {
10109 : : spdk_blob_op_with_handle_complete cb_fn;
10110 : : void *cb_arg;
10111 : : struct spdk_blob *blob;
10112 : : struct spdk_bs_dev *back_bs_dev;
10113 : : bool abort_io;
10114 : : };
10115 : :
10116 : : static void
10117 : 723 : blob_esnap_destroy_channels_done(struct spdk_io_channel_iter *i, int status)
10118 : : {
10119 : 723 : struct blob_esnap_destroy_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
10120 [ # # # # ]: 723 : struct spdk_blob *blob = ctx->blob;
10121 [ # # # # ]: 723 : struct spdk_blob_store *bs = blob->bs;
10122 : :
10123 [ + + - + : 723 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": done destroying channels for this blob\n",
# # # # #
# ]
10124 : : blob->id);
10125 : :
10126 [ + + # # : 723 : if (ctx->cb_fn != NULL) {
# # ]
10127 [ # # # # : 659 : ctx->cb_fn(ctx->cb_arg, blob, status);
# # # # #
# # # ]
10128 : 155 : }
10129 : 723 : free(ctx);
10130 : :
10131 [ # # ]: 723 : bs->esnap_channels_unloading--;
10132 [ + - + + : 723 : if (bs->esnap_channels_unloading == 0 && bs->esnap_unload_cb_fn != NULL) {
# # # # #
# # # ]
10133 [ # # # # : 36 : spdk_bs_unload(bs, bs->esnap_unload_cb_fn, bs->esnap_unload_cb_arg);
# # # # ]
10134 : 5 : }
10135 : 723 : }
10136 : :
10137 : : static void
10138 : 763 : blob_esnap_destroy_one_channel(struct spdk_io_channel_iter *i)
10139 : : {
10140 : 763 : struct blob_esnap_destroy_ctx *ctx = spdk_io_channel_iter_get_ctx(i);
10141 [ # # # # ]: 763 : struct spdk_blob *blob = ctx->blob;
10142 [ # # # # ]: 763 : struct spdk_bs_dev *bs_dev = ctx->back_bs_dev;
10143 : 763 : struct spdk_io_channel *channel = spdk_io_channel_iter_get_channel(i);
10144 : 763 : struct spdk_bs_channel *bs_channel = spdk_io_channel_get_ctx(channel);
10145 : : struct blob_esnap_channel *esnap_channel;
10146 : 763 : struct blob_esnap_channel find = {};
10147 : :
10148 [ + + # # ]: 763 : assert(spdk_get_thread() == spdk_io_channel_get_thread(channel));
10149 : :
10150 [ # # # # : 763 : find.blob_id = blob->id;
# # ]
10151 [ # # ]: 763 : esnap_channel = RB_FIND(blob_esnap_channel_tree, &bs_channel->esnap_channels, &find);
10152 [ + + ]: 763 : if (esnap_channel != NULL) {
10153 [ + + - + : 81 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": destroying channel on thread %s\n",
# # # # #
# ]
10154 : : blob->id, spdk_thread_get_name(spdk_get_thread()));
10155 [ # # ]: 81 : RB_REMOVE(blob_esnap_channel_tree, &bs_channel->esnap_channels, esnap_channel);
10156 : :
10157 [ + + + + : 81 : if (ctx->abort_io) {
# # # # ]
10158 : : spdk_bs_user_op_t *op, *tmp;
10159 : :
10160 [ + + - + : 42 : TAILQ_FOREACH_SAFE(op, &bs_channel->queued_io, link, tmp) {
# # # # #
# # # # #
# # ]
10161 [ # # # # : 0 : if (op->back_channel == esnap_channel->channel) {
# # # # #
# ]
10162 [ # # # # : 0 : TAILQ_REMOVE(&bs_channel->queued_io, op, link);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
10163 : 0 : bs_user_op_abort(op, -EIO);
10164 : 0 : }
10165 : 0 : }
10166 : 10 : }
10167 : :
10168 [ # # # # : 81 : bs_dev->destroy_channel(bs_dev, esnap_channel->channel);
# # # # #
# # # ]
10169 : 81 : free(esnap_channel);
10170 : 15 : }
10171 : :
10172 : 763 : spdk_for_each_channel_continue(i, 0);
10173 : 763 : }
10174 : :
10175 : : /*
10176 : : * Destroy the channels for a specific blob on each thread with a blobstore channel. This should be
10177 : : * used when closing an esnap clone blob and after decoupling from the parent.
10178 : : */
10179 : : static void
10180 : 2577 : blob_esnap_destroy_bs_dev_channels(struct spdk_blob *blob, bool abort_io,
10181 : : spdk_blob_op_with_handle_complete cb_fn, void *cb_arg)
10182 : : {
10183 : : struct blob_esnap_destroy_ctx *ctx;
10184 : :
10185 [ + + + + : 2577 : if (!blob_is_esnap_clone(blob) || blob->back_bs_dev == NULL) {
# # # # ]
10186 [ + + ]: 1854 : if (cb_fn != NULL) {
10187 [ # # # # ]: 1854 : cb_fn(cb_arg, blob, 0);
10188 : 437 : }
10189 : 1854 : return;
10190 : : }
10191 : :
10192 : 723 : ctx = calloc(1, sizeof(*ctx));
10193 [ + + ]: 723 : if (ctx == NULL) {
10194 [ # # ]: 0 : if (cb_fn != NULL) {
10195 [ # # # # ]: 0 : cb_fn(cb_arg, blob, -ENOMEM);
10196 : 0 : }
10197 : 0 : return;
10198 : : }
10199 [ # # # # ]: 723 : ctx->cb_fn = cb_fn;
10200 [ # # # # ]: 723 : ctx->cb_arg = cb_arg;
10201 [ # # # # ]: 723 : ctx->blob = blob;
10202 [ # # # # : 723 : ctx->back_bs_dev = blob->back_bs_dev;
# # # # ]
10203 [ # # # # : 723 : ctx->abort_io = abort_io;
# # ]
10204 : :
10205 [ + + - + : 723 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64 ": destroying channels for this blob\n",
# # # # #
# ]
10206 : : blob->id);
10207 : :
10208 [ # # # # : 723 : blob->bs->esnap_channels_unloading++;
# # ]
10209 [ # # # # ]: 723 : spdk_for_each_channel(blob->bs, blob_esnap_destroy_one_channel, ctx,
10210 : : blob_esnap_destroy_channels_done);
10211 : 607 : }
10212 : :
10213 : : /*
10214 : : * Destroy all bs_dev channels on a specific blobstore channel. This should be used when a
10215 : : * bs_channel is destroyed.
10216 : : */
10217 : : static void
10218 : 11513 : blob_esnap_destroy_bs_channel(struct spdk_bs_channel *ch)
10219 : : {
10220 : : struct blob_esnap_channel *esnap_channel, *esnap_channel_tmp;
10221 : :
10222 [ + + # # ]: 11513 : assert(spdk_get_thread() == spdk_io_channel_get_thread(spdk_io_channel_from_ctx(ch)));
10223 : :
10224 [ + + + + : 11513 : SPDK_DEBUGLOG(blob_esnap, "destroying channels on thread %s\n",
+ - ]
10225 : : spdk_thread_get_name(spdk_get_thread()));
10226 [ + + + + : 11673 : RB_FOREACH_SAFE(esnap_channel, blob_esnap_channel_tree, &ch->esnap_channels,
- + ]
10227 : : esnap_channel_tmp) {
10228 [ + + - + : 160 : SPDK_DEBUGLOG(blob_esnap, "blob 0x%" PRIx64
# # # # #
# ]
10229 : : ": destroying one channel in thread %s\n",
10230 : : esnap_channel->blob_id, spdk_thread_get_name(spdk_get_thread()));
10231 [ # # ]: 160 : RB_REMOVE(blob_esnap_channel_tree, &ch->esnap_channels, esnap_channel);
10232 [ # # # # ]: 160 : spdk_put_io_channel(esnap_channel->channel);
10233 : 160 : free(esnap_channel);
10234 : 40 : }
10235 [ + + + + : 11513 : SPDK_DEBUGLOG(blob_esnap, "done destroying channels on thread %s\n",
+ - ]
10236 : : spdk_thread_get_name(spdk_get_thread()));
10237 : 11513 : }
10238 : :
10239 : : static void
10240 : 149 : blob_set_back_bs_dev_done(void *_ctx, int bserrno)
10241 : : {
10242 : 149 : struct set_bs_dev_ctx *ctx = _ctx;
10243 : :
10244 [ - + ]: 149 : if (bserrno != 0) {
10245 : : /* Even though the unfreeze failed, the update may have succeed. */
10246 [ # # # # : 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": unfreeze failed with error %d\n", ctx->blob->id,
# # # # ]
10247 : : bserrno);
10248 : 0 : }
10249 [ # # # # : 149 : ctx->cb_fn(ctx->cb_arg, ctx->bserrno);
# # # # #
# # # # #
# # ]
10250 : 149 : free(ctx);
10251 : 149 : }
10252 : :
10253 : : static void
10254 : 149 : blob_frozen_set_back_bs_dev(void *_ctx, struct spdk_blob *blob, int bserrno)
10255 : : {
10256 : 149 : struct set_bs_dev_ctx *ctx = _ctx;
10257 : : int rc;
10258 : :
10259 [ - + ]: 149 : if (bserrno != 0) {
10260 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": failed to release old back_bs_dev with error %d\n",
10261 : : blob->id, bserrno);
10262 [ # # # # ]: 0 : ctx->bserrno = bserrno;
10263 : 0 : blob_unfreeze_io(blob, blob_set_back_bs_dev_done, ctx);
10264 : 0 : return;
10265 : : }
10266 : :
10267 [ + + # # : 149 : if (blob->back_bs_dev != NULL) {
# # ]
10268 : 149 : blob_unref_back_bs_dev(blob);
10269 : 35 : }
10270 : :
10271 [ + + # # : 149 : if (ctx->parent_refs_cb_fn) {
# # ]
10272 [ # # # # : 106 : rc = ctx->parent_refs_cb_fn(blob, ctx->parent_refs_cb_arg);
# # # # #
# # # ]
10273 [ - + ]: 106 : if (rc != 0) {
10274 [ # # # # ]: 0 : ctx->bserrno = rc;
10275 : 0 : blob_unfreeze_io(blob, blob_set_back_bs_dev_done, ctx);
10276 : 0 : return;
10277 : : }
10278 : 25 : }
10279 : :
10280 [ # # # # ]: 149 : SPDK_NOTICELOG("blob 0x%" PRIx64 ": hotplugged back_bs_dev\n", blob->id);
10281 [ # # # # : 149 : blob->back_bs_dev = ctx->back_bs_dev;
# # # # ]
10282 [ # # # # ]: 149 : ctx->bserrno = 0;
10283 : :
10284 : 149 : blob_unfreeze_io(blob, blob_set_back_bs_dev_done, ctx);
10285 : 35 : }
10286 : :
10287 : : static void
10288 : 149 : blob_set_back_bs_dev_frozen(void *_ctx, int bserrno)
10289 : : {
10290 : 149 : struct set_bs_dev_ctx *ctx = _ctx;
10291 [ # # # # ]: 149 : struct spdk_blob *blob = ctx->blob;
10292 : :
10293 [ - + ]: 149 : if (bserrno != 0) {
10294 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": failed to freeze with error %d\n", blob->id,
10295 : : bserrno);
10296 [ # # # # : 0 : ctx->cb_fn(ctx->cb_arg, bserrno);
# # # # #
# # # ]
10297 : 0 : free(ctx);
10298 : 0 : return;
10299 : : }
10300 : :
10301 : : /*
10302 : : * This does not prevent future reads from the esnap device because any future IO will
10303 : : * lazily create a new esnap IO channel.
10304 : : */
10305 : 149 : blob_esnap_destroy_bs_dev_channels(blob, true, blob_frozen_set_back_bs_dev, ctx);
10306 : 35 : }
10307 : :
10308 : : void
10309 : 43 : spdk_blob_set_esnap_bs_dev(struct spdk_blob *blob, struct spdk_bs_dev *back_bs_dev,
10310 : : spdk_blob_op_complete cb_fn, void *cb_arg)
10311 : : {
10312 [ - + ]: 43 : if (!blob_is_esnap_clone(blob)) {
10313 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": not an esnap clone\n", blob->id);
10314 [ # # # # ]: 0 : cb_fn(cb_arg, -EINVAL);
10315 : 0 : return;
10316 : : }
10317 : :
10318 : 43 : blob_set_back_bs_dev(blob, back_bs_dev, NULL, NULL, cb_fn, cb_arg);
10319 : 10 : }
10320 : :
10321 : : struct spdk_bs_dev *
10322 : 172 : spdk_blob_get_esnap_bs_dev(const struct spdk_blob *blob)
10323 : : {
10324 [ - + ]: 172 : if (!blob_is_esnap_clone(blob)) {
10325 [ # # # # ]: 0 : SPDK_ERRLOG("blob 0x%" PRIx64 ": not an esnap clone\n", blob->id);
10326 : 0 : return NULL;
10327 : : }
10328 : :
10329 [ # # # # ]: 172 : return blob->back_bs_dev;
10330 : 5 : }
10331 : :
10332 : : bool
10333 : 1253 : spdk_blob_is_degraded(const struct spdk_blob *blob)
10334 : : {
10335 [ + + + + : 1253 : if (blob->bs->dev->is_degraded != NULL && blob->bs->dev->is_degraded(blob->bs->dev)) {
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
10336 : 20 : return true;
10337 : : }
10338 [ + + + + : 1233 : if (blob->back_bs_dev == NULL || blob->back_bs_dev->is_degraded == NULL) {
# # # # #
# # # # #
# # ]
10339 : 1036 : return false;
10340 : : }
10341 : :
10342 [ # # # # : 197 : return blob->back_bs_dev->is_degraded(blob->back_bs_dev);
# # # # #
# # # # #
# # ]
10343 : 52 : }
10344 : :
10345 : 2328 : SPDK_LOG_REGISTER_COMPONENT(blob)
10346 : 2328 : SPDK_LOG_REGISTER_COMPONENT(blob_esnap)
10347 : :
10348 : : static void
10349 : 2136 : blob_trace(void)
10350 : : {
10351 : 2136 : struct spdk_trace_tpoint_opts opts[] = {
10352 : : {
10353 : : "BLOB_REQ_SET_START", TRACE_BLOB_REQ_SET_START,
10354 : : OWNER_TYPE_NONE, OBJECT_BLOB_CB_ARG, 1,
10355 : : {
10356 : : { "ctx", SPDK_TRACE_ARG_TYPE_PTR, 8 }
10357 : : }
10358 : : },
10359 : : {
10360 : : "BLOB_REQ_SET_COMPLETE", TRACE_BLOB_REQ_SET_COMPLETE,
10361 : : OWNER_TYPE_NONE, OBJECT_BLOB_CB_ARG, 0,
10362 : : {
10363 : : { "ctx", SPDK_TRACE_ARG_TYPE_PTR, 8 }
10364 : : }
10365 : : },
10366 : : };
10367 : :
10368 : 2136 : spdk_trace_register_object(OBJECT_BLOB_CB_ARG, 'a');
10369 : 2136 : spdk_trace_register_description_ext(opts, SPDK_COUNTOF(opts));
10370 : 2136 : spdk_trace_tpoint_register_relation(TRACE_BDEV_IO_START, OBJECT_BLOB_CB_ARG, 1);
10371 : 2136 : spdk_trace_tpoint_register_relation(TRACE_BDEV_IO_DONE, OBJECT_BLOB_CB_ARG, 0);
10372 : 2136 : }
10373 : 2328 : SPDK_TRACE_REGISTER_FN(blob_trace, "blob", TRACE_GROUP_BLOB)
|