rpc: Rename create_pmem_pool to bdev_pmem_create_pool

Change-Id: Ie3cafb3ff4a22b0c38f54ed5d45f19eab9381c23
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/466708
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>

doc/bdev.md

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

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

@@ -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[] = {
+static const struct spdk_json_object_decoder rpc_bdev_pmem_create_pool_decoders[] = {
-	{"pmem_file", offsetof(struct rpc_create_pmem_pool, pmem_file), spdk_json_decode_string},
+	{"pmem_file", offsetof(struct rpc_bdev_pmem_create_pool, pmem_file), spdk_json_decode_string},
-	{"num_blocks", offsetof(struct rpc_create_pmem_pool, num_blocks), spdk_json_decode_uint64},
+	{"num_blocks", offsetof(struct rpc_bdev_pmem_create_pool, num_blocks), spdk_json_decode_uint64},
-	{"block_size", offsetof(struct rpc_create_pmem_pool, block_size), spdk_json_decode_uint32},
+	{"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)
+			       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,
+	if (spdk_json_decode_object(params, rpc_bdev_pmem_create_pool_decoders,
-				    SPDK_COUNTOF(rpc_create_pmem_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

@@ -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,
+                                       pmem_file=args.pmem_file,
-                                  num_blocks=num_blocks,
+                                       num_blocks=num_blocks,
-                                  block_size=args.block_size)
+                                       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

@@ -1,4 +1,8 @@
-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):

scripts/spdkcli/ui_node.py

@@ -48,7 +48,7 @@ class UINode(ConfigNode):
                             "allow_any_host", "split_bdev", "add_lun",
                             "add_pg_ig_maps", "remove_target", "add_secret",
                             "destruct_split_bdev", "delete_pmem_pool",
-                            "create_pmem_pool", "delete_secret_all",
+                            "bdev_pmem_create_pool", "delete_secret_all",
                             "delete_initiator", "set_auth", "delete_secret",
                             "delete_pg_ig_maps", "load_config",
                             "load_subsystem_config"]:
@@ -425,14 +425,14 @@ class UIPmemBdev(UIBdev):
     def delete(self, name):
         self.get_root().bdev_pmem_delete(name=name)
 
-    def ui_command_create_pmem_pool(self, pmem_file, total_size, block_size):
+    def ui_command_bdev_pmem_create_pool(self, pmem_file, total_size, block_size):
         total_size = self.ui_eval_param(total_size, "number", None)
         block_size = self.ui_eval_param(block_size, "number", None)
         num_blocks = int((total_size * 1024 * 1024) / block_size)
 
-        self.get_root().create_pmem_pool(pmem_file=pmem_file,
+        self.get_root().bdev_pmem_create_pool(pmem_file=pmem_file,
-                                         num_blocks=num_blocks,
+                                              num_blocks=num_blocks,
-                                         block_size=block_size)
+                                              block_size=block_size)
 
     def ui_command_delete_pmem_pool(self, pmem_file):
         self.get_root().delete_pmem_pool(pmem_file=pmem_file)

scripts/spdkcli/ui_root.py

@@ -206,8 +206,8 @@ class UIRoot(UINode):
         rpc.lvol.bdev_lvol_delete_lvstore(self.client, **kwargs)
 
     @verbose
-    def create_pmem_pool(self, **kwargs):
+    def bdev_pmem_create_pool(self, **kwargs):
-        response = rpc.pmem.create_pmem_pool(self.client, **kwargs)
+        response = rpc.pmem.bdev_pmem_create_pool(self.client, **kwargs)
         return response
 
     @verbose

test/pmem/common.sh

@@ -37,7 +37,7 @@ function pmem_create_pool_file()
 
 	pmem_clean_pool_file $pool_file
 	echo "Creating new pool file"
-	if ! $rpc_py create_pmem_pool $pool_file $size $block_size; then
+	if ! $rpc_py bdev_pmem_create_pool $pool_file $size $block_size; then
 		error "Creating pool_file failed!"
 	fi
 

test/pmem/pmem.sh

@@ -31,7 +31,7 @@ function usage()
 	echo "-h, --help                Print help and exit"
 	echo "-x                        set -x for script debug"
 	echo "    --info                Run test cases for pmem_pool_info"
-	echo "    --create              Run test cases for create_pmem_pool"
+	echo "    --create              Run test cases for bdev_pmem_create_pool"
 	echo "    --delete              Run test cases for delete_pmem_pool"
 	echo "    --construct_bdev      Run test cases for constructing pmem bdevs"
 	echo "    --delete_bdev         Run test cases for deleting pmem bdevs"
@@ -130,60 +130,60 @@ function pmem_pool_info_tc4()
 }
 
 #================================================
-# create_pmem_pool tests
+# bdev_pmem_create_pool tests
 #================================================
-function create_pmem_pool_tc1()
+function bdev_pmem_create_pool_tc1()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 
-	if $rpc_py create_pmem_pool 32 512; then
+	if $rpc_py bdev_pmem_create_pool 32 512; then
 		error "Mem pool file created w/out given path!"
 	fi
 
-	if $rpc_py create_pmem_pool $default_pool_file; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file; then
 		error "Mem pool file created w/out size & block size arguments!"
 	fi
 
 	if $rpc_py pmem_pool_info $default_pool_file; then
-		error "create_pmem_pool created invalid pool file!"
+		error "bdev_pmem_create_pool created invalid pool file!"
 	fi
 
-	if $rpc_py create_pmem_pool $default_pool_file 32; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file 32; then
 		error "Mem pool file created w/out block size argument!"
 	fi
 
 	if $rpc_py pmem_pool_info $default_pool_file; then
-		error "create_pmem_pool created invalid pool file!"
+		error "bdev_pmem_create_pool created invalid pool file!"
 	fi
 
 	pmem_clean_pool_file
 	return 0
 }
 
-function create_pmem_pool_tc2()
+function bdev_pmem_create_pool_tc2()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 
-	if  $rpc_py create_pmem_pool $rootdir/non/existing/path/non_existent_file 32 512; then
+	if  $rpc_py bdev_pmem_create_pool $rootdir/non/existing/path/non_existent_file 32 512; then
 		error "Mem pool file created with incorrect path!"
 	fi
 
 	if $rpc_py pmem_pool_info $rootdir/non/existing/path/non_existent_file; then
-		error "create_pmem_pool created invalid pool file!"
+		error "bdev_pmem_create_pool created invalid pool file!"
 	fi
 
 	pmem_clean_pool_file
 	return 0
 }
 
