bdev: add a null bdev module

Also change the discovery/nvmf.sh test to use it.

Signed-off-by: Jim Harris <james.r.harris@intel.com>
Change-Id: I56bce9a84bd46f13b6d4f34da81abf23413f2598

lib/bdev/Makefile

@@ -38,7 +38,7 @@ CFLAGS += $(ENV_CFLAGS) -I.
 C_SRCS = bdev.c scsi_nvme.c
 LIBNAME = bdev
 
-DIRS-y += malloc nvme rpc split
+DIRS-y += malloc null nvme rpc split
 
 ifeq ($(OS),Linux)
 DIRS-y += aio

lib/bdev/null/Makefile

@@ -0,0 +1,41 @@
+#
+#  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.
+#
+
+SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..)
+include $(SPDK_ROOT_DIR)/mk/spdk.common.mk
+
+CFLAGS += $(ENV_CFLAGS) -I$(SPDK_ROOT_DIR)/lib/bdev/
+C_SRCS = blockdev_null.c blockdev_null_rpc.c
+LIBNAME = bdev_null
+
+include $(SPDK_ROOT_DIR)/mk/spdk.lib.mk

lib/bdev/null/blockdev_null.c

@@ -0,0 +1,282 @@
+/*-
+ *   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/bdev.h"
+#include "spdk/conf.h"
+#include "spdk/env.h"
+#include "spdk/io_channel.h"
+
+#include "spdk_internal/bdev.h"
+#include "spdk_internal/log.h"
+
+#include "blockdev_null.h"
+
+struct null_bdev {
+	struct spdk_bdev	bdev;
+	TAILQ_ENTRY(null_bdev)	tailq;
+};
+
+static TAILQ_HEAD(, null_bdev) g_null_bdev_head;
+static void *g_null_read_buf;
+
+static int
+blockdev_null_get_ctx_size(void)
+{
+	return 0;
+}
+
+static int
+blockdev_null_destruct(void *ctx)
+{
+	struct null_bdev *bdev = ctx;
+
+	TAILQ_REMOVE(&g_null_bdev_head, bdev, tailq);
+	spdk_free(bdev);
+
+	return 0;
+}
+
+static void
+blockdev_null_submit_request(struct spdk_io_channel *ch, struct spdk_bdev_io *bdev_io)
+{
+	switch (bdev_io->type) {
+	case SPDK_BDEV_IO_TYPE_READ:
+		if (bdev_io->u.read.iovs[0].iov_base == NULL) {
+			assert(bdev_io->u.read.iovcnt == 1);
+			bdev_io->u.read.iovs[0].iov_base = g_null_read_buf;
+			bdev_io->u.read.iovs[0].iov_len = bdev_io->u.read.len;
+		}
+		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);
+		break;
+	case SPDK_BDEV_IO_TYPE_WRITE:
+	case SPDK_BDEV_IO_TYPE_RESET:
+		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_SUCCESS);
+		break;
+	case SPDK_BDEV_IO_TYPE_FLUSH:
+	case SPDK_BDEV_IO_TYPE_UNMAP:
+	default:
+		spdk_bdev_io_complete(bdev_io, SPDK_BDEV_IO_STATUS_FAILED);
+		break;
+	}
+}
+
+static bool
+blockdev_null_io_type_supported(void *ctx, enum spdk_bdev_io_type io_type)
+{
+	switch (io_type) {
+	case SPDK_BDEV_IO_TYPE_READ:
+	case SPDK_BDEV_IO_TYPE_WRITE:
+	case SPDK_BDEV_IO_TYPE_RESET:
+		return true;
+	case SPDK_BDEV_IO_TYPE_FLUSH:
+	case SPDK_BDEV_IO_TYPE_UNMAP:
+	default:
+		return false;
+	}
+}
+
+static struct spdk_io_channel *
+blockdev_null_get_io_channel(void *ctx, uint32_t priority)
+{
+	return spdk_get_io_channel(&g_null_bdev_head, priority, false, NULL);
+}
+
+static const struct spdk_bdev_fn_table null_fn_table = {
+	.destruct		= blockdev_null_destruct,
+	.submit_request		= blockdev_null_submit_request,
+	.io_type_supported	= blockdev_null_io_type_supported,
+	.get_io_channel		= blockdev_null_get_io_channel,
+};
+
+struct spdk_bdev *
+create_null_bdev(const char *name, uint64_t num_blocks, uint32_t block_size)
+{
+	struct null_bdev *bdev;
+
+	if (block_size % 512 != 0) {
+		SPDK_ERRLOG("Block size %u is not a multiple of 512.\n", block_size);
+		return NULL;
+	}
+
+	if (num_blocks == 0) {
+		SPDK_ERRLOG("Disk must be more than 0 blocks\n");
+		return NULL;
+	}
+
+	bdev = spdk_zmalloc(sizeof(*bdev), 0, NULL);
+	if (!bdev) {
+		SPDK_ERRLOG("could not allocate null_bdev\n");
+		return NULL;
+	}
+
+	snprintf(bdev->bdev.name, SPDK_BDEV_MAX_NAME_LENGTH, "%s", name);
+	snprintf(bdev->bdev.product_name, SPDK_BDEV_MAX_PRODUCT_NAME_LENGTH, "Null disk");
+
+	bdev->bdev.write_cache = 0;
+	bdev->bdev.blocklen = block_size;
+	bdev->bdev.blockcnt = num_blocks;
+	bdev->bdev.max_unmap_bdesc_count = 0;
+
+	bdev->bdev.ctxt = bdev;
+	bdev->bdev.fn_table = &null_fn_table;
+
+	spdk_bdev_register(&bdev->bdev);
+
+	TAILQ_INSERT_TAIL(&g_null_bdev_head, bdev, tailq);
+
+	return &bdev->bdev;
+}
+
+static int
+null_bdev_create_cb(void *io_device, uint32_t priority, void *ctx_buf, void *unique_ctx)
+{
+	return 0;
+}
+
+static void
+null_bdev_destroy_cb(void *io_device, void *ctx_buf)
+{
+}
+
+static int
+blockdev_null_initialize(void)
+{
+	struct spdk_conf_section *sp = spdk_conf_find_section(NULL, "Null");
+	uint64_t size_in_mb, num_blocks;
+	int block_size, i;
+	struct spdk_bdev *bdev;
+	const char *name, *val;
+
+	TAILQ_INIT(&g_null_bdev_head);
+
+	/*
+	 * This will be used if upper layer expects us to allocate the read buffer.
+	 *  Instead of using a real rbuf from the bdev pool, just always point to
+	 *  this same zeroed buffer.
+	 */
+	g_null_read_buf = spdk_zmalloc(SPDK_BDEV_LARGE_BUF_MAX_SIZE, 0, NULL);
+
+	/*
+	 * We need to pick some unique address as our "io device" - so just use the
+	 *  address of the global tailq.
+	 */
+	spdk_io_device_register(&g_null_bdev_head, null_bdev_create_cb, null_bdev_destroy_cb, 0);
+
+	if (sp == NULL) {
+		return 0;
+	}
+
+	i = 0;
+	while (true) {
+		val = spdk_conf_section_get_nval(sp, "Dev", i);
+		if (val == NULL) {
+			break;
+		}
+
+		name = spdk_conf_section_get_nmval(sp, "Dev", i, 0);
+		if (name == NULL) {
+			SPDK_ERRLOG("Null entry %d: Name must be provided\n", i);
+			continue;
+		}
+
+		val = spdk_conf_section_get_nmval(sp, "Dev", i, 1);
+		if (val == NULL) {
+			SPDK_ERRLOG("Null entry %d: Size in MB must be provided\n", i);
+			continue;
+		}
+
+		errno = 0;
+		size_in_mb = strtoull(val, NULL, 10);
+		if (errno) {
+			SPDK_ERRLOG("Null entry %d: Invalid size in MB %s\n", i, val);
+			continue;
+		}
+
+		val = spdk_conf_section_get_nmval(sp, "Dev", i, 2);
+		if (val == NULL) {
+			block_size = 512;
+		} else {
+			errno = 0;
+			block_size = (int)strtol(val, NULL, 10);
+			if (errno) {
+				SPDK_ERRLOG("Null entry %d: Invalid block size %s\n", i, val);
+				continue;
+			}
+		}
+
+		num_blocks = size_in_mb * (1024 * 1024) / block_size;
+
+		bdev = create_null_bdev(name, num_blocks, block_size);
+		if (bdev == NULL) {
+			SPDK_ERRLOG("Could not create null bdev\n");
+			return EINVAL;
+		}
+
+		i++;
+	}
+	return 0;
+}
+
+static void
+blockdev_null_finish(void)
+{
+	struct null_bdev *bdev, *tmp;
+
+	TAILQ_FOREACH_SAFE(bdev, &g_null_bdev_head, tailq, tmp) {
+		TAILQ_REMOVE(&g_null_bdev_head, bdev, tailq);
+		spdk_free(bdev);
+	}
+}
+
+static void
+blockdev_null_get_spdk_running_config(FILE *fp)
+{
+	struct null_bdev *bdev;
+	uint64_t null_bdev_size;
+
+	fprintf(fp, "\n[Null]\n");
+
+	TAILQ_FOREACH(bdev, &g_null_bdev_head, tailq) {
+		null_bdev_size = bdev->bdev.blocklen * bdev->bdev.blockcnt;
+		null_bdev_size /= (1024 * 1024);
+		fprintf(fp, "  %s %" PRIu64 " %d\n",
+			bdev->bdev.name, null_bdev_size, bdev->bdev.blocklen);
+	}
+}
+
+SPDK_BDEV_MODULE_REGISTER(blockdev_null_initialize, blockdev_null_finish,
+			  blockdev_null_get_spdk_running_config, blockdev_null_get_ctx_size)
+
+SPDK_LOG_REGISTER_TRACE_FLAG("bdev_null", SPDK_TRACE_BDEV_NULL)

