ivampiresp/Spdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

RPC: rename rpc construct_lvol_bdev to bdev_lvol_create

Browse Source 
Signed-off-by: Maciej Wawryk <maciejx.wawryk@intel.com>
Change-Id: Idfcfdee1b81866307d2c256b093ff3dda16a3a7f
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/466711
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Maciej Wawryk 2019-08-29 13:01:30 +02:00 committed by Ben Walker
parent b5fdf4ec24
commit c57cd922a4
24 changed files with 223 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/bdev.md
View File

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

6
doc/jsonrpc.md
View File

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

4
doc/lvol.md
View File

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

37
module/bdev/lvol/vbdev_lvol_rpc.c
View File

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

21
scripts/rpc.py
View File

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

5
scripts/rpc/lvol.py
View File

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

2
scripts/spdkcli/ui_root.py
View File

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

2
test/blobstore/blob_io_wait/blob_io_wait.sh
View File

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

2
test/compress/compress.sh
View File

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

4
test/iscsi_tgt/filesystem/filesystem.sh
View File

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

2
test/iscsi_tgt/lvol/iscsi_lvol.sh
View File

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

2
test/iscsi_tgt/multiconnection/multiconnection.sh
View File

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

4
test/json_config/json_config.sh
View File

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

10
test/lvol/lvol.sh
View File

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

6
test/lvol/rpc_commands_lib.py
View File

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

306
test/lvol/test_cases.py
View File

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

4
test/nvmf/host/fio.sh
View File

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

4
test/nvmf/host/perf.sh
View File

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

2
test/nvmf/target/nvmf_lvol.sh
View File

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

2
test/vhost/fiotest/fio.sh
View File

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

2
test/vhost/integrity/integrity_start.sh
View File

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

6
test/vhost/lvol/lvol_test.sh
View File

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

2
test/vhost/perf_bench/vhost_perf.sh
View File

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

2
test/vhost/vhost_boot/vhost_boot.sh
View File

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