-function create_pmem_pool_tc3()
+function bdev_pmem_create_pool_tc3()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 
-	if ! $rpc_py create_pmem_pool $default_pool_file 256 512; then
+	if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 512; then
 		error "Failed to create pmem pool!"
 	fi
 
@@ -207,14 +207,14 @@ function create_pmem_pool_tc3()
 	return 0
 }
 
-function create_pmem_pool_tc4()
+function bdev_pmem_create_pool_tc4()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 
 	pmem_unmount_ramspace
 	mkdir $rootdir/test/pmem/ramspace
 	mount -t tmpfs -o size=300m tmpfs $rootdir/test/pmem/ramspace
-	if ! $rpc_py create_pmem_pool $rootdir/test/pmem/ramspace/pool_file 256 512; then
+	if ! $rpc_py bdev_pmem_create_pool $rootdir/test/pmem/ramspace/pool_file 256 512; then
 		pmem_unmount_ramspace
 		error "Failed to create pmem pool!"
 	fi
@@ -238,14 +238,14 @@ function create_pmem_pool_tc4()
 	return 0
 }
 
-function create_pmem_pool_tc5()
+function bdev_pmem_create_pool_tc5()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 	local pmem_block_size
 	local pmem_num_block
 
-	if ! $rpc_py create_pmem_pool $default_pool_file 256 512; then
+	if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 512; then
 		error "Failed to create pmem pool!"
 	fi
 
@@ -256,7 +256,7 @@ function create_pmem_pool_tc5()
 		error "Failed to get pmem info!"
 	fi
 
