bdev: implement claims v2 (a7eb6187) · Commits · Public Repositories / spdk

CHANGELOG.md

+7 −0

Original line number	Diff line number	Diff line
		@@ -2,6 +2,13 @@

		## v23.05: (Upcoming Release)

		### bdev

		A new API `spdk_bdev_module_claim_bdev_desc` was added. Unlike `spdk_bdev_module_claim_bdev`, this
		function requires a bdev descriptor to be passed and the claim is automatically released when the
		descriptor is closed. It allows bdev modules to claim bdevs as a single writer, multiple writers, or
		multiple readers.

		### env

		New function `spdk_env_get_main_core` was added.

doc/bdev_module.md

+35 −14

Original line number	Diff line number	Diff line
		@@ -155,21 +155,42 @@ bdevs, but take the one additional step of claiming the bdev.

		The module can open the underlying bdevs it wishes to route I/O to using
		spdk_bdev_open_ext(), where the string name is provided by the user via an RPC.
		This will return a bdev descriptor that may be used with future calls to
		spdk_bdev_module_claim_bdev() and spdk_bdev_get_io_channel(). The bdev structure
		required by spdk_bdev_module_claim_bdev() may be obtained with
		spdk_bdev_module_open_ext() followed by spdk_bdev_desc_get_bdev().
		To ensure that other consumers do not modify the underlying bdev in an unexpected
		way, the virtual bdev should take a claim on the underlying bdev before
		reading from or writing to the underlying bdev.

		There are two slightly different APIs for taking and releasing claims. The
		preferred interface uses `spdk_bdev_module_claim_bdev_desc()`. This method allows
		claims that ensure there is a single writer with
		`SPDK_BDEV_CLAIM_READ_WRITE_ONCE`, cooperating shared writers with
		`SPDK_BDEV_CLAIM_READ_WRITE_MANY`, and shared readers that prevent any
		writers with `SPDK_BDEV_CLAIM_READ_ONLY_MANY`. In all cases,
		`spdk_bdev_open_ext()` may be used to open the underlying bdev read-only. If a
		read-only bdev descriptor successfully claims a bdev with
		`SPDK_BDEV_CLAIM_READ_WRITE_ONCE` or `SPDK_BDEV_CLAIM_READ_WRITE_MANY`
		the bdev descriptor is promoted to read-write.
		Any claim that is obtained with `spdk_bdev_module_claim_bdev_desc()` is
		automatically released upon closing the bdev descriptor used to obtain the
		claim. Shared claims continue to block new incompatible claims and new writers
		until the last claim is released.

		The non-preferred interface for obtaining a claim allows the caller to obtain
		an exclusive writer claim with `spdk_bdev_module_claim_bdev()`. It may be
		be released with `spdk_bdev_module_release_bdev()`. If a read-only bdev
		descriptor is passed, it is promoted to read-write. NULL may be passed instead
		of a bdev descriptor to avoid promotion and to block new writers. New code
		should use `spdk_bdev_module_claim_bdev_desc()` with the claim type that is
		tailored to the virtual bdev's needs.

		The descriptor obtained from the successful spdk_bdev_open_ext() may be used
		with spdk_bdev_get_io_channel() to obtain I/O channels for the bdev. This is
		likely done in response to the virtual bdev's `get_io_channel` callback.
		Channels may be obtained before and/or after claiming the underlying
		bdev. Claims are described below.

		The final step is to have the module use its open descriptor to call
		spdk_bdev_module_claim_bdev(), indicating that it is consuming the underlying
		bdev. This prevents other users from opening descriptors with write permissions.
		This effectively 'promotes' the descriptor to write-exclusive and is an
		operation only available to bdev modules. If a virtual bdev module wishes to
		prevent a descriptor from being upgraded to read-write,
		spdk_bdev_module_claim_bdev() may be called with a NULL descriptor.
		Channels may be obtained before and/or after claiming the underlying bdev, but
		beware there may be other unknown writers until the underlying bdev has been
		claimed.

		When a virtual bdev module claims an underlying bdev from its `examine_config`
		callback, it causes the `examine_disk` callback to only be called for this
		module and any others that establish a shared claim. If no claims are taken by
		`examine_config` callbacks, all virtual bdevs' `examine_disk` callbacks are
		called.

