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

RPC: rename rpc get_lvol_stores to bdev_lvol_get_lvstores

Browse Source 
Signed-off-by: Maciej Wawryk <maciejx.wawryk@intel.com>
Change-Id: I419488ba971d523fd5285a51d467fbac9dd218a2
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/466282
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-26 13:54:05 +02:00 committed by Jim Harris
parent 9f5cbf4c7f
commit 0b3f378f7a
12 changed files with 269 additions and 266 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
doc/bdev.md
View File

@ -433,7 +433,7 @@ 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
identifier.
User can get list of available lvol stores using `get_lvol_stores` RPC command (no
User can get list of available lvol stores using `bdev_lvol_get_lvstores` RPC command (no
parameters available).
Example response

6
doc/jsonrpc.md
View File

@ -299,7 +299,7 @@ Example response:
"bdev_malloc_create",
"delete_ftl_bdev",
"construct_ftl_bdev",
"get_lvol_stores",
"bdev_lvol_get_lvstores",
"destroy_lvol_bdev",
"resize_lvol_bdev",
"set_read_only_lvol_bdev",
@ -4852,7 +4852,7 @@ Example response:
}
~~~
## get_lvol_stores {#rpc_get_lvol_stores}
## bdev_lvol_get_lvstores {#rpc_bdev_lvol_get_lvstores}
Get a list of logical volume stores.
@ -4873,7 +4873,7 @@ Example request:
~~~
{
"jsonrpc": "2.0",
"method": "get_lvol_stores",
"method": "bdev_lvol_get_lvstores",
"id": 1,
"params": {
"lvs_name": "LVS0"

2
doc/lvol.md
View File

@ -97,7 +97,7 @@ destroy_lvol_store [-h] [-u UUID] [-l LVS_NAME]
using destroy_lvol_bdev rpc call.
optional arguments:
-h, --help show help
get_lvol_stores [-h] [-u UUID] [-l LVS_NAME]
bdev_lvol_get_lvstores [-h] [-u UUID] [-l LVS_NAME]
Display current logical volume store list
optional arguments:
-h, --help show help

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

@ -985,21 +985,21 @@ cleanup:
SPDK_RPC_REGISTER("destroy_lvol_bdev", spdk_rpc_destroy_lvol_bdev, SPDK_RPC_RUNTIME)
struct rpc_get_lvol_stores {
struct rpc_bdev_lvol_get_lvstores {
char *uuid;
char *lvs_name;
};
static void
free_rpc_get_lvol_stores(struct rpc_get_lvol_stores *req)
free_rpc_bdev_lvol_get_lvstores(struct rpc_bdev_lvol_get_lvstores *req)
{
free(req->uuid);
free(req->lvs_name);
}
static const struct spdk_json_object_decoder rpc_get_lvol_stores_decoders[] = {
{"uuid", offsetof(struct rpc_get_lvol_stores, uuid), spdk_json_decode_string, true},
{"lvs_name", offsetof(struct rpc_get_lvol_stores, lvs_name), spdk_json_decode_string, true},
static const struct spdk_json_object_decoder rpc_bdev_lvol_get_lvstores_decoders[] = {
{"uuid", offsetof(struct rpc_bdev_lvol_get_lvstores, uuid), spdk_json_decode_string, true},
{"lvs_name", offsetof(struct rpc_bdev_lvol_get_lvstores, lvs_name), spdk_json_decode_string, true},
};
static void
@ -1035,18 +1035,18 @@ spdk_rpc_dump_lvol_store_info(struct spdk_json_write_ctx *w, struct lvol_store_b
}
static void
spdk_rpc_get_lvol_stores(struct spdk_jsonrpc_request *request,
spdk_rpc_bdev_lvol_get_lvstores(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_get_lvol_stores req = {};
struct rpc_bdev_lvol_get_lvstores req = {};
struct spdk_json_write_ctx *w;
struct lvol_store_bdev *lvs_bdev = NULL;
struct spdk_lvol_store *lvs = NULL;
int rc;
if (params != NULL) {
if (spdk_json_decode_object(params, rpc_get_lvol_stores_decoders,
SPDK_COUNTOF(rpc_get_lvol_stores_decoders),
if (spdk_json_decode_object(params, rpc_bdev_lvol_get_lvstores_decoders,
SPDK_COUNTOF(rpc_bdev_lvol_get_lvstores_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,
@ -1083,7 +1083,8 @@ spdk_rpc_get_lvol_stores(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w);
cleanup:
free_rpc_get_lvol_stores(&req);
free_rpc_bdev_lvol_get_lvstores(&req);
}
SPDK_RPC_REGISTER("get_lvol_stores", spdk_rpc_get_lvol_stores, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER("bdev_lvol_get_lvstores", spdk_rpc_bdev_lvol_get_lvstores, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_lvol_get_lvstores, get_lvol_stores)

9
scripts/rpc.py
View File

@ -1267,15 +1267,16 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.add_argument('-l', '--lvs-name', help='lvol store name', required=False)
p.set_defaults(func=destroy_lvol_store)
def get_lvol_stores(args):
print_dict(rpc.lvol.get_lvol_stores(args.client,
def bdev_lvol_get_lvstores(args):
print_dict(rpc.lvol.bdev_lvol_get_lvstores(args.client,
uuid=args.uuid,
lvs_name=args.lvs_name))
p = subparsers.add_parser('get_lvol_stores', help='Display current logical volume store list')
p = subparsers.add_parser('bdev_lvol_get_lvstores', aliases=['get_lvol_stores'],
help='Display current logical volume store list')
p.add_argument('-u', '--uuid', help='lvol store UUID', required=False)
p.add_argument('-l', '--lvs-name', help='lvol store name', required=False)
p.set_defaults(func=get_lvol_stores)
p.set_defaults(func=bdev_lvol_get_lvstores)
def get_raid_bdevs(args):
print_array(rpc.bdev.get_raid_bdevs(args.client,

5
scripts/rpc/lvol.py
View File

@ -197,7 +197,8 @@ def destroy_lvol_store(client, uuid=None, lvs_name=None):
return client.call('destroy_lvol_store', params)
def get_lvol_stores(client, uuid=None, lvs_name=None):
@deprecated_alias('get_lvol_stores')
def bdev_lvol_get_lvstores(client, uuid=None, lvs_name=None):
"""List logical volume stores.
Args:
@ -214,4 +215,4 @@ def get_lvol_stores(client, uuid=None, lvs_name=None):
params['uuid'] = uuid
if lvs_name:
params['lvs_name'] = lvs_name
return client.call('get_lvol_stores', params)
return client.call('bdev_lvol_get_lvstores', params)

2
scripts/spdkcli/ui_node.py
View File

@ -85,7 +85,7 @@ class UILvolStores(UINode):
def refresh(self):
self._children = set([])
for lvs in self.get_root().get_lvol_stores():
for lvs in self.get_root().bdev_lvol_get_lvstores():
UILvsObj(lvs, self)
def delete(self, name, uuid):

4
scripts/spdkcli/ui_root.py
View File

@ -190,9 +190,9 @@ class UIRoot(UINode):
@verbose
@is_method_available
def get_lvol_stores(self):
def bdev_lvol_get_lvstores(self):
if self.is_init:
self.current_lvol_stores = rpc.lvol.get_lvol_stores(self.client)
self.current_lvol_stores = rpc.lvol.bdev_lvol_get_lvstores(self.client)
for lvs in self.current_lvol_stores:
yield LvolStore(lvs)

2
test/common/autotest_common.sh
View File

@ -778,7 +778,7 @@ function fio_nvme()
function get_lvs_free_mb()
{
local lvs_uuid=$1
local lvs_info=$($rpc_py get_lvol_stores)
local lvs_info=$($rpc_py bdev_lvol_get_lvstores)
local fc=$(jq ".[] | select(.uuid==\"$lvs_uuid\") .free_clusters" <<< "$lvs_info")
local cs=$(jq ".[] | select(.uuid==\"$lvs_uuid\") .cluster_size" <<< "$lvs_info")

22
test/lvol/rpc_commands_lib.py
View File

@ -62,9 +62,9 @@ class Commands_Rpc(object):
json_value=json_value))
return 1
def check_get_lvol_stores(self, base_name, uuid, cluster_size=None, lvs_name=""):
print("INFO: RPC COMMAND get_lvol_stores")
json_value = self.get_lvol_stores()
def check_bdev_lvol_get_lvstores(self, base_name, uuid, cluster_size=None, lvs_name=""):
print("INFO: RPC COMMAND bdev_lvol_get_lvstores")
json_value = self.bdev_lvol_get_lvstores()
if json_value:
for i in range(len(json_value)):
json_uuid = json_value[i]['uuid']
@ -75,14 +75,14 @@ class Commands_Rpc(object):
if base_name in json_base_name \
and uuid in json_uuid:
print("INFO: base_name:{base_name} is found in RPC "
"Command: get_lvol_stores "
"Command: bdev_lvol_get_lvstores "
"response".format(base_name=base_name))
print("INFO: UUID:{uuid} is found in RPC Command: "
"get_lvol_stores response".format(uuid=uuid))
"bdev_lvol_get_lvstores response".format(uuid=uuid))
if cluster_size:
if str(cluster_size) in str(json_cluster):
print("Info: Cluster size :{cluster_size} is found in RPC "
"Command: get_lvol_stores "
"Command: bdev_lvol_get_lvstores "
"response".format(cluster_size=cluster_size))
else:
print("ERROR: Wrong cluster size in lvol store")
@ -99,7 +99,7 @@ class Commands_Rpc(object):
return 1
return 0
print("FAILED: UUID: lvol store {uuid} on base_bdev: "
"{base_name} not found in get_lvol_stores()".format(uuid=uuid,
"{base_name} not found in bdev_lvol_get_lvstores()".format(uuid=uuid,
base_name=base_name))
return 1
else:
@ -179,12 +179,12 @@ class Commands_Rpc(object):
output, rc = self.rpc.stop_nbd_disk(nbd_name)
return rc
def get_lvol_stores(self, name=None):
print("INFO: RPC COMMAND get_lvol_stores")
def bdev_lvol_get_lvstores(self, name=None):
print("INFO: RPC COMMAND bdev_lvol_get_lvstores")
if name:
output = json.loads(self.rpc.get_lvol_stores("-l", name)[0])
output = json.loads(self.rpc.bdev_lvol_get_lvstores("-l", name)[0])
else:
output = json.loads(self.rpc.get_lvol_stores()[0])
output = json.loads(self.rpc.bdev_lvol_get_lvstores()[0])
return output
def get_lvol_bdevs(self):

290
test/lvol/test_cases.py
View File

@ -300,18 +300,18 @@ class TestCases(object):
return 0
def get_lvs_size(self, lvs_name="lvs_test"):
lvs = self.c.get_lvol_stores(lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(lvs_name)[0]
return int(int(lvs['free_clusters'] * lvs['cluster_size']) / MEGABYTE)
def get_lvs_divided_size(self, split_num, lvs_name="lvs_test"):
# Actual size of lvol bdevs on creation is rounded up to multiple of cluster size.
# In order to avoid over provisioning, this function returns
# lvol store size in MB divided by split_num - rounded down to multiple of cluster size."
lvs = self.c.get_lvol_stores(lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(lvs_name)[0]
return int(int(lvs['free_clusters'] / split_num) * lvs['cluster_size'] / MEGABYTE)
def get_lvs_cluster_size(self, lvs_name="lvs_test"):
lvs = self.c.get_lvol_stores(lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(lvs_name)[0]
return int(int(lvs['cluster_size']) / MEGABYTE)
# positive tests
@ -329,17 +329,17 @@ class TestCases(object):
# Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
self.c.destroy_lvol_store(uuid_store)
self.c.delete_malloc_bdev(base_name)
if self.c.check_get_lvol_stores("", "", "") == 1:
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
# Expected result
# - call successful, return code = 0, uuid printed to stdout
# - get_lvol_stores: backend used for construct_lvol_store has uuid
# - bdev_lvol_get_lvstores: backend used for construct_lvol_store has uuid
# field set with the same uuid as returned from RPC call
# - no other operation fails
return fail_count
@ -358,8 +358,8 @@ class TestCases(object):
# Create lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs_size = self.get_lvs_size()
@ -397,7 +397,7 @@ class TestCases(object):
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Verify lvol store was created correctly
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(4)
@ -440,8 +440,8 @@ class TestCases(object):
# Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs_size = self.get_lvs_size()
# Create logical volume on lvol store by using a friendly name
@ -482,9 +482,9 @@ class TestCases(object):
uuid_store_2 = self.c.construct_lvol_store(base_name_2,
self.lvs_name + "2")
# Verify stores were created correctly
fail_count = self.c.check_get_lvol_stores(base_name_1, uuid_store_1,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name_1, uuid_store_1,
self.cluster_size)
fail_count = self.c.check_get_lvol_stores(base_name_2, uuid_store_2,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name_2, uuid_store_2,
self.cluster_size)
lvs_size = self.get_lvs_size(self.lvs_name + "1")
@ -548,8 +548,8 @@ class TestCases(object):
# Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response from get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# 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,
self.cluster_size)
lvs_size = self.get_lvs_size()
# Construct lvol bdev on correct lvs_uuid
@ -592,8 +592,8 @@ class TestCases(object):
# Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Using get_lvol_stores verify that logical volume store was correctly created
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# 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,
self.cluster_size)
size = self.get_lvs_size()
# Construct logical volume on lvol store and verify it was correctly created
@ -635,8 +635,8 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Construct lvol bdev on correct lvs_uuid and
# size is equal to one quarter of size malloc bdev
@ -708,8 +708,8 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Construct_lvol_bdev on correct lvs_uuid and
# size is equal one quarter of size malloc bdev
@ -749,19 +749,19 @@ class TestCases(object):
# Create lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Destroy lvol store
self.c.destroy_lvol_store(uuid_store)
# Check correct response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check correct response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -780,19 +780,19 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(self.lvs_name)
# Check correct response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check correct response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -811,8 +811,8 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Construct lvol bdev on correct lvs_uuid
# and size is equal to size malloc bdev
@ -826,14 +826,14 @@ class TestCases(object):
if self.c.destroy_lvol_store(uuid_store) != 0:
fail_count += 1
# Check correct response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check correct response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
self.c.delete_malloc_bdev(base_name)
# Expected result:
# - calls successful, return code = 0
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -853,8 +853,8 @@ class TestCases(object):
# Construct lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(4)
# Construct four lvol bdevs on correct lvs_uuid and
@ -867,8 +867,8 @@ class TestCases(object):
# Destroy lvol store
self.c.destroy_lvol_store(uuid_store)
# Check correct response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check correct response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
self.c.delete_malloc_bdev(base_name)
@ -893,8 +893,8 @@ class TestCases(object):
# Construct lvol store on create malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
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
@ -936,7 +936,7 @@ class TestCases(object):
# Destroy lvol store
self.c.destroy_lvol_store(uuid_store)
if self.c.check_get_lvol_stores("", "", "") == 1:
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
self.c.delete_malloc_bdev(base_name)
@ -944,7 +944,7 @@ class TestCases(object):
# - lvol bdev should change size after resize operations
# - calls successful, return code = 0
# - no other operation fails
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
return fail_count
@case_message
@ -962,7 +962,7 @@ class TestCases(object):
# Create lvol store on created aio bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Destroy lvol store
if self.c.destroy_lvol_store(self.lvs_name) != 0:
@ -976,14 +976,14 @@ class TestCases(object):
sleep(1)
# check if destroyed lvol store does not exist on aio bdev
ret_value = self.c.check_get_lvol_stores(base_name, uuid_store,
ret_value = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
if ret_value == 0:
fail_count += 1
self.c.bdev_aio_delete(base_name)
# Expected result:
# - get_lvol_stores should not report any existsing lvol stores in configuration
# - bdev_lvol_get_lvstores should not report any existsing lvol stores in configuration
# after deleting and adding NVMe bdev
# - no other operation fails
return fail_count
@ -1020,8 +1020,8 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Delete malloc bdev
@ -1072,8 +1072,8 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Try construct_lvol_store on the same bdev as in last step
# This call should fail as base bdev is already claimed by lvol store
@ -1102,9 +1102,9 @@ class TestCases(object):
# Construct lvol store on first malloc
uuid_store_1 = self.c.construct_lvol_store(base_name_1,
self.lvs_name)
# using get_lvol_stores 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)
fail_count += self.c.check_get_lvol_stores(base_name_1,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name_1,
uuid_store_1,
self.cluster_size)
# Try to create another logical volume store on second malloc bdev using the
@ -1134,8 +1134,8 @@ class TestCases(object):
# Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Construct lvol bdev
size = self.get_lvs_size()
@ -1145,8 +1145,8 @@ class TestCases(object):
nested_lvs_name = self.lvs_name + "_nested"
nested_lvs_uuid = self.c.construct_lvol_store(uuid_bdev,
nested_lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count += self.c.check_get_lvol_stores(uuid_bdev, nested_lvs_uuid,
# 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,
self.cluster_size)
# Construct nested lvol bdev on previously created nested lvol store
# with size equal to size of nested lvol store
@ -1184,17 +1184,17 @@ class TestCases(object):
# Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Delete malloc bdev
self.c.delete_malloc_bdev(base_name)
# Check response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
# Expected result:
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -1218,10 +1218,10 @@ class TestCases(object):
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()
lvs = self.c.bdev_lvol_get_lvstores()
size = int(int(lvs[0]['free_clusters'] * lvs[0]['cluster_size']) / 4 / MEGABYTE)
# Construct thin provisioned lvol bdev
@ -1251,14 +1251,14 @@ class TestCases(object):
# Destroy lvol store
fail_count += self.c.destroy_lvol_store(uuid_store)
# Check response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
# Delete malloc bdev
self.c.delete_malloc_bdev(base_name)
# Expected result:
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -1283,10 +1283,10 @@ class TestCases(object):
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()
lvs = self.c.bdev_lvol_get_lvstores()
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
@ -1311,14 +1311,14 @@ class TestCases(object):
# Destroy lvol store without deleting lvol bdevs
fail_count += self.c.destroy_lvol_store(uuid_store)
# Check response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
# Delete malloc bdev
self.c.delete_malloc_bdev(base_name)
# Expected result:
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -1344,10 +1344,10 @@ class TestCases(object):
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name,
self.cluster_size)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()
lvs = self.c.bdev_lvol_get_lvstores()
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
@ -1366,12 +1366,12 @@ class TestCases(object):
# Delete malloc bdev
self.c.delete_malloc_bdev(base_name)
# Check response get_lvol_stores command
if self.c.check_get_lvol_stores("", "", "") == 1:
# Check response bdev_lvol_get_lvstores command
if self.c.check_bdev_lvol_get_lvstores("", "", "") == 1:
fail_count += 1
# Expected result:
# - get_lvol_stores: response should be of no value after destroyed lvol store
# - bdev_lvol_get_lvstores: response should be of no value after destroyed lvol store
# - no other operation fails
return fail_count
@ -1392,7 +1392,7 @@ class TestCases(object):
lvol_uuid = self.c.construct_lvol_store(base_name,
self.lvs_name,
(self.total_size * 1024 * 1024) + 1) == 0
if self.c.check_get_lvol_stores(base_name, lvol_uuid) == 0:
if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0:
fail_count += 1
fail_count += self.c.delete_malloc_bdev(base_name)
@ -1416,7 +1416,7 @@ class TestCases(object):
# Try construct lvol store on malloc bdev with cluster size 8191
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, 8191)
# Verify that lvol store was not created
if self.c.check_get_lvol_stores(base_name, lvol_uuid) == 0:
if self.c.check_bdev_lvol_get_lvstores(base_name, lvol_uuid) == 0:
fail_count += 1
fail_count += self.c.delete_malloc_bdev(base_name)
@ -1438,7 +1438,7 @@ class TestCases(object):
self.block_size)
# Construct lvol store with clear method 'none'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="none")
fail_count += self.c.check_get_lvol_stores(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)
# Create malloc bdev
@ -1446,7 +1446,7 @@ class TestCases(object):
self.block_size)
# Construct lvol store with clear method 'unmap'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="unmap")
fail_count += self.c.check_get_lvol_stores(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)
# Create malloc bdev
@ -1454,7 +1454,7 @@ class TestCases(object):
self.block_size)
# Construct lvol store with clear method 'write_zeroes'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="write_zeroes")
fail_count += self.c.check_get_lvol_stores(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)
# Expected result:
@ -1476,15 +1476,15 @@ class TestCases(object):
# create lvol store on mamloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
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)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
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
if free_clusters_start != free_clusters_create_lvol:
@ -1496,7 +1496,7 @@ class TestCases(object):
size = int(lvs['cluster_size'])
# write data (lvs cluster size) to created lvol bdev starting from offset 0.
fail_count += self.run_fio_test("/dev/nbd0", 0, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_first_fio = int(lvs['free_clusters'])
# check that free clusters on lvol store was decremented by 1
if free_clusters_start != free_clusters_first_fio + 1:
@ -1508,7 +1508,7 @@ class TestCases(object):
free_clusters_create_lvol) * 1.5)
# write data (lvs cluster size) to lvol bdev with offset set to one and half of cluster size
fail_count += self.run_fio_test(nbd_name, offset, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_second_fio = int(lvs['free_clusters'])
# check that free clusters on lvol store was decremented by 2
if free_clusters_start != free_clusters_second_fio + 3:
@ -1519,7 +1519,7 @@ class TestCases(object):
free_clusters_create_lvol * 3)
# write data to lvol bdev to the end of its size
fail_count += self.run_fio_test(nbd_name, offset, size, "write", "0xcc")
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_third_fio = int(lvs['free_clusters'])
# check that lvol store free clusters number equals to 0
if free_clusters_third_fio != 0:
@ -1528,7 +1528,7 @@ class TestCases(object):
fail_count += self.c.stop_nbd_disk(nbd_name)
# destroy thin provisioned lvol bdev
fail_count += self.c.destroy_lvol_bdev(lvol_bdev['name'])
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_end = int(lvs['free_clusters'])
# check that saved number of free clusters equals to current free clusters
if free_clusters_start != free_clusters_end:
@ -1556,9 +1556,9 @@ class TestCases(object):
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
lbd_name0 = self.lbd_name + str("0")
lbd_name1 = self.lbd_name + str("1")
@ -1614,9 +1614,9 @@ class TestCases(object):
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
bdev_size = self.get_lvs_size()
# construct thin provisioned lvol bdev with size equal to lvol store
@ -1655,7 +1655,7 @@ class TestCases(object):
self.block_size)
# Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Construct thin provisioned lvol bdevs on created lvol store
# with size equal to 50% of lvol store
@ -1669,7 +1669,7 @@ class TestCases(object):
fail_count += self.run_fio_test(nbd_name, 0, size*MEGABYTE, "write", "0xcc", 0)
fail_count += self.c.stop_nbd_disk(nbd_name)
# Save number of free clusters for lvs
lvs = self.c.get_lvol_stores()[0]
lvs = self.c.bdev_lvol_get_lvstores()[0]
free_clusters_start = int(lvs['free_clusters'])
# Resize bdev to full size of lvs
full_size = int(lvs['total_data_clusters'] * lvs['cluster_size'] / MEGABYTE)
@ -1681,7 +1681,7 @@ class TestCases(object):
if full_size != lbd_size:
fail_count += 1
# Check if free_clusters on lvs remain unaffected
lvs = self.c.get_lvol_stores()[0]
lvs = self.c.bdev_lvol_get_lvstores()[0]
free_clusters_resize = int(lvs['free_clusters'])
if free_clusters_start != free_clusters_resize:
fail_count += 1
@ -1693,14 +1693,14 @@ class TestCases(object):
int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0)
fail_count += self.c.stop_nbd_disk(nbd_name)
# Check if free clusters on lvs equals to zero
lvs = self.c.get_lvol_stores()[0]
lvs = self.c.bdev_lvol_get_lvstores()[0]
if int(lvs['free_clusters']) != 0:
fail_count += 1
# Resize bdev to 25% of lvs and check if it ended with success
size = self.get_lvs_divided_size(4)
fail_count += self.c.resize_lvol_bdev(uuid_bdev, size)
# Check free clusters on lvs
lvs = self.c.get_lvol_stores()[0]
lvs = self.c.bdev_lvol_get_lvstores()[0]
free_clusters_resize2 = int(lvs['free_clusters'])
free_clusters_expected = int((full_size - size) * MEGABYTE / lvs['cluster_size'])
if free_clusters_expected != free_clusters_resize2:
@ -1729,9 +1729,9 @@ class TestCases(object):
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
lbd_name0 = self.lbd_name + str("0")
lbd_name1 = self.lbd_name + str("1")
@ -1743,7 +1743,7 @@ class TestCases(object):
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1,
bdev_size, thin=True)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_create_lvol = int(lvs['free_clusters'])
if free_clusters_start != free_clusters_create_lvol:
fail_count += 1
@ -1800,9 +1800,9 @@ class TestCases(object):
self.block_size)
# construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores(self.lvs_name)[0]
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
free_clusters_start = int(lvs['free_clusters'])
lbd_name0 = self.lbd_name + str("0")
lbd_name1 = self.lbd_name + str("1")
@ -1871,7 +1871,7 @@ class TestCases(object):
# save info of all lvs and lvol bdevs
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
uuid_store,
self.cluster_size)
@ -1886,7 +1886,7 @@ class TestCases(object):
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size)
old_bdevs = sorted(self.c.get_lvol_bdevs(), key=lambda x: x["name"])
old_stores = self.c.get_lvol_stores()
old_stores = self.c.bdev_lvol_get_lvstores()
# Shut down vhost instance and restart with new instance
fail_count += self._stop_vhost(pid_path)
@ -1899,7 +1899,7 @@ class TestCases(object):
# Check if configuration was properly loaded after tasting
# get all info all lvs and lvol bdevs, compare with previous info
new_bdevs = sorted(self.c.get_lvol_bdevs(), key=lambda x: x["name"])
new_stores = self.c.get_lvol_stores()
new_stores = self.c.bdev_lvol_get_lvstores()
if old_stores != new_stores:
fail_count += 1
@ -1945,7 +1945,7 @@ class TestCases(object):
# verify all configuration call results
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
uuid_store,
self.cluster_size)
@ -1979,7 +1979,7 @@ class TestCases(object):
# construct lvol store on aio bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
self.c.bdev_aio_delete(base_name)
@ -1987,7 +1987,7 @@ class TestCases(object):
# wait 1 second to allow time for lvolstore tasting
sleep(1)
# check if lvol store still exists in vhost configuration
if self.c.check_get_lvol_stores(base_name, uuid_store,
if self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) != 0:
fail_count += 1
# destroy lvol store from aio bdev
@ -2031,7 +2031,7 @@ class TestCases(object):
self.lvs_name + "_1M",
cluster_size_1M)
fail_count += self.c.check_get_lvol_stores(base_name_1M,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name_1M,
uuid_store_1M,
cluster_size_1M)
@ -2039,7 +2039,7 @@ class TestCases(object):
self.lvs_name + "_32M",
cluster_size_32M)
fail_count += self.c.check_get_lvol_stores(base_name_32M,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name_32M,
uuid_store_32M,
cluster_size_32M)
@ -2064,7 +2064,7 @@ class TestCases(object):
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size_32M)
old_bdevs = sorted(self.c.get_lvol_bdevs(), key=lambda x: x["name"])
old_stores = sorted(self.c.get_lvol_stores(), key=lambda x: x["name"])
old_stores = sorted(self.c.bdev_lvol_get_lvstores(), key=lambda x: x["name"])
# Shut down vhost instance and restart with new instance
fail_count += self._stop_vhost(pid_path)
@ -2082,7 +2082,7 @@ class TestCases(object):
# Check if configuration was properly loaded after tasting
# get all info all lvs and lvol bdevs, compare with previous info
new_bdevs = sorted(self.c.get_lvol_bdevs(), key=lambda x: x["name"])
new_stores = sorted(self.c.get_lvol_stores(), key=lambda x: x["name"])
new_stores = sorted(self.c.bdev_lvol_get_lvstores(), key=lambda x: x["name"])
if old_stores != new_stores:
fail_count += 1
@ -2137,10 +2137,10 @@ class TestCases(object):
# Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()[0]
lvs = self.c.bdev_lvol_get_lvstores()[0]
free_clusters_start = int(lvs['free_clusters'])
bdev_size = self.get_lvs_divided_size(3)
# Create lvol bdev with 33% of lvol store space
@ -2191,7 +2191,7 @@ class TestCases(object):
# Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(6)
lbd_name0 = self.lbd_name + str(0)
@ -2266,7 +2266,7 @@ class TestCases(object):
# Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Create thin provisioned lvol bdev with size equal to 50% of lvs space
size = self.get_lvs_divided_size(2)
@ -2321,7 +2321,7 @@ class TestCases(object):
# Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Create thick provisioned lvol bdev
size = self.get_lvs_divided_size(2)
@ -2368,9 +2368,9 @@ class TestCases(object):
# Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()
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,
@ -2431,7 +2431,7 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(6)
lbd_name0 = self.lbd_name + str(0)
@ -2504,7 +2504,7 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(6)
@ -2594,7 +2594,7 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(4)
@ -2685,7 +2685,7 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
size = self.get_lvs_divided_size(4)
@ -2756,9 +2756,9 @@ class TestCases(object):
# Create lvol store
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
lvs = self.c.get_lvol_stores()
lvs = self.c.bdev_lvol_get_lvstores()
size = int(5 * lvs[0]['cluster_size'] / MEGABYTE)
# Construct thin provisioned lvol bdev
@ -2855,11 +2855,11 @@ class TestCases(object):
# Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Create lvol bdev with 50% of lvol store space
lvs = self.c.get_lvol_stores()[0]
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,
@ -2919,11 +2919,11 @@ class TestCases(object):
# Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Create lvol bdev with 50% of lvol store space
lvs = self.c.get_lvol_stores()[0]
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)
@ -2999,11 +2999,11 @@ class TestCases(object):
# Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name, uuid_store,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Create lvol bdev with one third of lvol store space
lvs = self.c.get_lvol_stores()[0]
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)
@ -3120,7 +3120,7 @@ class TestCases(object):
# Construct lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_name,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
lvs_uuid,
self.cluster_size,
self.lvs_name)
@ -3142,7 +3142,7 @@ class TestCases(object):
fail_count += self.c.rename_lvol_store(self.lvs_name, new_lvs_name)
fail_count += self.c.check_get_lvol_stores(base_name,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_name,
lvs_uuid,
self.cluster_size,
new_lvs_name)
@ -3235,13 +3235,13 @@ class TestCases(object):
# Create lvol store on each malloc bdev
lvs_uuid_1 = self.c.construct_lvol_store(base_bdev_1,
lvs_name_1)
fail_count += self.c.check_get_lvol_stores(base_bdev_1,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_1,
lvs_uuid_1,
self.cluster_size,
lvs_name_1)
lvs_uuid_2 = self.c.construct_lvol_store(base_bdev_2,
lvs_name_2)
fail_count += self.c.check_get_lvol_stores(base_bdev_2,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_2,
lvs_uuid_2,
self.cluster_size,
lvs_name_2)
@ -3272,11 +3272,11 @@ class TestCases(object):
fail_count += 1
# Verify that names of lvol stores and lvol bdevs did not change
fail_count += self.c.check_get_lvol_stores(base_bdev_1,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_1,
lvs_uuid_1,
self.cluster_size,
lvs_name_1)
fail_count += self.c.check_get_lvol_stores(base_bdev_2,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev_2,
lvs_uuid_2,
self.cluster_size,
lvs_name_2)
@ -3341,7 +3341,7 @@ class TestCases(object):
# Create lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_bdev,
self.lvs_name)
fail_count += self.c.check_get_lvol_stores(base_bdev,
fail_count += self.c.check_bdev_lvol_get_lvstores(base_bdev,
lvs_uuid,
self.cluster_size,
self.lvs_name)
@ -3392,8 +3392,8 @@ class TestCases(object):
# Construct lvol store on created malloc bddev
uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name)
# Check correct uuid values in response get_lvol_stores command
fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,
# Check correct uuid values in response bdev_lvol_get_lvstores command
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size)
# Send SIGTERM signal to the application

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

@ -171,7 +171,7 @@ done
bdev_info=$($rpc_py get_bdevs)
notice "Configuration after initial set-up:"
$rpc_py get_lvol_stores
$rpc_py bdev_lvol_get_lvstores
echo "$bdev_info"
# Set up VMs
@ -277,7 +277,7 @@ fi
clean_lvol_cfg
$rpc_py get_lvol_stores
$rpc_py bdev_lvol_get_lvstores
$rpc_py get_bdevs
$rpc_py get_vhost_controllers