-	if $rpc_py create_pmem_pool $default_pool_file 512 4096; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file 512 4096; then
 		error "Pmem pool with already occupied path has been created!"
 	fi
 
@@ -280,7 +280,7 @@ function create_pmem_pool_tc5()
 	return 0
 }
 
-function create_pmem_pool_tc6()
+function bdev_pmem_create_pool_tc6()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
@@ -288,7 +288,7 @@ function create_pmem_pool_tc6()
 
 	for i in 511 512 1024 2048 4096 131072 262144
 	do
-		if ! $rpc_py create_pmem_pool $default_pool_file 256 $i; then
+		if ! $rpc_py bdev_pmem_create_pool $default_pool_file 256 $i; then
 			error "Failed to create pmem pool!"
 		fi
 
@@ -310,12 +310,12 @@ function create_pmem_pool_tc6()
 	return 0
 }
 
-function create_pmem_pool_tc7()
+function bdev_pmem_create_pool_tc7()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 
-	if $rpc_py create_pmem_pool $default_pool_file 15 512; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file 15 512; then
 		error "Created pmem pool with invalid size!"
 	fi
 
@@ -327,12 +327,12 @@ function create_pmem_pool_tc7()
 	return 0
 }
 
-function create_pmem_pool_tc8()
+function bdev_pmem_create_pool_tc8()
 {
-	pmem_print_tc_name "create_pmem_pool_tc8"
+	pmem_print_tc_name "bdev_pmem_create_pool_tc8"
 	pmem_clean_pool_file
 
-	if $rpc_py create_pmem_pool $default_pool_file 32 65536; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file 32 65536; then
 		error "Created pmem pool with invalid block number!"
 	fi
 
@@ -344,25 +344,25 @@ function create_pmem_pool_tc8()
 	return 0
 }
 
