[ceph.git] / ceph / src / spdk / lib / blob / blobstore.h

/*-
 *   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 resize_in_progress;
};

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"

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 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 {
	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_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
Commit	Line	Data
7c673cae FG	1	/*-
	2	* BSD LICENSE
	3	*
	4	* Copyright (c) Intel Corporation.
	5	* All rights reserved.
	6	*
	7	* Redistribution and use in source and binary forms, with or without
	8	* modification, are permitted provided that the following conditions
	9	* are met:
	10	*
	11	* * Redistributions of source code must retain the above copyright
	12	* notice, this list of conditions and the following disclaimer.
	13	* * Redistributions in binary form must reproduce the above copyright
	14	* notice, this list of conditions and the following disclaimer in
	15	* the documentation and/or other materials provided with the
	16	* distribution.
	17	* * Neither the name of Intel Corporation nor the names of its
	18	* contributors may be used to endorse or promote products derived
	19	* from this software without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	22	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	23	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	24	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	25	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	26	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	27	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	28	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	29	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	30	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	31	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	32	*/
	33
	34	#ifndef SPDK_BLOBSTORE_H
	35	#define SPDK_BLOBSTORE_H
	36
	37	#include "spdk/assert.h"
	38	#include "spdk/blob.h"
	39	#include "spdk/queue.h"
	40	#include "spdk/util.h"
	41
11fdf7f2 TL	42	#include "request.h"
11fdf7f2 TL	43
7c673cae FG	44	/* In Memory Data Structures
	45	*
	46	* The following data structures exist only in memory.
	47	*/
	48
	49	#define SPDK_BLOB_OPTS_CLUSTER_SZ (1024 * 1024)
	50	#define SPDK_BLOB_OPTS_NUM_MD_PAGES UINT32_MAX
	51	#define SPDK_BLOB_OPTS_MAX_MD_OPS 32
