Commit b318d5f0 authored by Pawel Kaminski's avatar Pawel Kaminski Committed by Jim Harris
Browse files

rpc: Rename send_nvme_cmd to bdev_nvme_send_cmd 



Change-Id: Ic441595cc2e5c3b3db1f998507660f6978759035
Signed-off-by: default avatarPawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/466503


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
parent b9063e4b

doc/jsonrpc.md

+3 −3
Original line number Diff line number Diff line
@@ -5640,11 +5640,11 @@ Example response: 


# Miscellaneous RPC commands



## send_nvme_cmd {#rpc_send_nvme_cmd}

## bdev_nvme_send_cmd {#rpc_bdev_nvme_send_cmd}



Send NVMe command directly to NVMe controller or namespace. Parameters and responses encoded by base64 urlsafe need further processing.



Notice: send_nvme_cmd requires user to guarentee the correctness of NVMe command itself, and also optional parameters. Illegal command contents or mismatching buffer size may result in unpredictable behavior.

Notice: bdev_nvme_send_cmd requires user to guarentee the correctness of NVMe command itself, and also optional parameters. Illegal command contents or mismatching buffer size may result in unpredictable behavior.



### Parameters
@@ -5675,7 +5675,7 @@ Example request: 
~~~

{

  "jsonrpc": "2.0",

  "method": "send_nvme_cmd",

  "method": "bdev_nvme_send_cmd",

  "id": 1,

  "params": {

    "name": "Nvme0",

module/bdev/nvme/nvme_rpc.c

+39 −37
Original line number Diff line number Diff line
@@ -47,7 +47,7 @@ enum spdk_nvme_rpc_type { 
	NVME_IO_CMD,

};



struct rpc_send_nvme_cmd_req {

struct rpc_bdev_nvme_send_cmd_req {

	char			*name;

	int			cmd_type;

	int			data_direction;
@@ -60,22 +60,22 @@ struct rpc_send_nvme_cmd_req { 
	char			*md;

};



struct rpc_send_nvme_cmd_resp {

struct rpc_bdev_nvme_send_cmd_resp {

	char	*cpl_text;

	char	*data_text;

	char	*md_text;

};



struct rpc_send_nvme_cmd_ctx {

struct rpc_bdev_nvme_send_cmd_ctx {

	struct spdk_jsonrpc_request	*jsonrpc_request;

	struct rpc_send_nvme_cmd_req	req;

	struct rpc_send_nvme_cmd_resp	resp;

	struct rpc_bdev_nvme_send_cmd_req	req;

	struct rpc_bdev_nvme_send_cmd_resp	resp;

	struct nvme_bdev_ctrlr		*nvme_bdev_ctrlr;

	struct spdk_io_channel		*ctrlr_io_ch;

};



static void

free_rpc_send_nvme_cmd_ctx(struct rpc_send_nvme_cmd_ctx *ctx)

free_rpc_bdev_nvme_send_cmd_ctx(struct rpc_bdev_nvme_send_cmd_ctx *ctx)

{

	assert(ctx != NULL);
@@ -90,8 +90,8 @@ free_rpc_send_nvme_cmd_ctx(struct rpc_send_nvme_cmd_ctx *ctx) 
}



static int

rpc_send_nvme_cmd_resp_construct(struct rpc_send_nvme_cmd_resp *resp,

				 struct rpc_send_nvme_cmd_req *req,

rpc_bdev_nvme_send_cmd_resp_construct(struct rpc_bdev_nvme_send_cmd_resp *resp,

				      struct rpc_bdev_nvme_send_cmd_req *req,

				      const struct spdk_nvme_cpl *cpl)

{

	resp->cpl_text = malloc(spdk_base64_get_encoded_strlen(sizeof(*cpl)) + 1);
@@ -121,13 +121,14 @@ rpc_send_nvme_cmd_resp_construct(struct rpc_send_nvme_cmd_resp *resp, 
}



static void

spdk_rpc_send_nvme_cmd_complete(struct rpc_send_nvme_cmd_ctx *ctx, const struct spdk_nvme_cpl *cpl)

spdk_rpc_bdev_nvme_send_cmd_complete(struct rpc_bdev_nvme_send_cmd_ctx *ctx,

				     const struct spdk_nvme_cpl *cpl)

{

	struct spdk_jsonrpc_request *request = ctx->jsonrpc_request;

	struct spdk_json_write_ctx *w;

	int ret;



	ret = rpc_send_nvme_cmd_resp_construct(&ctx->resp, &ctx->req, cpl);

	ret = rpc_bdev_nvme_send_cmd_resp_construct(&ctx->resp, &ctx->req, cpl);

	if (ret) {

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,

						 spdk_strerror(-ret));
@@ -150,25 +151,25 @@ spdk_rpc_send_nvme_cmd_complete(struct rpc_send_nvme_cmd_ctx *ctx, const struct 
	spdk_jsonrpc_end_result(request, w);



out:

	free_rpc_send_nvme_cmd_ctx(ctx);

	free_rpc_bdev_nvme_send_cmd_ctx(ctx);

	return;

}



static void

nvme_rpc_bdev_nvme_cb(void *ref, const struct spdk_nvme_cpl *cpl)

{

	struct rpc_send_nvme_cmd_ctx *ctx = (struct rpc_send_nvme_cmd_ctx *)ref;

	struct rpc_bdev_nvme_send_cmd_ctx *ctx = (struct rpc_bdev_nvme_send_cmd_ctx *)ref;



	if (ctx->ctrlr_io_ch) {

		spdk_put_io_channel(ctx->ctrlr_io_ch);

		ctx->ctrlr_io_ch = NULL;

	}



	spdk_rpc_send_nvme_cmd_complete(ctx, cpl);

	spdk_rpc_bdev_nvme_send_cmd_complete(ctx, cpl);

}



static int

nvme_rpc_admin_cmd_bdev_nvme(struct rpc_send_nvme_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd,

nvme_rpc_admin_cmd_bdev_nvme(struct rpc_bdev_nvme_send_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd,

			     void *buf, uint32_t nbytes, uint32_t timeout_ms)

{

	struct nvme_bdev_ctrlr *_nvme_ctrlr = ctx->nvme_bdev_ctrlr;
@@ -181,7 +182,7 @@ nvme_rpc_admin_cmd_bdev_nvme(struct rpc_send_nvme_cmd_ctx *ctx, struct spdk_nvme 
}



static int

nvme_rpc_io_cmd_bdev_nvme(struct rpc_send_nvme_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd,

nvme_rpc_io_cmd_bdev_nvme(struct rpc_bdev_nvme_send_cmd_ctx *ctx, struct spdk_nvme_cmd *cmd,

			  void *buf, uint32_t nbytes, void *md_buf, uint32_t md_len,

			  uint32_t timeout_ms)

{
@@ -203,9 +204,9 @@ nvme_rpc_io_cmd_bdev_nvme(struct rpc_send_nvme_cmd_ctx *ctx, struct spdk_nvme_cm 
}



static int

rpc_send_nvme_cmd_exec(struct rpc_send_nvme_cmd_ctx *ctx)

rpc_bdev_nvme_send_cmd_exec(struct rpc_bdev_nvme_send_cmd_ctx *ctx)

{

	struct rpc_send_nvme_cmd_req *req = &ctx->req;

	struct rpc_bdev_nvme_send_cmd_req *req = &ctx->req;

	int ret = -EINVAL;



	switch (req->cmd_type) {
@@ -296,7 +297,7 @@ out: 
static int

rpc_decode_data(const struct spdk_json_val *val, void *out)

{

	struct rpc_send_nvme_cmd_req *req = (struct rpc_send_nvme_cmd_req *)out;

	struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out;

	char *text = NULL;

	size_t text_strlen;

	int rc;
@@ -333,7 +334,7 @@ out: 
static int

rpc_decode_data_len(const struct spdk_json_val *val, void *out)

{

	struct rpc_send_nvme_cmd_req *req = (struct rpc_send_nvme_cmd_req *)out;

	struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out;

	uint32_t data_len;

	int rc;
@@ -362,7 +363,7 @@ rpc_decode_data_len(const struct spdk_json_val *val, void *out) 
static int

rpc_decode_metadata(const struct spdk_json_val *val, void *out)

{

	struct rpc_send_nvme_cmd_req *req = (struct rpc_send_nvme_cmd_req *)out;

	struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out;

	char *text = NULL;

	size_t text_strlen;

	int rc;
@@ -399,7 +400,7 @@ out: 
static int

rpc_decode_metadata_len(const struct spdk_json_val *val, void *out)

{

	struct rpc_send_nvme_cmd_req *req = (struct rpc_send_nvme_cmd_req *)out;

	struct rpc_bdev_nvme_send_cmd_req *req = (struct rpc_bdev_nvme_send_cmd_req *)out;

	uint32_t md_len;

	int rc;
@@ -425,12 +426,12 @@ rpc_decode_metadata_len(const struct spdk_json_val *val, void *out) 
	return rc;

}



static const struct spdk_json_object_decoder rpc_send_nvme_cmd_req_decoders[] = {

	{"name", offsetof(struct rpc_send_nvme_cmd_req, name), spdk_json_decode_string},

	{"cmd_type", offsetof(struct rpc_send_nvme_cmd_req, cmd_type), rpc_decode_cmd_type},

	{"data_direction", offsetof(struct rpc_send_nvme_cmd_req, data_direction), rpc_decode_data_direction},

	{"cmdbuf", offsetof(struct rpc_send_nvme_cmd_req, cmdbuf), rpc_decode_cmdbuf},

	{"timeout_ms", offsetof(struct rpc_send_nvme_cmd_req, timeout_ms), spdk_json_decode_uint32, true},

static const struct spdk_json_object_decoder rpc_bdev_nvme_send_cmd_req_decoders[] = {

	{"name", offsetof(struct rpc_bdev_nvme_send_cmd_req, name), spdk_json_decode_string},

	{"cmd_type", offsetof(struct rpc_bdev_nvme_send_cmd_req, cmd_type), rpc_decode_cmd_type},

	{"data_direction", offsetof(struct rpc_bdev_nvme_send_cmd_req, data_direction), rpc_decode_data_direction},

	{"cmdbuf", offsetof(struct rpc_bdev_nvme_send_cmd_req, cmdbuf), rpc_decode_cmdbuf},

	{"timeout_ms", offsetof(struct rpc_bdev_nvme_send_cmd_req, timeout_ms), spdk_json_decode_uint32, true},

	{"data_len", 0, rpc_decode_data_len, true},

	{"metadata_len", 0, rpc_decode_metadata_len, true},

	{"data", 0, rpc_decode_data, true},
@@ -438,10 +439,10 @@ static const struct spdk_json_object_decoder rpc_send_nvme_cmd_req_decoders[] = 
};



static void

spdk_rpc_send_nvme_cmd(struct spdk_jsonrpc_request *request,

spdk_rpc_bdev_nvme_send_cmd(struct spdk_jsonrpc_request *request,

			    const struct spdk_json_val *params)

{

	struct rpc_send_nvme_cmd_ctx *ctx;

	struct rpc_bdev_nvme_send_cmd_ctx *ctx;

	int ret, error_code;



	ctx = calloc(1, sizeof(*ctx));
@@ -452,8 +453,8 @@ spdk_rpc_send_nvme_cmd(struct spdk_jsonrpc_request *request, 
		goto invalid;

	}



	if (spdk_json_decode_object(params, rpc_send_nvme_cmd_req_decoders,

				    SPDK_COUNTOF(rpc_send_nvme_cmd_req_decoders),

	if (spdk_json_decode_object(params, rpc_bdev_nvme_send_cmd_req_decoders,

				    SPDK_COUNTOF(rpc_bdev_nvme_send_cmd_req_decoders),

				    &ctx->req)) {

		SPDK_ERRLOG("spdk_json_decode_object failed\n");

		error_code = SPDK_JSONRPC_ERROR_INVALID_PARAMS;
@@ -471,9 +472,9 @@ spdk_rpc_send_nvme_cmd(struct spdk_jsonrpc_request *request, 


	ctx->jsonrpc_request = request;



	ret = rpc_send_nvme_cmd_exec(ctx);

	ret = rpc_bdev_nvme_send_cmd_exec(ctx);

	if (ret < 0) {

		SPDK_NOTICELOG("Failed at rpc_send_nvme_cmd_exec\n");

		SPDK_NOTICELOG("Failed at rpc_bdev_nvme_send_cmd_exec\n");

		error_code = SPDK_JSONRPC_ERROR_INTERNAL_ERROR;

		goto invalid;

	}
@@ -482,7 +483,8 @@ spdk_rpc_send_nvme_cmd(struct spdk_jsonrpc_request *request, 


invalid:

	spdk_jsonrpc_send_error_response(request, error_code, spdk_strerror(-ret));

	free_rpc_send_nvme_cmd_ctx(ctx);

	free_rpc_bdev_nvme_send_cmd_ctx(ctx);

	return;

}

SPDK_RPC_REGISTER("send_nvme_cmd", spdk_rpc_send_nvme_cmd, SPDK_RPC_RUNTIME)
 
SPDK_RPC_REGISTER("bdev_nvme_send_cmd", spdk_rpc_bdev_nvme_send_cmd, SPDK_RPC_RUNTIME)

SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_nvme_send_cmd, send_nvme_cmd)

scripts/rpc.py

+16 −15
Original line number Diff line number Diff line
@@ -1891,9 +1891,9 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse 
    domain:bus:device.function format or domain.bus.device.function format""")

    p.set_defaults(func=scan_ioat_copy_engine)



    # send_nvme_cmd

    def send_nvme_cmd(args):

        print_dict(rpc.nvme.send_nvme_cmd(args.client,

    # bdev_nvme_send_cmd

    def bdev_nvme_send_cmd(args):

        print_dict(rpc.nvme.bdev_nvme_send_cmd(args.client,

                                               name=args.nvme_name,

                                               cmd_type=args.cmd_type,

                                               data_direction=args.data_direction,
@@ -1904,7 +1904,8 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse 
                                               metadata_len=args.metadata_length,

                                               timeout_ms=args.timeout_ms))



    p = subparsers.add_parser('send_nvme_cmd', help='NVMe passthrough cmd.')

    p = subparsers.add_parser('bdev_nvme_send_cmd', aliases=['send_nvme_cmd'],

                              help='NVMe passthrough cmd.')

    p.add_argument('-n', '--nvme-name', help="""Name of the operating NVMe controller""")

    p.add_argument('-t', '--cmd-type', help="""Type of nvme cmd. Valid values are: admin, io""")

    p.add_argument('-r', '--data-direction', help="""Direction of data transfer. Valid values are: c2h, h2c""")
@@ -1915,7 +1916,7 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse 
    p.add_argument('-M', '--metadata-length', help="""Metadata length required to transfer from controller to host""", type=int)

    p.add_argument('-T', '--timeout-ms',

                   help="""Command execution timeout value, in milliseconds,  if 0, don't track timeout""", type=int, default=0)

    p.set_defaults(func=send_nvme_cmd)

    p.set_defaults(func=bdev_nvme_send_cmd)



    # Notifications

    def get_notification_types(args):

scripts/rpc/nvme.py

+6 −5
Original line number Diff line number Diff line 
from .helpers import deprecated_alias





def send_nvme_cmd(client, name, cmd_type, data_direction, cmdbuf,

@deprecated_alias('send_nvme_cmd')

def bdev_nvme_send_cmd(client, name, cmd_type, data_direction, cmdbuf,

                       data=None, metadata=None,

                       data_len=None, metadata_len=None,

                       timeout_ms=None):
@@ -37,7 +38,7 @@ def send_nvme_cmd(client, name, cmd_type, data_direction, cmdbuf, 
    if timeout_ms:

        params['timeout_ms'] = timeout_ms



    return client.call('send_nvme_cmd', params)

    return client.call('bdev_nvme_send_cmd', params)





@deprecated_alias('get_nvme_controllers')