d/numam-spdk
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

bdev: add a null bdev module

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

Signed-off-by: Jim Harris <james.r.harris@intel.com>
Change-Id: I56bce9a84bd46f13b6d4f34da81abf23413f2598
This commit is contained in:
Jim Harris 2017-05-05 10:50:46 -07:00 committed by Ben Walker
parent 7455910d1b
commit 4eafea0360
8 changed files with 476 additions and 6 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
lib/bdev/Makefile
View File

@ -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

41
lib/bdev/null/Makefile Normal file
View File

@ -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

282
lib/bdev/null/blockdev_null.c Normal file
View File

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

43
lib/bdev/null/blockdev_null.h Normal file
View File

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

92
lib/bdev/null/blockdev_null_rpc.c Normal file
View File

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

2
mk/spdk.modules.mk
View File

@ -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

12
scripts/rpc.py
View File

@ -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}

8
test/nvmf/discovery/discovery.sh
View File

@ -5,8 +5,8 @@ rootdir=$(readlink -f $testdir/../../..)
source $rootdir/scripts/autotest_common.sh
source $rootdir/test/nvmf/common.sh
MALLOC_BDEV_SIZE=64
MALLOC_BLOCK_SIZE=512
NULL_BDEV_SIZE=102400
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_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_null_bdev Null1 $NULL_BDEV_SIZE $NULL_BLOCK_SIZE)"
modprobe -v nvme-rdma