11fdf7f2 TL	52	#define SPDK_BLOB_OPTS_DEFAULT_CHANNEL_OPS 512
11fdf7f2 TL	53	#define SPDK_BLOB_BLOBID_HIGH_BIT (1ULL << 32)
7c673cae FG	54
7c673cae FG	55	struct spdk_xattr {
7c673cae	56	uint32_t index;
11fdf7f2	57	uint16_t value_len;
7c673cae FG	58	char *name;
7c673cae FG	59	void *value;
7c673cae FG	60	TAILQ_ENTRY(spdk_xattr) link;
	61	};
	62
	63	/* The mutable part of the blob data that is sync'd to
	64	* disk. The data in here is both mutable and persistent.
	65	*/
	66	struct spdk_blob_mut_data {
	67	/* Number of data clusters in the blob */
	68	uint64_t num_clusters;
	69
	70	/* Array LBAs that are the beginning of a cluster, in
	71	* the order they appear in the blob.
	72	*/
	73	uint64_t *clusters;
	74
	75	/* The size of the clusters array. This is greater than or
	76	* equal to 'num_clusters'.
	77	*/
	78	size_t cluster_array_size;
	79
	80	/* Number of metadata pages */
	81	uint32_t num_pages;
	82
	83	/* Array of page offsets into the metadata region, in
	84	* the order of the metadata page sequence.
	85	*/
	86	uint32_t *pages;
	87	};
	88
	89	enum spdk_blob_state {
	90	/* The blob in-memory version does not match the on-disk
	91	* version.
	92	*/
	93	SPDK_BLOB_STATE_DIRTY,
	94
	95	/* The blob in memory version of the blob matches the on disk
	96	* version.
	97	*/
	98	SPDK_BLOB_STATE_CLEAN,
	99
	100	/* The in-memory state being synchronized with the on-disk
	101	* blob state. */
	102	SPDK_BLOB_STATE_LOADING,
11fdf7f2	103	};
7c673cae	104
11fdf7f2 TL	105	TAILQ_HEAD(spdk_xattr_tailq, spdk_xattr);
	106
	107	struct spdk_blob_list {
	108	spdk_blob_id id;
	109	size_t clone_count;
	110	TAILQ_HEAD(, spdk_blob_list) clones;
	111	TAILQ_ENTRY(spdk_blob_list) link;
7c673cae FG	112	};
	113
	114	struct spdk_blob {
	115	struct spdk_blob_store *bs;
	116
	117	uint32_t open_ref;
	118
	119	spdk_blob_id id;
11fdf7f2	120	spdk_blob_id parent_id;
7c673cae FG	121
	122	enum spdk_blob_state state;
	123
	124	/* Two copies of the mutable data. One is a version
	125	* that matches the last known data on disk (clean).
	126	* The other (active) is the current data. Syncing
	127	* a blob makes the clean match the active.
	128	*/
	129	struct spdk_blob_mut_data clean;
	130	struct spdk_blob_mut_data active;
	131
11fdf7f2 TL	132	bool invalid;
	133	bool data_ro;
	134	bool md_ro;
	135
	136	uint64_t invalid_flags;
	137	uint64_t data_ro_flags;
	138	uint64_t md_ro_flags;
	139
	140	struct spdk_bs_dev *back_bs_dev;
	141
7c673cae	142	/* TODO: The xattrs are mutable, but we don't want to be
11fdf7f2	143	* copying them unnecessarily. Figure this out.
7c673cae	144	*/
11fdf7f2 TL	145	struct spdk_xattr_tailq xattrs;
11fdf7f2 TL	146	struct spdk_xattr_tailq xattrs_internal;
7c673cae FG	147
7c673cae FG	148	TAILQ_ENTRY(spdk_blob) link;
11fdf7f2 TL	149
	150	uint32_t frozen_refcnt;
	151	bool resize_in_progress;
7c673cae FG	152	};
	153
	154	struct spdk_blob_store {
	155	uint64_t md_start; /* Offset from beginning of disk, in pages */
	156	uint32_t md_len; /* Count, in pages */
11fdf7f2	157
7c673cae	158	struct spdk_io_channel *md_channel;
11fdf7f2 TL	159	uint32_t max_channel_ops;
	160
	161	struct spdk_thread *md_thread;
7c673cae FG	162
	163	struct spdk_bs_dev *dev;
	164
	165	struct spdk_bit_array *used_md_pages;
	166	struct spdk_bit_array *used_clusters;
11fdf7f2 TL	167	struct spdk_bit_array *used_blobids;
	168
	169	pthread_mutex_t used_clusters_mutex;
7c673cae FG	170
	171	uint32_t cluster_sz;
	172	uint64_t total_clusters;
11fdf7f2	173	uint64_t total_data_clusters;
7c673cae	174	uint64_t num_free_clusters;
11fdf7f2 TL	175	uint64_t pages_per_cluster;
11fdf7f2 TL	176	uint32_t io_unit_size;
7c673cae FG	177
7c673cae FG	178	spdk_blob_id super_blob;
11fdf7f2 TL	179	struct spdk_bs_type bstype;
	180
	181	struct spdk_bs_cpl unload_cpl;
	182	int unload_err;
7c673cae	183
11fdf7f2 TL	184	TAILQ_HEAD(, spdk_blob) blobs;
	185	TAILQ_HEAD(, spdk_blob_list) snapshots;
	186
	187	bool clean;
7c673cae FG	188	};
	189
	190	struct spdk_bs_channel {
	191	struct spdk_bs_request_set *req_mem;
	192	TAILQ_HEAD(, spdk_bs_request_set) reqs;
	193
	194	struct spdk_blob_store *bs;
	195
	196	struct spdk_bs_dev *dev;
	197	struct spdk_io_channel *dev_channel;
11fdf7f2 TL	198
	199	TAILQ_HEAD(, spdk_bs_request_set) need_cluster_alloc;
	200	TAILQ_HEAD(, spdk_bs_request_set) queued_io;
	201	};
	202
	203	/** operation type */
	204	enum spdk_blob_op_type {
	205	SPDK_BLOB_WRITE,
	206	SPDK_BLOB_READ,
	207	SPDK_BLOB_UNMAP,
	208	SPDK_BLOB_WRITE_ZEROES,
	209	SPDK_BLOB_WRITEV,
	210	SPDK_BLOB_READV,
	211	};
	212
	213	/* back bs_dev */
	214
	215	#define BLOB_SNAPSHOT "SNAP"
	216	#define SNAPSHOT_IN_PROGRESS "SNAPTMP"
	217
	218	struct spdk_blob_bs_dev {
	219	struct spdk_bs_dev bs_dev;
	220	struct spdk_blob *blob;
7c673cae FG	221	};
	222
	223	/* On-Disk Data Structures
	224	*
	225	* The following data structures exist on disk.
	226	*/
