From c8b6a884fd1c265bab7d7d9261b9c7df04bfc73a Mon Sep 17 00:00:00 2001 From: John Kariuki Date: Mon, 7 Oct 2019 16:04:23 -0700 Subject: [PATCH] bdev/uring: add rpc calls added rpc calls for configuring uring bdevs Signed-off-by: John Kariuki Change-Id: I6c8273fd6e869402fcc244c9a08226d0c2db025c Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/471323 Reviewed-by: Jim Harris Reviewed-by: Shuhei Matsumoto Reviewed-by: Tomasz Zawadzki Tested-by: SPDK CI Jenkins --- module/bdev/uring/Makefile | 2 +- module/bdev/uring/bdev_uring_rpc.c | 148 +++++++++++++++++++++++++++++ scripts/rpc.py | 18 ++++ scripts/rpc/bdev.py | 24 +++++ 4 files changed, 191 insertions(+), 1 deletion(-) create mode 100644 module/bdev/uring/bdev_uring_rpc.c diff --git a/module/bdev/uring/Makefile b/module/bdev/uring/Makefile index 53cc7324b..edf562dd3 100644 --- a/module/bdev/uring/Makefile +++ b/module/bdev/uring/Makefile @@ -34,7 +34,7 @@ SPDK_ROOT_DIR := $(abspath $(CURDIR)/../../..) include $(SPDK_ROOT_DIR)/mk/spdk.common.mk -C_SRCS = bdev_uring.c +C_SRCS = bdev_uring.c bdev_uring_rpc.c LIBNAME = bdev_uring LOCAL_SYS_LIBS = -luring diff --git a/module/bdev/uring/bdev_uring_rpc.c b/module/bdev/uring/bdev_uring_rpc.c new file mode 100644 index 000000000..b221c68c0 --- /dev/null +++ b/module/bdev/uring/bdev_uring_rpc.c @@ -0,0 +1,148 @@ +/*- + * 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 "bdev_uring.h" +#include "spdk/rpc.h" +#include "spdk/util.h" +#include "spdk/string.h" +#include "spdk_internal/log.h" + +/* Structure to hold the parameters for this RPC method. */ +struct rpc_create_uring { + char *name; + char *filename; +}; + +/* Free the allocated memory resource after the RPC handling. */ +static void +free_rpc_create_uring(struct rpc_create_uring *r) +{ + free(r->name); + free(r->filename); +} + +/* Structure to decode the input parameters for this RPC method. */ +static const struct spdk_json_object_decoder rpc_create_uring_decoders[] = { + {"name", offsetof(struct rpc_create_uring, name), spdk_json_decode_string}, + {"filename", offsetof(struct rpc_create_uring, filename), spdk_json_decode_string}, +}; + +/* Decode the parameters for this RPC method and properly create the uring + * device. Error status returned in the failed cases. + */ +static void +spdk_rpc_bdev_uring_create(struct spdk_jsonrpc_request *request, + const struct spdk_json_val *params) +{ + struct rpc_create_uring req = {}; + struct spdk_json_write_ctx *w; + struct spdk_bdev *bdev; + + if (spdk_json_decode_object(params, rpc_create_uring_decoders, + SPDK_COUNTOF(rpc_create_uring_decoders), + &req)) { + SPDK_ERRLOG("spdk_json_decode_object failed\n"); + spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, + "spdk_json_decode_object failed"); + goto cleanup; + } + + bdev = create_uring_bdev(req.name, req.filename); + if (!bdev) { + SPDK_ERRLOG("Unable to create URING bdev from file %s\n", req.filename); + spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, + "Unable to create URING bdev."); + goto cleanup; + } + + w = spdk_jsonrpc_begin_result(request); + spdk_json_write_string(w, req.name); + spdk_jsonrpc_end_result(request, w); + +cleanup: + free_rpc_create_uring(&req); +} +SPDK_RPC_REGISTER("bdev_uring_create", spdk_rpc_bdev_uring_create, SPDK_RPC_RUNTIME) + +struct rpc_delete_uring { + char *name; +}; + +static void +free_rpc_delete_uring(struct rpc_delete_uring *req) +{ + free(req->name); +} + +static const struct spdk_json_object_decoder rpc_delete_uring_decoders[] = { + {"name", offsetof(struct rpc_delete_uring, name), spdk_json_decode_string}, +}; + +static void +_spdk_rpc_bdev_uring_delete_cb(void *cb_arg, int bdeverrno) +{ + struct spdk_jsonrpc_request *request = cb_arg; + struct spdk_json_write_ctx *w = spdk_jsonrpc_begin_result(request); + + spdk_json_write_bool(w, bdeverrno == 0); + spdk_jsonrpc_end_result(request, w); + +} + +static void +spdk_rpc_bdev_uring_delete(struct spdk_jsonrpc_request *request, + const struct spdk_json_val *params) +{ + struct rpc_delete_uring req = {NULL}; + struct spdk_bdev *bdev; + + if (spdk_json_decode_object(params, rpc_delete_uring_decoders, + SPDK_COUNTOF(rpc_delete_uring_decoders), + &req)) { + spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, + "spdk_json_decode_object failed"); + goto cleanup; + } + + bdev = spdk_bdev_get_by_name(req.name); + if (bdev == NULL) { + spdk_jsonrpc_send_error_response(request, -ENODEV, spdk_strerror(ENODEV)); + goto cleanup; + } + + delete_uring_bdev(bdev, _spdk_rpc_bdev_uring_delete_cb, request); + +cleanup: + free_rpc_delete_uring(&req); +} +SPDK_RPC_REGISTER("bdev_uring_delete", spdk_rpc_bdev_uring_delete, SPDK_RPC_RUNTIME) diff --git a/scripts/rpc.py b/scripts/rpc.py index ac9ef827a..160abb9e2 100755 --- a/scripts/rpc.py +++ b/scripts/rpc.py @@ -326,6 +326,24 @@ if __name__ == "__main__": p.add_argument('name', help='aio bdev name') p.set_defaults(func=bdev_aio_delete) + def bdev_uring_create(args): + print_json(rpc.bdev.bdev_uring_create(args.client, + filename=args.filename, + name=args.name)) + + p = subparsers.add_parser('bdev_uring_create', help='Create a bdev with io_uring backend') + p.add_argument('name', help='bdev name') + p.add_argument('filename', help='Path to device or file (ex: /dev/nvme0n1)') + p.set_defaults(func=bdev_uring_create) + + def bdev_uring_delete(args): + rpc.bdev.bdev_uring_delete(args.client, + name=args.name) + + p = subparsers.add_parser('bdev_uring_delete', help='Delete a uring bdev') + p.add_argument('name', help='uring bdev name') + p.set_defaults(func=bdev_uring_delete) + def bdev_nvme_set_options(args): rpc.bdev.bdev_nvme_set_options(args.client, action_on_timeout=args.action_on_timeout, diff --git a/scripts/rpc/bdev.py b/scripts/rpc/bdev.py index 4fd360e89..d187ca11e 100644 --- a/scripts/rpc/bdev.py +++ b/scripts/rpc/bdev.py @@ -321,6 +321,30 @@ def bdev_aio_delete(client, name): return client.call('bdev_aio_delete', params) +def bdev_uring_create(client, filename, name): + """Create a bdev with Linux io_uring backend. + Args: + name: name of bdev + filename: path to device or file (ex: /dev/nvme0n1) + Returns: + Name of created bdev. + """ + params = {'name': name, + 'filename': filename} + + return client.call('bdev_uring_create', params) + + +def bdev_uring_delete(client, name): + """Delete a uring bdev. + + Args: + name: name of uring bdev to delete + """ + params = {'name': name} + return client.call('bdev_uring_delete', params) + + @deprecated_alias('set_bdev_nvme_options') def bdev_nvme_set_options(client, action_on_timeout=None, timeout_us=None, retry_count=None, arbitration_burst=None, low_priority_weight=None,