lib/bdev/null/blockdev_null.h

@@ -0,0 +1,43 @@
+/*-
+ *   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_BLOCKDEV_NULL_H
+#define SPDK_BLOCKDEV_NULL_H
+
+#include "spdk/stdinc.h"
+
+struct spdk_bdev;
+
+struct spdk_bdev *create_null_bdev(const char *name, uint64_t num_blocks, uint32_t block_size);
+
+#endif /* SPDK_BLOCKDEV_NULL_H */

lib/bdev/null/blockdev_null_rpc.c

@@ -0,0 +1,92 @@
+/*-
+ *   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/bdev.h"
+#include "spdk/rpc.h"
+#include "spdk/util.h"
+
+#include "spdk_internal/log.h"
+
+#include "blockdev_null.h"
+
+struct rpc_construct_null {
+	char *name;
+	uint32_t num_blocks;
+	uint32_t block_size;
+};
+
+static const struct spdk_json_object_decoder rpc_construct_null_decoders[] = {
+	{"name", offsetof(struct rpc_construct_null, name), spdk_json_decode_string},
+	{"num_blocks", offsetof(struct rpc_construct_null, num_blocks), spdk_json_decode_uint32},
+	{"block_size", offsetof(struct rpc_construct_null, block_size), spdk_json_decode_uint32},
+};
+
+static void
+spdk_rpc_construct_null_bdev(struct spdk_jsonrpc_server_conn *conn,
+			     const struct spdk_json_val *params,
+			     const struct spdk_json_val *id)
+{
+	struct rpc_construct_null req = {};
+	struct spdk_json_write_ctx *w;
+	struct spdk_bdev *bdev;
+
+	if (spdk_json_decode_object(params, rpc_construct_null_decoders,
+				    SPDK_COUNTOF(rpc_construct_null_decoders),
+				    &req)) {
+		SPDK_TRACELOG(SPDK_TRACE_DEBUG, "spdk_json_decode_object failed\n");
+		goto invalid;
+	}
+
+	bdev = create_null_bdev(req.name, req.num_blocks, req.block_size);
+	if (bdev == NULL) {
+		goto invalid;
+	}
+
+	if (id == NULL) {
+		free(req.name);
+		return;
+	}
+
+	w = spdk_jsonrpc_begin_result(conn, id);
+	spdk_json_write_array_begin(w);
+	spdk_json_write_string(w, bdev->name);
+	spdk_json_write_array_end(w);
+	spdk_jsonrpc_end_result(conn, w);
+	free(req.name);
+	return;
+
+invalid:
+	spdk_jsonrpc_send_error_response(conn, id, SPDK_JSONRPC_ERROR_INVALID_PARAMS, "Invalid parameters");
+	free(req.name);
+}
+SPDK_RPC_REGISTER("construct_null_bdev", spdk_rpc_construct_null_bdev)

mk/spdk.modules.mk

@@ -31,7 +31,7 @@
 #  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 
-BLOCKDEV_MODULES_LIST = bdev_malloc bdev_nvme nvme vbdev_split
+BLOCKDEV_MODULES_LIST = bdev_malloc bdev_null bdev_nvme nvme vbdev_split
 
 ifeq ($(CONFIG_RDMA),y)
 BLOCKDEV_MODULES_DEPS += -libverbs -lrdmacm

scripts/rpc.py

@@ -174,6 +174,18 @@ p.add_argument('block_size', help='Block size for this bdev', type=int)
 p.set_defaults(func=construct_malloc_bdev)
 
 
+def construct_null_bdev(args):
+    num_blocks = (args.total_size * 1024 * 1024) / args.block_size
+    params = {'name': args.name, 'num_blocks': num_blocks, 'block_size': args.block_size}
+    print_array(jsonrpc_call('construct_null_bdev', params))
+
+p = subparsers.add_parser('construct_null_bdev', help='Add a bdev with null backend')
+p.add_argument('name', help='Block device name')
+p.add_argument('total_size', help='Size of null bdev in MB (int > 0)', type=int)
+p.add_argument('block_size', help='Block size for this bdev', type=int)
+p.set_defaults(func=construct_null_bdev)
+
+
 def construct_aio_bdev(args):
     params = {'name': args.name,
               'fname': args.fname}

test/nvmf/discovery/discovery.sh

@@ -5,8 +5,8 @@ rootdir=$(readlink -f $testdir/../../..)
 source $rootdir/scripts/autotest_common.sh
 source $rootdir/test/nvmf/common.sh
 
-MALLOC_BDEV_SIZE=64
+NULL_BDEV_SIZE=102400
-MALLOC_BLOCK_SIZE=512
+NULL_BLOCK_SIZE=512
 
 rpc_py="python $rootdir/scripts/rpc.py"
 
@@ -32,8 +32,8 @@ trap "killprocess $nvmfpid; exit 1" SIGINT SIGTERM EXIT
 
 waitforlisten $nvmfpid ${RPC_PORT}
 
-bdevs="$bdevs $($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
+bdevs="$bdevs $($rpc_py construct_null_bdev Null0 $NULL_BDEV_SIZE $NULL_BLOCK_SIZE)"
-bdevs="$bdevs $($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
+bdevs="$bdevs $($rpc_py construct_null_bdev Null1 $NULL_BDEV_SIZE $NULL_BLOCK_SIZE)"
 
 modprobe -v nvme-rdma