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

rpc: Rename create_pmem_pool to bdev_pmem_create_pool 



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


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarPaul Luse <paul.e.luse@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarBroadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
parent bd78196c

doc/bdev.md

+2 −2
Original line number Diff line number Diff line
@@ -509,11 +509,11 @@ First, user needs to configure SPDK to include PMDK support: 


`configure --with-pmdk`



To create pmemblk pool for use with SPDK user should use `create_pmem_pool` RPC command.

To create pmemblk pool for use with SPDK user should use `bdev_pmem_create_pool` RPC command.



Example command



`rpc.py create_pmem_pool /path/to/pmem_pool 25 4096`

`rpc.py bdev_pmem_create_pool /path/to/pmem_pool 25 4096`



To get information on created pmem pool file user can use `pmem_pool_info` RPC command.

doc/jsonrpc.md

+2 −2
Original line number Diff line number Diff line
@@ -2096,7 +2096,7 @@ Example response: 
~~~





## create_pmem_pool {#rpc_create_pmem_pool}

## bdev_pmem_create_pool {#rpc_bdev_pmem_create_pool}



Create a @ref bdev_config_pmem blk pool file. It is equivalent of following `pmempool create` command:
@@ -2126,7 +2126,7 @@ Example request: 
    "pmem_file": "/tmp/pmem_file"

  },

  "jsonrpc": "2.0",

  "method": "create_pmem_pool",

  "method": "bdev_pmem_create_pool",

  "id": 1

}

~~~

module/bdev/pmem/bdev_pmem_rpc.c

+14 −13
Original line number Diff line number Diff line
@@ -143,35 +143,35 @@ cleanup: 
SPDK_RPC_REGISTER("bdev_pmem_delete", spdk_rpc_bdev_pmem_delete, SPDK_RPC_RUNTIME)

SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_pmem_delete, delete_pmem_bdev)



struct rpc_create_pmem_pool {

struct rpc_bdev_pmem_create_pool {

	char *pmem_file;

	uint64_t num_blocks;

	uint32_t block_size;

};



static const struct spdk_json_object_decoder rpc_create_pmem_pool_decoders[] = {

	{"pmem_file", offsetof(struct rpc_create_pmem_pool, pmem_file), spdk_json_decode_string},

	{"num_blocks", offsetof(struct rpc_create_pmem_pool, num_blocks), spdk_json_decode_uint64},

	{"block_size", offsetof(struct rpc_create_pmem_pool, block_size), spdk_json_decode_uint32},

static const struct spdk_json_object_decoder rpc_bdev_pmem_create_pool_decoders[] = {

	{"pmem_file", offsetof(struct rpc_bdev_pmem_create_pool, pmem_file), spdk_json_decode_string},

	{"num_blocks", offsetof(struct rpc_bdev_pmem_create_pool, num_blocks), spdk_json_decode_uint64},

	{"block_size", offsetof(struct rpc_bdev_pmem_create_pool, block_size), spdk_json_decode_uint32},

};



static void

free_rpc_create_pmem_pool(struct rpc_create_pmem_pool *req)

free_rpc_bdev_pmem_create_pool(struct rpc_bdev_pmem_create_pool *req)

{

	free(req->pmem_file);

}



static void

spdk_rpc_create_pmem_pool(struct spdk_jsonrpc_request *request,

spdk_rpc_bdev_pmem_create_pool(struct spdk_jsonrpc_request *request,

			       const struct spdk_json_val *params)

{

	struct rpc_create_pmem_pool req = {};

	struct rpc_bdev_pmem_create_pool req = {};

	struct spdk_json_write_ctx *w;

	uint64_t pool_size;

	PMEMblkpool *pbp;



	if (spdk_json_decode_object(params, rpc_create_pmem_pool_decoders,

				    SPDK_COUNTOF(rpc_create_pmem_pool_decoders),

	if (spdk_json_decode_object(params, rpc_bdev_pmem_create_pool_decoders,

				    SPDK_COUNTOF(rpc_bdev_pmem_create_pool_decoders),

				    &req)) {

		SPDK_DEBUGLOG(SPDK_LOG_BDEV_PMEM, "spdk_json_decode_object failed\n");

		spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
@@ -210,9 +210,10 @@ spdk_rpc_create_pmem_pool(struct spdk_jsonrpc_request *request, 
	spdk_jsonrpc_end_result(request, w);



cleanup:

	free_rpc_create_pmem_pool(&req);

	free_rpc_bdev_pmem_create_pool(&req);

}

SPDK_RPC_REGISTER("create_pmem_pool", spdk_rpc_create_pmem_pool, SPDK_RPC_RUNTIME)

SPDK_RPC_REGISTER("bdev_pmem_create_pool", spdk_rpc_bdev_pmem_create_pool, SPDK_RPC_RUNTIME)

SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_pmem_create_pool, create_pmem_pool)



struct rpc_pmem_pool_info {

	char *pmem_file;

scripts/rpc.py

+8 −7
Original line number Diff line number Diff line
@@ -1708,18 +1708,19 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse 
    p.set_defaults(func=nvmf_get_stats)



    # pmem

    def create_pmem_pool(args):

    def bdev_pmem_create_pool(args):

        num_blocks = int((args.total_size * 1024 * 1024) / args.block_size)

        rpc.pmem.create_pmem_pool(args.client,

        rpc.pmem.bdev_pmem_create_pool(args.client,

                                       pmem_file=args.pmem_file,

                                       num_blocks=num_blocks,

                                       block_size=args.block_size)



    p = subparsers.add_parser('create_pmem_pool', help='Create pmem pool')

    p = subparsers.add_parser('bdev_pmem_create_pool', aliases=['create_pmem_pool'],

                              help='Create pmem pool')

    p.add_argument('pmem_file', help='Path to pmemblk pool file')

    p.add_argument('total_size', help='Size of malloc bdev in MB (int > 0)', type=int)

    p.add_argument('block_size', help='Block size for this pmem pool', type=int)

    p.set_defaults(func=create_pmem_pool)

    p.set_defaults(func=bdev_pmem_create_pool)



    def pmem_pool_info(args):

        print_dict(rpc.pmem.pmem_pool_info(args.client,

scripts/rpc/pmem.py

+6 −2
Original line number Diff line number Diff line 
def create_pmem_pool(client, pmem_file, num_blocks, block_size):

from .helpers import deprecated_alias





@deprecated_alias('create_pmem_pool')

def bdev_pmem_create_pool(client, pmem_file, num_blocks, block_size):

    """Create pmem pool at specified path.

    Args:

        pmem_file: path at which to create pmem pool
@@ -8,7 +12,7 @@ def create_pmem_pool(client, pmem_file, num_blocks, block_size): 
    params = {'pmem_file': pmem_file,

              'num_blocks': num_blocks,

              'block_size': block_size}

    return client.call('create_pmem_pool', params)

    return client.call('bdev_pmem_create_pool', params)





def pmem_pool_info(client, pmem_file):