11fdf7f2 TL	227	#define SPDK_BS_INITIAL_VERSION 1
11fdf7f2 TL	228	#define SPDK_BS_VERSION 3 /* current version */
7c673cae FG	229
	230	#pragma pack(push, 1)
	231
	232	#define SPDK_MD_MASK_TYPE_USED_PAGES 0
	233	#define SPDK_MD_MASK_TYPE_USED_CLUSTERS 1
11fdf7f2	234	#define SPDK_MD_MASK_TYPE_USED_BLOBIDS 2
7c673cae FG	235
	236	struct spdk_bs_md_mask {
	237	uint8_t type;
	238	uint32_t length; /* In bits */
	239	uint8_t mask[0];
	240	};
	241
	242	#define SPDK_MD_DESCRIPTOR_TYPE_PADDING 0
	243	#define SPDK_MD_DESCRIPTOR_TYPE_EXTENT 1
	244	#define SPDK_MD_DESCRIPTOR_TYPE_XATTR 2
11fdf7f2 TL	245	#define SPDK_MD_DESCRIPTOR_TYPE_FLAGS 3
11fdf7f2 TL	246	#define SPDK_MD_DESCRIPTOR_TYPE_XATTR_INTERNAL 4
7c673cae FG	247
	248	struct spdk_blob_md_descriptor_xattr {
	249	uint8_t type;
	250	uint32_t length;
	251
	252	uint16_t name_length;
	253	uint16_t value_length;
	254
	255	char name[0];
	256	/* String name immediately followed by string value. */
	257	};
	258
	259	struct spdk_blob_md_descriptor_extent {
	260	uint8_t type;
	261	uint32_t length;
	262
	263	struct {
	264	uint32_t cluster_idx;
	265	uint32_t length; /* In units of clusters */
	266	} extents[0];
	267	};
	268
11fdf7f2 TL	269	#define SPDK_BLOB_THIN_PROV (1ULL << 0)
	270	#define SPDK_BLOB_INTERNAL_XATTR (1ULL << 1)
	271	#define SPDK_BLOB_INVALID_FLAGS_MASK (SPDK_BLOB_THIN_PROV \| SPDK_BLOB_INTERNAL_XATTR)
	272
	273	#define SPDK_BLOB_READ_ONLY (1ULL << 0)
	274	#define SPDK_BLOB_DATA_RO_FLAGS_MASK SPDK_BLOB_READ_ONLY
	275	#define SPDK_BLOB_MD_RO_FLAGS_MASK 0
	276
	277	struct spdk_blob_md_descriptor_flags {
	278	uint8_t type;
	279	uint32_t length;
	280
	281	/*
	282	* If a flag in invalid_flags is set that the application is not aware of,
	283	* it will not allow the blob to be opened.
	284	*/
	285	uint64_t invalid_flags;
	286
	287	/*
	288	* If a flag in data_ro_flags is set that the application is not aware of,
	289	* allow the blob to be opened in data_read_only and md_read_only mode.
	290	*/
	291	uint64_t data_ro_flags;
	292
	293	/*
	294	* If a flag in md_ro_flags is set the the application is not aware of,
	295	* allow the blob to be opened in md_read_only mode.
	296	*/
	297	uint64_t md_ro_flags;
	298	};
	299
