3e372f35c3
In future patches new type of extents will be added, for compatibility the current extent type will be still handled in the code. To signify the difference between those two types, current type is renamed to SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE. Along with any variables throughout the code, to make it clear which ones are used. There are no functional changes in this patch. Signed-off-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com> Change-Id: I7186ccc452d200036188abf1dcea9660dcedee72 Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/468230 Tested-by: SPDK CI Jenkins <sys_sgci@intel.com> Reviewed-by: Ben Walker <benjamin.walker@intel.com> Reviewed-by: Jim Harris <james.r.harris@intel.com>
577 lines
15 KiB
C
577 lines
15 KiB
C
/*-
|
|
* BSD LICENSE
|
|
*
|
|
* Copyright (c) Intel Corporation.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
* * Neither the name of Intel Corporation nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifndef SPDK_BLOBSTORE_H
|
|
#define SPDK_BLOBSTORE_H
|
|
|
|
#include "spdk/assert.h"
|
|
#include "spdk/blob.h"
|
|
#include "spdk/queue.h"
|
|
#include "spdk/util.h"
|
|
|
|
#include "request.h"
|
|
|
|
/* In Memory Data Structures
|
|
*
|
|
* The following data structures exist only in memory.
|
|
*/
|
|
|
|
#define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024)
|
|
#define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX
|
|
#define SPDK_BLOB_OPTS_MAX_MD_OPS 32
|
|
#define SPDK_BLOB_OPTS_DEFAULT_CHANNEL_OPS 512
|
|
#define SPDK_BLOB_BLOBID_HIGH_BIT (1ULL << 32)
|
|
|
|
struct spdk_xattr {
|
|
uint32_t index;
|
|
uint16_t value_len;
|
|
char *name;
|
|
void *value;
|
|
TAILQ_ENTRY(spdk_xattr) link;
|
|
};
|
|
|
|
/* The mutable part of the blob data that is sync'd to
|
|
* disk. The data in here is both mutable and persistent.
|
|
*/
|
|
struct spdk_blob_mut_data {
|
|
/* Number of data clusters in the blob */
|
|
uint64_t num_clusters;
|
|
|
|
/* Array LBAs that are the beginning of a cluster, in
|
|
* the order they appear in the blob.
|
|
*/
|
|
uint64_t *clusters;
|
|
|
|
/* The size of the clusters array. This is greater than or
|
|
* equal to 'num_clusters'.
|
|
*/
|
|
size_t cluster_array_size;
|
|
|
|
/* Number of metadata pages */
|
|
uint32_t num_pages;
|
|
|
|
/* Array of page offsets into the metadata region, in
|
|
* the order of the metadata page sequence.
|
|
*/
|
|
uint32_t *pages;
|
|
};
|
|
|
|
enum spdk_blob_state {
|
|
/* The blob in-memory version does not match the on-disk
|
|
* version.
|
|
*/
|
|
SPDK_BLOB_STATE_DIRTY,
|
|
|
|
/* The blob in memory version of the blob matches the on disk
|
|
* version.
|
|
*/
|
|
SPDK_BLOB_STATE_CLEAN,
|
|
|
|
/* The in-memory state being synchronized with the on-disk
|
|
* blob state. */
|
|
SPDK_BLOB_STATE_LOADING,
|
|
};
|
|
|
|
TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr);
|
|
|
|
struct spdk_blob_list {
|
|
spdk_blob_id id;
|
|
size_t clone_count;
|
|
TAILQ_HEAD(, spdk_blob_list) clones;
|
|
TAILQ_ENTRY(spdk_blob_list) link;
|
|
};
|
|
|
|
struct spdk_blob {
|
|
struct spdk_blob_store *bs;
|
|
|
|
uint32_t open_ref;
|
|
|
|
spdk_blob_id id;
|
|
spdk_blob_id parent_id;
|
|
|
|
enum spdk_blob_state state;
|
|
|
|
/* Two copies of the mutable data. One is a version
|
|
* that matches the last known data on disk (clean).
|
|
* The other (active) is the current data. Syncing
|
|
* a blob makes the clean match the active.
|
|
*/
|
|
struct spdk_blob_mut_data clean;
|
|
struct spdk_blob_mut_data active;
|
|
|
|
bool invalid;
|
|
bool data_ro;
|
|
bool md_ro;
|
|
|
|
uint64_t invalid_flags;
|
|
uint64_t data_ro_flags;
|
|
uint64_t md_ro_flags;
|
|
|
|
struct spdk_bs_dev *back_bs_dev;
|
|
|
|
/* TODO: The xattrs are mutable, but we don't want to be
|
|
* copying them unnecessarily. Figure this out.
|
|
*/
|
|
struct spdk_xattr_tailq xattrs;
|
|
struct spdk_xattr_tailq xattrs_internal;
|
|
|
|
TAILQ_ENTRY(spdk_blob) link;
|
|
|
|
uint32_t frozen_refcnt;
|
|
bool locked_operation_in_progress;
|
|
enum blob_clear_method clear_method;
|
|
};
|
|
|
|
struct spdk_blob_store {
|
|
uint64_t md_start; /* Offset from beginning of disk, in pages */
|
|
uint32_t md_len; /* Count, in pages */
|
|
|
|
struct spdk_io_channel *md_channel;
|
|
uint32_t max_channel_ops;
|
|
|
|
struct spdk_thread *md_thread;
|
|
|
|
struct spdk_bs_dev *dev;
|
|
|
|
struct spdk_bit_array *used_md_pages;
|
|
struct spdk_bit_array *used_clusters;
|
|
struct spdk_bit_array *used_blobids;
|
|
|
|
pthread_mutex_t used_clusters_mutex;
|
|
|
|
uint32_t cluster_sz;
|
|
uint64_t total_clusters;
|
|
uint64_t total_data_clusters;
|
|
uint64_t num_free_clusters;
|
|
uint64_t pages_per_cluster;
|
|
uint32_t io_unit_size;
|
|
|
|
spdk_blob_id super_blob;
|
|
struct spdk_bs_type bstype;
|
|
|
|
struct spdk_bs_cpl unload_cpl;
|
|
int unload_err;
|
|
|
|
TAILQ_HEAD(, spdk_blob) blobs;
|
|
TAILQ_HEAD(, spdk_blob_list) snapshots;
|
|
|
|
bool clean;
|
|
};
|
|
|
|
struct spdk_bs_channel {
|
|
struct spdk_bs_request_set *req_mem;
|
|
TAILQ_HEAD(, spdk_bs_request_set) reqs;
|
|
|
|
struct spdk_blob_store *bs;
|
|
|
|
struct spdk_bs_dev *dev;
|
|
struct spdk_io_channel *dev_channel;
|
|
|
|
TAILQ_HEAD(, spdk_bs_request_set) need_cluster_alloc;
|
|
TAILQ_HEAD(, spdk_bs_request_set) queued_io;
|
|
};
|
|
|
|
/** operation type */
|
|
enum spdk_blob_op_type {
|
|
SPDK_BLOB_WRITE,
|
|
SPDK_BLOB_READ,
|
|
SPDK_BLOB_UNMAP,
|
|
SPDK_BLOB_WRITE_ZEROES,
|
|
SPDK_BLOB_WRITEV,
|
|
SPDK_BLOB_READV,
|
|
};
|
|
|
|
/* back bs_dev */
|
|
|
|
#define BLOB_SNAPSHOT "SNAP"
|
|
#define SNAPSHOT_IN_PROGRESS "SNAPTMP"
|
|
#define SNAPSHOT_PENDING_REMOVAL "SNAPRM"
|
|
|
|
struct spdk_blob_bs_dev {
|
|
struct spdk_bs_dev bs_dev;
|
|
struct spdk_blob *blob;
|
|
};
|
|
|
|
/* On-Disk Data Structures
|
|
*
|
|
* The following data structures exist on disk.
|
|
*/
|
|
#define SPDK_BS_INITIAL_VERSION 1
|
|
#define SPDK_BS_VERSION 3 /* current version */
|
|
|
|
#pragma pack(push, 1)
|
|
|
|
#define SPDK_MD_MASK_TYPE_USED_PAGES 0
|
|
#define SPDK_MD_MASK_TYPE_USED_CLUSTERS 1
|
|
#define SPDK_MD_MASK_TYPE_USED_BLOBIDS 2
|
|
|
|
struct spdk_bs_md_mask {
|
|
uint8_t type;
|
|
uint32_t length; /* In bits */
|
|
uint8_t mask[0];
|
|
};
|
|
|
|
#define SPDK_MD_DESCRIPTOR_TYPE_PADDING 0
|
|
#define SPDK_MD_DESCRIPTOR_TYPE_EXTENT_RLE 1
|
|
#define SPDK_MD_DESCRIPTOR_TYPE_XATTR 2
|
|
#define SPDK_MD_DESCRIPTOR_TYPE_FLAGS 3
|
|
#define SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL 4
|
|
|
|
struct spdk_blob_md_descriptor_xattr {
|
|
uint8_t type;
|
|
uint32_t length;
|
|
|
|
uint16_t name_length;
|
|
uint16_t value_length;
|
|
|
|
char name[0];
|
|
/* String name immediately followed by string value. */
|
|
};
|
|
|
|
struct spdk_blob_md_descriptor_extent_rle {
|
|
uint8_t type;
|
|
uint32_t length;
|
|
|
|
struct {
|
|
uint32_t cluster_idx;
|
|
uint32_t length; /* In units of clusters */
|
|
} extents[0];
|
|
};
|
|
|
|
#define SPDK_BLOB_THIN_PROV (1ULL << 0)
|
|
#define SPDK_BLOB_INTERNAL_XATTR (1ULL << 1)
|
|
#define SPDK_BLOB_INVALID_FLAGS_MASK (SPDK_BLOB_THIN_PROV | SPDK_BLOB_INTERNAL_XATTR)
|
|
|
|
#define SPDK_BLOB_READ_ONLY (1ULL << 0)
|
|
#define SPDK_BLOB_DATA_RO_FLAGS_MASK SPDK_BLOB_READ_ONLY
|
|
#define SPDK_BLOB_MD_RO_FLAGS_MASK 0
|
|
|
|
struct spdk_blob_md_descriptor_flags {
|
|
uint8_t type;
|
|
uint32_t length;
|
|
|
|
/*
|
|
* If a flag in invalid_flags is set that the application is not aware of,
|
|
* it will not allow the blob to be opened.
|
|
*/
|
|
uint64_t invalid_flags;
|
|
|
|
/*
|
|
* If a flag in data_ro_flags is set that the application is not aware of,
|
|
* allow the blob to be opened in data_read_only and md_read_only mode.
|
|
*/
|
|
uint64_t data_ro_flags;
|
|
|
|
/*
|
|
* If a flag in md_ro_flags is set the the application is not aware of,
|
|
* allow the blob to be opened in md_read_only mode.
|
|
*/
|
|
uint64_t md_ro_flags;
|
|
};
|
|
|
|
struct spdk_blob_md_descriptor {
|
|
uint8_t type;
|
|
uint32_t length;
|
|
};
|
|
|
|
#define SPDK_INVALID_MD_PAGE UINT32_MAX
|
|
|
|
struct spdk_blob_md_page {
|
|
spdk_blob_id id;
|
|
|
|
uint32_t sequence_num;
|
|
uint32_t reserved0;
|
|
|
|
/* Descriptors here */
|
|
uint8_t descriptors[4072];
|
|
|
|
uint32_t next;
|
|
uint32_t crc;
|
|
};
|
|
#define SPDK_BS_PAGE_SIZE 0x1000
|
|
SPDK_STATIC_ASSERT(SPDK_BS_PAGE_SIZE == sizeof(struct spdk_blob_md_page), "Invalid md page size");
|
|
|
|
#define SPDK_BS_MAX_DESC_SIZE sizeof(((struct spdk_blob_md_page*)0)->descriptors)
|
|
|
|
#define SPDK_BS_SUPER_BLOCK_SIG "SPDKBLOB"
|
|
|
|
struct spdk_bs_super_block {
|
|
uint8_t signature[8];
|
|
uint32_t version;
|
|
uint32_t length;
|
|
uint32_t clean; /* If there was a clean shutdown, this is 1. */
|
|
spdk_blob_id super_blob;
|
|
|
|
uint32_t cluster_size; /* In bytes */
|
|
|
|
uint32_t used_page_mask_start; /* Offset from beginning of disk, in pages */
|
|
uint32_t used_page_mask_len; /* Count, in pages */
|
|
|
|
uint32_t used_cluster_mask_start; /* Offset from beginning of disk, in pages */
|
|
uint32_t used_cluster_mask_len; /* Count, in pages */
|
|
|
|
uint32_t md_start; /* Offset from beginning of disk, in pages */
|
|
uint32_t md_len; /* Count, in pages */
|
|
|
|
struct spdk_bs_type bstype; /* blobstore type */
|
|
|
|
uint32_t used_blobid_mask_start; /* Offset from beginning of disk, in pages */
|
|
uint32_t used_blobid_mask_len; /* Count, in pages */
|
|
|
|
uint64_t size; /* size of blobstore in bytes */
|
|
uint32_t io_unit_size; /* Size of io unit in bytes */
|
|
|
|
uint8_t reserved[4000];
|
|
uint32_t crc;
|
|
};
|
|
SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_super_block) == 0x1000, "Invalid super block size");
|
|
|
|
#pragma pack(pop)
|
|
|
|
struct spdk_bs_dev *spdk_bs_create_zeroes_dev(void);
|
|
struct spdk_bs_dev *spdk_bs_create_blob_bs_dev(struct spdk_blob *blob);
|
|
|
|
/* Unit Conversions
|
|
*
|
|
* The blobstore works with several different units:
|
|
* - Byte: Self explanatory
|
|
* - LBA: The logical blocks on the backing storage device.
|
|
* - Page: The read/write units of blobs and metadata. This is
|
|
* an offset into a blob in units of 4KiB.
|
|
* - Cluster Index: The disk is broken into a sequential list of
|
|
* clusters. This is the offset from the beginning.
|
|
*
|
|
* NOTE: These conversions all act on simple magnitudes, not with any sort
|
|
* of knowledge about the blobs themselves. For instance, converting
|
|
* a page to an lba with the conversion function below simply converts
|
|
* a number of pages to an equivalent number of lbas, but that
|
|
* lba certainly isn't the right lba that corresponds to a page offset
|
|
* for a particular blob.
|
|
*/
|
|
static inline uint64_t
|
|
_spdk_bs_byte_to_lba(struct spdk_blob_store *bs, uint64_t length)
|
|
{
|
|
assert(length % bs->dev->blocklen == 0);
|
|
|
|
return length / bs->dev->blocklen;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_dev_byte_to_lba(struct spdk_bs_dev *bs_dev, uint64_t length)
|
|
{
|
|
assert(length % bs_dev->blocklen == 0);
|
|
|
|
return length / bs_dev->blocklen;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_page_to_lba(struct spdk_blob_store *bs, uint64_t page)
|
|
{
|
|
return page * SPDK_BS_PAGE_SIZE / bs->dev->blocklen;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_dev_page_to_lba(struct spdk_bs_dev *bs_dev, uint64_t page)
|
|
{
|
|
return page * SPDK_BS_PAGE_SIZE / bs_dev->blocklen;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_io_unit_per_page(struct spdk_blob_store *bs)
|
|
{
|
|
return SPDK_BS_PAGE_SIZE / bs->io_unit_size;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_io_unit_to_page(struct spdk_blob_store *bs, uint64_t io_unit)
|
|
{
|
|
return io_unit / _spdk_bs_io_unit_per_page(bs);
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_cluster_to_page(struct spdk_blob_store *bs, uint32_t cluster)
|
|
{
|
|
return (uint64_t)cluster * bs->pages_per_cluster;
|
|
}
|
|
|
|
static inline uint32_t
|
|
_spdk_bs_page_to_cluster(struct spdk_blob_store *bs, uint64_t page)
|
|
{
|
|
assert(page % bs->pages_per_cluster == 0);
|
|
|
|
return page / bs->pages_per_cluster;
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_cluster_to_lba(struct spdk_blob_store *bs, uint32_t cluster)
|
|
{
|
|
return (uint64_t)cluster * (bs->cluster_sz / bs->dev->blocklen);
|
|
}
|
|
|
|
static inline uint32_t
|
|
_spdk_bs_lba_to_cluster(struct spdk_blob_store *bs, uint64_t lba)
|
|
{
|
|
assert(lba % (bs->cluster_sz / bs->dev->blocklen) == 0);
|
|
|
|
return lba / (bs->cluster_sz / bs->dev->blocklen);
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_io_unit_to_back_dev_lba(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
return io_unit * (blob->bs->io_unit_size / blob->back_bs_dev->blocklen);
|
|
}
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_back_dev_lba_to_io_unit(struct spdk_blob *blob, uint64_t lba)
|
|
{
|
|
return lba * (blob->back_bs_dev->blocklen / blob->bs->io_unit_size);
|
|
}
|
|
|
|
/* End basic conversions */
|
|
|
|
static inline uint64_t
|
|
_spdk_bs_blobid_to_page(spdk_blob_id id)
|
|
{
|
|
return id & 0xFFFFFFFF;
|
|
}
|
|
|
|
/* The blob id is a 64 bit number. The lower 32 bits are the page_idx. The upper
|
|
* 32 bits are not currently used. Stick a 1 there just to catch bugs where the
|
|
* code assumes blob id == page_idx.
|
|
*/
|
|
static inline spdk_blob_id
|
|
_spdk_bs_page_to_blobid(uint64_t page_idx)
|
|
{
|
|
if (page_idx > UINT32_MAX) {
|
|
return SPDK_BLOBID_INVALID;
|
|
}
|
|
return SPDK_BLOB_BLOBID_HIGH_BIT | page_idx;
|
|
}
|
|
|
|
/* Given an io unit offset into a blob, look up the LBA for the
|
|
* start of that io unit.
|
|
*/
|
|
static inline uint64_t
|
|
_spdk_bs_blob_io_unit_to_lba(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
uint64_t lba;
|
|
uint64_t pages_per_cluster;
|
|
uint64_t io_units_per_cluster;
|
|
uint64_t io_units_per_page;
|
|
uint64_t page;
|
|
|
|
page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
|
|
|
|
pages_per_cluster = blob->bs->pages_per_cluster;
|
|
io_units_per_page = _spdk_bs_io_unit_per_page(blob->bs);
|
|
io_units_per_cluster = io_units_per_page * pages_per_cluster;
|
|
|
|
assert(page < blob->active.num_clusters * pages_per_cluster);
|
|
|
|
lba = blob->active.clusters[page / pages_per_cluster];
|
|
lba += io_unit % io_units_per_cluster;
|
|
return lba;
|
|
}
|
|
|
|
/* Given an io_unit offset into a blob, look up the number of io_units until the
|
|
* next cluster boundary.
|
|
*/
|
|
static inline uint32_t
|
|
_spdk_bs_num_io_units_to_cluster_boundary(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
uint64_t io_units_per_cluster;
|
|
|
|
io_units_per_cluster = _spdk_bs_io_unit_per_page(blob->bs) * blob->bs->pages_per_cluster;
|
|
|
|
return io_units_per_cluster - (io_unit % io_units_per_cluster);
|
|
}
|
|
|
|
/* Given a page offset into a blob, look up the number of pages until the
|
|
* next cluster boundary.
|
|
*/
|
|
static inline uint32_t
|
|
_spdk_bs_num_pages_to_cluster_boundary(struct spdk_blob *blob, uint64_t page)
|
|
{
|
|
uint64_t pages_per_cluster;
|
|
|
|
pages_per_cluster = blob->bs->pages_per_cluster;
|
|
|
|
return pages_per_cluster - (page % pages_per_cluster);
|
|
}
|
|
|
|
/* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
|
|
static inline uint32_t
|
|
_spdk_bs_io_unit_to_cluster_start(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
uint64_t pages_per_cluster;
|
|
uint64_t page;
|
|
|
|
pages_per_cluster = blob->bs->pages_per_cluster;
|
|
page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
|
|
|
|
return page - (page % pages_per_cluster);
|
|
}
|
|
|
|
/* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
|
|
static inline uint32_t
|
|
_spdk_bs_io_unit_to_cluster_number(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
return (io_unit / _spdk_bs_io_unit_per_page(blob->bs)) / blob->bs->pages_per_cluster;
|
|
}
|
|
|
|
/* Given an io unit offset into a blob, look up if it is from allocated cluster. */
|
|
static inline bool
|
|
_spdk_bs_io_unit_is_allocated(struct spdk_blob *blob, uint64_t io_unit)
|
|
{
|
|
uint64_t lba;
|
|
uint64_t page;
|
|
uint64_t pages_per_cluster;
|
|
|
|
pages_per_cluster = blob->bs->pages_per_cluster;
|
|
page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
|
|
|
|
assert(page < blob->active.num_clusters * pages_per_cluster);
|
|
|
|
lba = blob->active.clusters[page / pages_per_cluster];
|
|
|
|
if (lba == 0) {
|
|
assert(spdk_blob_is_thin_provisioned(blob));
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
#endif
|