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

RPC: rename rpc construct_lvol_store to bdev_lvol_create_lvstore

Browse Source 
Signed-off-by: Maciej Wawryk <maciejx.wawryk@intel.com>
Change-Id: I7af61a37f04740425d777a69ac4ba6cd46371e7e
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/466757
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
This commit is contained in:
Maciej Wawryk 2019-08-29 15:31:19 +02:00 committed by Ben Walker
parent 90e4ae5de5
commit de7568531d
26 changed files with 209 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/bdev.md
View File

@ -423,11 +423,11 @@ please refer to @ref lvol.
Before creating any logical volumes (lvols), an lvol store has to be created first on Before creating any logical volumes (lvols), an lvol store has to be created first on
selected block device. Lvol store is lvols vessel responsible for managing underlying selected block device. Lvol store is lvols vessel responsible for managing underlying
bdev space assignment to lvol bdevs and storing metadata. To create lvol store user bdev space assignment to lvol bdevs and storing metadata. To create lvol store user
should use using `construct_lvol_store` RPC command. should use using `bdev_lvol_create_lvstore` RPC command.
Example command Example command
`rpc.py construct_lvol_store Malloc2 lvs -c 4096` `rpc.py bdev_lvol_create_lvstore Malloc2 lvs -c 4096`
This will create lvol store named `lvs` with cluster size 4096, build on top of This will create lvol store named `lvs` with cluster size 4096, build on top of
`Malloc2` bdev. In response user will be provided with uuid which is unique lvol store `Malloc2` bdev. In response user will be provided with uuid which is unique lvol store

6
doc/jsonrpc.md
View File