7c673cae FG	300	struct spdk_blob_md_descriptor {
	301	uint8_t type;
	302	uint32_t length;
	303	};
	304
	305	#define SPDK_INVALID_MD_PAGE UINT32_MAX
	306
	307	struct spdk_blob_md_page {
	308	spdk_blob_id id;
	309
	310	uint32_t sequence_num;
	311	uint32_t reserved0;
	312
	313	/* Descriptors here */
	314	uint8_t descriptors[4072];
	315
	316	uint32_t next;
	317	uint32_t crc;
	318	};
11fdf7f2 TL	319	#define SPDK_BS_PAGE_SIZE 0x1000
11fdf7f2 TL	320	SPDK_STATIC_ASSERT(SPDK_BS_PAGE_SIZE == sizeof(struct spdk_blob_md_page), "Invalid md page size");
7c673cae FG	321
	322	#define SPDK_BS_SUPER_BLOCK_SIG "SPDKBLOB"
	323
	324	struct spdk_bs_super_block {
	325	uint8_t signature[8];
	326	uint32_t version;
	327	uint32_t length;
	328	uint32_t clean; /* If there was a clean shutdown, this is 1. */
	329	spdk_blob_id super_blob;
	330
	331	uint32_t cluster_size; /* In bytes */
	332
	333	uint32_t used_page_mask_start; /* Offset from beginning of disk, in pages */
	334	uint32_t used_page_mask_len; /* Count, in pages */
	335
	336	uint32_t used_cluster_mask_start; /* Offset from beginning of disk, in pages */
	337	uint32_t used_cluster_mask_len; /* Count, in pages */
	338
	339	uint32_t md_start; /* Offset from beginning of disk, in pages */
	340	uint32_t md_len; /* Count, in pages */
	341
11fdf7f2 TL	342	struct spdk_bs_type bstype; /* blobstore type */
	343
	344	uint32_t used_blobid_mask_start; /* Offset from beginning of disk, in pages */
	345	uint32_t used_blobid_mask_len; /* Count, in pages */
	346
	347	uint64_t size; /* size of blobstore in bytes */
	348	uint32_t io_unit_size; /* Size of io unit in bytes */
	349
	350	uint8_t reserved[4000];
	351	uint32_t crc;
7c673cae FG	352	};
	353	SPDK_STATIC_ASSERT(sizeof(struct spdk_bs_super_block) == 0x1000, "Invalid super block size");
	354
	355	#pragma pack(pop)
	356
11fdf7f2 TL	357	struct spdk_bs_dev *spdk_bs_create_zeroes_dev(void);
	358	struct spdk_bs_dev spdk_bs_create_blob_bs_dev(struct spdk_blob blob);
	359
7c673cae FG	360	/* Unit Conversions
	361	*
	362	* The blobstore works with several different units:
	363	* - Byte: Self explanatory
	364	* - LBA: The logical blocks on the backing storage device.
	365	* - Page: The read/write units of blobs and metadata. This is
	366	* an offset into a blob in units of 4KiB.
	367	* - Cluster Index: The disk is broken into a sequential list of
	368	* clusters. This is the offset from the beginning.
	369	*
	370	* NOTE: These conversions all act on simple magnitudes, not with any sort
	371	* of knowledge about the blobs themselves. For instance, converting
	372	* a page to an lba with the conversion function below simply converts
	373	* a number of pages to an equivalent number of lbas, but that
	374	* lba certainly isn't the right lba that corresponds to a page offset
	375	* for a particular blob.
	376	*/
	377	static inline uint64_t
	378	_spdk_bs_byte_to_lba(struct spdk_blob_store *bs, uint64_t length)
	379	{
	380	assert(length % bs->dev->blocklen == 0);
	381
	382	return length / bs->dev->blocklen;
	383	}
	384
	385	static inline uint64_t
