Line data Source code
1 : /* SPDX-License-Identifier: BSD-3-Clause
2 : * Copyright (C) 2017 Intel Corporation.
3 : * All rights reserved.
4 : * Copyright (c) 2022-2023 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
5 : */
6 :
7 : #ifndef SPDK_BLOBSTORE_H
8 : #define SPDK_BLOBSTORE_H
9 :
10 : #include "spdk/assert.h"
11 : #include "spdk/blob.h"
12 : #include "spdk/queue.h"
13 : #include "spdk/util.h"
14 : #include "spdk/tree.h"
15 : #include "spdk/thread.h"
16 :
17 : #include "request.h"
18 :
19 : /* In Memory Data Structures
20 : *
21 : * The following data structures exist only in memory.
22 : */
23 :
24 : #define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024)
25 : #define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX
26 : #define SPDK_BLOB_OPTS_MAX_MD_OPS 32
27 : #define SPDK_BLOB_OPTS_DEFAULT_CHANNEL_OPS 512
28 : #define SPDK_BLOB_BLOBID_HIGH_BIT (1ULL << 32)
29 :
30 : struct spdk_xattr {
31 : uint32_t index;
32 : uint16_t value_len;
33 : char *name;
34 : void *value;
35 : TAILQ_ENTRY(spdk_xattr) link;
36 : };
37 :
38 : /* The mutable part of the blob data that is sync'd to
39 : * disk. The data in here is both mutable and persistent.
40 : */
41 : struct spdk_blob_mut_data {
42 : /* Number of data clusters in the blob */
43 : uint64_t num_clusters;
44 :
45 : /* Array LBAs that are the beginning of a cluster, in
46 : * the order they appear in the blob.
47 : */
48 : uint64_t *clusters;
49 :
50 : /* The size of the clusters array. This is greater than or
51 : * equal to 'num_clusters'.
52 : */
53 : size_t cluster_array_size;
54 :
55 : /* The number of allocated clusters in the clusters array */
56 : uint64_t num_allocated_clusters;
57 :
58 : /* Number of extent pages */
59 : uint64_t num_extent_pages;
60 :
61 : /* Array of page offsets into the metadata region,
62 : * containing extents. Can contain entries for not yet
63 : * allocated pages. */
64 : uint32_t *extent_pages;
65 :
66 : /* The size of the extent page array. This is greater than or
67 : * equal to 'num_extent_pages'. */
68 : size_t extent_pages_array_size;
69 :
70 : /* Number of metadata pages */
71 : uint32_t num_pages;
72 :
73 : /* Array of page offsets into the metadata region, in
74 : * the order of the metadata page sequence.
75 : */
76 : uint32_t *pages;
77 : };
78 :
79 : enum spdk_blob_state {
80 : /* The blob in-memory version does not match the on-disk
81 : * version.
82 : */
83 : SPDK_BLOB_STATE_DIRTY,
84 :
85 : /* The blob in memory version of the blob matches the on disk
86 : * version.
87 : */
88 : SPDK_BLOB_STATE_CLEAN,
89 :
90 : /* The in-memory state being synchronized with the on-disk
91 : * blob state. */
92 : SPDK_BLOB_STATE_LOADING,
93 : };
94 :
95 : TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr);
96 :
97 : struct spdk_blob_list {
98 : spdk_blob_id id;
99 : size_t clone_count;
100 : TAILQ_HEAD(, spdk_blob_list) clones;
101 : TAILQ_ENTRY(spdk_blob_list) link;
102 : };
103 :
104 : struct spdk_blob {
105 : struct spdk_blob_store *bs;
106 :
107 : uint32_t open_ref;
108 :
109 : spdk_blob_id id;
110 : spdk_blob_id parent_id;
111 :
112 : enum spdk_blob_state state;
113 :
114 : /* Two copies of the mutable data. One is a version
115 : * that matches the last known data on disk (clean).
116 : * The other (active) is the current data. Syncing
117 : * a blob makes the clean match the active.
118 : */
119 : struct spdk_blob_mut_data clean;
120 : struct spdk_blob_mut_data active;
121 :
122 : bool invalid;
123 : bool data_ro;
124 : bool md_ro;
125 :
126 : uint64_t invalid_flags;
127 : uint64_t data_ro_flags;
128 : uint64_t md_ro_flags;
129 :
130 : struct spdk_bs_dev *back_bs_dev;
131 :
132 : /* When deparenting child of an esnap clone, two blobs
133 : * can share the same back_bs_dev. So, we need to keep
134 : * track of shared references.
135 : *
136 : * Note that these links will form a headless list,
137 : * so le_prev of the first element is NULL.
138 : */
139 : LIST_ENTRY(spdk_blob) back_bs_dev_link;
140 :
141 : /* TODO: The xattrs are mutable, but we don't want to be
142 : * copying them unnecessarily. Figure this out.
143 : */
144 : struct spdk_xattr_tailq xattrs;
145 : struct spdk_xattr_tailq xattrs_internal;
146 :
147 : RB_ENTRY(spdk_blob) link;
148 :
149 : uint32_t frozen_refcnt;
150 : bool locked_operation_in_progress;
151 : enum blob_clear_method clear_method;
152 : bool extent_rle_found;
153 : bool extent_table_found;
154 : bool use_extent_table;
155 :
156 : /* A list of pending metadata pending_persists */
157 : TAILQ_HEAD(, spdk_blob_persist_ctx) pending_persists;
158 : TAILQ_HEAD(, spdk_blob_persist_ctx) persists_to_complete;
159 :
160 : /* Number of data clusters retrieved from extent table,
161 : * that many have to be read from extent pages. */
162 : uint64_t remaining_clusters_in_et;
163 : };
164 :
165 : struct spdk_blob_store {
166 : uint64_t md_start; /* Offset from beginning of disk, in pages */
167 : uint32_t md_len; /* Count, in pages */
168 :
169 : struct spdk_io_channel *md_channel;
170 : uint32_t max_channel_ops;
171 :
172 : struct spdk_thread *md_thread;
173 :
174 : struct spdk_bs_dev *dev;
175 :
176 : struct spdk_bit_array *used_md_pages; /* Protected by used_lock */
177 : struct spdk_bit_pool *used_clusters; /* Protected by used_lock */
178 : struct spdk_bit_array *used_blobids;
179 : struct spdk_bit_array *open_blobids;
180 :
181 : struct spdk_spinlock used_lock;
182 :
183 : uint32_t cluster_sz;
184 : uint64_t total_clusters;
185 : uint64_t total_data_clusters;
186 : uint64_t num_free_clusters; /* Protected by used_lock */
187 : uint64_t pages_per_cluster;
188 : uint8_t pages_per_cluster_shift;
189 : uint32_t io_unit_size;
190 :
191 : spdk_blob_id super_blob;
192 : struct spdk_bs_type bstype;
193 :
194 : struct spdk_bs_cpl unload_cpl;
195 : int unload_err;
196 :
197 : RB_HEAD(spdk_blob_tree, spdk_blob) open_blobs;
198 : TAILQ_HEAD(, spdk_blob_list) snapshots;
199 :
200 : bool clean;
201 :
202 : spdk_bs_esnap_dev_create esnap_bs_dev_create;
203 : void *esnap_ctx;
204 :
205 : /* If external snapshot channels are being destroyed while
206 : * the blobstore is unloaded, the unload is deferred until
207 : * after the channel destruction completes.
208 : */
209 : uint32_t esnap_channels_unloading;
210 : spdk_bs_op_complete esnap_unload_cb_fn;
211 : void *esnap_unload_cb_arg;
212 : };
213 :
214 : struct spdk_bs_channel {
215 : struct spdk_bs_request_set *req_mem;
216 : TAILQ_HEAD(, spdk_bs_request_set) reqs;
217 :
218 : struct spdk_blob_store *bs;
219 :
220 : struct spdk_bs_dev *dev;
221 : struct spdk_io_channel *dev_channel;
222 :
223 : /* This page is only used during insert of a new cluster. */
224 : struct spdk_blob_md_page *new_cluster_page;
225 :
226 : TAILQ_HEAD(, spdk_bs_request_set) need_cluster_alloc;
227 : TAILQ_HEAD(, spdk_bs_request_set) queued_io;
228 :
229 : RB_HEAD(blob_esnap_channel_tree, blob_esnap_channel) esnap_channels;
230 : };
231 :
232 : /** operation type */
233 : enum spdk_blob_op_type {
234 : SPDK_BLOB_WRITE,
235 : SPDK_BLOB_READ,
236 : SPDK_BLOB_UNMAP,
237 : SPDK_BLOB_WRITE_ZEROES,
238 : SPDK_BLOB_WRITEV,
239 : SPDK_BLOB_READV,
240 : };
241 :
242 : /* back bs_dev */
243 :
244 : #define BLOB_SNAPSHOT "SNAP"
245 : #define SNAPSHOT_IN_PROGRESS "SNAPTMP"
246 : #define SNAPSHOT_PENDING_REMOVAL "SNAPRM"
247 : #define BLOB_EXTERNAL_SNAPSHOT_ID "EXTSNAP"
248 :
249 : struct spdk_blob_bs_dev {
250 : struct spdk_bs_dev bs_dev;
251 : struct spdk_blob *blob;
252 : };
253 :
254 : /* On-Disk Data Structures
255 : *
256 : * The following data structures exist on disk.
257 : */
258 : #define SPDK_BS_INITIAL_VERSION 1
259 : #define SPDK_BS_VERSION 3 /* current version */
260 :
261 : #pragma pack(push, 1)
262 :
263 : #define SPDK_MD_MASK_TYPE_USED_PAGES 0
264 : #define SPDK_MD_MASK_TYPE_USED_CLUSTERS 1
265 : #define SPDK_MD_MASK_TYPE_USED_BLOBIDS 2
266 :
267 : struct spdk_bs_md_mask {
268 : uint8_t type;
269 : uint32_t length; /* In bits */
270 : uint8_t mask[0];
271 : };
272 :
273 : #define SPDK_MD_DESCRIPTOR_TYPE_PADDING 0
274 : #define SPDK_MD_DESCRIPTOR_TYPE_XATTR 2
275 : #define SPDK_MD_DESCRIPTOR_TYPE_FLAGS 3
276 : #define SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL 4
277 :
278 : /* Following descriptors define cluster layout in a blob.
279 : * EXTENT_RLE cannot be present in blobs metadata,
280 : * at the same time as EXTENT_TABLE and EXTENT_PAGE descriptors. */
281 :
282 : /* EXTENT_RLE descriptor holds an array of LBA that points to
283 : * beginning of allocated clusters. The array is run-length encoded,
284 : * with 0's being unallocated clusters. It is part of serialized
285 : * metadata chain for a blob. */
286 : #define SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE 1
287 : /* EXTENT_TABLE descriptor holds array of md page offsets that
288 : * point to pages with EXTENT_PAGE descriptor. The 0's in the array
289 : * are run-length encoded, non-zero values are unallocated pages.
290 : * It is part of serialized metadata chain for a blob. */
291 : #define SPDK_MD_DESCRIPTOR_TYPE_EXTENT_TABLE 5
292 : /* EXTENT_PAGE descriptor holds an array of LBAs that point to
293 : * beginning of allocated clusters. The array is run-length encoded,
294 : * with 0's being unallocated clusters. It is NOT part of
295 : * serialized metadata chain for a blob. */
296 : #define SPDK_MD_DESCRIPTOR_TYPE_EXTENT_PAGE 6
297 :
298 : struct spdk_blob_md_descriptor_xattr {
299 : uint8_t type;
300 : uint32_t length;
301 :
302 : uint16_t name_length;
303 : uint16_t value_length;
304 :
305 : char name[0];
306 : /* String name immediately followed by string value. */
307 : };
308 :
309 : struct spdk_blob_md_descriptor_extent_rle {
310 : uint8_t type;
311 : uint32_t length;
312 :
313 : struct {
314 : uint32_t cluster_idx;
315 : uint32_t length; /* In units of clusters */
316 : } extents[0];
317 : };
318 :
319 : struct spdk_blob_md_descriptor_extent_table {
320 : uint8_t type;
321 : uint32_t length;
322 :
323 : /* Number of data clusters in the blob */
324 : uint64_t num_clusters;
325 :
326 : struct {
327 : uint32_t page_idx;
328 : uint32_t num_pages; /* In units of pages */
329 : } extent_page[0];
330 : };
331 :
332 : struct spdk_blob_md_descriptor_extent_page {
333 : uint8_t type;
334 : uint32_t length;
335 :
336 : /* First cluster index in this extent page */
337 : uint32_t start_cluster_idx;
338 :
339 : uint32_t cluster_idx[0];
340 : };
341 :
342 : #define SPDK_BLOB_THIN_PROV (1ULL << 0)
343 : #define SPDK_BLOB_INTERNAL_XATTR (1ULL << 1)
344 : #define SPDK_BLOB_EXTENT_TABLE (1ULL << 2)
345 : #define SPDK_BLOB_EXTERNAL_SNAPSHOT (1ULL << 3)
346 : #define SPDK_BLOB_INVALID_FLAGS_MASK (SPDK_BLOB_THIN_PROV | SPDK_BLOB_INTERNAL_XATTR | \
347 : SPDK_BLOB_EXTENT_TABLE | SPDK_BLOB_EXTERNAL_SNAPSHOT)
348 :
349 : #define SPDK_BLOB_READ_ONLY (1ULL << 0)
350 : #define SPDK_BLOB_DATA_RO_FLAGS_MASK SPDK_BLOB_READ_ONLY
351 :
352 : #define SPDK_BLOB_CLEAR_METHOD_SHIFT 0
353 : #define SPDK_BLOB_CLEAR_METHOD (3ULL << SPDK_BLOB_CLEAR_METHOD_SHIFT)
354 : #define SPDK_BLOB_MD_RO_FLAGS_MASK SPDK_BLOB_CLEAR_METHOD
355 :
356 : struct spdk_blob_md_descriptor_flags {
357 : uint8_t type;
358 : uint32_t length;
359 :
360 : /*
361 : * If a flag in invalid_flags is set that the application is not aware of,
362 : * it will not allow the blob to be opened.
363 : */
364 : uint64_t invalid_flags;
365 :
366 : /*
367 : * If a flag in data_ro_flags is set that the application is not aware of,
368 : * allow the blob to be opened in data_read_only and md_read_only mode.
369 : */
370 : uint64_t data_ro_flags;
371 :
372 : /*
373 : * If a flag in md_ro_flags is set the application is not aware of,
374 : * allow the blob to be opened in md_read_only mode.
375 : */
376 : uint64_t md_ro_flags;
377 : };
378 :
379 : struct spdk_blob_md_descriptor {
380 : uint8_t type;
381 : uint32_t length;
382 : };
383 :
384 : #define SPDK_INVALID_MD_PAGE UINT32_MAX
385 :
386 : struct spdk_blob_md_page {
387 : spdk_blob_id id;
388 :
389 : uint32_t sequence_num;
390 : uint32_t reserved0;
391 :
392 : /* Descriptors here */
393 : uint8_t descriptors[4072];
394 :
395 : uint32_t next;
396 : uint32_t crc;
397 : };
398 : #define SPDK_BS_PAGE_SIZE 0x1000
399 : SPDK_STATIC_ASSERT(SPDK_BS_PAGE_SIZE == sizeof(struct spdk_blob_md_page), "Invalid md page size");
400 :
401 : #define SPDK_BS_MAX_DESC_SIZE SPDK_SIZEOF_MEMBER(struct spdk_blob_md_page, descriptors)
402 :
403 : /* Maximum number of extents a single Extent Page can fit.
404 : * For an SPDK_BS_PAGE_SIZE of 4K SPDK_EXTENTS_PER_EP would be 512. */
405 : #define SPDK_EXTENTS_PER_EP_MAX ((SPDK_BS_MAX_DESC_SIZE - sizeof(struct spdk_blob_md_descriptor_extent_page)) / sizeof(uint32_t))
406 : #define SPDK_EXTENTS_PER_EP (spdk_align64pow2(SPDK_EXTENTS_PER_EP_MAX + 1) >> 1u)
407 :
408 : #define SPDK_BS_SUPER_BLOCK_SIG "SPDKBLOB"
409 :
410 : struct spdk_bs_super_block {
411 : uint8_t signature[8];
412 : uint32_t version;
413 : uint32_t length;
414 : uint32_t clean; /* If there was a clean shutdown, this is 1. */
415 : spdk_blob_id super_blob;
416 :
417 : uint32_t cluster_size; /* In bytes */
418 :
419 : uint32_t used_page_mask_start; /* Offset from beginning of disk, in pages */
420 : uint32_t used_page_mask_len; /* Count, in pages */
421 :
422 : uint32_t used_cluster_mask_start; /* Offset from beginning of disk, in pages */
423 : uint32_t used_cluster_mask_len; /* Count, in pages */
424 :
425 : uint32_t md_start; /* Offset from beginning of disk, in pages */
426 : uint32_t md_len; /* Count, in pages */
427 :
428 : struct spdk_bs_type bstype; /* blobstore type */
429 :
430 : uint32_t used_blobid_mask_start; /* Offset from beginning of disk, in pages */
431 : uint32_t used_blobid_mask_len; /* Count, in pages */
432 :
433 : uint64_t size; /* size of blobstore in bytes */
434 : uint32_t io_unit_size; /* Size of io unit in bytes */
435 :
436 : uint8_t reserved[4000];
437 : uint32_t crc;
438 : };
439 : SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_super_block) == 0x1000, "Invalid super block size");
440 :
441 : #pragma pack(pop)
442 :
443 : struct spdk_bs_dev *bs_create_zeroes_dev(void);
444 : struct spdk_bs_dev *bs_create_blob_bs_dev(struct spdk_blob *blob);
445 : struct spdk_io_channel *blob_esnap_get_io_channel(struct spdk_io_channel *ch,
446 : struct spdk_blob *blob);
447 :
448 : /* Unit Conversions
449 : *
450 : * The blobstore works with several different units:
451 : * - Byte: Self explanatory
452 : * - LBA: The logical blocks on the backing storage device.
453 : * - Page: The read/write units of blobs and metadata. This is
454 : * an offset into a blob in units of 4KiB.
455 : * - Cluster Index: The disk is broken into a sequential list of
456 : * clusters. This is the offset from the beginning.
457 : *
458 : * NOTE: These conversions all act on simple magnitudes, not with any sort
459 : * of knowledge about the blobs themselves. For instance, converting
460 : * a page to an lba with the conversion function below simply converts
461 : * a number of pages to an equivalent number of lbas, but that
462 : * lba certainly isn't the right lba that corresponds to a page offset
463 : * for a particular blob.
464 : */
465 : static inline uint64_t
466 32356 : bs_byte_to_lba(struct spdk_blob_store *bs, uint64_t length)
467 : {
468 32356 : assert(length % bs->dev->blocklen == 0);
469 :
470 32356 : return length / bs->dev->blocklen;
471 : }
472 :
473 : static inline uint64_t
474 2636 : bs_dev_byte_to_lba(struct spdk_bs_dev *bs_dev, uint64_t length)
475 : {
476 2636 : assert(length % bs_dev->blocklen == 0);
477 :
478 2636 : return length / bs_dev->blocklen;
479 : }
480 :
481 : static inline uint64_t
482 26930 : bs_page_to_lba(struct spdk_blob_store *bs, uint64_t page)
483 : {
484 26930 : return page * SPDK_BS_PAGE_SIZE / bs->dev->blocklen;
485 : }
486 :
487 : static inline uint64_t
488 18422 : bs_md_page_to_lba(struct spdk_blob_store *bs, uint32_t page)
489 : {
490 18422 : assert(page < bs->md_len);
491 18422 : return bs_page_to_lba(bs, page + bs->md_start);
492 : }
493 :
494 : static inline uint64_t
495 2684 : bs_dev_page_to_lba(struct spdk_bs_dev *bs_dev, uint64_t page)
496 : {
497 2684 : return page * SPDK_BS_PAGE_SIZE / bs_dev->blocklen;
498 : }
499 :
500 : static inline uint64_t
501 161126 : bs_io_unit_per_page(struct spdk_blob_store *bs)
502 : {
503 161126 : return SPDK_BS_PAGE_SIZE / bs->io_unit_size;
504 : }
505 :
506 : static inline uint64_t
507 79766 : bs_io_unit_to_page(struct spdk_blob_store *bs, uint64_t io_unit)
508 : {
509 79766 : return io_unit / bs_io_unit_per_page(bs);
510 : }
511 :
512 : static inline uint64_t
513 28 : bs_cluster_to_page(struct spdk_blob_store *bs, uint32_t cluster)
514 : {
515 28 : return (uint64_t)cluster * bs->pages_per_cluster;
516 : }
517 :
518 : static inline uint32_t
519 408 : bs_page_to_cluster(struct spdk_blob_store *bs, uint64_t page)
520 : {
521 408 : assert(page % bs->pages_per_cluster == 0);
522 :
523 408 : return page / bs->pages_per_cluster;
524 : }
525 :
526 : static inline uint64_t
527 1136010 : bs_cluster_to_lba(struct spdk_blob_store *bs, uint32_t cluster)
528 : {
529 1136010 : assert(bs->cluster_sz / bs->dev->blocklen > 0);
530 :
531 1136010 : return (uint64_t)cluster * (bs->cluster_sz / bs->dev->blocklen);
532 : }
533 :
534 : static inline uint32_t
535 1069595 : bs_lba_to_cluster(struct spdk_blob_store *bs, uint64_t lba)
536 : {
537 1069595 : assert(lba % (bs->cluster_sz / bs->dev->blocklen) == 0);
538 :
539 1069595 : return lba / (bs->cluster_sz / bs->dev->blocklen);
540 : }
541 :
542 : static inline uint64_t
543 6464 : bs_io_unit_to_back_dev_lba(struct spdk_blob *blob, uint64_t io_unit)
544 : {
545 6464 : return io_unit * (blob->bs->io_unit_size / blob->back_bs_dev->blocklen);
546 : }
547 :
548 : static inline uint64_t
549 4712 : bs_cluster_to_extent_table_id(uint64_t cluster_num)
550 : {
551 4712 : return cluster_num / SPDK_EXTENTS_PER_EP;
552 : }
553 :
554 : static inline uint32_t *
555 4712 : bs_cluster_to_extent_page(struct spdk_blob *blob, uint64_t cluster_num)
556 : {
557 4712 : uint64_t extent_table_id = bs_cluster_to_extent_table_id(cluster_num);
558 :
559 4712 : assert(blob->use_extent_table);
560 4712 : assert(extent_table_id < blob->active.extent_pages_array_size);
561 :
562 4712 : return &blob->active.extent_pages[extent_table_id];
563 : }
564 :
565 : static inline uint64_t
566 42438 : bs_io_units_per_cluster(struct spdk_blob *blob)
567 : {
568 : uint64_t io_units_per_cluster;
569 42438 : uint8_t shift = blob->bs->pages_per_cluster_shift;
570 :
571 42438 : if (shift != 0) {
572 42438 : io_units_per_cluster = bs_io_unit_per_page(blob->bs) << shift;
573 : } else {
574 0 : io_units_per_cluster = bs_io_unit_per_page(blob->bs) * blob->bs->pages_per_cluster;
575 : }
576 :
577 42438 : return io_units_per_cluster;
578 : }
579 :
580 : /* End basic conversions */
581 :
582 : static inline uint64_t
583 30629 : bs_blobid_to_page(spdk_blob_id id)
584 : {
585 30629 : return id & 0xFFFFFFFF;
586 : }
587 :
588 : /* The blob id is a 64 bit number. The lower 32 bits are the page_idx. The upper
589 : * 32 bits are not currently used. Stick a 1 there just to catch bugs where the
590 : * code assumes blob id == page_idx.
591 : */
592 : static inline spdk_blob_id
593 2518 : bs_page_to_blobid(uint64_t page_idx)
594 : {
595 2518 : if (page_idx > UINT32_MAX) {
596 0 : return SPDK_BLOBID_INVALID;
597 : }
598 2518 : return SPDK_BLOB_BLOBID_HIGH_BIT | page_idx;
599 : }
600 :
601 : /* Given an io unit offset into a blob, look up the LBA for the
602 : * start of that io unit.
603 : */
604 : static inline uint64_t
605 37342 : bs_blob_io_unit_to_lba(struct spdk_blob *blob, uint64_t io_unit)
606 : {
607 : uint64_t lba;
608 : uint64_t pages_per_cluster;
609 : uint8_t shift;
610 : uint64_t io_units_per_cluster;
611 : uint64_t io_units_per_page;
612 : uint64_t page;
613 :
614 37342 : page = bs_io_unit_to_page(blob->bs, io_unit);
615 :
616 37342 : pages_per_cluster = blob->bs->pages_per_cluster;
617 37342 : shift = blob->bs->pages_per_cluster_shift;
618 37342 : io_units_per_page = bs_io_unit_per_page(blob->bs);
619 :
620 37342 : assert(page < blob->active.num_clusters * pages_per_cluster);
621 :
622 37342 : if (shift != 0) {
623 37342 : io_units_per_cluster = io_units_per_page << shift;
624 37342 : lba = blob->active.clusters[page >> shift];
625 : } else {
626 0 : io_units_per_cluster = io_units_per_page * pages_per_cluster;
627 0 : lba = blob->active.clusters[page / pages_per_cluster];
628 : }
629 37342 : lba += io_unit % io_units_per_cluster;
630 37342 : return lba;
631 : }
632 :
633 : /* Given an io_unit offset into a blob, look up the number of io_units until the
634 : * next cluster boundary.
635 : */
636 : static inline uint32_t
637 42298 : bs_num_io_units_to_cluster_boundary(struct spdk_blob *blob, uint64_t io_unit)
638 : {
639 : uint64_t io_units_per_cluster;
640 :
641 42298 : io_units_per_cluster = bs_io_units_per_cluster(blob);
642 :
643 42298 : return io_units_per_cluster - (io_unit % io_units_per_cluster);
644 : }
645 :
646 : /* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
647 : static inline uint32_t
648 872 : bs_io_unit_to_cluster_start(struct spdk_blob *blob, uint64_t io_unit)
649 : {
650 : uint64_t pages_per_cluster;
651 : uint64_t page;
652 :
653 872 : pages_per_cluster = blob->bs->pages_per_cluster;
654 872 : page = bs_io_unit_to_page(blob->bs, io_unit);
655 :
656 872 : return page - (page % pages_per_cluster);
657 : }
658 :
659 : /* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
660 : static inline uint32_t
661 872 : bs_io_unit_to_cluster_number(struct spdk_blob *blob, uint64_t io_unit)
662 : {
663 872 : uint64_t pages_per_cluster = blob->bs->pages_per_cluster;
664 872 : uint8_t shift = blob->bs->pages_per_cluster_shift;
665 : uint32_t page_offset;
666 :
667 872 : page_offset = io_unit / bs_io_unit_per_page(blob->bs);
668 872 : if (shift != 0) {
669 872 : return page_offset >> shift;
670 : } else {
671 0 : return page_offset / pages_per_cluster;
672 : }
673 : }
674 :
675 : /* Given an io unit offset into a blob, look up if it is from allocated cluster. */
676 : static inline bool
677 40978 : bs_io_unit_is_allocated(struct spdk_blob *blob, uint64_t io_unit)
678 : {
679 : uint64_t lba;
680 : uint64_t page;
681 : uint64_t pages_per_cluster;
682 : uint8_t shift;
683 :
684 40978 : shift = blob->bs->pages_per_cluster_shift;
685 40978 : pages_per_cluster = blob->bs->pages_per_cluster;
686 40978 : page = bs_io_unit_to_page(blob->bs, io_unit);
687 :
688 40978 : assert(page < blob->active.num_clusters * pages_per_cluster);
689 :
690 40978 : if (shift != 0) {
691 40978 : lba = blob->active.clusters[page >> shift];
692 : } else {
693 0 : lba = blob->active.clusters[page / pages_per_cluster];
694 : }
695 :
696 40978 : if (lba == 0) {
697 3356 : assert(spdk_blob_is_thin_provisioned(blob));
698 3356 : return false;
699 : } else {
700 37622 : return true;
701 : }
702 : }
703 :
704 : #endif
|