@ -311,7 +311,7 @@ Example response:
"bdev_lvol_create", "bdev_lvol_create",
"bdev_lvol_delete_lvstore", "bdev_lvol_delete_lvstore",
"bdev_lvol_rename_lvstore", "bdev_lvol_rename_lvstore",
"construct_lvol_store" "bdev_lvol_create_lvstore"
] ]
} }
~~~ ~~~
@ -4770,7 +4770,7 @@ The alias of the logical volume takes the format _lvs_name/lvol_name_ where:
* _lvs_name_ is the name of the logical volume store. * _lvs_name_ is the name of the logical volume store.
* _lvol_name_ is specified on creation and can be renamed. * _lvol_name_ is specified on creation and can be renamed.
## construct_lvol_store {#rpc_construct_lvol_store} ## bdev_lvol_create_lvstore {#rpc_bdev_lvol_create_lvstore}
Construct a logical volume store. Construct a logical volume store.
@ -4795,7 +4795,7 @@ Example request:
{ {
"jsonrpc": "2.0", "jsonrpc": "2.0",
"id": 1, "id": 1,
"method": "construct_lvol_store", "method": "bdev_lvol_create_lvstore",
"params": { "params": {
"lvs_name": "LVS0", "lvs_name": "LVS0",
"bdev_name": "Malloc0" "bdev_name": "Malloc0"

2
doc/lvol.md
View File

@ -80,7 +80,7 @@ There is no static configuration available for logical volumes. All configuratio
RPC regarding lvolstore: RPC regarding lvolstore:
``` ```
construct_lvol_store [-h] [-c CLUSTER_SZ] bdev_name lvs_name bdev_lvol_create_lvstore [-h] [-c CLUSTER_SZ] bdev_name lvs_name
Constructs lvolstore on specified bdev with specified name. During Constructs lvolstore on specified bdev with specified name. During
construction bdev is unmapped at initialization and all data is construction bdev is unmapped at initialization and all data is
erased. Then original bdev is claimed by erased. Then original bdev is claimed by

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

@ -40,7 +40,7 @@
SPDK_LOG_REGISTER_COMPONENT("lvolrpc", SPDK_LOG_LVOL_RPC) SPDK_LOG_REGISTER_COMPONENT("lvolrpc", SPDK_LOG_LVOL_RPC)
struct rpc_construct_lvol_store { struct rpc_bdev_lvol_create_lvstore {
char *lvs_name; char *lvs_name;
char *bdev_name; char *bdev_name;
uint32_t cluster_sz; uint32_t cluster_sz;
@ -78,18 +78,18 @@ vbdev_get_lvol_store_by_uuid_xor_name(const char *uuid, const char *lvs_name,
} }
static void static void
free_rpc_construct_lvol_store(struct rpc_construct_lvol_store *req) free_rpc_bdev_lvol_create_lvstore(struct rpc_bdev_lvol_create_lvstore *req)
{ {
free(req->bdev_name); free(req->bdev_name);
free(req->lvs_name); free(req->lvs_name);
free(req->clear_method); free(req->clear_method);
} }
static const struct spdk_json_object_decoder rpc_construct_lvol_store_decoders[] = { static const struct spdk_json_object_decoder rpc_bdev_lvol_create_lvstore_decoders[] = {
{"bdev_name", offsetof(struct rpc_construct_lvol_store, bdev_name), spdk_json_decode_string}, {"bdev_name", offsetof(struct rpc_bdev_lvol_create_lvstore, bdev_name), spdk_json_decode_string},
{"cluster_sz", offsetof(struct rpc_construct_lvol_store, cluster_sz), spdk_json_decode_uint32, true}, {"cluster_sz", offsetof(struct rpc_bdev_lvol_create_lvstore, cluster_sz), spdk_json_decode_uint32, true},
{"lvs_name", offsetof(struct rpc_construct_lvol_store, lvs_name), spdk_json_decode_string}, {"lvs_name", offsetof(struct rpc_bdev_lvol_create_lvstore, lvs_name), spdk_json_decode_string},
{"clear_method", offsetof(struct rpc_construct_lvol_store, clear_method), spdk_json_decode_string, true}, {"clear_method", offsetof(struct rpc_bdev_lvol_create_lvstore, clear_method), spdk_json_decode_string, true},
}; };
static void static void
@ -116,16 +116,16 @@ invalid:
} }
static void static void
spdk_rpc_construct_lvol_store(struct spdk_jsonrpc_request *request, spdk_rpc_bdev_lvol_create_lvstore(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_construct_lvol_store req = {}; struct rpc_bdev_lvol_create_lvstore req = {};
struct spdk_bdev *bdev; struct spdk_bdev *bdev;
int rc = 0; int rc = 0;
enum lvs_clear_method clear_method; enum lvs_clear_method clear_method;
if (spdk_json_decode_object(params, rpc_construct_lvol_store_decoders, if (spdk_json_decode_object(params, rpc_bdev_lvol_create_lvstore_decoders,
SPDK_COUNTOF(rpc_construct_lvol_store_decoders), SPDK_COUNTOF(rpc_bdev_lvol_create_lvstore_decoders),
&req)) { &req)) {
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n"); SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
@ -161,14 +161,15 @@ spdk_rpc_construct_lvol_store(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_send_error_response(request, -rc, spdk_strerror(rc)); spdk_jsonrpc_send_error_response(request, -rc, spdk_strerror(rc));
goto cleanup; goto cleanup;
} }
free_rpc_construct_lvol_store(&req); free_rpc_bdev_lvol_create_lvstore(&req);
return; return;
cleanup: cleanup:
free_rpc_construct_lvol_store(&req); free_rpc_bdev_lvol_create_lvstore(&req);
} }
SPDK_RPC_REGISTER("construct_lvol_store", spdk_rpc_construct_lvol_store, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("bdev_lvol_create_lvstore", spdk_rpc_bdev_lvol_create_lvstore, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_lvol_create_lvstore, construct_lvol_store)
struct rpc_bdev_lvol_rename_lvstore { struct rpc_bdev_lvol_rename_lvstore {
char *old_name; char *old_name;

9
scripts/rpc.py
View File

@ -1152,20 +1152,21 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.set_defaults(func=get_log_print_level) p.set_defaults(func=get_log_print_level)
# lvol # lvol
def construct_lvol_store(args): def bdev_lvol_create_lvstore(args):
print_json(rpc.lvol.construct_lvol_store(args.client, print_json(rpc.lvol.bdev_lvol_create_lvstore(args.client,
bdev_name=args.bdev_name, bdev_name=args.bdev_name,
lvs_name=args.lvs_name, lvs_name=args.lvs_name,
cluster_sz=args.cluster_sz, cluster_sz=args.cluster_sz,
clear_method=args.clear_method)) clear_method=args.clear_method))
p = subparsers.add_parser('construct_lvol_store', help='Add logical volume store on base bdev') p = subparsers.add_parser('bdev_lvol_create_lvstore', aliases=['construct_lvol_store'],
help='Add logical volume store on base bdev')
p.add_argument('bdev_name', help='base bdev name') p.add_argument('bdev_name', help='base bdev name')
p.add_argument('lvs_name', help='name for lvol store') p.add_argument('lvs_name', help='name for lvol store')
p.add_argument('-c', '--cluster-sz', help='size of cluster (in bytes)', type=int, required=False) p.add_argument('-c', '--cluster-sz', help='size of cluster (in bytes)', type=int, required=False)
p.add_argument('--clear-method', help="""Change clear method for data region. p.add_argument('--clear-method', help="""Change clear method for data region.
Available: none, unmap, write_zeroes""", required=False) Available: none, unmap, write_zeroes""", required=False)
p.set_defaults(func=construct_lvol_store) p.set_defaults(func=bdev_lvol_create_lvstore)
def bdev_lvol_rename_lvstore(args): def bdev_lvol_rename_lvstore(args):
rpc.lvol.bdev_lvol_rename_lvstore(args.client, rpc.lvol.bdev_lvol_rename_lvstore(args.client,

5
scripts/rpc/lvol.py
View File

@ -1,7 +1,8 @@
from .helpers import deprecated_alias from .helpers import deprecated_alias
def construct_lvol_store(client, bdev_name, lvs_name, cluster_sz=None, clear_method=None): @deprecated_alias('construct_lvol_store')
def bdev_lvol_create_lvstore(client, bdev_name, lvs_name, cluster_sz=None, clear_method=None):
"""Construct a logical volume store. """Construct a logical volume store.
Args: Args:
@ -18,7 +19,7 @@ def construct_lvol_store(client, bdev_name, lvs_name, cluster_sz=None, clear_met
params['cluster_sz'] = cluster_sz params['cluster_sz'] = cluster_sz
if clear_method: if clear_method:
params['clear_method'] = clear_method params['clear_method'] = clear_method
return client.call('construct_lvol_store', params) return client.call('bdev_lvol_create_lvstore', params)
@deprecated_alias('rename_lvol_store') @deprecated_alias('rename_lvol_store')

2
scripts/spdkcli/ui_node.py
View File

@ -105,7 +105,7 @@ class UILvolStores(UINode):
""" """
cluster_size = self.ui_eval_param(cluster_size, "number", None) cluster_size = self.ui_eval_param(cluster_size, "number", None)
self.get_root().create_lvol_store(lvs_name=name, bdev_name=bdev_name, cluster_sz=cluster_size) self.get_root().bdev_lvol_create_lvstore(lvs_name=name, bdev_name=bdev_name, cluster_sz=cluster_size)
def ui_command_delete(self, name=None, uuid=None): def ui_command_delete(self, name=None, uuid=None):
""" """

4
scripts/spdkcli/ui_root.py
View File

@ -197,8 +197,8 @@ class UIRoot(UINode):
yield LvolStore(lvs) yield LvolStore(lvs)
@verbose @verbose
def create_lvol_store(self, **kwargs): def bdev_lvol_create_lvstore(self, **kwargs):
response = rpc.lvol.construct_lvol_store(self.client, **kwargs) response = rpc.lvol.bdev_lvol_create_lvstore(self.client, **kwargs)
return response return response
@verbose @verbose

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

@ -23,7 +23,7 @@ trap 'killprocess $bdev_svc_pid; exit 1' SIGINT SIGTERM EXIT
waitforlisten $bdev_svc_pid waitforlisten $bdev_svc_pid
$rpc_py bdev_aio_create $testdir/aio.bdev aio0 4096 $rpc_py bdev_aio_create $testdir/aio.bdev aio0 4096
$rpc_py construct_lvol_store aio0 lvs0 $rpc_py bdev_lvol_create_lvstore aio0 lvs0
$rpc_py bdev_lvol_create -l lvs0 lvol0 32 $rpc_py bdev_lvol_create -l lvs0 lvol0 32
killprocess $bdev_svc_pid killprocess $bdev_svc_pid

2
test/compress/compress.sh
View File

@ -24,7 +24,7 @@ trap 'killprocess $bdev_svc_pid; compress_err_cleanup; exit 1' SIGINT SIGTERM EX
waitforlisten $bdev_svc_pid waitforlisten $bdev_svc_pid
bdf=$(iter_pci_class_code 01 08 02 | head -1) bdf=$(iter_pci_class_code 01 08 02 | head -1)
$rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf $rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf
lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0) lvs_u=$($rpc_py bdev_lvol_create_lvstore Nvme0n1 lvs0)
$rpc_py bdev_lvol_create -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 # this will force isal_pmd as some of the CI systems need a qat driver update
$rpc_py set_compress_pmd -p 2 $rpc_py set_compress_pmd -p 2

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

@ -47,7 +47,7 @@ $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf $rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf
ls_guid=$($rpc_py construct_lvol_store Nvme0n1 lvs_0) ls_guid=$($rpc_py bdev_lvol_create_lvstore Nvme0n1 lvs_0)
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
# Using maximum 2048MiB to reduce the test time # Using maximum 2048MiB to reduce the test time
if [ $free_mb -gt 2048 ]; then if [ $free_mb -gt 2048 ]; then

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

@ -56,7 +56,7 @@ for i in $(seq 1 $NUM_LVS); do
# construct malloc bdev and put its name in $bdev # construct malloc bdev and put its name in $bdev
bdev=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) bdev=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
fi fi
ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576) ls_guid=$($rpc_py bdev_lvol_create_lvstore $bdev lvs_$i -c 1048576)
LUNs="" LUNs=""
for j in $(seq 1 $NUM_LVOL); do for j in $(seq 1 $NUM_LVOL); do
lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j 10) lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j 10)

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

@ -52,7 +52,7 @@ $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
echo "Creating an iSCSI target node." echo "Creating an iSCSI target node."
ls_guid=$($rpc_py construct_lvol_store "Nvme0n1" "lvs0" -c 1048576) ls_guid=$($rpc_py bdev_lvol_create_lvstore "Nvme0n1" "lvs0" -c 1048576)
# Assign even size for each lvol_bdev. # Assign even size for each lvol_bdev.
get_lvs_free_mb $ls_guid get_lvs_free_mb $ls_guid

2
test/json_config/json_config.sh
View File

@ -200,7 +200,7 @@ function create_bdev_subsystem_config() {
# For LVOLs use split to check for proper order of initialization. # For LVOLs use split to check for proper order of initialization.
# If LVOLs cofniguration will be reordered (eg moved before splits or AIO/NVMe) # If LVOLs cofniguration will be reordered (eg moved before splits or AIO/NVMe)
# it should fail loading JSON config from file. # it should fail loading JSON config from file.
tgt_rpc construct_lvol_store -c 1048576 ${lvol_store_base_bdev}p0 lvs_test tgt_rpc bdev_lvol_create_lvstore -c 1048576 ${lvol_store_base_bdev}p0 lvs_test
tgt_rpc bdev_lvol_create -l lvs_test lvol0 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_create -l lvs_test -t lvol1 32
tgt_rpc bdev_lvol_snapshot lvs_test/lvol0 snapshot0 tgt_rpc bdev_lvol_snapshot lvs_test/lvol0 snapshot0

6
test/lvol/lvol.sh
View File

@ -50,9 +50,9 @@ function usage() {
551: 'delete_lvol_bdev', 551: 'delete_lvol_bdev',
552: 'bdev_lvol_delete_lvstore_with_clones', 552: 'bdev_lvol_delete_lvstore_with_clones',
553: 'unregister_lvol_bdev', 553: 'unregister_lvol_bdev',
600: 'construct_lvol_store_with_cluster_size_max', 600: 'bdev_lvol_create_lvstore_with_cluster_size_max',
601: 'construct_lvol_store_with_cluster_size_min', 601: 'bdev_lvol_create_lvstore_with_cluster_size_min',
602: 'construct_lvol_store_with_all_clear_methods', 602: 'bdev_lvol_create_lvstore_with_all_clear_methods',
650: 'thin_provisioning_check_space', 650: 'thin_provisioning_check_space',
651: 'thin_provisioning_read_empty_bdev', 651: 'thin_provisioning_read_empty_bdev',
652: 'thin_provisioning_data_integrity_test', 652: 'thin_provisioning_data_integrity_test',

10
test/lvol/rpc_commands_lib.py
View File

@ -112,18 +112,18 @@ class Commands_Rpc(object):
output = self.rpc.bdev_malloc_create(total_size, block_size)[0] output = self.rpc.bdev_malloc_create(total_size, block_size)[0]
return output.rstrip('\n') return output.rstrip('\n')
def construct_lvol_store(self, base_name, lvs_name, cluster_size=None, clear_method=None): def bdev_lvol_create_lvstore(self, base_name, lvs_name, cluster_size=None, clear_method=None):
print("INFO: RPC COMMAND construct_lvol_store") print("INFO: RPC COMMAND bdev_lvol_create_lvstore")
if cluster_size: if cluster_size:
output = self.rpc.construct_lvol_store(base_name, output = self.rpc.bdev_lvol_create_lvstore(base_name,
lvs_name, lvs_name,
"-c {cluster_sz}".format(cluster_sz=cluster_size))[0] "-c {cluster_sz}".format(cluster_sz=cluster_size))[0]
elif clear_method: elif clear_method:
output = self.rpc.construct_lvol_store(base_name, output = self.rpc.bdev_lvol_create_lvstore(base_name,
lvs_name, lvs_name,
"--clear-method {clear_m}".format(clear_m=clear_method))[0] "--clear-method {clear_m}".format(clear_m=clear_method))[0]
else: else:
output = self.rpc.construct_lvol_store(base_name, lvs_name)[0] output = self.rpc.bdev_lvol_create_lvstore(base_name, lvs_name)[0]
return output.rstrip('\n') return output.rstrip('\n')
def bdev_lvol_create(self, uuid, lbd_name, size, thin=False): def bdev_lvol_create(self, uuid, lbd_name, size, thin=False):

160
test/lvol/test_cases.py
View File

@ -110,7 +110,7 @@ def test_counter():
def case_message(func): def case_message(func):
def inner(*args, **kwargs): def inner(*args, **kwargs):
test_name = { test_name = {
# construct_lvol_store - positive tests # bdev_lvol_create_lvstore - positive tests
1: 'construct_lvs_positive', 1: 'construct_lvs_positive',
# bdev_lvol_create - positive tests # bdev_lvol_create - positive tests
50: 'construct_logical_volume_positive', 50: 'construct_logical_volume_positive',
@ -136,7 +136,7 @@ def case_message(func):
# bdev_lvol_delete_lvstore - negative tests # bdev_lvol_delete_lvstore - negative tests
300: 'bdev_lvol_delete_lvstore_nonexistent_lvs_uuid', 300: 'bdev_lvol_delete_lvstore_nonexistent_lvs_uuid',
301: 'delete_lvol_store_underlying_bdev', 301: 'delete_lvol_store_underlying_bdev',
# construct_lvol_store - negative tests # bdev_lvol_create_lvstore - negative tests
450: 'construct_lvs_nonexistent_bdev', 450: 'construct_lvs_nonexistent_bdev',
451: 'construct_lvs_on_bdev_twice', 451: 'construct_lvs_on_bdev_twice',
452: 'construct_lvs_name_twice', 452: 'construct_lvs_name_twice',
@ -146,9 +146,9 @@ def case_message(func):
551: 'delete_lvol_bdev', 551: 'delete_lvol_bdev',
552: 'bdev_lvol_delete_lvstore_with_clones', 552: 'bdev_lvol_delete_lvstore_with_clones',
553: 'unregister_lvol_bdev', 553: 'unregister_lvol_bdev',
600: 'construct_lvol_store_with_cluster_size_max', 600: 'bdev_lvol_create_lvstore_with_cluster_size_max',
601: 'construct_lvol_store_with_cluster_size_min', 601: 'bdev_lvol_create_lvstore_with_cluster_size_min',
602: 'construct_lvol_store_with_all_clear_methods', 602: 'bdev_lvol_create_lvstore_with_all_clear_methods',
# Provisioning # Provisioning
650: 'thin_provisioning_check_space', 650: 'thin_provisioning_check_space',
651: 'thin_provisioning_read_empty_bdev', 651: 'thin_provisioning_read_empty_bdev',
@ -321,13 +321,13 @@ class TestCases(object):
construct_lvs_positive construct_lvs_positive
Positive test for constructing a new lvol store. Positive test for constructing a new lvol store.
Call construct_lvol_store with correct base bdev name. Call bdev_lvol_create_lvstore with correct base bdev name.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -339,7 +339,7 @@ class TestCases(object):
# Expected result # Expected result
# - call successful, return code = 0, uuid printed to stdout # - call successful, return code = 0, uuid printed to stdout
# - bdev_lvol_get_lvstores: backend used for construct_lvol_store has uuid # - bdev_lvol_get_lvstores: backend used for bdev_lvol_create_lvstore has uuid
# field set with the same uuid as returned from RPC call # field set with the same uuid as returned from RPC call
# - no other operation fails # - no other operation fails
return fail_count return fail_count
@ -356,7 +356,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on correct, exisitng malloc bdev # Create lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -394,7 +394,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on correct, exisitng malloc bdev # Construct lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Verify lvol store was created correctly # Verify lvol store was created correctly
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -438,7 +438,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -477,9 +477,9 @@ class TestCases(object):
base_name_2 = self.c.bdev_malloc_create(self.total_size, base_name_2 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume stores on created malloc bdevs # Create logical volume stores on created malloc bdevs
uuid_store_1 = self.c.construct_lvol_store(base_name_1, uuid_store_1 = self.c.bdev_lvol_create_lvstore(base_name_1,
self.lvs_name + "1") self.lvs_name + "1")
uuid_store_2 = self.c.construct_lvol_store(base_name_2, uuid_store_2 = self.c.bdev_lvol_create_lvstore(base_name_2,
self.lvs_name + "2") self.lvs_name + "2")
# Verify stores were created correctly # Verify stores were created correctly
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name_1, uuid_store_1, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name_1, uuid_store_1,
@ -546,7 +546,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume store on malloc bdev # Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response from bdev_lvol_get_lvstores command # Check correct uuid values in response from bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -590,7 +590,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume store on malloc bdev # Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Using bdev_lvol_get_lvstores verify that logical volume store was correctly created # Using bdev_lvol_get_lvstores verify that logical volume store was correctly created
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -633,7 +633,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -706,7 +706,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -747,7 +747,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on created malloc bdev # Create lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# check correct uuid values in response bdev_lvol_get_lvstores command # check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -778,7 +778,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -809,7 +809,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -851,7 +851,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on correct, exisitng malloc bdev # Construct lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -891,7 +891,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on create malloc bdev # Construct lvol store on create malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -960,7 +960,7 @@ class TestCases(object):
# Construct aio bdev # Construct aio bdev
self.c.bdev_aio_create(aio_bdev0, base_name, 4096) self.c.bdev_aio_create(aio_bdev0, base_name, 4096)
# Create lvol store on created aio bdev # Create lvol store on created aio bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -1018,7 +1018,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -1046,13 +1046,13 @@ class TestCases(object):
construct_lvs_nonexistent_bdev construct_lvs_nonexistent_bdev
Negative test for constructing a new lvol store. Negative test for constructing a new lvol store.
Call construct_lvol_store with base bdev name which does not Call bdev_lvol_create_lvstore with base bdev name which does not
exist in configuration. exist in configuration.
""" """
fail_count = 0 fail_count = 0
bad_bdev_id = random.randrange(999999999) bad_bdev_id = random.randrange(999999999)
# Try construct_lvol_store on bdev which does not exist # Try bdev_lvol_create_lvstore on bdev which does not exist
if self.c.construct_lvol_store(bad_bdev_id, if self.c.bdev_lvol_create_lvstore(bad_bdev_id,
self.lvs_name, self.lvs_name,
self.cluster_size) == 0: self.cluster_size) == 0:
fail_count += 1 fail_count += 1
@ -1064,20 +1064,20 @@ class TestCases(object):
construct_lvs_on_bdev_twice construct_lvs_on_bdev_twice
Negative test for constructing a new lvol store. Negative test for constructing a new lvol store.
Call construct_lvol_store with base bdev name twice. Call bdev_lvol_create_lvstore with base bdev name twice.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
# Try construct_lvol_store on the same bdev as in last step # Try bdev_lvol_create_lvstore on the same bdev as in last step
# This call should fail as base bdev is already claimed by lvol store # This call should fail as base bdev is already claimed by lvol store
if self.c.construct_lvol_store(base_name, if self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) == 0: self.lvs_name) == 0:
fail_count += 1 fail_count += 1
self.c.bdev_lvol_delete_lvstore(uuid_store) self.c.bdev_lvol_delete_lvstore(uuid_store)
@ -1100,7 +1100,7 @@ class TestCases(object):
base_name_2 = self.c.bdev_malloc_create(self.total_size, base_name_2 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on first malloc # Construct lvol store on first malloc
uuid_store_1 = self.c.construct_lvol_store(base_name_1, uuid_store_1 = self.c.bdev_lvol_create_lvstore(base_name_1,
self.lvs_name) self.lvs_name)
# using bdev_lvol_get_lvstores verify that logical volume store was correctly created # using bdev_lvol_get_lvstores verify that logical volume store was correctly created
# and has arguments as provided in step earlier (cluster size, friendly name, base bdev) # and has arguments as provided in step earlier (cluster size, friendly name, base bdev)
@ -1110,7 +1110,7 @@ class TestCases(object):
# Try to create another logical volume store on second malloc bdev using the # Try to create another logical volume store on second malloc bdev using the
# same friendly name as before. This step is expected to fail as lvol stores # same friendly name as before. This step is expected to fail as lvol stores
# cannot have the same name # cannot have the same name
if self.c.construct_lvol_store(base_name_2, if self.c.bdev_lvol_create_lvstore(base_name_2,
self.lvs_name) == 0: self.lvs_name) == 0:
fail_count += 1 fail_count += 1
@ -1132,7 +1132,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -1143,7 +1143,7 @@ class TestCases(object):
self.lbd_name, size) self.lbd_name, size)
# Construct nested lvol store on created lvol_bdev # Construct nested lvol store on created lvol_bdev
nested_lvs_name = self.lvs_name + "_nested" nested_lvs_name = self.lvs_name + "_nested"
nested_lvs_uuid = self.c.construct_lvol_store(uuid_bdev, nested_lvs_uuid = self.c.bdev_lvol_create_lvstore(uuid_bdev,
nested_lvs_name) nested_lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count += self.c.check_bdev_lvol_get_lvstores(uuid_bdev, nested_lvs_uuid, fail_count += self.c.check_bdev_lvol_get_lvstores(uuid_bdev, nested_lvs_uuid,
@ -1176,13 +1176,13 @@ class TestCases(object):
delete_bdev_positive delete_bdev_positive
Positive test for deleting malloc bdev. Positive test for deleting malloc bdev.
Call construct_lvol_store with correct base bdev name. Call bdev_lvol_create_lvstore with correct base bdev name.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
@ -1215,7 +1215,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name, self.lvs_name,
self.cluster_size) self.cluster_size)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
@ -1280,7 +1280,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name, self.lvs_name,
self.cluster_size) self.cluster_size)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
@ -1341,7 +1341,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name, self.lvs_name,
self.cluster_size) self.cluster_size)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
@ -1378,10 +1378,10 @@ class TestCases(object):
@case_message @case_message
def test_case600(self): def test_case600(self):
""" """
construct_lvol_store_with_cluster_size_max bdev_lvol_create_lvstore_with_cluster_size_max
Negative test for constructing a new lvol store. Negative test for constructing a new lvol store.
Call construct_lvol_store with cluster size is equal malloc bdev size + 1B. Call bdev_lvol_create_lvstore with cluster size is equal malloc bdev size + 1B.
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
@ -1389,7 +1389,7 @@ class TestCases(object):
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev and cluster size equal # Construct_lvol_store on correct, exisitng malloc bdev and cluster size equal
# malloc bdev size in bytes + 1B # malloc bdev size in bytes + 1B
lvol_uuid = self.c.construct_lvol_store(base_name, lvol_uuid = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name, self.lvs_name,
(self.total_size * 1024 * 1024) + 1) == 0 (self.total_size * 1024 * 1024) + 1) == 0
if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0: if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0:
@ -1404,17 +1404,17 @@ class TestCases(object):
@case_message @case_message
def test_case601(self): def test_case601(self):
""" """
construct_lvol_store_with_cluster_size_min bdev_lvol_create_lvstore_with_cluster_size_min
Negative test for constructing a new lvol store. Negative test for constructing a new lvol store.
Call construct_lvol_store with cluster size smaller than minimal value of 8192. Call bdev_lvol_create_lvstore with cluster size smaller than minimal value of 8192.
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Try construct lvol store on malloc bdev with cluster size 8191 # Try construct lvol store on malloc bdev with cluster size 8191
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, 8191) lvol_uuid = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name, 8191)
# Verify that lvol store was not created # Verify that lvol store was not created
if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0: if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0:
fail_count += 1 fail_count += 1
@ -1428,16 +1428,16 @@ class TestCases(object):
@case_message @case_message
def test_case602(self): def test_case602(self):
""" """
construct_lvol_store_with_all_clear_methods bdev_lvol_create_lvstore_with_all_clear_methods
Call construct_lvol_store with all options for clear methods. Call bdev_lvol_create_lvstore with all options for clear methods.
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'none' # Construct lvol store with clear method 'none'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="none") lvol_uuid = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name, clear_method="none")
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid)
fail_count += self.c.delete_malloc_bdev(base_name) fail_count += self.c.delete_malloc_bdev(base_name)
@ -1445,7 +1445,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'unmap' # Construct lvol store with clear method 'unmap'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="unmap") lvol_uuid = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name, clear_method="unmap")
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid)
fail_count += self.c.delete_malloc_bdev(base_name) fail_count += self.c.delete_malloc_bdev(base_name)
@ -1453,7 +1453,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'write_zeroes' # Construct lvol store with clear method 'write_zeroes'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="write_zeroes") lvol_uuid = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name, clear_method="write_zeroes")
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid)
fail_count += self.c.delete_malloc_bdev(base_name) fail_count += self.c.delete_malloc_bdev(base_name)
@ -1474,7 +1474,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# create lvol store on mamloc bdev # create lvol store on mamloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -1554,7 +1554,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -1612,7 +1612,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -1654,7 +1654,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
# Construct thin provisioned lvol bdevs on created lvol store # Construct thin provisioned lvol bdevs on created lvol store
@ -1728,7 +1728,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0] lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
@ -1799,7 +1799,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.bdev_lvol_create_lvstore(base_name, self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0] lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
@ -1869,7 +1869,7 @@ class TestCases(object):
# Create initial configuration on running vhost instance # Create initial configuration on running vhost instance
# create lvol store, create 5 bdevs # create lvol store, create 5 bdevs
# save info of all lvs and lvol bdevs # save info of all lvs and lvol bdevs
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
uuid_store, uuid_store,
@ -1943,7 +1943,7 @@ class TestCases(object):
# Create lvol store on aio bdev, create ten lvol bdevs on lvol store and # Create lvol store on aio bdev, create ten lvol bdevs on lvol store and
# verify all configuration call results # verify all configuration call results
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
uuid_store, uuid_store,
@ -1977,7 +1977,7 @@ class TestCases(object):
self.c.bdev_aio_create(aio_bdev0, base_name, 4096) self.c.bdev_aio_create(aio_bdev0, base_name, 4096)
# construct lvol store on aio bdev # construct lvol store on aio bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2027,7 +2027,7 @@ class TestCases(object):
# Create initial configuration on running vhost instance # Create initial configuration on running vhost instance
# create lvol store, create 5 bdevs # create lvol store, create 5 bdevs
# save info of all lvs and lvol bdevs # save info of all lvs and lvol bdevs
uuid_store_1M = self.c.construct_lvol_store(base_name_1M, uuid_store_1M = self.c.bdev_lvol_create_lvstore(base_name_1M,
self.lvs_name + "_1M", self.lvs_name + "_1M",
cluster_size_1M) cluster_size_1M)
@ -2035,7 +2035,7 @@ class TestCases(object):
uuid_store_1M, uuid_store_1M,
cluster_size_1M) cluster_size_1M)
uuid_store_32M = self.c.construct_lvol_store(base_name_32M, uuid_store_32M = self.c.bdev_lvol_create_lvstore(base_name_32M,
self.lvs_name + "_32M", self.lvs_name + "_32M",
cluster_size_32M) cluster_size_32M)
@ -2135,7 +2135,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2189,7 +2189,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2264,7 +2264,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2319,7 +2319,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2366,7 +2366,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2429,7 +2429,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2502,7 +2502,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2592,7 +2592,7 @@ class TestCases(object):
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2683,7 +2683,7 @@ class TestCases(object):
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2754,7 +2754,7 @@ class TestCases(object):
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2853,7 +2853,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2917,7 +2917,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -2997,7 +2997,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
@ -3118,7 +3118,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_name, lvs_uuid = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
lvs_uuid, lvs_uuid,
@ -3233,13 +3233,13 @@ class TestCases(object):
self.block_size) self.block_size)
# Create lvol store on each malloc bdev # Create lvol store on each malloc bdev
lvs_uuid_1 = self.c.construct_lvol_store(base_bdev_1, lvs_uuid_1 = self.c.bdev_lvol_create_lvstore(base_bdev_1,
lvs_name_1) lvs_name_1)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_1, fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_1,
lvs_uuid_1, lvs_uuid_1,
self.cluster_size, self.cluster_size,
lvs_name_1) lvs_name_1)
lvs_uuid_2 = self.c.construct_lvol_store(base_bdev_2, lvs_uuid_2 = self.c.bdev_lvol_create_lvstore(base_bdev_2,
lvs_name_2) lvs_name_2)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_2, fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_2,
lvs_uuid_2, lvs_uuid_2,
@ -3339,7 +3339,7 @@ class TestCases(object):
base_bdev = self.c.bdev_malloc_create(self.total_size, base_bdev = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on created malloc bdev # Create lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_bdev, lvs_uuid = self.c.bdev_lvol_create_lvstore(base_bdev,
self.lvs_name) self.lvs_name)
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev, fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev,
lvs_uuid, lvs_uuid,
@ -3390,7 +3390,7 @@ class TestCases(object):
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bddev # Construct lvol store on created malloc bddev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.bdev_lvol_create_lvstore(base_name,
self.lvs_name) self.lvs_name)
# Check correct uuid values in response bdev_lvol_get_lvstores command # Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,

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