11fdf7f2	386	_spdk_bs_dev_byte_to_lba(struct spdk_bs_dev *bs_dev, uint64_t length)
7c673cae	387	{
11fdf7f2 TL	388	assert(length % bs_dev->blocklen == 0);
	389
	390	return length / bs_dev->blocklen;
7c673cae FG	391	}
	392
	393	static inline uint64_t
	394	_spdk_bs_page_to_lba(struct spdk_blob_store *bs, uint64_t page)
	395	{
11fdf7f2	396	return page * SPDK_BS_PAGE_SIZE / bs->dev->blocklen;
7c673cae FG	397	}
7c673cae FG	398
11fdf7f2 TL	399	static inline uint64_t
11fdf7f2 TL	400	_spdk_bs_dev_page_to_lba(struct spdk_bs_dev *bs_dev, uint64_t page)
7c673cae	401	{
11fdf7f2 TL	402	return page * SPDK_BS_PAGE_SIZE / bs_dev->blocklen;
11fdf7f2 TL	403	}
7c673cae	404
11fdf7f2 TL	405	static inline uint64_t
	406	_spdk_bs_io_unit_per_page(struct spdk_blob_store *bs)
	407	{
	408	return SPDK_BS_PAGE_SIZE / bs->io_unit_size;
	409	}
7c673cae	410
11fdf7f2 TL	411	static inline uint64_t
	412	_spdk_bs_io_unit_to_page(struct spdk_blob_store *bs, uint64_t io_unit)
	413	{
	414	return io_unit / _spdk_bs_io_unit_per_page(bs);
7c673cae FG	415	}
	416
	417	static inline uint64_t
	418	_spdk_bs_cluster_to_page(struct spdk_blob_store *bs, uint32_t cluster)
	419	{
11fdf7f2	420	return (uint64_t)cluster * bs->pages_per_cluster;
7c673cae FG	421	}
	422
	423	static inline uint32_t
	424	_spdk_bs_page_to_cluster(struct spdk_blob_store *bs, uint64_t page)
	425	{
	426	assert(page % bs->pages_per_cluster == 0);
	427
	428	return page / bs->pages_per_cluster;
	429	}
	430
	431	static inline uint64_t
	432	_spdk_bs_cluster_to_lba(struct spdk_blob_store *bs, uint32_t cluster)
	433	{
11fdf7f2	434	return (uint64_t)cluster * (bs->cluster_sz / bs->dev->blocklen);
7c673cae FG	435	}
	436
	437	static inline uint32_t
	438	_spdk_bs_lba_to_cluster(struct spdk_blob_store *bs, uint64_t lba)
	439	{
	440	assert(lba % (bs->cluster_sz / bs->dev->blocklen) == 0);
	441
	442	return lba / (bs->cluster_sz / bs->dev->blocklen);
	443	}
	444
11fdf7f2 TL	445	static inline uint64_t
	446	_spdk_bs_io_unit_to_back_dev_lba(struct spdk_blob *blob, uint64_t io_unit)
	447	{
	448	return io_unit * (blob->bs->io_unit_size / blob->back_bs_dev->blocklen);
	449	}
	450
	451	static inline uint64_t
	452	_spdk_bs_back_dev_lba_to_io_unit(struct spdk_blob *blob, uint64_t lba)
	453	{
	454	return lba * (blob->back_bs_dev->blocklen / blob->bs->io_unit_size);
	455	}
	456
7c673cae FG	457	/* End basic conversions */
7c673cae FG	458
11fdf7f2	459	static inline uint64_t
7c673cae FG	460	_spdk_bs_blobid_to_page(spdk_blob_id id)
	461	{
	462	return id & 0xFFFFFFFF;
	463	}
	464