-function create_pmem_pool_tc9()
+function bdev_pmem_create_pool_tc9()
 {
 	pmem_print_tc_name ${FUNCNAME[0]}
 	pmem_clean_pool_file
 
-	if $rpc_py create_pmem_pool $default_pool_file 256 -1; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file 256 -1; then
 		error "Created pmem pool with negative block size number!"
 	fi
 
 	if $rpc_py pmem_pool_info $default_pool_file; then
-		error "create_pmem_pool create invalid pool file!"
+		error "bdev_pmem_create_pool create invalid pool file!"
 	fi
 
-	if $rpc_py create_pmem_pool $default_pool_file -1 512; then
+	if $rpc_py bdev_pmem_create_pool $default_pool_file -1 512; then
 		error "Created pmem pool with negative size number!"
 	fi
 
 	if $rpc_py pmem_pool_info $default_pool_file; then
-		error "create_pmem_pool create invalid pool file!"
+		error "bdev_pmem_create_pool create invalid pool file!"
 	fi
 
 	pmem_clean_pool_file
@@ -664,15 +664,15 @@ if $test_info || $test_all; then
 fi
 
 if $test_create || $test_all; then
-	create_pmem_pool_tc1
+	bdev_pmem_create_pool_tc1
-	create_pmem_pool_tc2
+	bdev_pmem_create_pool_tc2
-	create_pmem_pool_tc3
+	bdev_pmem_create_pool_tc3
-	create_pmem_pool_tc4
+	bdev_pmem_create_pool_tc4
-	create_pmem_pool_tc5
+	bdev_pmem_create_pool_tc5
-	create_pmem_pool_tc6
+	bdev_pmem_create_pool_tc6
-	create_pmem_pool_tc7
+	bdev_pmem_create_pool_tc7
-	create_pmem_pool_tc8
+	bdev_pmem_create_pool_tc8
-	create_pmem_pool_tc9
+	bdev_pmem_create_pool_tc9
 fi
 
 if $test_delete || $test_all; then

test/pmem/test_plan.md

@@ -57,7 +57,7 @@ Steps & expected results:
 - Call pmem_pool_info with path argument that points to existing file.
 - Check that return code == 0
 
-### create_pmem_pool
+### bdev_pmem_create_pool
 From libpmemblk documentation:
 - PMEM block size has to be bigger than 512 internal blocks; if lower value
 is used then PMEM library will silently round it up to 512 which is defined
@@ -66,36 +66,36 @@ in pmem/libpmemblk.h file as PMEMBLK_MIN_BLK.
 pmem/libpmemblk.h file as PMEMBLK_MIN_POOL
 - Total number of segments in PMEP pool file cannot be less than 256
 
-#### create_pmem_pool_tc1
+#### bdev_pmem_create_pool_tc1
 Negative test case for creating a new pmem.
-Call create_pmem_pool with missing arguments.
+Call bdev_pmem_create_pool with missing arguments.
 Steps & expected results:
-- call create_pmem_pool without path argument
+- call bdev_pmem_create_pool without path argument
 - call return code != 0
 - call pmem_pool_info and check that pmem pool file was not created
 - call return code != 0
-- call create_pmem_pool with path but without size and block size arguments
+- call bdev_pmem_create_pool with path but without size and block size arguments
 - call return code != 0
 - call pmem_pool_info and check that pmem pool file was not created
 - call return code != 0
-- call create_pmem_pool with path and size but without block size arguments
+- call bdev_pmem_create_pool with path and size but without block size arguments
 - call return code != 0
 - call pmem_pool_info and check that pmem pool file was not created
 - call return code != 0
 
-#### create_pmem_pool_tc2
+#### bdev_pmem_create_pool_tc2
 Negative test case for creating a new pmem.
-Call create_pmem_pool with non existing path argument.
+Call bdev_pmem_create_pool with non existing path argument.
 Steps & expected results:
-- call create_pmem_pool with path that does not exist
+- call bdev_pmem_create_pool with path that does not exist
 - call return code != 0
 - call pmem_pool_info and check that pmem pool file was not created
 - call return code != 0
 
-#### create_pmem_pool_tc3
+#### bdev_pmem_create_pool_tc3
 Positive test case for creating a new pmem pool on disk space.
 Steps & expected results:
-- call create_pmem_pool with correct path argument,
+- call bdev_pmem_create_pool with correct path argument,
 blocksize=512 and total size=256MB
 - call return code = 0
 - call pmem_pool_info and check that pmem file was created
@@ -103,11 +103,11 @@ blocksize=512 and total size=256MB
 - call delete_pmem_pool on previously created pmem
 - return code = 0 and no error code
 
-#### create_pmem_pool_tc4
+#### bdev_pmem_create_pool_tc4
 Positive test case for creating a new pmem pool in RAM space.
 # TODO: Research test steps for creating a pool in RAM!!!
 Steps & expected results:
-- call create_pmem_pool with correct path argument,
+- call bdev_pmem_create_pool with correct path argument,
 blocksize=512 and total size=256MB
 - call return code = 0
 - call pmem_pool_info and check that pmem file was created
@@ -115,27 +115,27 @@ blocksize=512 and total size=256MB
 - call delete_pmem_pool on previously created pmem
 - return code = 0 and no error code
 
-#### create_pmem_pool_tc5
+#### bdev_pmem_create_pool_tc5
 Negative test case for creating two pmems with same path.
 Steps & expected results:
-- call create_pmem_pool with correct path argument,
+- call bdev_pmem_create_pool with correct path argument,
 blocksize=512 and total size=256MB
 - call return code = 0
 - call pmem_pool_info and check that pmem file was created
 - call return code = 0
-- call create_pmem_pool with the same path argument as before,
+- call bdev_pmem_create_pool with the same path argument as before,
 blocksize=4096 and total size=512MB
 - call return code != 0, error code = EEXIST
-- call create_pmem_pool and check that first pmem pool file is still
+- call bdev_pmem_create_pool and check that first pmem pool file is still
 available and not modified (block size and total size stay the same)
 - call return code = 0
 - call delete_pmem_pool on first created pmem pool
 - return code =0 and no error code
 
-#### create_pmem_pool_tc6
+#### bdev_pmem_create_pool_tc6
 Positive test case for creating pmem pool file with various block sizes.
 Steps & expected results:
-- call create_pmem_pool with correct path argument, total size=256MB
+- call bdev_pmem_create_pool with correct path argument, total size=256MB
 with different block size arguments - 1, 511, 512, 513, 1024, 4096, 128k and 256k
 - call pmem_pool_info on each of created pmem pool and check if it was created;
 For pool files created with block size <512 their block size should be rounded up
@@ -144,19 +144,19 @@ command
 - call return code = 0; block sizes as expected
 - call delete_pmem_pool on all created pool files
 
-#### create_pmem_pool_tc7
+#### bdev_pmem_create_pool_tc7
 Negative test case for creating pmem pool file with total size of less than 16MB.
 Steps & expected results:
-- call create_pmem_pool with correct path argument, block size=512 and
+- call bdev_pmem_create_pool with correct path argument, block size=512 and
 total size less than 16MB
 - return code !=0 and error code !=0
 - call pmem_pool_info to verify pmem pool file was not created
 - return code = 0
 
-#### create_pmem_pool_tc8
+#### bdev_pmem_create_pool_tc8
 Negative test case for creating pmem pool file with less than 256 blocks.
 Steps & expected results:
-- call create_pmem_pool with correct path argument, block size=128k and
+- call bdev_pmem_create_pool with correct path argument, block size=128k and
 total size=30MB
 - return code !=0 and error code !=0
 - call pmem_pool_info to verify pmem pool file was not created
@@ -183,7 +183,7 @@ Steps & expected results:
 #### delete_pmem_pool_tc3
 Positive test case for creating and deleting a pemem.
 Steps & expected results:
-- call create_pmem_pool with correct arguments
+- call bdev_pmem_create_pool with correct arguments
 - return code = 0 and no error code
 - using pmem_pool_info check that pmem was created
 - return code = 0 and no error code
@@ -234,7 +234,7 @@ Steps & expected results:
 #### bdev_pmem_create_tc5
 Positive test for constructing pmem bdev.
 Steps & expected results:
-- call create_pmem_pool with correct arguments
+- call bdev_pmem_create_pool with correct arguments
 - return code = 0, no errors
 - call pmem_pool_info and check if pmem files exists
 - return code = 0, no errors
@@ -249,7 +249,7 @@ Steps & expected results:
 #### bdev_pmem_create_tc6
 Negative test for constructing pmem bdevs twice on the same pmem.
 Steps & expected results:
-- call create_pmem_pool with correct arguments
+- call bdev_pmem_create_pool with correct arguments
 - return code = 0, no errors
 - call pmem_pool_info and check if pmem files exists
 - return code = 0, no errors
@@ -270,7 +270,7 @@ Positive test for deleting pmem bdevs using bdev_pmem_delete call.
 Steps & expected results:
 - construct malloc and aio bdevs (also NVMe if possible)
 - all calls - return code = 0, no errors; bdevs created
-- call create_pmem_pool with correct path argument,
+- call bdev_pmem_create_pool with correct path argument,
 block size=512, total size=256M
 - return code = 0, no errors
 - call pmem_pool_info and check if pmem file exists
@@ -286,7 +286,7 @@ were unaffected.
 #### bdev_pmem_delete_tc2
 Negative test for deleting pmem bdev twice.
 Steps & expected results:
-- call create_pmem_pool with correct path argument,
+- call bdev_pmem_create_pool with correct path argument,
 block size=512, total size=256M
 - return code = 0, no errors
 - call pmem_pool_info and check if pmem file exists

test/spdkcli/pmem.sh

@@ -16,8 +16,8 @@ run_spdk_tgt
 timing_exit run_spdk_tgt
 
 timing_enter spdkcli_create_pmem_config
-$spdkcli_job "'/bdevs/pmemblk create_pmem_pool /tmp/sample_pmem0 32 512' '' True
+$spdkcli_job "'/bdevs/pmemblk bdev_pmem_create_pool /tmp/sample_pmem0 32 512' '' True
-'/bdevs/pmemblk create_pmem_pool /tmp/sample_pmem1 32 512' '' True
+'/bdevs/pmemblk bdev_pmem_create_pool /tmp/sample_pmem1 32 512' '' True
 "
 
 # Saving pmem pool info before they get claimed by /bdevs/pmemblk create