@ -47,7 +47,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
# Test fio_plugin as host with nvme lvol backend # Test fio_plugin as host with nvme lvol backend
bdfs=$(iter_pci_class_code 01 08 02) bdfs=$(iter_pci_class_code 01 08 02)
$rpc_py construct_nvme_bdev -b Nvme0 -t PCIe -a $(echo $bdfs | awk '{ print $1 }') -i $NVMF_FIRST_TARGET_IP $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) ls_guid=$($rpc_py bdev_lvol_create_lvstore -c 1073741824 Nvme0n1 lvs_0)
get_lvs_free_mb $ls_guid get_lvs_free_mb $ls_guid
$rpc_py bdev_lvol_create -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_create nqn.2016-06.io.spdk:cnode2 -a -s SPDK00000000000001
@ -58,7 +58,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
$rpc_py delete_nvmf_subsystem nqn.2016-06.io.spdk:cnode2 $rpc_py delete_nvmf_subsystem nqn.2016-06.io.spdk:cnode2
# Test fio_plugin as host with nvme lvol nested backend # 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) ls_nested_guid=$($rpc_py bdev_lvol_create_lvstore --clear-method none lvs_0/lbd_0 lvs_n_0)
get_lvs_free_mb $ls_nested_guid get_lvs_free_mb $ls_nested_guid
$rpc_py bdev_lvol_create -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_create nqn.2016-06.io.spdk:cnode3 -a -s SPDK00000000000001

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

