Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2018 Intel Corporation.
3 : : * Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES.
4 : : * All rights reserved.
5 : : */
6 : :
7 : : /*
8 : : * Common code for partition-like virtual bdevs.
9 : : */
10 : :
11 : : #include "spdk/bdev.h"
12 : : #include "spdk/likely.h"
13 : : #include "spdk/log.h"
14 : : #include "spdk/string.h"
15 : : #include "spdk/thread.h"
16 : :
17 : : #include "spdk/bdev_module.h"
18 : :
19 : : /* This namespace UUID was generated using uuid_generate() method. */
20 : : #define BDEV_PART_NAMESPACE_UUID "976b899e-3e1e-4d71-ab69-c2b08e9df8b8"
21 : :
22 : : struct spdk_bdev_part_base {
23 : : struct spdk_bdev *bdev;
24 : : struct spdk_bdev_desc *desc;
25 : : uint32_t ref;
26 : : uint32_t channel_size;
27 : : spdk_bdev_part_base_free_fn base_free_fn;
28 : : void *ctx;
29 : : bool claimed;
30 : : struct spdk_bdev_module *module;
31 : : struct spdk_bdev_fn_table *fn_table;
32 : : struct bdev_part_tailq *tailq;
33 : : spdk_io_channel_create_cb ch_create_cb;
34 : : spdk_io_channel_destroy_cb ch_destroy_cb;
35 : : spdk_bdev_remove_cb_t remove_cb;
36 : : struct spdk_thread *thread;
37 : : };
38 : :
39 : : struct spdk_bdev *
40 : 6337 : spdk_bdev_part_base_get_bdev(struct spdk_bdev_part_base *part_base)
41 : : {
42 [ + - + - ]: 6337 : return part_base->bdev;
43 : : }
44 : :
45 : : struct spdk_bdev_desc *
46 : 5373 : spdk_bdev_part_base_get_desc(struct spdk_bdev_part_base *part_base)
47 : : {
48 [ + - + - ]: 5373 : return part_base->desc;
49 : : }
50 : :
51 : : struct bdev_part_tailq *
52 : 32 : spdk_bdev_part_base_get_tailq(struct spdk_bdev_part_base *part_base)
53 : : {
54 [ # # # # ]: 32 : return part_base->tailq;
55 : : }
56 : :
57 : : void *
58 : 25 : spdk_bdev_part_base_get_ctx(struct spdk_bdev_part_base *part_base)
59 : : {
60 [ # # # # ]: 25 : return part_base->ctx;
61 : : }
62 : :
63 : : const char *
64 : 0 : spdk_bdev_part_base_get_bdev_name(struct spdk_bdev_part_base *part_base)
65 : : {
66 [ # # # # : 0 : return part_base->bdev->name;
# # # # ]
67 : : }
68 : :
69 : : static void
70 : 0 : bdev_part_base_free(void *ctx)
71 : : {
72 : 0 : struct spdk_bdev_desc *desc = ctx;
73 : :
74 : 0 : spdk_bdev_close(desc);
75 : 0 : }
76 : :
77 : : void
78 : 5601 : spdk_bdev_part_base_free(struct spdk_bdev_part_base *base)
79 : : {
80 [ + + + - : 5601 : if (base->desc) {
- + ]
81 : : /* Close the underlying bdev on its same opened thread. */
82 [ + - + + : 5601 : if (base->thread && base->thread != spdk_get_thread()) {
+ - + - +
- + - ]
83 [ # # # # : 0 : spdk_thread_send_msg(base->thread, bdev_part_base_free, base->desc);
# # # # ]
84 : 0 : } else {
85 [ + - + - ]: 5601 : spdk_bdev_close(base->desc);
86 : : }
87 : 313 : }
88 : :
89 [ + + + - : 5601 : if (base->base_free_fn != NULL) {
- + ]
90 [ + - + - : 5514 : base->base_free_fn(base->ctx);
- + + - +
- + - ]
91 : 307 : }
92 : :
93 : 5601 : free(base);
94 : 5601 : }
95 : :
96 : : static void
97 : 757 : bdev_part_free_cb(void *io_device)
98 : : {
99 : 757 : struct spdk_bdev_part *part = io_device;
100 : : struct spdk_bdev_part_base *base;
101 : :
102 [ + + # # ]: 757 : assert(part);
103 [ - + # # : 757 : assert(part->internal.base);
# # # # #
# ]
104 : :
105 [ # # # # : 757 : base = part->internal.base;
# # ]
106 : :
107 [ + + # # : 757 : TAILQ_REMOVE(base->tailq, part, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ]
108 : :
109 [ + + # # ]: 757 : if (--base->ref == 0) {
110 [ # # # # ]: 268 : spdk_bdev_module_release_bdev(base->bdev);
111 : 268 : spdk_bdev_part_base_free(base);
112 : 24 : }
113 : :
114 [ # # # # ]: 757 : spdk_bdev_destruct_done(&part->internal.bdev, 0);
115 [ # # # # : 757 : free(part->internal.bdev.name);
# # # # ]
116 [ # # # # : 757 : free(part->internal.bdev.product_name);
# # # # ]
117 : 757 : free(part);
118 : 757 : }
119 : :
120 : : int
121 : 757 : spdk_bdev_part_free(struct spdk_bdev_part *part)
122 : : {
123 : 757 : spdk_io_device_unregister(part, bdev_part_free_cb);
124 : :
125 : : /* Return 1 to indicate that this is an asynchronous operation that isn't complete
126 : : * until spdk_bdev_destruct_done is called */
127 : 757 : return 1;
128 : : }
129 : :
130 : : void
131 : 24 : spdk_bdev_part_base_hotremove(struct spdk_bdev_part_base *part_base, struct bdev_part_tailq *tailq)
132 : : {
133 : : struct spdk_bdev_part *part, *tmp;
134 : :
135 [ + + + + : 95 : TAILQ_FOREACH_SAFE(part, tailq, tailq, tmp) {
# # # # #
# # # #
# ]
136 [ + + # # : 71 : if (part->internal.base == part_base) {
# # # # ]
137 [ # # # # ]: 71 : spdk_bdev_unregister(&part->internal.bdev, NULL, NULL);
138 : 8 : }
139 : 8 : }
140 : 24 : }
141 : :
142 : : static bool
143 : 1837961 : bdev_part_io_type_supported(void *_part, enum spdk_bdev_io_type io_type)
144 : : {
145 : 1837961 : struct spdk_bdev_part *part = _part;
146 : :
147 : : /* We can't decode/modify passthrough NVMe commands, so don't report
148 : : * that a partition supports these io types, even if the underlying
149 : : * bdev does.
150 : : */
151 [ + + ]: 1837961 : switch (io_type) {
152 : 13656 : case SPDK_BDEV_IO_TYPE_NVME_ADMIN:
153 : : case SPDK_BDEV_IO_TYPE_NVME_IO:
154 : : case SPDK_BDEV_IO_TYPE_NVME_IO_MD:
155 : 13731 : return false;
156 : 1516223 : default:
157 : 1824230 : break;
158 : : }
159 : :
160 [ # # # # : 2132237 : return part->internal.base->bdev->fn_table->io_type_supported(part->internal.base->bdev->ctxt,
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
161 : 308007 : io_type);
162 : 308082 : }
163 : :
164 : : static struct spdk_io_channel *
165 : 1609 : bdev_part_get_io_channel(void *_part)
166 : : {
167 : 1609 : struct spdk_bdev_part *part = _part;
168 : :
169 : 1609 : return spdk_get_io_channel(part);
170 : : }
171 : :
172 : : struct spdk_bdev *
173 : 90 : spdk_bdev_part_get_bdev(struct spdk_bdev_part *part)
174 : : {
175 [ # # # # ]: 90 : return &part->internal.bdev;
176 : : }
177 : :
178 : : struct spdk_bdev_part_base *
179 : 656 : spdk_bdev_part_get_base(struct spdk_bdev_part *part)
180 : : {
181 [ # # # # : 656 : return part->internal.base;
# # ]
182 : : }
183 : :
184 : : struct spdk_bdev *
185 : 4562 : spdk_bdev_part_get_base_bdev(struct spdk_bdev_part *part)
186 : : {
187 [ # # # # : 4562 : return part->internal.base->bdev;
# # # # #
# ]
188 : : }
189 : :
190 : : uint64_t
191 : 2699 : spdk_bdev_part_get_offset_blocks(struct spdk_bdev_part *part)
192 : : {
193 [ # # # # : 2699 : return part->internal.offset_blocks;
# # ]
194 : : }
195 : :
196 : : static int
197 : 22734930 : bdev_part_remap_dif(struct spdk_bdev_io *bdev_io, uint32_t offset,
198 : : uint32_t remapped_offset)
199 : : {
200 [ # # # # ]: 22734930 : struct spdk_bdev *bdev = bdev_io->bdev;
201 : 11145379 : struct spdk_dif_ctx dif_ctx;
202 : 22734930 : struct spdk_dif_error err_blk = {};
203 : : int rc;
204 : 11145379 : struct spdk_dif_ctx_init_ext_opts dif_opts;
205 : :
206 [ + - # # : 22734930 : if (spdk_likely(!(bdev_io->u.bdev.dif_check_flags & SPDK_DIF_FLAGS_REFTAG_CHECK))) {
# # # # #
# # # ]
207 : 22734930 : return 0;
208 : : }
209 : :
210 : 0 : dif_opts.size = SPDK_SIZEOF(&dif_opts, dif_pi_format);
211 [ # # ]: 0 : dif_opts.dif_pi_format = SPDK_DIF_PI_FORMAT_16;
212 : 0 : rc = spdk_dif_ctx_init(&dif_ctx,
213 [ # # # # : 0 : bdev->blocklen, bdev->md_len, bdev->md_interleave,
# # # # #
# # # #
# ]
214 [ # # # # : 0 : bdev->dif_is_head_of_md, bdev->dif_type, bdev_io->u.bdev.dif_check_flags,
# # # # #
# # # # #
# # # # ]
215 : 0 : offset, 0, 0, 0, 0, &dif_opts);
216 [ # # ]: 0 : if (rc != 0) {
217 : 0 : SPDK_ERRLOG("Initialization of DIF context failed\n");
218 : 0 : return rc;
219 : : }
220 : :
221 : 0 : spdk_dif_ctx_set_remapped_init_ref_tag(&dif_ctx, remapped_offset);
222 : :
223 [ # # # # : 0 : if (bdev->md_interleave) {
# # # # ]
224 [ # # # # : 0 : rc = spdk_dif_remap_ref_tag(bdev_io->u.bdev.iovs, bdev_io->u.bdev.iovcnt,
# # # # #
# # # # #
# # ]
225 [ # # # # : 0 : bdev_io->u.bdev.num_blocks, &dif_ctx, &err_blk, true);
# # # # ]
226 : 0 : } else {
227 : 0 : struct iovec md_iov = {
228 [ # # # # : 0 : .iov_base = bdev_io->u.bdev.md_buf,
# # # # ]
229 [ # # # # : 0 : .iov_len = bdev_io->u.bdev.num_blocks * bdev->md_len,
# # # # #
# # # ]
230 : : };
231 : :
232 [ # # # # : 0 : rc = spdk_dix_remap_ref_tag(&md_iov, bdev_io->u.bdev.num_blocks, &dif_ctx, &err_blk, true);
# # # # ]
233 : : }
234 : :
235 [ # # ]: 0 : if (rc != 0) {
236 [ # # ]: 0 : SPDK_ERRLOG("Remapping reference tag failed. type=%d, offset=%" PRIu32 "\n",
237 : : err_blk.err_type, err_blk.err_offset);
238 : 0 : }
239 : :
240 : 0 : return rc;
241 : 7158308 : }
242 : :
243 : : static void
244 : 29162008 : bdev_part_complete_io(struct spdk_bdev_io *bdev_io, bool success, void *cb_arg)
245 : : {
246 : 29162008 : struct spdk_bdev_io *part_io = cb_arg;
247 : : uint32_t offset, remapped_offset;
248 : : int rc;
249 : :
250 [ + + + # : 29162008 : switch (bdev_io->type) {
# # # ]
251 : 4938812 : case SPDK_BDEV_IO_TYPE_READ:
252 [ + + # # ]: 6652116 : if (success) {
253 [ # # # # : 6652033 : offset = bdev_io->u.bdev.offset_blocks;
# # # # ]
254 [ # # # # : 6652033 : remapped_offset = part_io->u.bdev.offset_blocks;
# # # # ]
255 : :
256 : 6652033 : rc = bdev_part_remap_dif(bdev_io, offset, remapped_offset);
257 [ - + ]: 6652033 : if (rc != 0) {
258 : 0 : success = false;
259 : 0 : }
260 : 1713221 : }
261 : 6652116 : break;
262 : 0 : case SPDK_BDEV_IO_TYPE_ZCOPY:
263 [ # # # # : 0 : spdk_bdev_io_set_buf(part_io, bdev_io->u.bdev.iovs[0].iov_base,
# # # # #
# # # #
# ]
264 [ # # # # : 0 : bdev_io->u.bdev.iovs[0].iov_len);
# # # # #
# # # #
# ]
265 : 0 : break;
266 : 15144985 : default:
267 : 22509892 : break;
268 : : }
269 : :
270 [ + + # # : 29162008 : if (part_io->internal.f.split) {
# # # # #
# ]
271 [ # # # # : 1765959 : part_io->internal.split.stored_user_cb(part_io, success, NULL);
# # # # #
# # # #
# ]
272 : 542499 : } else {
273 : 27396049 : spdk_bdev_io_complete_base_io_status(part_io, bdev_io);
274 : : }
275 : :
276 : 29162008 : spdk_bdev_free_io(bdev_io);
277 : 29162008 : }
278 : :
279 : : static inline void
280 : 22749912 : bdev_part_init_ext_io_opts(struct spdk_bdev_io *bdev_io, struct spdk_bdev_ext_io_opts *opts)
281 : : {
282 [ - + ]: 22749912 : memset(opts, 0, sizeof(*opts));
283 [ # # # # ]: 22749912 : opts->size = sizeof(*opts);
284 [ # # # # : 22749912 : opts->memory_domain = bdev_io->u.bdev.memory_domain;
# # # # #
# # # ]
285 [ # # # # : 22749912 : opts->memory_domain_ctx = bdev_io->u.bdev.memory_domain_ctx;
# # # # #
# # # ]
286 [ # # # # : 22749912 : opts->metadata = bdev_io->u.bdev.md_buf;
# # # # #
# # # ]
287 [ # # # # : 22749912 : opts->dif_check_flags_exclude_mask = ~bdev_io->u.bdev.dif_check_flags;
# # # # #
# # # ]
288 : 22749912 : }
289 : :
290 : : int
291 : 30607685 : spdk_bdev_part_submit_request_ext(struct spdk_bdev_part_channel *ch, struct spdk_bdev_io *bdev_io,
292 : : spdk_bdev_io_completion_cb cb)
293 : : {
294 [ # # # # ]: 30607685 : struct spdk_bdev_part *part = ch->part;
295 [ # # # # ]: 30607685 : struct spdk_io_channel *base_ch = ch->base_ch;
296 [ # # # # : 30607685 : struct spdk_bdev_desc *base_desc = part->internal.base->desc;
# # # # #
# ]
297 : 14478156 : struct spdk_bdev_ext_io_opts io_opts;
298 : : uint64_t offset, remapped_offset, remapped_src_offset;
299 : 30607685 : int rc = 0;
300 : :
301 [ + + ]: 30607685 : if (cb != NULL) {
302 [ # # # # : 1573307 : bdev_io->internal.f.split = true;
# # # # ]
303 [ # # # # : 1573307 : bdev_io->internal.split.stored_user_cb = cb;
# # # # ]
304 : 349847 : }
305 : :
306 [ # # # # : 30607685 : offset = bdev_io->u.bdev.offset_blocks;
# # # # ]
307 [ # # # # : 30607685 : remapped_offset = offset + part->internal.offset_blocks;
# # ]
308 : :
309 : : /* Modify the I/O to adjust for the offset within the base bdev. */
310 [ + + + + : 30607685 : switch (bdev_io->type) {
+ + + - +
- + + # #
# # ]
311 : 4938812 : case SPDK_BDEV_IO_TYPE_READ:
312 : 6667667 : bdev_part_init_ext_io_opts(bdev_io, &io_opts);
313 [ # # # # : 8396522 : rc = spdk_bdev_readv_blocks_ext(base_desc, base_ch, bdev_io->u.bdev.iovs,
# # # # ]
314 [ # # # # : 1728855 : bdev_io->u.bdev.iovcnt, remapped_offset,
# # # # ]
315 [ # # # # : 1728855 : bdev_io->u.bdev.num_blocks,
# # # # ]
316 : 1728855 : bdev_part_complete_io, bdev_io, &io_opts);
317 : 6667667 : break;
318 : 10637810 : case SPDK_BDEV_IO_TYPE_WRITE:
319 : 16202083 : rc = bdev_part_remap_dif(bdev_io, offset, remapped_offset);
320 [ + + ]: 16202083 : if (rc != 0) {
321 : 0 : return SPDK_BDEV_IO_STATUS_FAILED;
322 : : }
323 : 16202083 : bdev_part_init_ext_io_opts(bdev_io, &io_opts);
324 [ # # # # : 21766356 : rc = spdk_bdev_writev_blocks_ext(base_desc, base_ch, bdev_io->u.bdev.iovs,
# # # # ]
325 [ # # # # : 5564273 : bdev_io->u.bdev.iovcnt, remapped_offset,
# # # # ]
326 [ # # # # : 5564273 : bdev_io->u.bdev.num_blocks,
# # # # ]
327 : 5564273 : bdev_part_complete_io, bdev_io, &io_opts);
328 : 16202083 : break;
329 : 642797 : case SPDK_BDEV_IO_TYPE_WRITE_ZEROES:
330 : 950093 : rc = spdk_bdev_write_zeroes_blocks(base_desc, base_ch, remapped_offset,
331 [ # # # # : 153648 : bdev_io->u.bdev.num_blocks, bdev_part_complete_io,
# # # # ]
332 : 153648 : bdev_io);
333 : 796445 : break;
334 : 3853874 : case SPDK_BDEV_IO_TYPE_UNMAP:
335 : 10008058 : rc = spdk_bdev_unmap_blocks(base_desc, base_ch, remapped_offset,
336 [ # # # # : 3077092 : bdev_io->u.bdev.num_blocks, bdev_part_complete_io,
# # # # ]
337 : 3077092 : bdev_io);
338 : 6930966 : break;
339 : 10382 : case SPDK_BDEV_IO_TYPE_FLUSH:
340 : 10382 : rc = spdk_bdev_flush_blocks(base_desc, base_ch, remapped_offset,
341 [ # # # # : 0 : bdev_io->u.bdev.num_blocks, bdev_part_complete_io,
# # # # ]
342 : 0 : bdev_io);
343 : 10382 : break;
344 : 52 : case SPDK_BDEV_IO_TYPE_RESET:
345 : 72 : rc = spdk_bdev_reset(base_desc, base_ch,
346 : 10 : bdev_part_complete_io, bdev_io);
347 : 62 : break;
348 : 0 : case SPDK_BDEV_IO_TYPE_ABORT:
349 [ # # # # : 0 : rc = spdk_bdev_abort(base_desc, base_ch, bdev_io->u.abort.bio_to_abort,
# # # # ]
350 : 0 : bdev_part_complete_io, bdev_io);
351 : 0 : break;
352 : 0 : case SPDK_BDEV_IO_TYPE_ZCOPY:
353 : 0 : rc = spdk_bdev_zcopy_start(base_desc, base_ch, NULL, 0, remapped_offset,
354 [ # # # # : 0 : bdev_io->u.bdev.num_blocks, bdev_io->u.bdev.zcopy.populate,
# # # # #
# # # # #
# # ]
355 : 0 : bdev_part_complete_io, bdev_io);
356 : 0 : break;
357 : 20 : case SPDK_BDEV_IO_TYPE_COMPARE:
358 [ + - # # : 20 : if (!bdev_io->u.bdev.md_buf) {
# # # # #
# ]
359 : 20 : rc = spdk_bdev_comparev_blocks(base_desc, base_ch,
360 [ # # # # : 0 : bdev_io->u.bdev.iovs,
# # # # ]
361 [ # # # # : 0 : bdev_io->u.bdev.iovcnt,
# # # # ]
362 : 0 : remapped_offset,
363 [ # # # # : 0 : bdev_io->u.bdev.num_blocks,
# # # # ]
364 : 0 : bdev_part_complete_io, bdev_io);
365 : 0 : } else {
366 : 0 : rc = spdk_bdev_comparev_blocks_with_md(base_desc, base_ch,
367 [ # # # # : 0 : bdev_io->u.bdev.iovs,
# # # # ]
368 [ # # # # : 0 : bdev_io->u.bdev.iovcnt,
# # # # ]
369 [ # # # # : 0 : bdev_io->u.bdev.md_buf,
# # # # ]
370 : 0 : remapped_offset,
371 [ # # # # : 0 : bdev_io->u.bdev.num_blocks,
# # # # ]
372 : 0 : bdev_part_complete_io, bdev_io);
373 : : }
374 : 20 : break;
375 : 0 : case SPDK_BDEV_IO_TYPE_COMPARE_AND_WRITE:
376 [ # # # # : 0 : rc = spdk_bdev_comparev_and_writev_blocks(base_desc, base_ch, bdev_io->u.bdev.iovs,
# # # # ]
377 [ # # # # : 0 : bdev_io->u.bdev.iovcnt,
# # # # ]
378 [ # # # # : 0 : bdev_io->u.bdev.fused_iovs,
# # # # ]
379 [ # # # # : 0 : bdev_io->u.bdev.fused_iovcnt,
# # # # ]
380 : 0 : remapped_offset,
381 [ # # # # : 0 : bdev_io->u.bdev.num_blocks,
# # # # ]
382 : 0 : bdev_part_complete_io, bdev_io);
383 : 0 : break;
384 : 50 : case SPDK_BDEV_IO_TYPE_COPY:
385 [ # # # # : 60 : remapped_src_offset = bdev_io->u.bdev.copy.src_offset_blocks + part->internal.offset_blocks;
# # # # #
# # # # #
# # ]
386 : 70 : rc = spdk_bdev_copy_blocks(base_desc, base_ch, remapped_offset, remapped_src_offset,
387 [ # # # # : 10 : bdev_io->u.bdev.num_blocks, bdev_part_complete_io,
# # # # ]
388 : 10 : bdev_io);
389 : 60 : break;
390 : 0 : default:
391 [ # # # # ]: 0 : SPDK_ERRLOG("unknown I/O type %d\n", bdev_io->type);
392 : 0 : return SPDK_BDEV_IO_STATUS_FAILED;
393 : : }
394 : :
395 : 30607685 : return rc;
396 : 10523888 : }
397 : :
398 : : int
399 : 27590182 : spdk_bdev_part_submit_request(struct spdk_bdev_part_channel *ch, struct spdk_bdev_io *bdev_io)
400 : : {
401 : 27590182 : return spdk_bdev_part_submit_request_ext(ch, bdev_io, NULL);
402 : : }
403 : :
404 : : static int
405 : 1609 : bdev_part_channel_create_cb(void *io_device, void *ctx_buf)
406 : : {
407 : 1609 : struct spdk_bdev_part *part = (struct spdk_bdev_part *)io_device;
408 : 1609 : struct spdk_bdev_part_channel *ch = ctx_buf;
409 : :
410 [ # # # # ]: 1609 : ch->part = part;
411 [ # # # # : 1609 : ch->base_ch = spdk_bdev_get_io_channel(part->internal.base->desc);
# # # # #
# # # #
# ]
412 [ + + # # : 1609 : if (ch->base_ch == NULL) {
# # ]
413 : 0 : return -1;
414 : : }
415 : :
416 [ + + # # : 1609 : if (part->internal.base->ch_create_cb) {
# # # # #
# # # ]
417 [ # # # # : 245 : return part->internal.base->ch_create_cb(io_device, ctx_buf);
# # # # #
# # # #
# ]
418 : : } else {
419 : 1364 : return 0;
420 : : }
421 : 176 : }
422 : :
423 : : static void
424 : 1609 : bdev_part_channel_destroy_cb(void *io_device, void *ctx_buf)
425 : : {
426 : 1609 : struct spdk_bdev_part *part = (struct spdk_bdev_part *)io_device;
427 : 1609 : struct spdk_bdev_part_channel *ch = ctx_buf;
428 : :
429 [ + + # # : 1609 : if (part->internal.base->ch_destroy_cb) {
# # # # #
# # # ]
430 [ # # # # : 245 : part->internal.base->ch_destroy_cb(io_device, ctx_buf);
# # # # #
# # # #
# ]
431 : 4 : }
432 [ # # # # ]: 1609 : spdk_put_io_channel(ch->base_ch);
433 : 1609 : }
434 : :
435 : : static void
436 : 1 : bdev_part_base_event_cb(enum spdk_bdev_event_type type, struct spdk_bdev *bdev,
437 : : void *event_ctx)
438 : : {
439 : 1 : struct spdk_bdev_part_base *base = event_ctx;
440 : :
441 [ + - ]: 1 : switch (type) {
442 : 1 : case SPDK_BDEV_EVENT_REMOVE:
443 [ # # # # : 1 : base->remove_cb(base);
# # # # ]
444 : 1 : break;
445 : 0 : default:
446 : 0 : SPDK_NOTICELOG("Unsupported bdev event: type %d\n", type);
447 : 0 : break;
448 : : }
449 : 1 : }
450 : :
451 : : int
452 : 5729 : spdk_bdev_part_base_construct_ext(const char *bdev_name,
453 : : spdk_bdev_remove_cb_t remove_cb, struct spdk_bdev_module *module,
454 : : struct spdk_bdev_fn_table *fn_table, struct bdev_part_tailq *tailq,
455 : : spdk_bdev_part_base_free_fn free_fn, void *ctx,
456 : : uint32_t channel_size, spdk_io_channel_create_cb ch_create_cb,
457 : : spdk_io_channel_destroy_cb ch_destroy_cb,
458 : : struct spdk_bdev_part_base **_base)
459 : : {
460 : : int rc;
461 : : struct spdk_bdev_part_base *base;
462 : :
463 [ + + ]: 5729 : if (_base == NULL) {
464 : 0 : return -EINVAL;
465 : : }
466 : :
467 : 5729 : base = calloc(1, sizeof(*base));
468 [ + + ]: 5729 : if (!base) {
469 : 0 : SPDK_ERRLOG("Memory allocation failure\n");
470 : 0 : return -ENOMEM;
471 : : }
472 [ + - + - ]: 5729 : fn_table->get_io_channel = bdev_part_get_io_channel;
473 [ + - + - ]: 5729 : fn_table->io_type_supported = bdev_part_io_type_supported;
474 : :
475 [ + - + - ]: 5729 : base->desc = NULL;
476 [ + - + - ]: 5729 : base->ref = 0;
477 [ + - + - ]: 5729 : base->module = module;
478 [ + - + - ]: 5729 : base->fn_table = fn_table;
479 [ + - + - ]: 5729 : base->tailq = tailq;
480 [ + - + - ]: 5729 : base->base_free_fn = free_fn;
481 [ + - + - ]: 5729 : base->ctx = ctx;
482 [ + - + - ]: 5729 : base->claimed = false;
483 [ + - + - ]: 5729 : base->channel_size = channel_size;
484 [ + - + - ]: 5729 : base->ch_create_cb = ch_create_cb;
485 [ + - + - ]: 5729 : base->ch_destroy_cb = ch_destroy_cb;
486 [ + - + - ]: 5729 : base->remove_cb = remove_cb;
487 : :
488 [ + - ]: 5729 : rc = spdk_bdev_open_ext(bdev_name, false, bdev_part_base_event_cb, base, &base->desc);
489 [ + + ]: 5729 : if (rc) {
490 [ + - ]: 128 : if (rc == -ENODEV) {
491 : 128 : free(base);
492 : 19 : } else {
493 [ # # ]: 0 : SPDK_ERRLOG("could not open bdev %s: %s\n", bdev_name, spdk_strerror(-rc));
494 : 0 : spdk_bdev_part_base_free(base);
495 : : }
496 : 128 : return rc;
497 : : }
498 : :
499 [ + - + - : 5601 : base->bdev = spdk_bdev_desc_get_bdev(base->desc);
+ - + - ]
500 : :
501 : : /* Save the thread where the base device is opened */
502 [ + - + - ]: 5601 : base->thread = spdk_get_thread();
503 : :
504 [ + - ]: 5601 : *_base = base;
505 : :
506 : 5601 : return 0;
507 : 332 : }
508 : :
509 : : void
510 : 773 : spdk_bdev_part_construct_opts_init(struct spdk_bdev_part_construct_opts *opts, uint64_t size)
511 : : {
512 [ + + ]: 773 : if (opts == NULL) {
513 : 0 : SPDK_ERRLOG("opts should not be NULL\n");
514 [ # # # # ]: 0 : assert(opts != NULL);
515 : 0 : return;
516 : : }
517 [ + + ]: 773 : if (size == 0) {
518 : 0 : SPDK_ERRLOG("size should not be zero\n");
519 [ # # # # ]: 0 : assert(size != 0);
520 : 0 : return;
521 : : }
522 : :
523 [ - + ]: 773 : memset(opts, 0, size);
524 [ # # # # ]: 773 : opts->opts_size = size;
525 : 98 : }
526 : :
527 : : static void
528 : 100 : part_construct_opts_copy(const struct spdk_bdev_part_construct_opts *src,
529 : : struct spdk_bdev_part_construct_opts *dst)
530 : : {
531 [ - + # # : 100 : if (src->opts_size == 0) {
# # ]
532 : 0 : SPDK_ERRLOG("size should not be zero\n");
533 [ # # ]: 0 : assert(false);
534 : : }
535 : :
536 [ - + ]: 100 : memset(dst, 0, sizeof(*dst));
537 [ # # # # : 100 : dst->opts_size = src->opts_size;
# # # # ]
538 : :
539 : : #define FIELD_OK(field) \
540 : : offsetof(struct spdk_bdev_part_construct_opts, field) + sizeof(src->field) <= src->opts_size
541 : :
542 : : #define SET_FIELD(field) \
543 : : if (FIELD_OK(field)) { \
544 : : dst->field = src->field; \
545 : : } \
546 : :
547 [ + + # # : 100 : SET_FIELD(uuid);
# # # # #
# ]
548 : :
549 : : /* You should not remove this statement, but need to update the assert statement
550 : : * if you add a new field, and also add a corresponding SET_FIELD statement */
551 : : SPDK_STATIC_ASSERT(sizeof(struct spdk_bdev_part_construct_opts) == 24, "Incorrect size");
552 : :
553 : : #undef FIELD_OK
554 : : #undef SET_FIELD
555 : 100 : }
556 : :
557 : : int
558 : 773 : spdk_bdev_part_construct_ext(struct spdk_bdev_part *part, struct spdk_bdev_part_base *base,
559 : : char *name, uint64_t offset_blocks, uint64_t num_blocks,
560 : : char *product_name, const struct spdk_bdev_part_construct_opts *_opts)
561 : : {
562 : : int rc;
563 : 773 : bool first_claimed = false;
564 : 494 : struct spdk_bdev_part_construct_opts opts;
565 : 494 : struct spdk_uuid ns_uuid;
566 : :
567 [ + + ]: 773 : if (_opts == NULL) {
568 : 673 : spdk_bdev_part_construct_opts_init(&opts, sizeof(opts));
569 : 97 : } else {
570 : 100 : part_construct_opts_copy(_opts, &opts);
571 : : }
572 : :
573 [ # # # # : 773 : part->internal.bdev.blocklen = base->bdev->blocklen;
# # # # #
# # # # #
# # ]
574 [ # # # # : 773 : part->internal.bdev.blockcnt = num_blocks;
# # # # ]
575 [ # # # # : 773 : part->internal.offset_blocks = offset_blocks;
# # ]
576 : :
577 [ # # # # : 773 : part->internal.bdev.write_cache = base->bdev->write_cache;
# # # # #
# # # # #
# # ]
578 [ # # # # : 773 : part->internal.bdev.required_alignment = base->bdev->required_alignment;
# # # # #
# # # # #
# # ]
579 [ # # # # : 773 : part->internal.bdev.ctxt = part;
# # # # ]
580 [ # # # # : 773 : part->internal.bdev.module = base->module;
# # # # #
# # # ]
581 [ # # # # : 773 : part->internal.bdev.fn_table = base->fn_table;
# # # # #
# # # ]
582 : :
583 [ - + # # : 773 : part->internal.bdev.md_interleave = base->bdev->md_interleave;
# # # # #
# # # # #
# # # # ]
584 [ # # # # : 773 : part->internal.bdev.md_len = base->bdev->md_len;
# # # # #
# # # # #
# # ]
585 [ # # # # : 773 : part->internal.bdev.dif_type = base->bdev->dif_type;
# # # # #
# # # # #
# # ]
586 [ - + # # : 773 : part->internal.bdev.dif_is_head_of_md = base->bdev->dif_is_head_of_md;
# # # # #
# # # # #
# # # # ]
587 [ # # # # : 773 : part->internal.bdev.dif_check_flags = base->bdev->dif_check_flags;
# # # # #
# # # # #
# # ]
588 : :
589 [ - + # # : 773 : part->internal.bdev.name = strdup(name);
# # # # #
# ]
590 [ + + # # : 773 : if (part->internal.bdev.name == NULL) {
# # # # #
# ]
591 [ # # # # ]: 0 : SPDK_ERRLOG("Failed to allocate name for new part of bdev %s\n", spdk_bdev_get_name(base->bdev));
592 : 0 : return -1;
593 : : }
594 : :
595 [ - + # # : 773 : part->internal.bdev.product_name = strdup(product_name);
# # # # #
# ]
596 [ + + # # : 773 : if (part->internal.bdev.product_name == NULL) {
# # # # #
# ]
597 [ # # # # : 0 : free(part->internal.bdev.name);
# # # # ]
598 [ # # # # ]: 0 : SPDK_ERRLOG("Failed to allocate product name for new part of bdev %s\n",
599 : : spdk_bdev_get_name(base->bdev));
600 : 0 : return -1;
601 : : }
602 : :
603 : : /* The caller may have already specified a UUID. If not, we'll generate one
604 : : * based on the namespace UUID, the base bdev's UUID and the block range of the
605 : : * partition.
606 : : */
607 [ + + ]: 773 : if (!spdk_uuid_is_null(&opts.uuid)) {
608 [ # # # # : 100 : spdk_uuid_copy(&part->internal.bdev.uuid, &opts.uuid);
# # ]
609 : 1 : } else {
610 : : struct {
611 : : struct spdk_uuid uuid;
612 : : uint64_t offset_blocks;
613 : : uint64_t num_blocks;
614 : 443 : } base_name;
615 : :
616 : : /* We need to create a unique base name for this partition. We can't just use
617 : : * the base bdev's UUID, since it may be used for multiple partitions. So
618 : : * construct a binary name consisting of the uuid + the block range for this
619 : : * partition.
620 : : */
621 [ # # # # : 673 : spdk_uuid_copy(&base_name.uuid, &base->bdev->uuid);
# # ]
622 [ # # ]: 673 : base_name.offset_blocks = offset_blocks;
623 [ # # ]: 673 : base_name.num_blocks = num_blocks;
624 : :
625 : 673 : spdk_uuid_parse(&ns_uuid, BDEV_PART_NAMESPACE_UUID);
626 [ # # # # : 673 : rc = spdk_uuid_generate_sha1(&part->internal.bdev.uuid, &ns_uuid,
# # ]
627 : : (const char *)&base_name, sizeof(base_name));
628 [ - + ]: 673 : if (rc) {
629 : 0 : SPDK_ERRLOG("Could not generate new UUID\n");
630 [ # # # # : 0 : free(part->internal.bdev.name);
# # # # ]
631 [ # # # # : 0 : free(part->internal.bdev.product_name);
# # # # ]
632 : 0 : return -1;
633 : : }
634 : : }
635 : :
636 [ # # ]: 773 : base->ref++;
637 [ # # # # : 773 : part->internal.base = base;
# # ]
638 : :
639 [ + + + + : 773 : if (!base->claimed) {
# # # # ]
640 : : int rc;
641 : :
642 [ # # # # : 276 : rc = spdk_bdev_module_claim_bdev(base->bdev, base->desc, base->module);
# # # # #
# # # ]
643 [ - + ]: 276 : if (rc) {
644 [ # # # # ]: 0 : SPDK_ERRLOG("could not claim bdev %s\n", spdk_bdev_get_name(base->bdev));
645 [ # # # # : 0 : free(part->internal.bdev.name);
# # # # ]
646 [ # # # # : 0 : free(part->internal.bdev.product_name);
# # # # ]
647 [ # # ]: 0 : base->ref--;
648 : 0 : return -1;
649 : : }
650 [ # # # # ]: 276 : base->claimed = true;
651 : 276 : first_claimed = true;
652 : 26 : }
653 : :
654 : 871 : spdk_io_device_register(part, bdev_part_channel_create_cb,
655 : : bdev_part_channel_destroy_cb,
656 [ # # # # ]: 98 : base->channel_size,
657 : 98 : name);
658 : :
659 [ # # # # ]: 773 : rc = spdk_bdev_register(&part->internal.bdev);
660 [ + + ]: 773 : if (rc == 0) {
661 [ # # # # : 769 : TAILQ_INSERT_TAIL(base->tailq, part, tailq);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # ]
662 : 97 : } else {
663 : 4 : spdk_io_device_unregister(part, NULL);
664 [ - + # # ]: 4 : if (--base->ref == 0) {
665 [ # # # # ]: 0 : spdk_bdev_module_release_bdev(base->bdev);
666 : 0 : }
667 [ # # # # : 4 : free(part->internal.bdev.name);
# # # # ]
668 [ # # # # : 4 : free(part->internal.bdev.product_name);
# # # # ]
669 [ + + # # ]: 4 : if (first_claimed == true) {
670 [ # # # # ]: 0 : base->claimed = false;
671 : 0 : }
672 : : }
673 : :
674 : 773 : return rc;
675 : 98 : }
676 : :
677 : : int
678 : 673 : spdk_bdev_part_construct(struct spdk_bdev_part *part, struct spdk_bdev_part_base *base,
679 : : char *name, uint64_t offset_blocks, uint64_t num_blocks,
680 : : char *product_name)
681 : : {
682 : 770 : return spdk_bdev_part_construct_ext(part, base, name, offset_blocks, num_blocks,
683 : 97 : product_name, NULL);
684 : : }
|