bdev/ocssd: create / delete calls (6bda87b3) · Commits · Public Repositories / spdk

module/bdev/nvme/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -34,7 +34,7 @@
		SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
		include $(SPDK_ROOT_DIR)/mk/spdk.common.mk

		C_SRCS = bdev_nvme.c bdev_nvme_rpc.c nvme_rpc.c common.c bdev_ocssd.c
		C_SRCS = bdev_nvme.c bdev_nvme_rpc.c nvme_rpc.c common.c bdev_ocssd.c bdev_ocssd_rpc.c
		C_SRCS-$(CONFIG_NVME_CUSE) += bdev_nvme_cuse_rpc.c

		ifeq ($(OS),Linux)

module/bdev/nvme/bdev_ocssd.c

+227 −0

Original line number	Diff line number	Diff line
		@@ -42,10 +42,20 @@
		#include "common.h"
		#include "bdev_ocssd.h"

		struct ocssd_bdev {
		struct nvme_bdev nvme_bdev;
		};

		struct bdev_ocssd_ns {
		struct spdk_ocssd_geometry_data geometry;
		};

		static struct bdev_ocssd_ns *
		bdev_ocssd_get_ns_from_nvme(struct nvme_bdev_ns *nvme_ns)
		{
		return nvme_ns->type_ctx;
		}

		static int
		bdev_ocssd_library_init(void)
		{
		@@ -79,6 +89,217 @@ static struct spdk_bdev_module ocssd_if = {

		SPDK_BDEV_MODULE_REGISTER(ocssd, &ocssd_if);

		static void
		bdev_ocssd_free_bdev(struct ocssd_bdev *ocssd_bdev)
		{
		if (!ocssd_bdev) {
		return;
		}

		free(ocssd_bdev->nvme_bdev.disk.name);
		free(ocssd_bdev);
		}

		static int
		bdev_ocssd_destruct(void *ctx)
		{
		struct ocssd_bdev *ocssd_bdev = ctx;
		struct nvme_bdev *nvme_bdev = &ocssd_bdev->nvme_bdev;

		nvme_bdev_detach_bdev_from_ns(nvme_bdev);
		bdev_ocssd_free_bdev(ocssd_bdev);

		return 0;
		}

		static void
		bdev_ocssd_submit_request(struct spdk_io_channel ioch, struct spdk_bdev_io bdev_io)
		{
		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
		}

		static bool
		bdev_ocssd_io_type_supported(void *ctx, enum spdk_bdev_io_type type)
		{
		return false;
		}

		static struct spdk_io_channel *
		bdev_ocssd_get_io_channel(void *ctx)
		{
		struct ocssd_bdev *ocssd_bdev = ctx;

		return spdk_get_io_channel(ocssd_bdev->nvme_bdev.nvme_bdev_ctrlr);
		}

		static struct spdk_bdev_fn_table ocssdlib_fn_table = {
		.destruct = bdev_ocssd_destruct,
		.submit_request = bdev_ocssd_submit_request,
		.io_type_supported = bdev_ocssd_io_type_supported,
		.get_io_channel = bdev_ocssd_get_io_channel,
		};

		void
		bdev_ocssd_create_bdev(const char ctrlr_name, const char bdev_name, uint32_t nsid,
		bdev_ocssd_create_cb cb_fn, void *cb_arg)
		{
		struct nvme_bdev_ctrlr *nvme_bdev_ctrlr;
		struct nvme_bdev *nvme_bdev = NULL;
		struct ocssd_bdev *ocssd_bdev = NULL;
		struct spdk_nvme_ns *ns;
		struct nvme_bdev_ns *nvme_ns;
		struct bdev_ocssd_ns *ocssd_ns;
		struct spdk_ocssd_geometry_data *geometry;
		int rc = 0;

		nvme_bdev_ctrlr = nvme_bdev_ctrlr_get_by_name(ctrlr_name);
		if (!nvme_bdev_ctrlr) {
		SPDK_ERRLOG("Unable to find controller %s\n", ctrlr_name);
		rc = -ENODEV;
		goto finish;
		}

		ns = spdk_nvme_ctrlr_get_ns(nvme_bdev_ctrlr->ctrlr, nsid);
		if (!ns) {
		SPDK_ERRLOG("Unable to retrieve namespace %"PRIu32"\n", nsid);
		rc = -ENODEV;
		goto finish;
		}

		if (!spdk_nvme_ns_is_active(ns)) {
		SPDK_ERRLOG("Namespace %"PRIu32" is inactive\n", nsid);
		rc = -EACCES;
		goto finish;
		}

		assert(nsid <= nvme_bdev_ctrlr->num_ns);
		nvme_ns = nvme_bdev_ctrlr->namespaces[nsid - 1];
		if (nvme_ns == NULL) {
		SPDK_ERRLOG("Namespace %"PRIu32" is not initialized\n", nsid);
		rc = -EINVAL;
		goto finish;
		}

		ocssd_ns = bdev_ocssd_get_ns_from_nvme(nvme_ns);
		if (ocssd_ns == NULL) {
		SPDK_ERRLOG("Namespace %"PRIu32" is not an OCSSD namespace\n", nsid);
		rc = -EINVAL;
		goto finish;
		}

		if (spdk_bdev_get_by_name(bdev_name) != NULL) {
		SPDK_ERRLOG("Device with provided name (%s) already exists\n", bdev_name);
		rc = -EEXIST;
		goto finish;
		}

		/* Only allow one bdev per namespace for now */
		if (!TAILQ_EMPTY(&nvme_ns->bdevs)) {
		SPDK_ERRLOG("Namespace %"PRIu32" was already claimed by bdev %s\n",
		nsid, TAILQ_FIRST(&nvme_ns->bdevs)->disk.name);
		rc = -EEXIST;
		goto finish;
		}

		ocssd_bdev = calloc(1, sizeof(*ocssd_bdev));
		if (!ocssd_bdev) {
		rc = -ENOMEM;
		goto finish;
		}

		nvme_bdev = &ocssd_bdev->nvme_bdev;
		nvme_bdev->nvme_ns = nvme_ns;
		nvme_bdev->nvme_bdev_ctrlr = nvme_bdev_ctrlr;
		geometry = &ocssd_ns->geometry;

		nvme_bdev->disk.name = strdup(bdev_name);
		if (!nvme_bdev->disk.name) {
		rc = -ENOMEM;
		goto finish;
		}

		nvme_bdev->disk.product_name = "Open Channel SSD";
		nvme_bdev->disk.ctxt = ocssd_bdev;
		nvme_bdev->disk.fn_table = &ocssdlib_fn_table;
		nvme_bdev->disk.module = &ocssd_if;
		nvme_bdev->disk.blocklen = spdk_nvme_ns_get_extended_sector_size(ns);
		nvme_bdev->disk.zoned = true;
		nvme_bdev->disk.blockcnt = geometry->num_grp * geometry->num_pu *
		geometry->num_chk * geometry->clba;
		nvme_bdev->disk.zone_size = geometry->clba;
		nvme_bdev->disk.max_open_zones = geometry->maxoc;
		nvme_bdev->disk.optimal_open_zones = geometry->num_grp * geometry->num_pu;
		nvme_bdev->disk.write_unit_size = geometry->ws_opt;

		if (geometry->maxocpu != 0 && geometry->maxocpu != geometry->maxoc) {
		SPDK_WARNLOG("Maximum open chunks per PU is not zero. Reducing the maximum "
		"number of open zones: %"PRIu32" -> %"PRIu32"\n",
		geometry->maxoc, geometry->maxocpu);
		nvme_bdev->disk.max_open_zones = geometry->maxocpu;
		}

		rc = spdk_bdev_register(&nvme_bdev->disk);
		if (spdk_unlikely(rc != 0)) {
		SPDK_ERRLOG("Failed to register bdev %s\n", nvme_bdev->disk.name);
		goto finish;
		}

		nvme_bdev_attach_bdev_to_ns(nvme_ns, nvme_bdev);
		finish:
		if (spdk_unlikely(rc != 0)) {
		bdev_ocssd_free_bdev(ocssd_bdev);
		bdev_name = NULL;
		}

		cb_fn(bdev_name, rc, cb_arg);
		}

		struct bdev_ocssd_delete_ctx {
		bdev_ocssd_delete_cb cb_fn;
		void *cb_arg;
		};

		static void
		bdev_ocssd_unregister_cb(void *cb_arg, int status)
		{
		struct bdev_ocssd_delete_ctx *delete_ctx = cb_arg;

		delete_ctx->cb_fn(status, delete_ctx->cb_arg);
		free(delete_ctx);
		}

		void
		bdev_ocssd_delete_bdev(const char bdev_name, bdev_ocssd_delete_cb cb_fn, void cb_arg)
		{
		struct spdk_bdev *bdev;
		struct bdev_ocssd_delete_ctx *delete_ctx;

		bdev = spdk_bdev_get_by_name(bdev_name);
		if (!bdev) {
		SPDK_ERRLOG("Unable to find bdev %s\n", bdev_name);
		cb_fn(-ENODEV, cb_arg);
		return;
		}

		if (bdev->module != &ocssd_if) {
		SPDK_ERRLOG("Specified bdev %s is not an OCSSD bdev\n", bdev_name);
		cb_fn(-EINVAL, cb_arg);
		return;
		}

		delete_ctx = calloc(1, sizeof(*delete_ctx));
		if (!delete_ctx) {
		SPDK_ERRLOG("Unable to allocate deletion context\n");
		cb_fn(-ENOMEM, cb_arg);
		return;
		}

		delete_ctx->cb_fn = cb_fn;
		delete_ctx->cb_arg = cb_arg;

		spdk_bdev_unregister(bdev, bdev_ocssd_unregister_cb, delete_ctx);
		}

		struct bdev_ocssd_populate_ns_ctx {
		struct nvme_async_probe_ctx *nvme_ctx;
		struct nvme_bdev_ns *nvme_ns;
		@@ -144,6 +365,12 @@ bdev_ocssd_populate_namespace(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr,
		void
		bdev_ocssd_depopulate_namespace(struct nvme_bdev_ns *ns)
		{
		struct nvme_bdev bdev, tmp;

		TAILQ_FOREACH_SAFE(bdev, &ns->bdevs, tailq, tmp) {
		spdk_bdev_unregister(&bdev->disk, NULL, NULL);
		}

		free(ns->type_ctx);
		ns->populated = false;
		ns->type_ctx = NULL;

module/bdev/nvme/bdev_ocssd.h

+7 −0

Original line number	Diff line number	Diff line
		@@ -37,6 +37,13 @@
		#include "spdk/stdinc.h"
		#include "common.h"

		typedef void (bdev_ocssd_create_cb)(const char bdev_name, int status, void *ctx);
		typedef void (bdev_ocssd_delete_cb)(int status, void ctx);

		void bdev_ocssd_create_bdev(const char ctrlr_name, const char bdev_name, uint32_t nsid,
		bdev_ocssd_create_cb cb_fn, void *cb_arg);
		void bdev_ocssd_delete_bdev(const char bdev_name, bdev_ocssd_delete_cb cb_fn, void cb_arg);

		void bdev_ocssd_populate_namespace(struct nvme_bdev_ctrlr *nvme_bdev_ctrlr,
		struct nvme_bdev_ns *nvme_ns,
		struct nvme_async_probe_ctx *ctx);

module/bdev/nvme/bdev_ocssd_rpc.c

0 → 100644

+178 −0

Original line number	Diff line number	Diff line
		/*-
		* 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.
		*/

		#include "spdk/stdinc.h"
		#include "spdk/rpc.h"
		#include "spdk/string.h"
		#include "spdk/util.h"
		#include "spdk/log.h"
		#include "spdk/likely.h"
		#include "bdev_ocssd.h"

		#define BDEV_OCSSD_DEFAULT_NSID 1

		struct rpc_create_ocssd_bdev {
		char *ctrlr_name;
		char *bdev_name;
		uint32_t nsid;
		};

		static const struct spdk_json_object_decoder rpc_create_ocssd_bdev_decoders[] = {
		{"ctrlr_name", offsetof(struct rpc_create_ocssd_bdev, ctrlr_name), spdk_json_decode_string},
		{"bdev_name", offsetof(struct rpc_create_ocssd_bdev, bdev_name), spdk_json_decode_string},
		{"nsid", offsetof(struct rpc_create_ocssd_bdev, nsid), spdk_json_decode_uint32, true},
		};

		static void
		free_rpc_create_ocssd_bdev(struct rpc_create_ocssd_bdev *rpc)
		{
		free(rpc->ctrlr_name);
		free(rpc->bdev_name);
		}

		struct rpc_bdev_ocssd_create_ctx {
		struct spdk_jsonrpc_request *request;
		struct rpc_create_ocssd_bdev rpc;
		};

		static void
		rpc_bdev_ocssd_create_done(const char bdev_name, int status, void _ctx)
		{
		struct rpc_bdev_ocssd_create_ctx *ctx = _ctx;
		struct spdk_json_write_ctx *w;

		if (status != 0) {
		spdk_jsonrpc_send_error_response(ctx->request, status, spdk_strerror(-status));
		goto out;
		}

		w = spdk_jsonrpc_begin_result(ctx->request);
		spdk_json_write_string(w, bdev_name);
		spdk_jsonrpc_end_result(ctx->request, w);
		out:
		free_rpc_create_ocssd_bdev(&ctx->rpc);
		free(ctx);
		}

		static void
		rpc_bdev_ocssd_create(struct spdk_jsonrpc_request request, const struct spdk_json_val params)
		{
		struct rpc_bdev_ocssd_create_ctx *ctx;

		ctx = calloc(1, sizeof(*ctx));
		if (!ctx) {
		spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
		return;
		}

		ctx->rpc.nsid = BDEV_OCSSD_DEFAULT_NSID;
		ctx->request = request;

		if (spdk_json_decode_object(params, rpc_create_ocssd_bdev_decoders,
		SPDK_COUNTOF(rpc_create_ocssd_bdev_decoders),
		&ctx->rpc)) {
		spdk_jsonrpc_send_error_response(request, -EINVAL, "Failed to parse the request");
		free_rpc_create_ocssd_bdev(&ctx->rpc);
		free(ctx);
		return;
		}

		bdev_ocssd_create_bdev(ctx->rpc.ctrlr_name, ctx->rpc.bdev_name, ctx->rpc.nsid,
		rpc_bdev_ocssd_create_done, ctx);
		}

		SPDK_RPC_REGISTER("bdev_ocssd_create", rpc_bdev_ocssd_create, SPDK_RPC_RUNTIME)

		struct rpc_delete_ocssd_bdev {
		char *name;
		};

		static const struct spdk_json_object_decoder rpc_delete_ocssd_bdev_decoders[] = {
		{"name", offsetof(struct rpc_delete_ocssd_bdev, name), spdk_json_decode_string},
		};

		static void
		free_rpc_delete_ocssd_bdev(struct rpc_delete_ocssd_bdev *rpc)
		{
		free(rpc->name);
		}

		struct rpc_bdev_ocssd_delete_ctx {
		struct spdk_jsonrpc_request *request;
		struct rpc_delete_ocssd_bdev rpc;
		};

		static void
		rpc_bdev_ocssd_delete_done(int status, void *_ctx)
		{
		struct rpc_bdev_ocssd_delete_ctx *ctx = _ctx;
		struct spdk_json_write_ctx *w;

		if (status != 0) {
		spdk_jsonrpc_send_error_response(ctx->request, status, spdk_strerror(-status));
		goto out;
		}

		w = spdk_jsonrpc_begin_result(ctx->request);
		spdk_json_write_bool(w, true);
		spdk_jsonrpc_end_result(ctx->request, w);
		out:
		free_rpc_delete_ocssd_bdev(&ctx->rpc);
		free(ctx);
		}

		static void
		rpc_bdev_ocssd_delete(struct spdk_jsonrpc_request request, const struct spdk_json_val params)
		{
		struct rpc_bdev_ocssd_delete_ctx *ctx;

		ctx = calloc(1, sizeof(*ctx));
		if (!ctx) {
		spdk_jsonrpc_send_error_response(request, -ENOMEM, spdk_strerror(ENOMEM));
		return;
		}

		ctx->request = request;
		if (spdk_json_decode_object(params, rpc_delete_ocssd_bdev_decoders,
		SPDK_COUNTOF(rpc_delete_ocssd_bdev_decoders),
		&ctx->rpc)) {
		spdk_jsonrpc_send_error_response(request, -EINVAL, "Failed to parse the request");
		free_rpc_delete_ocssd_bdev(&ctx->rpc);
		free(ctx);
		return;
		}

		bdev_ocssd_delete_bdev(ctx->rpc.name, rpc_bdev_ocssd_delete_done, ctx);
		}

		SPDK_RPC_REGISTER("bdev_ocssd_delete", rpc_bdev_ocssd_delete, SPDK_RPC_RUNTIME)

scripts/rpc.py

+24 −0

Original line number	Diff line number	Diff line
		@@ -2065,6 +2065,30 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
		p.add_argument('name', help='Virtio device name. E.g. VirtioUser0')
		p.set_defaults(func=bdev_virtio_detach_controller)

		# OCSSD
		def bdev_ocssd_create(args):
		nsid = int(args.nsid) if args.nsid is not None else None
		print_json(rpc.bdev.bdev_ocssd_create(args.client,
		ctrlr_name=args.ctrlr_name,
		bdev_name=args.name,
		nsid=nsid))

		p = subparsers.add_parser('bdev_ocssd_create',
		help='Creates zoned bdev on specified Open Channel controller')
		p.add_argument('-c', '--ctrlr_name', help='Name of the OC NVMe controller', required=True)
		p.add_argument('-b', '--name', help='Name of the bdev to create', required=True)
		p.add_argument('-n', '--nsid', help='Namespace ID', required=False)
		p.set_defaults(func=bdev_ocssd_create)

		def bdev_ocssd_delete(args):
		print_json(rpc.bdev.bdev_ocssd_delete(args.client,
		name=args.name))

		p = subparsers.add_parser('bdev_ocssd_delete',
		help='Deletes Open Channel bdev')
		p.add_argument('name', help='Name of the Open Channel bdev')
		p.set_defaults(func=bdev_ocssd_delete)

		# ioat
		def ioat_scan_copy_engine(args):
		pci_whitelist = []