@ -44,7 +44,7 @@ $rpc_py delete_nvmf_subsystem nqn.2016-06.io.spdk:cnode1
if [ $RUN_NIGHTLY -eq 1 ]; then if [ $RUN_NIGHTLY -eq 1 ]; then
# Configure nvme devices with nvmf lvol_bdev backend # Configure nvme devices with nvmf lvol_bdev backend
if [ -n "$local_nvme_trid" ]; then if [ -n "$local_nvme_trid" ]; then
ls_guid=$($rpc_py construct_lvol_store Nvme0n1 lvs_0) ls_guid=$($rpc_py bdev_lvol_create_lvstore Nvme0n1 lvs_0)
get_lvs_free_mb $ls_guid get_lvs_free_mb $ls_guid
# We don't need to create an lvol larger than 20G for this test. # We don't need to create an lvol larger than 20G for this test.
# decreasing the size of the nested lvol allows us to take less time setting up # decreasing the size of the nested lvol allows us to take less time setting up
@ -55,7 +55,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
lb_guid=$($rpc_py bdev_lvol_create -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 # Create lvol bdev for nested lvol stores
ls_nested_guid=$($rpc_py construct_lvol_store $lb_guid lvs_n_0) ls_nested_guid=$($rpc_py bdev_lvol_create_lvstore $lb_guid lvs_n_0)
get_lvs_free_mb $ls_nested_guid get_lvs_free_mb $ls_nested_guid
if [ $free_mb -gt 20480 ]; then if [ $free_mb -gt 20480 ]; then
free_mb=20480 free_mb=20480

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

@ -32,7 +32,7 @@ base_bdevs+=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs" $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs"
# Create the logical volume store on the RAID volume # Create the logical volume store on the RAID volume
lvs=$($rpc_py construct_lvol_store raid0 lvs) lvs=$($rpc_py bdev_lvol_create_lvstore raid0 lvs)
# Create a logical volume on the logical volume store # Create a logical volume on the logical volume store
lvol=$($rpc_py bdev_lvol_create -u $lvs lvol $LVOL_BDEV_INIT_SIZE) lvol=$($rpc_py bdev_lvol_create -u $lvs lvol $LVOL_BDEV_INIT_SIZE)

2
test/openstack/run_openstack_tests.sh
View File

@ -34,7 +34,7 @@ timing_exit run_rpc_proxy
timing_enter configure_spdk timing_enter configure_spdk
$rpc_py get_bdevs $rpc_py get_bdevs
$rpc_py bdev_lvol_delete_lvstore -l lvs0 || true $rpc_py bdev_lvol_delete_lvstore -l lvs0 || true
$rpc_py construct_lvol_store Nvme0n1 lvs0 $rpc_py bdev_lvol_create_lvstore Nvme0n1 lvs0
$rpc_py get_bdevs $rpc_py get_bdevs
timing_exit configure_spdk timing_exit configure_spdk

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

@ -116,7 +116,7 @@ for vm_conf in ${vms[@]}; do
for disk in "${disks[@]}"; do for disk in "${disks[@]}"; do
notice "Create a lvol store on RaidBdev2 and then a lvol bdev on the lvol store" notice "Create a lvol store on RaidBdev2 and then a lvol bdev on the lvol store"
if [[ $disk == "RaidBdev2" ]]; then if [[ $disk == "RaidBdev2" ]]; then
ls_guid=$($rpc_py construct_lvol_store RaidBdev2 lvs_0 -c 4194304) ls_guid=$($rpc_py bdev_lvol_create_lvstore RaidBdev2 lvs_0 -c 4194304)
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
based_disk=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb) based_disk=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb)
else else

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