11fdf7f2 TL	465	/* The blob id is a 64 bit number. The lower 32 bits are the page_idx. The upper
	466	* 32 bits are not currently used. Stick a 1 there just to catch bugs where the
	467	* code assumes blob id == page_idx.
	468	*/
	469	static inline spdk_blob_id
	470	_spdk_bs_page_to_blobid(uint64_t page_idx)
	471	{
	472	if (page_idx > UINT32_MAX) {
	473	return SPDK_BLOBID_INVALID;
	474	}
	475	return SPDK_BLOB_BLOBID_HIGH_BIT \| page_idx;
	476	}
	477
	478	/* Given an io unit offset into a blob, look up the LBA for the
	479	* start of that io unit.
7c673cae FG	480	*/
7c673cae FG	481	static inline uint64_t
11fdf7f2	482	_spdk_bs_blob_io_unit_to_lba(struct spdk_blob *blob, uint64_t io_unit)
7c673cae FG	483	{
7c673cae FG	484	uint64_t lba;
11fdf7f2 TL	485	uint64_t pages_per_cluster;
	486	uint64_t io_units_per_cluster;
	487	uint64_t io_units_per_page;
	488	uint64_t page;
	489
	490	page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
7c673cae FG	491
7c673cae FG	492	pages_per_cluster = blob->bs->pages_per_cluster;
11fdf7f2 TL	493	io_units_per_page = _spdk_bs_io_unit_per_page(blob->bs);
11fdf7f2 TL	494	io_units_per_cluster = io_units_per_page * pages_per_cluster;
7c673cae FG	495
	496	assert(page < blob->active.num_clusters * pages_per_cluster);
	497
	498	lba = blob->active.clusters[page / pages_per_cluster];
11fdf7f2	499	lba += io_unit % io_units_per_cluster;
7c673cae FG	500	return lba;
	501	}
	502
11fdf7f2 TL	503	/* Given an io_unit offset into a blob, look up the number of io_units until the
	504	* next cluster boundary.
	505	*/
	506	static inline uint32_t
	507	_spdk_bs_num_io_units_to_cluster_boundary(struct spdk_blob *blob, uint64_t io_unit)
	508	{
	509	uint64_t io_units_per_cluster;
	510
	511	io_units_per_cluster = _spdk_bs_io_unit_per_page(blob->bs) * blob->bs->pages_per_cluster;
	512
	513	return io_units_per_cluster - (io_unit % io_units_per_cluster);
	514	}
	515
7c673cae FG	516	/* Given a page offset into a blob, look up the number of pages until the
	517	* next cluster boundary.
	518	*/
	519	static inline uint32_t
11fdf7f2	520	_spdk_bs_num_pages_to_cluster_boundary(struct spdk_blob *blob, uint64_t page)
7c673cae	521	{
11fdf7f2	522	uint64_t pages_per_cluster;
7c673cae FG	523
	524	pages_per_cluster = blob->bs->pages_per_cluster;
	525
	526	return pages_per_cluster - (page % pages_per_cluster);
	527	}
	528
11fdf7f2 TL	529	/* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
	530	static inline uint32_t
	531	_spdk_bs_io_unit_to_cluster_start(struct spdk_blob *blob, uint64_t io_unit)
	532	{
	533	uint64_t pages_per_cluster;
	534	uint64_t page;
	535
	536	pages_per_cluster = blob->bs->pages_per_cluster;
	537	page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
	538
	539	return page - (page % pages_per_cluster);
	540	}
	541
	542	/* Given an io_unit offset into a blob, look up the number of pages into blob to beginning of current cluster */
	543	static inline uint32_t
	544	_spdk_bs_io_unit_to_cluster_number(struct spdk_blob *blob, uint64_t io_unit)
	545	{
	546	return (io_unit / _spdk_bs_io_unit_per_page(blob->bs)) / blob->bs->pages_per_cluster;
	547	}
	548
	549	/* Given an io unit offset into a blob, look up if it is from allocated cluster. */
	550	static inline bool
	551	_spdk_bs_io_unit_is_allocated(struct spdk_blob *blob, uint64_t io_unit)
	552	{
	553	uint64_t lba;
	554	uint64_t page;
	555	uint64_t pages_per_cluster;
	556
	557	pages_per_cluster = blob->bs->pages_per_cluster;
	558	page = _spdk_bs_io_unit_to_page(blob->bs, io_unit);
	559
	560	assert(page < blob->active.num_clusters * pages_per_cluster);
	561
	562	lba = blob->active.clusters[page / pages_per_cluster];
	563
	564	if (lba == 0) {
	565	assert(spdk_blob_is_thin_provisioned(blob));
	566	return false;
	567	} else {
	568	return true;
	569	}
	570	}
	571
7c673cae	572	#endif