diff --git a/doc/bdev.md b/doc/bdev.md index bff74f73f..a7c0de8aa 100644 --- a/doc/bdev.md +++ b/doc/bdev.md @@ -460,14 +460,14 @@ Example commands ## Lvols {#bdev_ug_lvols} -To create lvols on existing lvol store user should use `construct_lvol_bdev` RPC command. +To create lvols on existing lvol store user should use `bdev_lvol_create` RPC command. Each created lvol will be represented by new bdev. Example commands -`rpc.py construct_lvol_bdev lvol1 25 -l lvs` +`rpc.py bdev_lvol_create lvol1 25 -l lvs` -`rpc.py construct_lvol_bdev lvol2 25 -u 330a6ab2-f468-11e7-983e-001e67edf35d` +`rpc.py bdev_lvol_create lvol2 25 -u 330a6ab2-f468-11e7-983e-001e67edf35d` # RAID {#bdev_ug_raid} diff --git a/doc/jsonrpc.md b/doc/jsonrpc.md index 114321311..8db26c50e 100644 --- a/doc/jsonrpc.md +++ b/doc/jsonrpc.md @@ -308,7 +308,7 @@ Example response: "bdev_lvol_rename", "bdev_lvol_clone", "bdev_lvol_snapshot", - "construct_lvol_bdev", + "bdev_lvol_create", "destroy_lvol_store", "rename_lvol_store", "construct_lvol_store" @@ -4938,7 +4938,7 @@ Example response: } ~~~ -## construct_lvol_bdev {#rpc_construct_lvol_bdev} +## bdev_lvol_create {#rpc_bdev_lvol_create} Create a logical volume on a logical volume store. @@ -4967,7 +4967,7 @@ Example request: ~~~ { "jsonrpc": "2.0", - "method": "construct_lvol_bdev", + "method": "bdev_lvol_create", "id": 1, "params": { "lvol_name": "LVOL0", diff --git a/doc/lvol.md b/doc/lvol.md index 5e2862bb8..c2ad9ab30 100644 --- a/doc/lvol.md +++ b/doc/lvol.md @@ -112,7 +112,7 @@ rename_lvol_store [-h] old_name new_name RPC regarding lvol and spdk bdev: ``` -construct_lvol_bdev [-h] [-u UUID] [-l LVS_NAME] [-t] [-c CLEAR_METHOD] lvol_name size +bdev_lvol_create [-h] [-u UUID] [-l LVS_NAME] [-t] [-c CLEAR_METHOD] lvol_name size Creates lvol with specified size and name on lvolstore specified by its uuid or name. Then constructs spdk bdev on top of that lvol and presents it as spdk bdev. User may use -t switch to create thin provisioned lvol. @@ -126,7 +126,7 @@ get_bdevs [-h] [-b NAME] -h, --help show help -b NAME, --name NAME Name of the block device. Example: Nvme0n1 bdev_lvol_delete [-h] bdev_name - Deletes a logical volume previously created by construct_lvol_bdev. + Deletes a logical volume previously created by bdev_lvol_create. optional arguments: -h, --help show help bdev_lvol_snapshot [-h] lvol_name snapshot_name diff --git a/module/bdev/lvol/vbdev_lvol_rpc.c b/module/bdev/lvol/vbdev_lvol_rpc.c index 128f8f073..2b77e5bbc 100644 --- a/module/bdev/lvol/vbdev_lvol_rpc.c +++ b/module/bdev/lvol/vbdev_lvol_rpc.c @@ -304,7 +304,7 @@ cleanup: } SPDK_RPC_REGISTER("destroy_lvol_store", spdk_rpc_destroy_lvol_store, SPDK_RPC_RUNTIME) -struct rpc_construct_lvol_bdev { +struct rpc_bdev_lvol_create { char *uuid; char *lvs_name; char *lvol_name; @@ -314,7 +314,7 @@ struct rpc_construct_lvol_bdev { }; static void -free_rpc_construct_lvol_bdev(struct rpc_construct_lvol_bdev *req) +free_rpc_bdev_lvol_create(struct rpc_bdev_lvol_create *req) { free(req->uuid); free(req->lvs_name); @@ -322,17 +322,17 @@ free_rpc_construct_lvol_bdev(struct rpc_construct_lvol_bdev *req) free(req->clear_method); } -static const struct spdk_json_object_decoder rpc_construct_lvol_bdev_decoders[] = { - {"uuid", offsetof(struct rpc_construct_lvol_bdev, uuid), spdk_json_decode_string, true}, - {"lvs_name", offsetof(struct rpc_construct_lvol_bdev, lvs_name), spdk_json_decode_string, true}, - {"lvol_name", offsetof(struct rpc_construct_lvol_bdev, lvol_name), spdk_json_decode_string}, - {"size", offsetof(struct rpc_construct_lvol_bdev, size), spdk_json_decode_uint64}, - {"thin_provision", offsetof(struct rpc_construct_lvol_bdev, thin_provision), spdk_json_decode_bool, true}, - {"clear_method", offsetof(struct rpc_construct_lvol_bdev, clear_method), spdk_json_decode_string, true}, +static const struct spdk_json_object_decoder rpc_bdev_lvol_create_decoders[] = { + {"uuid", offsetof(struct rpc_bdev_lvol_create, uuid), spdk_json_decode_string, true}, + {"lvs_name", offsetof(struct rpc_bdev_lvol_create, lvs_name), spdk_json_decode_string, true}, + {"lvol_name", offsetof(struct rpc_bdev_lvol_create, lvol_name), spdk_json_decode_string}, + {"size", offsetof(struct rpc_bdev_lvol_create, size), spdk_json_decode_uint64}, + {"thin_provision", offsetof(struct rpc_bdev_lvol_create, thin_provision), spdk_json_decode_bool, true}, + {"clear_method", offsetof(struct rpc_bdev_lvol_create, clear_method), spdk_json_decode_string, true}, }; static void -_spdk_rpc_construct_lvol_bdev_cb(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) +_spdk_rpc_bdev_lvol_create_cb(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) { struct spdk_json_write_ctx *w; struct spdk_jsonrpc_request *request = cb_arg; @@ -352,18 +352,18 @@ invalid: } static void -spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request, - const struct spdk_json_val *params) +spdk_rpc_bdev_lvol_create(struct spdk_jsonrpc_request *request, + const struct spdk_json_val *params) { - struct rpc_construct_lvol_bdev req = {}; + struct rpc_bdev_lvol_create req = {}; enum lvol_clear_method clear_method; int rc = 0; struct spdk_lvol_store *lvs = NULL; SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "Creating blob\n"); - if (spdk_json_decode_object(params, rpc_construct_lvol_bdev_decoders, - SPDK_COUNTOF(rpc_construct_lvol_bdev_decoders), + if (spdk_json_decode_object(params, rpc_bdev_lvol_create_decoders, + SPDK_COUNTOF(rpc_bdev_lvol_create_decoders), &req)) { SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n"); spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, @@ -393,17 +393,18 @@ spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request, } rc = vbdev_lvol_create(lvs, req.lvol_name, req.size, req.thin_provision, - clear_method, _spdk_rpc_construct_lvol_bdev_cb, request); + clear_method, _spdk_rpc_bdev_lvol_create_cb, request); if (rc < 0) { spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); goto cleanup; } cleanup: - free_rpc_construct_lvol_bdev(&req); + free_rpc_bdev_lvol_create(&req); } -SPDK_RPC_REGISTER("construct_lvol_bdev", spdk_rpc_construct_lvol_bdev, SPDK_RPC_RUNTIME) +SPDK_RPC_REGISTER("bdev_lvol_create", spdk_rpc_bdev_lvol_create, SPDK_RPC_RUNTIME) +SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_lvol_create, construct_lvol_bdev) struct rpc_bdev_lvol_snapshot { char *lvol_name; diff --git a/scripts/rpc.py b/scripts/rpc.py index fb2e94e62..ba3243b15 100755 --- a/scripts/rpc.py +++ b/scripts/rpc.py @@ -1177,16 +1177,17 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse p.add_argument('new_name', help='new name') p.set_defaults(func=rename_lvol_store) - def construct_lvol_bdev(args): - print_json(rpc.lvol.construct_lvol_bdev(args.client, - lvol_name=args.lvol_name, - size=args.size * 1024 * 1024, - thin_provision=args.thin_provision, - clear_method=args.clear_method, - uuid=args.uuid, - lvs_name=args.lvs_name)) + def bdev_lvol_create(args): + print_json(rpc.lvol.bdev_lvol_create(args.client, + lvol_name=args.lvol_name, + size=args.size * 1024 * 1024, + thin_provision=args.thin_provision, + clear_method=args.clear_method, + uuid=args.uuid, + lvs_name=args.lvs_name)) - p = subparsers.add_parser('construct_lvol_bdev', help='Add a bdev with an logical volume backend') + p = subparsers.add_parser('bdev_lvol_create', aliases=['construct_lvol_bdev'], + help='Add a bdev with an logical volume backend') p.add_argument('-u', '--uuid', help='lvol store UUID', required=False) p.add_argument('-l', '--lvs-name', help='lvol store name', required=False) p.add_argument('-t', '--thin-provision', action='store_true', help='create lvol bdev as thin provisioned') @@ -1194,7 +1195,7 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse Available: none, unmap, write_zeroes""", required=False) p.add_argument('lvol_name', help='name for this lvol') p.add_argument('size', help='size in MiB for this bdev', type=int) - p.set_defaults(func=construct_lvol_bdev) + p.set_defaults(func=bdev_lvol_create) def bdev_lvol_snapshot(args): print_json(rpc.lvol.bdev_lvol_snapshot(args.client, diff --git a/scripts/rpc/lvol.py b/scripts/rpc/lvol.py index 6809924e5..30b9906ba 100644 --- a/scripts/rpc/lvol.py +++ b/scripts/rpc/lvol.py @@ -35,7 +35,8 @@ def rename_lvol_store(client, old_name, new_name): return client.call('rename_lvol_store', params) -def construct_lvol_bdev(client, lvol_name, size, thin_provision=False, uuid=None, lvs_name=None, clear_method=None): +@deprecated_alias('construct_lvol_bdev') +def bdev_lvol_create(client, lvol_name, size, thin_provision=False, uuid=None, lvs_name=None, clear_method=None): """Create a logical volume on a logical volume store. Args: @@ -62,7 +63,7 @@ def construct_lvol_bdev(client, lvol_name, size, thin_provision=False, uuid=None params['lvs_name'] = lvs_name if clear_method: params['clear_method'] = clear_method - return client.call('construct_lvol_bdev', params) + return client.call('bdev_lvol_create', params) @deprecated_alias('snapshot_lvol_bdev') diff --git a/scripts/spdkcli/ui_root.py b/scripts/spdkcli/ui_root.py index 2c3d9036d..f18a7b3f0 100644 --- a/scripts/spdkcli/ui_root.py +++ b/scripts/spdkcli/ui_root.py @@ -154,7 +154,7 @@ class UIRoot(UINode): @verbose def create_lvol_bdev(self, **kwargs): - response = rpc.lvol.construct_lvol_bdev(self.client, **kwargs) + response = rpc.lvol.bdev_lvol_create(self.client, **kwargs) return response @verbose diff --git a/test/blobstore/blob_io_wait/blob_io_wait.sh b/test/blobstore/blob_io_wait/blob_io_wait.sh index 301ebf671..2550ddeee 100755 --- a/test/blobstore/blob_io_wait/blob_io_wait.sh +++ b/test/blobstore/blob_io_wait/blob_io_wait.sh @@ -24,7 +24,7 @@ trap 'killprocess $bdev_svc_pid; exit 1' SIGINT SIGTERM EXIT waitforlisten $bdev_svc_pid $rpc_py bdev_aio_create $testdir/aio.bdev aio0 4096 $rpc_py construct_lvol_store aio0 lvs0 -$rpc_py construct_lvol_bdev -l lvs0 lvol0 32 +$rpc_py bdev_lvol_create -l lvs0 lvol0 32 killprocess $bdev_svc_pid diff --git a/test/compress/compress.sh b/test/compress/compress.sh index 766002981..099255d63 100755 --- a/test/compress/compress.sh +++ b/test/compress/compress.sh @@ -25,7 +25,7 @@ waitforlisten $bdev_svc_pid bdf=$(iter_pci_class_code 01 08 02 | head -1) $rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0) -$rpc_py construct_lvol_bdev -t -u $lvs_u lv0 100 +$rpc_py bdev_lvol_create -t -u $lvs_u lv0 100 # this will force isal_pmd as some of the CI systems need a qat driver update $rpc_py set_compress_pmd -p 2 compress_bdev=$($rpc_py bdev_compress_create -b lvs0/lv0 -p /tmp) diff --git a/test/iscsi_tgt/filesystem/filesystem.sh b/test/iscsi_tgt/filesystem/filesystem.sh index 1642b36e6..fe43f4e1b 100755 --- a/test/iscsi_tgt/filesystem/filesystem.sh +++ b/test/iscsi_tgt/filesystem/filesystem.sh @@ -51,9 +51,9 @@ ls_guid=$($rpc_py construct_lvol_store Nvme0n1 lvs_0) free_mb=$(get_lvs_free_mb "$ls_guid") # Using maximum 2048MiB to reduce the test time if [ $free_mb -gt 2048 ]; then - $rpc_py construct_lvol_bdev -u $ls_guid lbd_0 2048 + $rpc_py bdev_lvol_create -u $ls_guid lbd_0 2048 else - $rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb + $rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb fi # "lvs_0/lbd_0:0" ==> use lvs_0/lbd_0 blockdev for LUN0 # "1:2" ==> map PortalGroup1 to InitiatorGroup2 diff --git a/test/iscsi_tgt/lvol/iscsi_lvol.sh b/test/iscsi_tgt/lvol/iscsi_lvol.sh index 8058f8ea8..f9cc5d058 100755 --- a/test/iscsi_tgt/lvol/iscsi_lvol.sh +++ b/test/iscsi_tgt/lvol/iscsi_lvol.sh @@ -59,7 +59,7 @@ for i in $(seq 1 $NUM_LVS); do ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576) LUNs="" for j in $(seq 1 $NUM_LVOL); do - lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_$j 10) + lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j 10) LUNs+="$lb_name:$((j - 1)) " done $rpc_py construct_target_node Target$i Target${i}_alias "$LUNs" "1:$INITIATOR_TAG" 256 -d diff --git a/test/iscsi_tgt/multiconnection/multiconnection.sh b/test/iscsi_tgt/multiconnection/multiconnection.sh index b6c5073e7..78ccec775 100755 --- a/test/iscsi_tgt/multiconnection/multiconnection.sh +++ b/test/iscsi_tgt/multiconnection/multiconnection.sh @@ -58,7 +58,7 @@ ls_guid=$($rpc_py construct_lvol_store "Nvme0n1" "lvs0" -c 1048576) get_lvs_free_mb $ls_guid lvol_bdev_size=$(($free_mb / $CONNECTION_NUMBER)) for i in $(seq 1 $CONNECTION_NUMBER); do - $rpc_py construct_lvol_bdev -u $ls_guid lbd_$i $lvol_bdev_size + $rpc_py bdev_lvol_create -u $ls_guid lbd_$i $lvol_bdev_size done for i in $(seq 1 $CONNECTION_NUMBER); do diff --git a/test/json_config/json_config.sh b/test/json_config/json_config.sh index a66ec8aeb..9b886aca5 100755 --- a/test/json_config/json_config.sh +++ b/test/json_config/json_config.sh @@ -201,8 +201,8 @@ function create_bdev_subsystem_config() { # If LVOLs cofniguration will be reordered (eg moved before splits or AIO/NVMe) # it should fail loading JSON config from file. tgt_rpc construct_lvol_store -c 1048576 ${lvol_store_base_bdev}p0 lvs_test - tgt_rpc construct_lvol_bdev -l lvs_test lvol0 32 - tgt_rpc construct_lvol_bdev -l lvs_test -t lvol1 32 + tgt_rpc bdev_lvol_create -l lvs_test lvol0 32 + tgt_rpc bdev_lvol_create -l lvs_test -t lvol1 32 tgt_rpc bdev_lvol_snapshot lvs_test/lvol0 snapshot0 tgt_rpc bdev_lvol_clone lvs_test/snapshot0 clone0 diff --git a/test/lvol/lvol.sh b/test/lvol/lvol.sh index 7b8842893..aa2c86a4d 100755 --- a/test/lvol/lvol.sh +++ b/test/lvol/lvol.sh @@ -24,11 +24,11 @@ function usage() { 1: 'construct_lvs_positive', 50: 'construct_logical_volume_positive', 51: 'construct_multi_logical_volumes_positive', - 52: 'construct_lvol_bdev_using_name_positive', - 53: 'construct_lvol_bdev_duplicate_names_positive', + 52: 'bdev_lvol_create_using_name_positive', + 53: 'bdev_lvol_create_duplicate_names_positive', 100: 'construct_logical_volume_nonexistent_lvs_uuid', - 101: 'construct_lvol_bdev_on_full_lvol_store', - 102: 'construct_lvol_bdev_name_twice', + 101: 'bdev_lvol_create_on_full_lvol_store', + 102: 'bdev_lvol_create_name_twice', 150: 'bdev_lvol_resize_positive', 200: 'resize_logical_volume_nonexistent_logical_volume', 201: 'resize_logical_volume_with_size_out_of_range', @@ -45,7 +45,7 @@ function usage() { 450: 'construct_lvs_nonexistent_bdev', 451: 'construct_lvs_on_bdev_twice', 452: 'construct_lvs_name_twice', - 500: 'nested_construct_lvol_bdev_on_full_lvol_store', + 500: 'nested_bdev_lvol_create_on_full_lvol_store', 550: 'delete_bdev_positive', 551: 'delete_lvol_bdev', 552: 'destroy_lvol_store_with_clones', diff --git a/test/lvol/rpc_commands_lib.py b/test/lvol/rpc_commands_lib.py index cdff5fc21..2361d6b9a 100644 --- a/test/lvol/rpc_commands_lib.py +++ b/test/lvol/rpc_commands_lib.py @@ -126,8 +126,8 @@ class Commands_Rpc(object): output = self.rpc.construct_lvol_store(base_name, lvs_name)[0] return output.rstrip('\n') - def construct_lvol_bdev(self, uuid, lbd_name, size, thin=False): - print("INFO: RPC COMMAND construct_lvol_bdev") + def bdev_lvol_create(self, uuid, lbd_name, size, thin=False): + print("INFO: RPC COMMAND bdev_lvol_create") try: uuid_obj = UUID(uuid) name_opt = "-u" @@ -136,7 +136,7 @@ class Commands_Rpc(object): thin_provisioned = "" if thin: thin_provisioned = "-t" - output = self.rpc.construct_lvol_bdev(name_opt, uuid, lbd_name, size, thin_provisioned)[0] + output = self.rpc.bdev_lvol_create(name_opt, uuid, lbd_name, size, thin_provisioned)[0] return output.rstrip('\n') def destroy_lvol_store(self, uuid): diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py index 16822cf03..c3ce4f41c 100644 --- a/test/lvol/test_cases.py +++ b/test/lvol/test_cases.py @@ -112,15 +112,15 @@ def case_message(func): test_name = { # construct_lvol_store - positive tests 1: 'construct_lvs_positive', - # construct_lvol_bdev - positive tests + # bdev_lvol_create - positive tests 50: 'construct_logical_volume_positive', 51: 'construct_multi_logical_volumes_positive', - 52: 'construct_lvol_bdev_using_name_positive', - 53: 'construct_lvol_bdev_duplicate_names_positive', - # construct_lvol_bdev - negative tests + 52: 'bdev_lvol_create_using_name_positive', + 53: 'bdev_lvol_create_duplicate_names_positive', + # bdev_lvol_create - negative tests 100: 'construct_logical_volume_nonexistent_lvs_uuid', - 101: 'construct_lvol_bdev_on_full_lvol_store', - 102: 'construct_lvol_bdev_name_twice', + 101: 'bdev_lvol_create_on_full_lvol_store', + 102: 'bdev_lvol_create_name_twice', # resize_lvol_store - positive tests 150: 'bdev_lvol_resize_positive', # resize lvol store - negative tests @@ -140,8 +140,8 @@ def case_message(func): 450: 'construct_lvs_nonexistent_bdev', 451: 'construct_lvs_on_bdev_twice', 452: 'construct_lvs_name_twice', - # nested construct_lvol_bdev - test negative - 500: 'nested_construct_lvol_bdev_on_full_lvol_store', + # nested bdev_lvol_create - test negative + 500: 'nested_bdev_lvol_create_on_full_lvol_store', 550: 'delete_bdev_positive', 551: 'delete_lvol_bdev', 552: 'destroy_lvol_store_with_clones', @@ -350,7 +350,7 @@ class TestCases(object): construct_logical_volume_positive Positive test for constructing a new logical volume. - Call construct_lvol_bdev with correct lvol store UUID and size in MiB for this bdev + Call bdev_lvol_create with correct lvol store UUID and size in MiB for this bdev """ # Create malloc bdev base_name = self.c.bdev_malloc_create(self.total_size, @@ -364,9 +364,9 @@ class TestCases(object): lvs_size = self.get_lvs_size() # Construct lvol bdev on correct lvs_uuid and size - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - lvs_size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + lvs_size) # Check correct uuid values in response get_bdevs command fail_count += self.c.check_get_bdevs_methods(uuid_bdev, lvs_size) @@ -376,7 +376,7 @@ class TestCases(object): # Expected result: # - call successful, return code = 0 - # - get_lvol_store: backend used for construct_lvol_bdev has name + # - get_lvol_store: backend used for bdev_lvol_create has name # field set with the same name as returned from RPC call for all repeat # - no other operation fails return fail_count @@ -387,7 +387,7 @@ class TestCases(object): construct_multi_logical_volumes_positive Positive test for constructing a multi logical volumes. - Call construct_lvol_bdev with correct lvol store UUID and + Call bdev_lvol_create with correct lvol store UUID and size is equal one quarter of the this bdev size. """ # Create malloc bdev @@ -408,9 +408,9 @@ class TestCases(object): for j in range(2): uuid_bdevs = [] for i in range(4): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + str(i), - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name + str(i), + size) uuid_bdevs.append(uuid_bdev) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) @@ -428,7 +428,7 @@ class TestCases(object): @case_message def test_case52(self): """ - construct_lvol_bdev_using_name_positive + bdev_lvol_create_using_name_positive Positive test for constructing a logical volume using friendly names. Verify that logical volumes can be created by using a friendly name @@ -446,9 +446,9 @@ class TestCases(object): lvs_size = self.get_lvs_size() # Create logical volume on lvol store by using a friendly name # as a reference - uuid_bdev = self.c.construct_lvol_bdev(self.lvs_name, - self.lbd_name, - lvs_size) + uuid_bdev = self.c.bdev_lvol_create(self.lvs_name, + self.lbd_name, + lvs_size) # Verify logical volume was correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev, lvs_size) @@ -465,7 +465,7 @@ class TestCases(object): @case_message def test_case53(self): """ - construct_lvol_bdev_duplicate_names_positive + bdev_lvol_create_duplicate_names_positive Positive test for constructing a logical volumes using friendly names. Verify that logical volumes can use the same argument for friendly names @@ -489,14 +489,14 @@ class TestCases(object): lvs_size = self.get_lvs_size(self.lvs_name + "1") # Create logical volume on first lvol store - uuid_bdev_1 = self.c.construct_lvol_bdev(uuid_store_1, - self.lbd_name, - lvs_size) + uuid_bdev_1 = self.c.bdev_lvol_create(uuid_store_1, + self.lbd_name, + lvs_size) # Using the same friendly name argument create logical volume on second # lvol store - uuid_bdev_2 = self.c.construct_lvol_bdev(uuid_store_2, - self.lbd_name, - lvs_size) + uuid_bdev_2 = self.c.bdev_lvol_create(uuid_store_2, + self.lbd_name, + lvs_size) # Verify two lvol bdevs were correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev_1, lvs_size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev_2, lvs_size) @@ -519,14 +519,14 @@ class TestCases(object): construct_logical_volume_nonexistent_lvs_uuid Negative test for constructing a new logical_volume. - Call construct_lvol_bdev with lvs_uuid which does not + Call bdev_lvol_create with lvs_uuid which does not exist in configuration. """ fail_count = 0 - # Try to call construct_lvol_bdev with lvs_uuid which does not exist - if self.c.construct_lvol_bdev(self._gen_lvs_uuid(), - self.lbd_name, - 32) == 0: + # Try to call bdev_lvol_create with lvs_uuid which does not exist + if self.c.bdev_lvol_create(self._gen_lvs_uuid(), + self.lbd_name, + 32) == 0: fail_count += 1 # Expected result: @@ -537,10 +537,10 @@ class TestCases(object): @case_message def test_case101(self): """ - construct_lvol_bdev_on_full_lvol_store + bdev_lvol_create_on_full_lvol_store Negative test for constructing a new lvol bdev. - Call construct_lvol_bdev on a full lvol store. + Call bdev_lvol_create on a full lvol store. """ # Create malloc bdev base_name = self.c.bdev_malloc_create(self.total_size, @@ -553,18 +553,18 @@ class TestCases(object): self.cluster_size) lvs_size = self.get_lvs_size() # Construct lvol bdev on correct lvs_uuid - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - lvs_size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + lvs_size) # Verify if lvol bdev was correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev, lvs_size) # Try construct lvol bdev on the same lvs_uuid as in last step # This call should fail as lvol store space is taken by previously # created bdev - if self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + "_1", - lvs_size) == 0: + if self.c.bdev_lvol_create(uuid_store, + self.lbd_name + "_1", + lvs_size) == 0: fail_count += 1 self.c.bdev_lvol_delete(uuid_bdev) @@ -573,7 +573,7 @@ class TestCases(object): # Expected result: # - first call successful - # - second construct_lvol_bdev call return code != 0 + # - second bdev_lvol_create call return code != 0 # - EEXIST response printed to stdout # - no other operation fails return fail_count @@ -581,7 +581,7 @@ class TestCases(object): @case_message def test_case102(self): """ - construct_lvol_bdev_name_twice + bdev_lvol_create_name_twice Negative test for constructing lvol bdev using the same friendly name twice on the same logical volume store. @@ -597,17 +597,17 @@ class TestCases(object): self.cluster_size) size = self.get_lvs_size() # Construct logical volume on lvol store and verify it was correctly created - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) # Try to create another logical volume on the same lvol store using # the same friendly name as in previous step # This step should fail - if self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - size) == 0: + if self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + size) == 0: fail_count += 1 self.c.bdev_lvol_delete(uuid_bdev) @@ -641,7 +641,7 @@ class TestCases(object): # Construct lvol bdev on correct lvs_uuid and # size is equal to one quarter of size malloc bdev size = self.get_lvs_divided_size(4) - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size) # Check size of the lvol bdev by rpc command get_bdevs fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) @@ -714,9 +714,9 @@ class TestCases(object): # Construct_lvol_bdev on correct lvs_uuid and # size is equal one quarter of size malloc bdev lvs_size = self.get_lvs_size() - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - lvs_size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + lvs_size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, lvs_size) # Try bdev_lvol_resize on correct lvs_uuid and size is @@ -817,9 +817,9 @@ class TestCases(object): # Construct lvol bdev on correct lvs_uuid # and size is equal to size malloc bdev lvs_size = self.get_lvs_size() - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - lvs_size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + lvs_size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, lvs_size) # Destroy lvol store @@ -844,7 +844,7 @@ class TestCases(object): Positive test for destroying a logical volume store with multiple lvol bdevs created on top. - Call construct_lvol_bdev with correct lvol store UUID and + Call bdev_lvol_create with correct lvol store UUID and size is equal to one quarter of the this bdev size. """ # Create malloc bdev @@ -860,9 +860,9 @@ class TestCases(object): # Construct four lvol bdevs on correct lvs_uuid and # size is equal to one quarter of the lvol size for i in range(4): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + str(i), - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name + str(i), + size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) # Destroy lvol store @@ -874,7 +874,7 @@ class TestCases(object): # Expected result: # - call successful, return code = 0 - # - get_lvol_store: backend used for construct_lvol_bdev has name + # - get_lvol_store: backend used for bdev_lvol_create has name # field set with the same name as returned from RPC call for all repeat # - no other operation fails return fail_count @@ -897,11 +897,11 @@ class TestCases(object): fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, self.cluster_size) size = self.get_lvs_divided_size(4) - # construct_lvol_bdev on correct lvs_uuid and size is + # bdev_lvol_create on correct lvs_uuid and size is # equal to one quarter of size malloc bdev - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, + size) # check size of the lvol bdev fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) sz = size + 4 @@ -1123,10 +1123,10 @@ class TestCases(object): @case_message def test_case500(self): """ - nested_construct_lvol_bdev_on_full_lvol_store + nested_bdev_lvol_create_on_full_lvol_store Negative test for constructing a new nested lvol bdev. - Call construct_lvol_bdev on a full lvol store. + Call bdev_lvol_create on a full lvol store. """ # Create malloc bdev base_name = self.c.bdev_malloc_create(self.total_size, @@ -1139,8 +1139,8 @@ class TestCases(object): self.cluster_size) # Construct lvol bdev size = self.get_lvs_size() - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size) # Construct nested lvol store on created lvol_bdev nested_lvs_name = self.lvs_name + "_nested" nested_lvs_uuid = self.c.construct_lvol_store(uuid_bdev, @@ -1152,20 +1152,20 @@ class TestCases(object): # with size equal to size of nested lvol store nested_size = self.get_lvs_size(nested_lvs_name) nested_lbd_name = self.lbd_name + "_nested" - nested_uuid_bdev = self.c.construct_lvol_bdev(nested_lvs_uuid, - nested_lbd_name, nested_size) + nested_uuid_bdev = self.c.bdev_lvol_create(nested_lvs_uuid, + nested_lbd_name, nested_size) fail_count += self.c.check_get_bdevs_methods(nested_uuid_bdev, nested_size) # Try construct another lvol bdev as in previous step; this call should fail # as nested lvol store space is already claimed by lvol bdev nested_lbd_name = self.lbd_name + "_nested2" - if self.c.construct_lvol_bdev(nested_lvs_uuid, nested_lbd_name, nested_size) == 0: + if self.c.bdev_lvol_create(nested_lvs_uuid, nested_lbd_name, nested_size) == 0: fail_count += 1 fail_count += self.c.delete_malloc_bdev(base_name) # Expected result: - # - second construct_lvol_bdev call on nested lvol store return code != 0 + # - second bdev_lvol_create call on nested lvol store return code != 0 # - EEXIST response printed to stdout # - no other operation fails return fail_count @@ -1225,8 +1225,8 @@ class TestCases(object): size = int(int(lvs[0]['free_clusters'] * lvs[0]['cluster_size']) / 4 / MEGABYTE) # Construct thin provisioned lvol bdev - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # Create snapshot of thin provisioned lvol bdev @@ -1290,7 +1290,7 @@ class TestCases(object): size = int(int(lvs[0]['free_clusters'] * lvs[0]['cluster_size']) / 4 / MEGABYTE) # Create lvol bdev, snapshot it, then clone it and then snapshot the clone - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) @@ -1351,7 +1351,7 @@ class TestCases(object): size = int(int(lvs[0]['free_clusters'] * lvs[0]['cluster_size']) / 4 / MEGABYTE) # Create lvol bdev, snapshot it, then clone it and then snapshot the clone - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) @@ -1482,8 +1482,8 @@ class TestCases(object): free_clusters_start = int(lvs['free_clusters']) bdev_size = self.get_lvs_size() # create thin provisioned lvol bdev with size equals to lvol store free space - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size, thin=True) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size, thin=True) lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0] free_clusters_create_lvol = int(lvs['free_clusters']) # check and save number of free clusters for lvol store @@ -1565,11 +1565,11 @@ class TestCases(object): # calculate bdev size in megabytes bdev_size = self.get_lvs_size() # create thick provisioned lvol bvdev with size equal to lvol store - bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, - bdev_size, thin=False) + bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0, + bdev_size, thin=False) # create thin provisioned lvol bdev with the same size - bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, - bdev_size, thin=True) + bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1, + bdev_size, thin=True) lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0) lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1) nbd_name0 = "/dev/nbd0" @@ -1620,8 +1620,8 @@ class TestCases(object): free_clusters_start = int(lvs['free_clusters']) bdev_size = self.get_lvs_size() # construct thin provisioned lvol bdev with size equal to lvol store - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size, thin=True) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) nbd_name = "/dev/nbd0" @@ -1660,8 +1660,8 @@ class TestCases(object): # Construct thin provisioned lvol bdevs on created lvol store # with size equal to 50% of lvol store size = self.get_lvs_divided_size(2) - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size, thin=True) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size, thin=True) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) # Fill all free space of lvol bdev with data nbd_name = "/dev/nbd0" @@ -1738,10 +1738,10 @@ class TestCases(object): bdev_size = self.get_lvs_size() # construct two thin provisioned lvol bdevs on created lvol store # with size equals to free lvs size - bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, - bdev_size, thin=True) - bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, - bdev_size, thin=True) + bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0, + bdev_size, thin=True) + bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1, + bdev_size, thin=True) lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0] free_clusters_create_lvol = int(lvs['free_clusters']) @@ -1810,10 +1810,10 @@ class TestCases(object): bdev_size = int(lvs_size * 0.7) # construct two thin provisioned lvol bdevs on created lvol store # with size equal to 70% of lvs size - bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, - bdev_size, thin=True) - bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, - bdev_size, thin=True) + bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0, + bdev_size, thin=True) + bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1, + bdev_size, thin=True) lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0) lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1) @@ -1878,9 +1878,9 @@ class TestCases(object): size = self.get_lvs_divided_size(10) for i in range(5): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + str(i), - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name + str(i), + size) uuid_bdevs.append(uuid_bdev) # Using get_bdevs command verify lvol bdevs were correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) @@ -1927,9 +1927,9 @@ class TestCases(object): # Add some lvol bdevs to existing lvol store then # remove all lvol configuration and re-create it again for i in range(5, 10): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + str(i), - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name + str(i), + size) uuid_bdevs.append(uuid_bdev) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) @@ -1950,9 +1950,9 @@ class TestCases(object): self.cluster_size) for i in range(10): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name + str(i), - size) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + self.lbd_name + str(i), + size) uuid_bdevs.append(uuid_bdev) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) @@ -2048,17 +2048,17 @@ class TestCases(object): size_32M = self.get_lvs_divided_size(5, self.lvs_name + "_32M") for i in range(5): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store_1M, - self.lbd_name + str(i) + "_1M", - size_1M) + uuid_bdev = self.c.bdev_lvol_create(uuid_store_1M, + self.lbd_name + str(i) + "_1M", + size_1M) uuid_bdevs.append(uuid_bdev) # Using get_bdevs command verify lvol bdevs were correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size_1M) for i in range(5): - uuid_bdev = self.c.construct_lvol_bdev(uuid_store_32M, - self.lbd_name + str(i) + "_32M", - size_32M) + uuid_bdev = self.c.bdev_lvol_create(uuid_store_32M, + self.lbd_name + str(i) + "_32M", + size_32M) uuid_bdevs.append(uuid_bdev) # Using get_bdevs command verify lvol bdevs were correctly created fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size_32M) @@ -2144,8 +2144,8 @@ class TestCases(object): free_clusters_start = int(lvs['free_clusters']) bdev_size = self.get_lvs_divided_size(3) # Create lvol bdev with 33% of lvol store space - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) # Create snapshot of lvol bdev fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) @@ -2197,11 +2197,11 @@ class TestCases(object): lbd_name0 = self.lbd_name + str(0) lbd_name1 = self.lbd_name + str(1) # Create thin provisioned lvol bdev with size less than 25% of lvs - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - lbd_name0, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + lbd_name0, size, thin=True) # Create thick provisioned lvol bdev with size less than 25% of lvs - uuid_bdev1 = self.c.construct_lvol_bdev(uuid_store, - lbd_name1, size, thin=False) + uuid_bdev1 = self.c.bdev_lvol_create(uuid_store, + lbd_name1, size, thin=False) lvol_bdev0 = self.c.get_lvol_bdev_with_name(uuid_bdev0) fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name[0]) fill_size = int(size * MEGABYTE / 2) @@ -2270,8 +2270,8 @@ class TestCases(object): self.cluster_size) # Create thin provisioned lvol bdev with size equal to 50% of lvs space size = self.get_lvs_divided_size(2) - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - size, thin=True) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name) @@ -2325,8 +2325,8 @@ class TestCases(object): self.cluster_size) # Create thick provisioned lvol bdev size = self.get_lvs_divided_size(2) - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - size, thin=False) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) # Create snapshot of created lvol bdev @@ -2373,8 +2373,8 @@ class TestCases(object): lvs = self.c.bdev_lvol_get_lvstores() # Create thick provisioned lvol bdev with size equal to 50% of lvs space size = self.get_lvs_divided_size(2) - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - size, thin=False) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) # Create clone of lvol bdev and check if it fails @@ -2436,8 +2436,8 @@ class TestCases(object): size = self.get_lvs_divided_size(6) lbd_name0 = self.lbd_name + str(0) # Construct thick provisioned lvol bdev - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - lbd_name0, size, thin=False) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + lbd_name0, size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # Install lvol bdev on /dev/nbd0 fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name[0]) @@ -2509,8 +2509,8 @@ class TestCases(object): size = self.get_lvs_divided_size(6) # Construct thick provisioned lvol bdev - uuid_bdev = self.c.construct_lvol_bdev(uuid_store, - lbd_name, size, thin=False) + uuid_bdev = self.c.bdev_lvol_create(uuid_store, + lbd_name, size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) # Create snapshot of thick provisioned lvol bdev @@ -2599,8 +2599,8 @@ class TestCases(object): size = self.get_lvs_divided_size(4) # Construct thick provisioned lvol bdev - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size, thin=False) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # Fill bdev with data of knonw pattern @@ -2690,8 +2690,8 @@ class TestCases(object): size = self.get_lvs_divided_size(4) # Construct thin provisioned lvol bdev - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # Decouple parent lvol bdev and check if it fails @@ -2762,8 +2762,8 @@ class TestCases(object): size = int(5 * lvs[0]['cluster_size'] / MEGABYTE) # Construct thin provisioned lvol bdev - uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, - self.lbd_name, size, thin=True) + uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, + self.lbd_name, size, thin=True) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # Fill first four out of 5 culsters of clone with data of known pattern @@ -2862,8 +2862,8 @@ class TestCases(object): lvs = self.c.bdev_lvol_get_lvstores()[0] free_clusters_start = int(lvs['free_clusters']) bdev_size = self.get_lvs_divided_size(2) - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size) # Set lvol bdev as read only lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) fail_count += self.c.bdev_lvol_set_read_only(lvol_bdev['name']) @@ -2925,8 +2925,8 @@ class TestCases(object): # Create lvol bdev with 50% of lvol store space lvs = self.c.bdev_lvol_get_lvstores()[0] bdev_size = self.get_lvs_divided_size(2) - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) # Perform write operation on lvol @@ -3005,8 +3005,8 @@ class TestCases(object): # Create lvol bdev with one third of lvol store space lvs = self.c.bdev_lvol_get_lvstores()[0] bdev_size = self.get_lvs_divided_size(3) - bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, - bdev_size) + bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, + bdev_size) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) # Perform write operation on lvol @@ -3127,9 +3127,9 @@ class TestCases(object): # Create 4 lvol bdevs on top of previously created lvol store bdev_size = self.get_lvs_divided_size(4) for name, alias in zip(bdev_names, bdev_aliases): - uuid = self.c.construct_lvol_bdev(lvs_uuid, - name, - bdev_size) + uuid = self.c.bdev_lvol_create(lvs_uuid, + name, + bdev_size) fail_count += self.c.check_get_bdevs_methods(uuid, bdev_size, alias) @@ -3250,17 +3250,17 @@ class TestCases(object): bdev_size_1 = self.get_lvs_divided_size(4, lvs_name_1) bdev_size_2 = self.get_lvs_divided_size(4, lvs_name_2) for name, alias in zip(bdev_names_1, bdev_aliases_1): - uuid = self.c.construct_lvol_bdev(lvs_uuid_1, - name, - bdev_size_1) + uuid = self.c.bdev_lvol_create(lvs_uuid_1, + name, + bdev_size_1) fail_count += self.c.check_get_bdevs_methods(uuid, bdev_size_1, alias) bdev_uuids_1.append(uuid) for name, alias in zip(bdev_names_2, bdev_aliases_2): - uuid = self.c.construct_lvol_bdev(lvs_uuid_2, - name, - bdev_size_2) + uuid = self.c.bdev_lvol_create(lvs_uuid_2, + name, + bdev_size_2) fail_count += self.c.check_get_bdevs_methods(uuid, bdev_size_2, alias) @@ -3347,14 +3347,14 @@ class TestCases(object): self.lvs_name) # Construct 2 lvol bdevs on lvol store bdev_size = self.get_lvs_divided_size(2) - bdev_uuid_1 = self.c.construct_lvol_bdev(lvs_uuid, - self.lbd_name + "1", - bdev_size) + bdev_uuid_1 = self.c.bdev_lvol_create(lvs_uuid, + self.lbd_name + "1", + bdev_size) fail_count += self.c.check_get_bdevs_methods(bdev_uuid_1, bdev_size) - bdev_uuid_2 = self.c.construct_lvol_bdev(lvs_uuid, - self.lbd_name + "2", - bdev_size) + bdev_uuid_2 = self.c.bdev_lvol_create(lvs_uuid, + self.lbd_name + "2", + bdev_size) fail_count += self.c.check_get_bdevs_methods(bdev_uuid_2, bdev_size) diff --git a/test/nvmf/host/fio.sh b/test/nvmf/host/fio.sh index d4acb10d7..9047ead19 100755 --- a/test/nvmf/host/fio.sh +++ b/test/nvmf/host/fio.sh @@ -49,7 +49,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then $rpc_py construct_nvme_bdev -b Nvme0 -t PCIe -a $(echo $bdfs | awk '{ print $1 }') -i $NVMF_FIRST_TARGET_IP ls_guid=$($rpc_py construct_lvol_store -c 1073741824 Nvme0n1 lvs_0) get_lvs_free_mb $ls_guid - $rpc_py construct_lvol_bdev -l lvs_0 lbd_0 $free_mb + $rpc_py bdev_lvol_create -l lvs_0 lbd_0 $free_mb $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode2 -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode2 lvs_0/lbd_0 $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode2 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT @@ -60,7 +60,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then # Test fio_plugin as host with nvme lvol nested backend ls_nested_guid=$($rpc_py construct_lvol_store --clear-method none lvs_0/lbd_0 lvs_n_0) get_lvs_free_mb $ls_nested_guid - $rpc_py construct_lvol_bdev -l lvs_n_0 lbd_nest_0 $free_mb + $rpc_py bdev_lvol_create -l lvs_n_0 lbd_nest_0 $free_mb $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode3 -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode3 lvs_n_0/lbd_nest_0 $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode3 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT diff --git a/test/nvmf/host/perf.sh b/test/nvmf/host/perf.sh index 4b0f2afe6..5125a1f85 100755 --- a/test/nvmf/host/perf.sh +++ b/test/nvmf/host/perf.sh @@ -52,7 +52,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then if [ $free_mb -gt 20480 ]; then free_mb=20480 fi - lb_guid=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb) + lb_guid=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb) # Create lvol bdev for nested lvol stores ls_nested_guid=$($rpc_py construct_lvol_store $lb_guid lvs_n_0) @@ -60,7 +60,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then if [ $free_mb -gt 20480 ]; then free_mb=20480 fi - lb_nested_guid=$($rpc_py construct_lvol_bdev -u $ls_nested_guid lbd_nest_0 $free_mb) + lb_nested_guid=$($rpc_py bdev_lvol_create -u $ls_nested_guid lbd_nest_0 $free_mb) $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 for bdev in $lb_nested_guid; do $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 $bdev diff --git a/test/nvmf/target/nvmf_lvol.sh b/test/nvmf/target/nvmf_lvol.sh index 2b4b3f2fe..3af88af4d 100755 --- a/test/nvmf/target/nvmf_lvol.sh +++ b/test/nvmf/target/nvmf_lvol.sh @@ -35,7 +35,7 @@ $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs" lvs=$($rpc_py construct_lvol_store raid0 lvs) # Create a logical volume on the logical volume store -lvol=$($rpc_py construct_lvol_bdev -u $lvs lvol $LVOL_BDEV_INIT_SIZE) +lvol=$($rpc_py bdev_lvol_create -u $lvs lvol $LVOL_BDEV_INIT_SIZE) # Create an NVMe-oF subsystem and add the logical volume as a namespace $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode0 -a -s SPDK0 diff --git a/test/vhost/fiotest/fio.sh b/test/vhost/fiotest/fio.sh index 9aab2721c..08cca5c49 100755 --- a/test/vhost/fiotest/fio.sh +++ b/test/vhost/fiotest/fio.sh @@ -118,7 +118,7 @@ for vm_conf in ${vms[@]}; do if [[ $disk == "RaidBdev2" ]]; then ls_guid=$($rpc_py construct_lvol_store RaidBdev2 lvs_0 -c 4194304) free_mb=$(get_lvs_free_mb "$ls_guid") - based_disk=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb) + based_disk=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb) else based_disk="$disk" fi diff --git a/test/vhost/integrity/integrity_start.sh b/test/vhost/integrity/integrity_start.sh index d2b13afd3..c9ff52746 100755 --- a/test/vhost/integrity/integrity_start.sh +++ b/test/vhost/integrity/integrity_start.sh @@ -67,7 +67,7 @@ notice "..." trap 'clean_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' SIGTERM SIGABRT ERR notice "Constructing lvol store and lvol bdev on top of Nvme0n1" lvs_uuid=$($rpc_py construct_lvol_store Nvme0n1 lvol_store) -$rpc_py construct_lvol_bdev lvol_bdev 10000 -l lvol_store +$rpc_py bdev_lvol_create lvol_bdev 10000 -l lvol_store if [[ "$ctrl_type" == "spdk_vhost_scsi" ]]; then $rpc_py construct_vhost_scsi_controller naa.Nvme0n1.0 diff --git a/test/vhost/lvol/lvol_test.sh b/test/vhost/lvol/lvol_test.sh index 31b7c67c9..c6b196c15 100755 --- a/test/vhost/lvol/lvol_test.sh +++ b/test/vhost/lvol/lvol_test.sh @@ -144,7 +144,7 @@ for (( i=0; i<$max_disks; i++ ));do size=$((free_mb / (vm_count+1) )) notice "Creating lvol bdev on lvol store: $ls_guid" - lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_nest $size $thin) + lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_nest $size $thin) notice "Creating nested lvol store on lvol bdev: $lb_name" nest_ls_guid=$($rpc_py construct_lvol_store $lb_name lvs_n_$i -c 4194304) @@ -154,7 +154,7 @@ for (( i=0; i<$max_disks; i++ ));do notice "Creating nested lvol bdev for VM $i on lvol store $nest_ls_guid" free_mb=$(get_lvs_free_mb "$nest_ls_guid") nest_size=$((free_mb / (vm_count-j) )) - lb_name=$($rpc_py construct_lvol_bdev -u $nest_ls_guid lbd_vm_$j $nest_size $thin) + lb_name=$($rpc_py bdev_lvol_create -u $nest_ls_guid lbd_vm_$j $nest_size $thin) nest_lvol_bdevs+=("$lb_name") done fi @@ -164,7 +164,7 @@ for (( i=0; i<$max_disks; i++ ));do notice "Creating lvol bdev for VM $i on lvol store $ls_guid" free_mb=$(get_lvs_free_mb "$ls_guid") size=$((free_mb / (vm_count-j) )) - lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_vm_$j $size $thin) + lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_vm_$j $size $thin) lvol_bdevs+=("$lb_name") done done diff --git a/test/vhost/perf_bench/vhost_perf.sh b/test/vhost/perf_bench/vhost_perf.sh index cbfef5e22..72d36cf5c 100755 --- a/test/vhost/perf_bench/vhost_perf.sh +++ b/test/vhost/perf_bench/vhost_perf.sh @@ -268,7 +268,7 @@ else for (( j=0; j<${splits[$i]}; j++)); do free_mb=$(get_lvs_free_mb "$ls_guid") size=$((free_mb / (${splits[$i]}-j) )) - lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_$j $size --clear-method none) + lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j $size --clear-method none) lvol_bdevs+=("$lb_name") done done diff --git a/test/vhost/vhost_boot/vhost_boot.sh b/test/vhost/vhost_boot/vhost_boot.sh index 9e7646257..a7a2445e3 100755 --- a/test/vhost/vhost_boot/vhost_boot.sh +++ b/test/vhost/vhost_boot/vhost_boot.sh @@ -75,7 +75,7 @@ if [[ $nvme_bdev_bs != 512 ]]; then fi lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0) -lvb_u=$($rpc_py construct_lvol_bdev -u $lvs_u lvb0 20000) +lvb_u=$($rpc_py bdev_lvol_create -u $lvs_u lvb0 20000) timing_exit create_lvol timing_enter convert_vm_image