include/spdk/bdev_module.h

+105 −4

Original line number	Diff line number	Diff line
		@@ -28,6 +28,8 @@
		extern "C" {
		#endif

		#define SPDK_BDEV_CLAIM_NAME_LEN 32

		/* This parameter is best defined for bdevs that share an underlying bdev,
		* such as multiple lvol bdevs sharing an nvme device, to avoid unnecessarily
		* resetting the underlying bdev and affecting other bdevs that are sharing it. */
		@@ -167,11 +169,94 @@ enum spdk_bdev_claim_type {
		SPDK_BDEV_CLAIM_NONE = 0,

		/**
		* Exclusive writer.
		* Exclusive writer, with allowances for legacy behavior. This matches the behavior of
		* `spdk_bdev_module_claim_bdev()` as of SPDK 22.09. New consumer should use
		* SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE instead.
		*/
		SPDK_BDEV_CLAIM_EXCL_WRITE,

		/**
		* The descriptor passed with this claim request is the only writer. Other claimless readers
		* are allowed.
		*/
		SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE,

		/**
		* Any number of readers, no writers. Readers without a claim are allowed.
		*/
		SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE,

		/**
		* Any number of writers with matching shared_claim_key. After the first writer establishes
		* a claim, future aspiring writers should open read-only and pass the read-only descriptor.
		* If the shared claim is granted to the aspiring writer, the descriptor will be upgraded to
		* read-write.
		*/
		SPDK_BDEV_CLAIM_EXCL_WRITE
		SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED
		};

		/** Options used when requesting a claim. */
		struct spdk_bdev_claim_opts {
		/* Size of this structure in bytes */
		size_t opts_size;
		/**
		* An arbitrary name for the claim. If set, it should be a string suitable for printing in
		* error messages. Must be '\0' terminated.
		*/
		char name[SPDK_BDEV_CLAIM_NAME_LEN];
		/**
		* Used with SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED claims. Any non-zero value is considered
		* a key.
		*/
		uint64_t shared_claim_key;
		};
		SPDK_STATIC_ASSERT(sizeof(struct spdk_bdev_claim_opts) == 48, "Incorrect size");

		/**
		* Retrieve the name of the bdev module claim type. The mapping between claim types and their names
		* is:
		*
		* SPDK_BDEV_CLAIM_NONE "not_claimed"
		* SPDK_BDEV_CLAIM_EXCL_WRITE "exclusive_write"
		* SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE "read_many_write_one"
		* SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE "read_many_write_none"
		* SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED "read_many_write_shared"
		*
		* Any other value will return "invalid_claim".
		*
		* \param claim_type The claim type.
		* \return A string that describes the claim type.
		*/
		const char *spdk_bdev_claim_get_name(enum spdk_bdev_claim_type claim_type);

		/**
		* Initialize bdev module claim options structure.
		*
		* \param opts The structure to initialize.
		* \param size The size of *opts.
		*/
		void spdk_bdev_claim_opts_init(struct spdk_bdev_claim_opts *opts, size_t size);

		/**
		* Claim the bdev referenced by the open descriptor. The claim is released as the descriptor is
		* closed.
		*
		* \param desc An open bdev descriptor. Some claim types may upgrade this from read-only to
		* read-write.
		* \param type The type of claim to establish.
		* \param opts NULL or options required by the particular claim type.
		* \param module The bdev module making this claim.
		* \return 0 on success
		* \return -ENOMEM if insufficient memory to track the claim
		* \return -EBUSY if the claim cannot be granted due to a conflict
		* \return -EINVAL if the claim type required options that were not passed or required parameters
		* were NULL.
		*/
		int spdk_bdev_module_claim_bdev_desc(struct spdk_bdev_desc *desc,
		enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts *opts,
		struct spdk_bdev_module *module);

		/**
		* Called by a bdev module to lay exclusive claim to a bdev.
		*
		@@ -311,6 +396,13 @@ struct spdk_bdev_alias {
		TAILQ_ENTRY(spdk_bdev_alias) tailq;
		};

		struct spdk_bdev_module_claim {
		struct spdk_bdev_module *module;
		struct spdk_bdev_desc *desc;
		char name[SPDK_BDEV_CLAIM_NAME_LEN];
		TAILQ_ENTRY(spdk_bdev_module_claim) link;
		};

		typedef TAILQ_HEAD(, spdk_bdev_io) bdev_io_tailq_t;
		typedef STAILQ_HEAD(, spdk_bdev_io) bdev_io_stailq_t;
		typedef TAILQ_HEAD(, lba_range) lba_range_tailq_t;
		@@ -541,14 +633,23 @@ struct spdk_bdev {

		/** Which module has claimed this bdev. Must hold spinlock on all updates. */
		union __bdev_internal_claim {
		/** Claims acquired with spdk_bdev_module_claim_bdev() */
		struct __bdev_internal_claim_v1 {
		/**
		* Pointer to the module that has claimed this bdev for purposes of
		* creating virtual bdevs on top of it. Set to NULL if the bdev has
		* not been claimed.
		* creating virtual bdevs on top of it. Set to NULL and set
		* claim_type to SPDK_BDEV_CLAIM_NONE if the bdev has not been
		* claimed.
		*/
		struct spdk_bdev_module *module;
		} v1;
		/** Claims acquired with spdk_bdev_module_claim_bdev_desc() */
		struct __bdev_internal_claim_v2 {
		/** The claims on this bdev */
		TAILQ_HEAD(v2_claims, spdk_bdev_module_claim) claims;
		/** See spdk_bdev_claim_opts.shared_claim_key */
		uint64_t key;
		} v2;
		} claim;

		/** Callback function that will be called after bdev destruct is completed. */

lib/bdev/bdev.c

+390 −3

Original line number	Diff line number	Diff line
		@@ -331,6 +331,7 @@ struct spdk_bdev_desc {
		spdk_bdev_io_timeout_cb cb_fn;
		void *cb_arg;
		struct spdk_poller *io_timeout_poller;
		struct spdk_bdev_module_claim *claim;
		};

		struct spdk_bdev_iostat_ctx {
		@@ -393,6 +394,9 @@ static inline void bdev_io_complete(void *ctx);
		static bool bdev_abort_queued_io(bdev_io_tailq_t queue, struct spdk_bdev_io bio_to_abort);
		static bool bdev_abort_buf_io(struct spdk_bdev_mgmt_channel ch, struct spdk_bdev_io bio_to_abort);

		static bool claim_type_is_v2(enum spdk_bdev_claim_type type);
		static void bdev_desc_release_claims(struct spdk_bdev_desc *desc);

		void
		spdk_bdev_get_opts(struct spdk_bdev_opts *opts, size_t opts_size)
		{
		@@ -1840,8 +1844,7 @@ bdev_finish_unregister_bdevs_iter(void *cb_arg, int bdeverrno)
		bdev; bdev = TAILQ_PREV(bdev, spdk_bdev_list, internal.link)) {
		spdk_spin_lock(&bdev->internal.spinlock);
		if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) {
		SPDK_DEBUGLOG(bdev, "Skipping claimed bdev '%s'(<-'%s').\n",
		bdev->name, bdev->internal.claim.v1.module->name);
		LOG_ALREADY_CLAIMED_DEBUG("claimed, skipping", bdev);
		spdk_spin_unlock(&bdev->internal.spinlock);
		continue;
		}
		@@ -7060,12 +7063,14 @@ log_already_claimed(enum spdk_log_level level, const int line, const char *func,
		const char typename, modname;
		extern struct spdk_log_flag SPDK_LOG_bdev;

		assert(spdk_spin_held(&bdev->internal.spinlock));

		if (level >= SPDK_LOG_INFO && !SPDK_LOG_bdev.enabled) {
		return;
		}

		type = bdev->internal.claim_type;
		typename = "exclusive_write";
		typename = spdk_bdev_claim_get_name(type);

		if (type == SPDK_BDEV_CLAIM_EXCL_WRITE) {
		modname = bdev->internal.claim.v1.module->name;
		@@ -7074,6 +7079,17 @@ log_already_claimed(enum spdk_log_level level, const int line, const char *func,
		return;
		}

		if (claim_type_is_v2(type)) {
		struct spdk_bdev_module_claim *claim;

		TAILQ_FOREACH(claim, &bdev->internal.claim.v2.claims, link) {
		modname = claim->module->name;
		spdk_log(level, __FILE__, line, func, "bdev %s %s: type %s by module %s\n",
		bdev->name, detail, typename, modname);
		}
		return;
		}

		assert(false);
		}

		@@ -7218,6 +7234,10 @@ bdev_close(struct spdk_bdev bdev, struct spdk_bdev_desc desc)

		desc->closed = true;

		if (desc->claim != NULL) {
		bdev_desc_release_claims(desc);
		}

		if (0 == desc->refs) {
		spdk_spin_unlock(&desc->spinlock);
		bdev_desc_free(desc);
		@@ -7361,6 +7381,373 @@ spdk_bdev_module_release_bdev(struct spdk_bdev *bdev)
		spdk_spin_unlock(&bdev->internal.spinlock);
		}

		/*
		* Start claims v2
		*/

		const char *
		spdk_bdev_claim_get_name(enum spdk_bdev_claim_type type)
		{
		switch (type) {
		case SPDK_BDEV_CLAIM_NONE:
		return "not_claimed";
		case SPDK_BDEV_CLAIM_EXCL_WRITE:
		return "exclusive_write";
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE:
		return "read_many_write_one";
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE:
		return "read_many_write_none";
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED:
		return "read_many_write_many";
		default:
		break;
		}
		return "invalid_claim";
		}

		static bool
		claim_type_is_v2(enum spdk_bdev_claim_type type)
		{
		switch (type) {
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE:
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE:
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED:
		return true;
		default:
		break;
		}
		return false;
		}

		/* Returns true if taking a claim with desc->write == false should make the descriptor writable. */
		static bool
		claim_type_promotes_to_write(enum spdk_bdev_claim_type type)
		{
		switch (type) {
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE:
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED:
		return true;
		default:
		break;
		}
		return false;
		}

		void
		spdk_bdev_claim_opts_init(struct spdk_bdev_claim_opts *opts, size_t size)
		{
		if (opts == NULL) {
		SPDK_ERRLOG("opts should not be NULL\n");
		assert(opts != NULL);
		return;
		}
		if (size == 0) {
		SPDK_ERRLOG("size should not be zero\n");
		assert(size != 0);
		return;
		}

		memset(opts, 0, size);
		opts->opts_size = size;

		#define FIELD_OK(field) \
		offsetof(struct spdk_bdev_claim_opts, field) + sizeof(opts->field) <= size

		#define SET_FIELD(field, value) \
		if (FIELD_OK(field)) { \
		opts->field = value; \
		} \

		SET_FIELD(shared_claim_key, 0);

		#undef FIELD_OK
		#undef SET_FIELD
		}

		static int
		claim_opts_copy(struct spdk_bdev_claim_opts src, struct spdk_bdev_claim_opts dst)
		{
		if (src->opts_size == 0) {
		SPDK_ERRLOG("size should not be zero\n");
		return -1;
		}

		memset(dst, 0, sizeof(*dst));
		dst->opts_size = src->opts_size;

		#define FIELD_OK(field) \
		offsetof(struct spdk_bdev_claim_opts, field) + sizeof(src->field) <= src->opts_size

		#define SET_FIELD(field) \
		if (FIELD_OK(field)) { \
		dst->field = src->field; \
		} \

		if (FIELD_OK(name)) {
		snprintf(dst->name, sizeof(dst->name), "%s", src->name);
		}

		SET_FIELD(shared_claim_key);

		/* You should not remove this statement, but need to update the assert statement
		* if you add a new field, and also add a corresponding SET_FIELD statement */
		SPDK_STATIC_ASSERT(sizeof(struct spdk_bdev_claim_opts) == 48, "Incorrect size");

		#undef FIELD_OK
		#undef SET_FIELD
		return 0;
		}

		/* Returns 0 if a read-write-once claim can be taken. */
		static int
		claim_verify_rwo(struct spdk_bdev_desc *desc, enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts opts, struct spdk_bdev_module module)
		{
		struct spdk_bdev *bdev = desc->bdev;
		struct spdk_bdev_desc *open_desc;

		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE);

		if (opts->shared_claim_key != 0) {
		SPDK_ERRLOG("%s: key option not supported with read-write-once claims\n",
		bdev->name);
		return -EINVAL;
		}
		if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) {
		LOG_ALREADY_CLAIMED_ERROR("already claimed", bdev);
		return -EPERM;
		}
		if (desc->claim != NULL) {
		SPDK_NOTICELOG("%s: descriptor already claimed bdev with module %s\n",
		bdev->name, desc->claim->module->name);
		return -EPERM;
		}
		TAILQ_FOREACH(open_desc, &bdev->internal.open_descs, link) {
		if (desc != open_desc && open_desc->write) {
		SPDK_NOTICELOG("%s: Cannot obtain read-write-once claim while "
		"another descriptor is open for writing\n",
		bdev->name);
		return -EPERM;
		}
		}

		return 0;
		}

		/* Returns 0 if a read-only-many claim can be taken. */
		static int
		claim_verify_rom(struct spdk_bdev_desc *desc, enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts opts, struct spdk_bdev_module module)
		{
		struct spdk_bdev *bdev = desc->bdev;
		struct spdk_bdev_desc *open_desc;

		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE);
		assert(desc->claim == NULL);

		if (desc->write) {
		SPDK_ERRLOG("%s: Cannot obtain read-only-many claim with writable descriptor\n",
		bdev->name);
		return -EINVAL;
		}
		if (opts->shared_claim_key != 0) {
		SPDK_ERRLOG("%s: key option not supported with read-only-may claims\n", bdev->name);
		return -EINVAL;
		}
		if (bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE) {
		TAILQ_FOREACH(open_desc, &bdev->internal.open_descs, link) {
		if (open_desc->write) {
		SPDK_NOTICELOG("%s: Cannot obtain read-only-many claim while "
		"another descriptor is open for writing\n",
		bdev->name);
		return -EPERM;
		}
		}
		}

		return 0;
		}

		/* Returns 0 if a read-write-many claim can be taken. */
		static int
		claim_verify_rwm(struct spdk_bdev_desc *desc, enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts opts, struct spdk_bdev_module module)
		{
		struct spdk_bdev *bdev = desc->bdev;
		struct spdk_bdev_desc *open_desc;

		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(type == SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED);
		assert(desc->claim == NULL);

		if (opts->shared_claim_key == 0) {
		SPDK_ERRLOG("%s: shared_claim_key option required with read-write-may claims\n",
		bdev->name);
		return -EINVAL;
		}
		switch (bdev->internal.claim_type) {
		case SPDK_BDEV_CLAIM_NONE:
		TAILQ_FOREACH(open_desc, &bdev->internal.open_descs, link) {
		if (open_desc == desc) {
		continue;
		}
		if (open_desc->write) {
		SPDK_NOTICELOG("%s: Cannot obtain read-write-many claim while "
		"another descriptor is open for writing without a "
		"claim\n", bdev->name);
		return -EPERM;
		}
		}
		break;
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED:
		if (opts->shared_claim_key != bdev->internal.claim.v2.key) {
		LOG_ALREADY_CLAIMED_ERROR("already claimed with another key", bdev);
		return -EPERM;
		}
		break;
		default:
		LOG_ALREADY_CLAIMED_ERROR("already claimed", bdev);
		return -EBUSY;
		}

		return 0;
		}

		/* Updates desc and its bdev with a v2 claim. */
		static int
		claim_bdev(struct spdk_bdev_desc *desc, enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts opts, struct spdk_bdev_module module)
		{
		struct spdk_bdev *bdev = desc->bdev;
		struct spdk_bdev_module_claim *claim;

		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(claim_type_is_v2(type));
		assert(desc->claim == NULL);

		claim = calloc(1, sizeof(*desc->claim));
		if (claim == NULL) {
		SPDK_ERRLOG("%s: out of memory while allocating claim\n", bdev->name);
		return -ENOMEM;
		}
		claim->module = module;
		claim->desc = desc;
		SPDK_STATIC_ASSERT(sizeof(claim->name) == sizeof(opts->name), "sizes must match");
		memcpy(claim->name, opts->name, sizeof(claim->name));
		desc->claim = claim;

		if (bdev->internal.claim_type == SPDK_BDEV_CLAIM_NONE) {
		bdev->internal.claim_type = type;
		TAILQ_INIT(&bdev->internal.claim.v2.claims);
		bdev->internal.claim.v2.key = opts->shared_claim_key;
		}
		assert(type == bdev->internal.claim_type);

		TAILQ_INSERT_TAIL(&bdev->internal.claim.v2.claims, claim, link);

		if (!desc->write && claim_type_promotes_to_write(type)) {
		desc->write = true;
		}

		return 0;
		}

		int
		spdk_bdev_module_claim_bdev_desc(struct spdk_bdev_desc *desc, enum spdk_bdev_claim_type type,
		struct spdk_bdev_claim_opts *_opts,
		struct spdk_bdev_module *module)
		{
		struct spdk_bdev *bdev = desc->bdev;
		struct spdk_bdev_claim_opts opts;
		int rc = 0;

		if (desc == NULL) {
		SPDK_ERRLOG("descriptor must not be NULL\n");
		return -EINVAL;
		}

		if (_opts == NULL) {
		spdk_bdev_claim_opts_init(&opts, sizeof(opts));
		} else if (claim_opts_copy(_opts, &opts) != 0) {
		return -EINVAL;
		}

		spdk_spin_lock(&bdev->internal.spinlock);

		if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE &&
		bdev->internal.claim_type != type) {
		LOG_ALREADY_CLAIMED_ERROR("already claimed", bdev);
		spdk_spin_unlock(&bdev->internal.spinlock);
		return -EPERM;
		}

		if (claim_type_is_v2(type) && desc->claim != NULL) {
		SPDK_ERRLOG("%s: descriptor already has %s claim with name '%s'\n",
		bdev->name, spdk_bdev_claim_get_name(type), desc->claim->name);
		spdk_spin_unlock(&bdev->internal.spinlock);
		return -EPERM;
		}

		switch (type) {
		case SPDK_BDEV_CLAIM_EXCL_WRITE:
		spdk_spin_unlock(&bdev->internal.spinlock);
		return spdk_bdev_module_claim_bdev(bdev, desc, module);
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_ONE:
		rc = claim_verify_rwo(desc, type, &opts, module);
		break;
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_NONE:
		rc = claim_verify_rom(desc, type, &opts, module);
		break;
		case SPDK_BDEV_CLAIM_READ_MANY_WRITE_SHARED:
		rc = claim_verify_rwm(desc, type, &opts, module);
		break;
		default:
		SPDK_ERRLOG("%s: claim type %d not supported\n", bdev->name, type);
		rc = -ENOTSUP;
		}

		if (rc == 0) {
		rc = claim_bdev(desc, type, &opts, module);
		}

		spdk_spin_unlock(&bdev->internal.spinlock);
		return rc;
		}

		static void
		claim_reset(struct spdk_bdev *bdev)
		{
		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(claim_type_is_v2(bdev->internal.claim_type));
		assert(TAILQ_EMPTY(&bdev->internal.claim.v2.claims));

		memset(&bdev->internal.claim, 0, sizeof(bdev->internal.claim));
		bdev->internal.claim_type = SPDK_BDEV_CLAIM_NONE;
		}

		static void
		bdev_desc_release_claims(struct spdk_bdev_desc *desc)
		{
		struct spdk_bdev *bdev = desc->bdev;

		assert(spdk_spin_held(&bdev->internal.spinlock));
		assert(claim_type_is_v2(bdev->internal.claim_type));

		TAILQ_REMOVE(&bdev->internal.claim.v2.claims, desc->claim, link);
		free(desc->claim);
		desc->claim = NULL;

		if (TAILQ_EMPTY(&bdev->internal.claim.v2.claims)) {
		claim_reset(bdev);
		}
		}

		/*
		* End claims v2
		*/

		struct spdk_bdev *
		spdk_bdev_desc_get_bdev(struct spdk_bdev_desc *desc)
		{

lib/bdev/bdev_rpc.c

+4 −0

Original line number	Diff line number	Diff line
		@@ -716,6 +716,10 @@ rpc_dump_bdev_info(void ctx, struct spdk_bdev bdev)

		spdk_json_write_named_bool(w, "claimed",
		(bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE));
		if (bdev->internal.claim_type != SPDK_BDEV_CLAIM_NONE) {
		spdk_json_write_named_string(w, "claim_type",
		spdk_bdev_claim_get_name(bdev->internal.claim_type));
		}

		spdk_json_write_named_bool(w, "zoned", bdev->zoned);
		if (bdev->zoned) {