@ -66,7 +66,7 @@ notice "..."
# Set up lvols and vhost controllers # Set up lvols and vhost controllers
trap 'clean_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' SIGTERM SIGABRT ERR trap 'clean_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' SIGTERM SIGABRT ERR
notice "Constructing lvol store and lvol bdev on top of Nvme0n1" notice "Constructing lvol store and lvol bdev on top of Nvme0n1"
lvs_uuid=$($rpc_py construct_lvol_store Nvme0n1 lvol_store) lvs_uuid=$($rpc_py bdev_lvol_create_lvstore Nvme0n1 lvol_store)
$rpc_py bdev_lvol_create lvol_bdev 10000 -l lvol_store $rpc_py bdev_lvol_create lvol_bdev 10000 -l lvol_store
if [[ "$ctrl_type" == "spdk_vhost_scsi" ]]; then if [[ "$ctrl_type" == "spdk_vhost_scsi" ]]; then

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

@ -136,7 +136,7 @@ for (( i=0; i<$max_disks; i++ ));do
# Create base lvol store on NVMe # Create base lvol store on NVMe
notice "Creating lvol store on device Nvme${i}n1" notice "Creating lvol store on device Nvme${i}n1"
ls_guid=$($rpc_py construct_lvol_store Nvme${i}n1 lvs_$i -c 4194304) ls_guid=$($rpc_py bdev_lvol_create_lvstore Nvme${i}n1 lvs_$i -c 4194304)
lvol_stores+=("$ls_guid") lvol_stores+=("$ls_guid")
if $nested_lvol; then if $nested_lvol; then
@ -147,7 +147,7 @@ for (( i=0; i<$max_disks; i++ ));do
lb_name=$($rpc_py bdev_lvol_create -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" 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) nest_ls_guid=$($rpc_py bdev_lvol_create_lvstore $lb_name lvs_n_$i -c 4194304)
nest_lvol_stores+=("$nest_ls_guid") nest_lvol_stores+=("$nest_ls_guid")
for (( j=0; j<$vm_count; j++)); do for (( j=0; j<$vm_count; j++)); do

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

@ -263,7 +263,7 @@ else
notice "Using logical volumes" notice "Using logical volumes"
trap 'cleanup_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' INT ERR trap 'cleanup_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' INT ERR
for (( i=0; i<$max_disks; i++ ));do for (( i=0; i<$max_disks; i++ ));do
ls_guid=$($rpc_py construct_lvol_store Nvme${i}n1 lvs_$i --clear-method none) ls_guid=$($rpc_py bdev_lvol_create_lvstore Nvme${i}n1 lvs_$i --clear-method none)
lvol_stores+=("$ls_guid") lvol_stores+=("$ls_guid")
for (( j=0; j<${splits[$i]}; j++)); do for (( j=0; j<${splits[$i]}; j++)); do
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")

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

@ -74,7 +74,7 @@ if [[ $nvme_bdev_bs != 512 ]]; then
false false
fi fi
lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0) lvs_u=$($rpc_py bdev_lvol_create_lvstore Nvme0n1 lvs0)
lvb_u=$($rpc_py bdev_lvol_create -u $lvs_u lvb0 20000) lvb_u=$($rpc_py bdev_lvol_create -u $lvs_u lvb0 20000)
timing_exit create_lvol timing_exit create_lvol