bdev: add a null bdev module

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

#

#  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

/*-

 *   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)

/*-

 *   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 */

/*-

 *   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)