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 `Malloc2` bdev. In response user will be provided with uuid which is unique lvol store
identifier. 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). parameters available).
Example response Example response

6
doc/jsonrpc.md
View File

@ -299,7 +299,7 @@ Example response:
"bdev_malloc_create", "bdev_malloc_create",
"delete_ftl_bdev", "delete_ftl_bdev",
"construct_ftl_bdev", "construct_ftl_bdev",
"get_lvol_stores", "bdev_lvol_get_lvstores",
"destroy_lvol_bdev", "destroy_lvol_bdev",
"resize_lvol_bdev", "resize_lvol_bdev",
"set_read_only_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. Get a list of logical volume stores.
@ -4873,7 +4873,7 @@ Example request:
~~~ ~~~
{ {
"jsonrpc": "2.0", "jsonrpc": "2.0",
"method": "get_lvol_stores", "method": "bdev_lvol_get_lvstores",
"id": 1, "id": 1,
"params": { "params": {
"lvs_name": "LVS0" "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. using destroy_lvol_bdev rpc call.
optional arguments: optional arguments:
-h, --help show help -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 Display current logical volume store list
optional arguments: optional arguments:
-h, --help show help -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) 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 *uuid;
char *lvs_name; char *lvs_name;
}; };
static void 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->uuid);
free(req->lvs_name); free(req->lvs_name);
} }
static const struct spdk_json_object_decoder rpc_get_lvol_stores_decoders[] = { static const struct spdk_json_object_decoder rpc_bdev_lvol_get_lvstores_decoders[] = {
{"uuid", offsetof(struct rpc_get_lvol_stores, uuid), spdk_json_decode_string, true}, {"uuid", offsetof(struct rpc_bdev_lvol_get_lvstores, uuid), spdk_json_decode_string, true},
{"lvs_name", offsetof(struct rpc_get_lvol_stores, lvs_name), spdk_json_decode_string, true}, {"lvs_name", offsetof(struct rpc_bdev_lvol_get_lvstores, lvs_name), spdk_json_decode_string, true},
}; };
static void static void
@ -1035,18 +1035,18 @@ spdk_rpc_dump_lvol_store_info(struct spdk_json_write_ctx *w, struct lvol_store_b
} }
static void 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) 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 spdk_json_write_ctx *w;
struct lvol_store_bdev *lvs_bdev = NULL; struct lvol_store_bdev *lvs_bdev = NULL;
struct spdk_lvol_store *lvs = NULL; struct spdk_lvol_store *lvs = NULL;
int rc; int rc;
if (params != NULL) { if (params != NULL) {
if (spdk_json_decode_object(params, rpc_get_lvol_stores_decoders, if (spdk_json_decode_object(params, rpc_bdev_lvol_get_lvstores_decoders,
SPDK_COUNTOF(rpc_get_lvol_stores_decoders), SPDK_COUNTOF(rpc_bdev_lvol_get_lvstores_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,
@ -1083,7 +1083,8 @@ spdk_rpc_get_lvol_stores(struct spdk_jsonrpc_request *request,
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
cleanup: 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.add_argument('-l', '--lvs-name', help='lvol store name', required=False)
p.set_defaults(func=destroy_lvol_store) p.set_defaults(func=destroy_lvol_store)
def get_lvol_stores(args): def bdev_lvol_get_lvstores(args):
print_dict(rpc.lvol.get_lvol_stores(args.client, print_dict(rpc.lvol.bdev_lvol_get_lvstores(args.client,
uuid=args.uuid, uuid=args.uuid,
lvs_name=args.lvs_name)) 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('-u', '--uuid', help='lvol store UUID', required=False)
p.add_argument('-l', '--lvs-name', help='lvol store name', 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): def get_raid_bdevs(args):
print_array(rpc.bdev.get_raid_bdevs(args.client, 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) 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. """List logical volume stores.
Args: Args:
@ -214,4 +215,4 @@ def get_lvol_stores(client, uuid=None, lvs_name=None):
params['uuid'] = uuid params['uuid'] = uuid
if lvs_name: if lvs_name:
params['lvs_name'] = 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): def refresh(self):
self._children = set([]) 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) UILvsObj(lvs, self)
def delete(self, name, uuid): def delete(self, name, uuid):

4
scripts/spdkcli/ui_root.py
View File

@ -190,9 +190,9 @@ class UIRoot(UINode):
@verbose @verbose
@is_method_available @is_method_available
def get_lvol_stores(self): def bdev_lvol_get_lvstores(self):
if self.is_init: 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: for lvs in self.current_lvol_stores:
yield LvolStore(lvs) yield LvolStore(lvs)

2
test/common/autotest_common.sh
View File

@ -778,7 +778,7 @@ function fio_nvme()
function get_lvs_free_mb() function get_lvs_free_mb()
{ {
local lvs_uuid=$1 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 fc=$(jq ".[] | select(.uuid==\"$lvs_uuid\") .free_clusters" <<< "$lvs_info")
local cs=$(jq ".[] | select(.uuid==\"$lvs_uuid\") .cluster_size" <<< "$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)) json_value=json_value))
return 1 return 1
def check_get_lvol_stores(self, base_name, uuid, cluster_size=None, lvs_name=""): def check_bdev_lvol_get_lvstores(self, base_name, uuid, cluster_size=None, lvs_name=""):
print("INFO: RPC COMMAND get_lvol_stores") print("INFO: RPC COMMAND bdev_lvol_get_lvstores")
json_value = self.get_lvol_stores() json_value = self.bdev_lvol_get_lvstores()
if json_value: if json_value:
for i in range(len(json_value)): for i in range(len(json_value)):
json_uuid = json_value[i]['uuid'] json_uuid = json_value[i]['uuid']
@ -75,14 +75,14 @@ class Commands_Rpc(object):
if base_name in json_base_name \ if base_name in json_base_name \
and uuid in json_uuid: and uuid in json_uuid:
print("INFO: base_name:{base_name} is found in RPC " 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)) "response".format(base_name=base_name))
print("INFO: UUID:{uuid} is found in RPC Command: " 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 cluster_size:
if str(cluster_size) in str(json_cluster): if str(cluster_size) in str(json_cluster):
print("Info: Cluster size :{cluster_size} is found in RPC " 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)) "response".format(cluster_size=cluster_size))
else: else:
print("ERROR: Wrong cluster size in lvol store") print("ERROR: Wrong cluster size in lvol store")
@ -99,7 +99,7 @@ class Commands_Rpc(object):
return 1 return 1
return 0 return 0
print("FAILED: UUID: lvol store {uuid} on base_bdev: " 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)) base_name=base_name))
return 1 return 1
else: else:
@ -179,12 +179,12 @@ class Commands_Rpc(object):
output, rc = self.rpc.stop_nbd_disk(nbd_name) output, rc = self.rpc.stop_nbd_disk(nbd_name)
return rc return rc
def get_lvol_stores(self, name=None): def bdev_lvol_get_lvstores(self, name=None):
print("INFO: RPC COMMAND get_lvol_stores") print("INFO: RPC COMMAND bdev_lvol_get_lvstores")
if name: 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: else:
output = json.loads(self.rpc.get_lvol_stores()[0]) output = json.loads(self.rpc.bdev_lvol_get_lvstores()[0])
return output return output
def get_lvol_bdevs(self): def get_lvol_bdevs(self):

290
test/lvol/test_cases.py
View File

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