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

RPC: rename rpc construct_lvol_bdev to bdev_lvol_create

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

6
doc/bdev.md
View File

@ -460,14 +460,14 @@ Example commands
## Lvols {#bdev_ug_lvols} ## Lvols {#bdev_ug_lvols}
To create lvols on existing lvol store user should use `construct_lvol_bdev` RPC command. To create lvols on existing lvol store user should use `bdev_lvol_create` RPC command.
Each created lvol will be represented by new bdev. Each created lvol will be represented by new bdev.
Example commands Example commands
`rpc.py construct_lvol_bdev lvol1 25 -l lvs` `rpc.py bdev_lvol_create lvol1 25 -l lvs`
`rpc.py construct_lvol_bdev lvol2 25 -u 330a6ab2-f468-11e7-983e-001e67edf35d` `rpc.py bdev_lvol_create lvol2 25 -u 330a6ab2-f468-11e7-983e-001e67edf35d`
# RAID {#bdev_ug_raid} # RAID {#bdev_ug_raid}

6
doc/jsonrpc.md
View File

@ -308,7 +308,7 @@ Example response:
"bdev_lvol_rename", "bdev_lvol_rename",
"bdev_lvol_clone", "bdev_lvol_clone",
"bdev_lvol_snapshot", "bdev_lvol_snapshot",
"construct_lvol_bdev", "bdev_lvol_create",
"destroy_lvol_store", "destroy_lvol_store",
"rename_lvol_store", "rename_lvol_store",
"construct_lvol_store" "construct_lvol_store"
@ -4938,7 +4938,7 @@ Example response:
} }
~~~ ~~~
## construct_lvol_bdev {#rpc_construct_lvol_bdev} ## bdev_lvol_create {#rpc_bdev_lvol_create}
Create a logical volume on a logical volume store. Create a logical volume on a logical volume store.
@ -4967,7 +4967,7 @@ Example request:
~~~ ~~~
{ {
"jsonrpc": "2.0", "jsonrpc": "2.0",
"method": "construct_lvol_bdev", "method": "bdev_lvol_create",
"id": 1, "id": 1,
"params": { "params": {
"lvol_name": "LVOL0", "lvol_name": "LVOL0",

4
doc/lvol.md
View File

@ -112,7 +112,7 @@ rename_lvol_store [-h] old_name new_name
RPC regarding lvol and spdk bdev: RPC regarding lvol and spdk bdev:
``` ```
construct_lvol_bdev [-h] [-u UUID] [-l LVS_NAME] [-t] [-c CLEAR_METHOD] lvol_name size bdev_lvol_create [-h] [-u UUID] [-l LVS_NAME] [-t] [-c CLEAR_METHOD] lvol_name size
Creates lvol with specified size and name on lvolstore specified by its uuid Creates lvol with specified size and name on lvolstore specified by its uuid
or name. Then constructs spdk bdev on top of that lvol and presents it as spdk bdev. or name. Then constructs spdk bdev on top of that lvol and presents it as spdk bdev.
User may use -t switch to create thin provisioned lvol. User may use -t switch to create thin provisioned lvol.
@ -126,7 +126,7 @@ get_bdevs [-h] [-b NAME]
-h, --help show help -h, --help show help
-b NAME, --name NAME Name of the block device. Example: Nvme0n1 -b NAME, --name NAME Name of the block device. Example: Nvme0n1
bdev_lvol_delete [-h] bdev_name bdev_lvol_delete [-h] bdev_name
Deletes a logical volume previously created by construct_lvol_bdev. Deletes a logical volume previously created by bdev_lvol_create.
optional arguments: optional arguments:
-h, --help show help -h, --help show help
bdev_lvol_snapshot [-h] lvol_name snapshot_name bdev_lvol_snapshot [-h] lvol_name snapshot_name

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

@ -304,7 +304,7 @@ cleanup:
} }
SPDK_RPC_REGISTER("destroy_lvol_store", spdk_rpc_destroy_lvol_store, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("destroy_lvol_store", spdk_rpc_destroy_lvol_store, SPDK_RPC_RUNTIME)
struct rpc_construct_lvol_bdev { struct rpc_bdev_lvol_create {
char *uuid; char *uuid;
char *lvs_name; char *lvs_name;
char *lvol_name; char *lvol_name;
@ -314,7 +314,7 @@ struct rpc_construct_lvol_bdev {
}; };
static void static void
free_rpc_construct_lvol_bdev(struct rpc_construct_lvol_bdev *req) free_rpc_bdev_lvol_create(struct rpc_bdev_lvol_create *req)
{ {
free(req->uuid); free(req->uuid);
free(req->lvs_name); free(req->lvs_name);
@ -322,17 +322,17 @@ free_rpc_construct_lvol_bdev(struct rpc_construct_lvol_bdev *req)
free(req->clear_method); free(req->clear_method);
} }
static const struct spdk_json_object_decoder rpc_construct_lvol_bdev_decoders[] = { static const struct spdk_json_object_decoder rpc_bdev_lvol_create_decoders[] = {
{"uuid", offsetof(struct rpc_construct_lvol_bdev, uuid), spdk_json_decode_string, true}, {"uuid", offsetof(struct rpc_bdev_lvol_create, uuid), spdk_json_decode_string, true},
{"lvs_name", offsetof(struct rpc_construct_lvol_bdev, lvs_name), spdk_json_decode_string, true}, {"lvs_name", offsetof(struct rpc_bdev_lvol_create, lvs_name), spdk_json_decode_string, true},
{"lvol_name", offsetof(struct rpc_construct_lvol_bdev, lvol_name), spdk_json_decode_string}, {"lvol_name", offsetof(struct rpc_bdev_lvol_create, lvol_name), spdk_json_decode_string},
{"size", offsetof(struct rpc_construct_lvol_bdev, size), spdk_json_decode_uint64}, {"size", offsetof(struct rpc_bdev_lvol_create, size), spdk_json_decode_uint64},
{"thin_provision", offsetof(struct rpc_construct_lvol_bdev, thin_provision), spdk_json_decode_bool, true}, {"thin_provision", offsetof(struct rpc_bdev_lvol_create, thin_provision), spdk_json_decode_bool, true},
{"clear_method", offsetof(struct rpc_construct_lvol_bdev, clear_method), spdk_json_decode_string, true}, {"clear_method", offsetof(struct rpc_bdev_lvol_create, clear_method), spdk_json_decode_string, true},
}; };
static void static void
_spdk_rpc_construct_lvol_bdev_cb(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno) _spdk_rpc_bdev_lvol_create_cb(void *cb_arg, struct spdk_lvol *lvol, int lvolerrno)
{ {
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
struct spdk_jsonrpc_request *request = cb_arg; struct spdk_jsonrpc_request *request = cb_arg;
@ -352,18 +352,18 @@ invalid:
} }
static void static void
spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request, spdk_rpc_bdev_lvol_create(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_construct_lvol_bdev req = {}; struct rpc_bdev_lvol_create req = {};
enum lvol_clear_method clear_method; enum lvol_clear_method clear_method;
int rc = 0; int rc = 0;
struct spdk_lvol_store *lvs = NULL; struct spdk_lvol_store *lvs = NULL;
SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "Creating blob\n"); SPDK_INFOLOG(SPDK_LOG_LVOL_RPC, "Creating blob\n");
if (spdk_json_decode_object(params, rpc_construct_lvol_bdev_decoders, if (spdk_json_decode_object(params, rpc_bdev_lvol_create_decoders,
SPDK_COUNTOF(rpc_construct_lvol_bdev_decoders), SPDK_COUNTOF(rpc_bdev_lvol_create_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,
@ -393,17 +393,18 @@ spdk_rpc_construct_lvol_bdev(struct spdk_jsonrpc_request *request,
} }
rc = vbdev_lvol_create(lvs, req.lvol_name, req.size, req.thin_provision, rc = vbdev_lvol_create(lvs, req.lvol_name, req.size, req.thin_provision,
clear_method, _spdk_rpc_construct_lvol_bdev_cb, request); clear_method, _spdk_rpc_bdev_lvol_create_cb, request);
if (rc < 0) { if (rc < 0) {
spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc)); spdk_jsonrpc_send_error_response(request, rc, spdk_strerror(-rc));
goto cleanup; goto cleanup;
} }
cleanup: cleanup:
free_rpc_construct_lvol_bdev(&req); free_rpc_bdev_lvol_create(&req);
} }
SPDK_RPC_REGISTER("construct_lvol_bdev", spdk_rpc_construct_lvol_bdev, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("bdev_lvol_create", spdk_rpc_bdev_lvol_create, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_lvol_create, construct_lvol_bdev)
struct rpc_bdev_lvol_snapshot { struct rpc_bdev_lvol_snapshot {
char *lvol_name; char *lvol_name;

9
scripts/rpc.py
View File

@ -1177,8 +1177,8 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.add_argument('new_name', help='new name') p.add_argument('new_name', help='new name')
p.set_defaults(func=rename_lvol_store) p.set_defaults(func=rename_lvol_store)
def construct_lvol_bdev(args): def bdev_lvol_create(args):
print_json(rpc.lvol.construct_lvol_bdev(args.client, print_json(rpc.lvol.bdev_lvol_create(args.client,
lvol_name=args.lvol_name, lvol_name=args.lvol_name,
size=args.size * 1024 * 1024, size=args.size * 1024 * 1024,
thin_provision=args.thin_provision, thin_provision=args.thin_provision,
@ -1186,7 +1186,8 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
uuid=args.uuid, uuid=args.uuid,
lvs_name=args.lvs_name)) lvs_name=args.lvs_name))
p = subparsers.add_parser('construct_lvol_bdev', help='Add a bdev with an logical volume backend') p = subparsers.add_parser('bdev_lvol_create', aliases=['construct_lvol_bdev'],
help='Add a bdev with an logical volume backend')
p.add_argument('-u', '--uuid', help='lvol store UUID', required=False) p.add_argument('-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.add_argument('-t', '--thin-provision', action='store_true', help='create lvol bdev as thin provisioned') p.add_argument('-t', '--thin-provision', action='store_true', help='create lvol bdev as thin provisioned')
@ -1194,7 +1195,7 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
Available: none, unmap, write_zeroes""", required=False) Available: none, unmap, write_zeroes""", required=False)
p.add_argument('lvol_name', help='name for this lvol') p.add_argument('lvol_name', help='name for this lvol')
p.add_argument('size', help='size in MiB for this bdev', type=int) p.add_argument('size', help='size in MiB for this bdev', type=int)
p.set_defaults(func=construct_lvol_bdev) p.set_defaults(func=bdev_lvol_create)
def bdev_lvol_snapshot(args): def bdev_lvol_snapshot(args):
print_json(rpc.lvol.bdev_lvol_snapshot(args.client, print_json(rpc.lvol.bdev_lvol_snapshot(args.client,

5
scripts/rpc/lvol.py
View File

@ -35,7 +35,8 @@ def rename_lvol_store(client, old_name, new_name):
return client.call('rename_lvol_store', params) return client.call('rename_lvol_store', params)
def construct_lvol_bdev(client, lvol_name, size, thin_provision=False, uuid=None, lvs_name=None, clear_method=None): @deprecated_alias('construct_lvol_bdev')
def bdev_lvol_create(client, lvol_name, size, thin_provision=False, uuid=None, lvs_name=None, clear_method=None):
"""Create a logical volume on a logical volume store. """Create a logical volume on a logical volume store.
Args: Args:
@ -62,7 +63,7 @@ def construct_lvol_bdev(client, lvol_name, size, thin_provision=False, uuid=None
params['lvs_name'] = lvs_name params['lvs_name'] = lvs_name
if clear_method: if clear_method:
params['clear_method'] = clear_method params['clear_method'] = clear_method
return client.call('construct_lvol_bdev', params) return client.call('bdev_lvol_create', params)
@deprecated_alias('snapshot_lvol_bdev') @deprecated_alias('snapshot_lvol_bdev')

2
scripts/spdkcli/ui_root.py
View File

@ -154,7 +154,7 @@ class UIRoot(UINode):
@verbose @verbose
def create_lvol_bdev(self, **kwargs): def create_lvol_bdev(self, **kwargs):
response = rpc.lvol.construct_lvol_bdev(self.client, **kwargs) response = rpc.lvol.bdev_lvol_create(self.client, **kwargs)
return response return response
@verbose @verbose

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

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

2
test/compress/compress.sh
View File

@ -25,7 +25,7 @@ waitforlisten $bdev_svc_pid
bdf=$(iter_pci_class_code 01 08 02 | head -1) bdf=$(iter_pci_class_code 01 08 02 | head -1)
$rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf $rpc_py construct_nvme_bdev -b "Nvme0" -t "pcie" -a $bdf
lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0) lvs_u=$($rpc_py construct_lvol_store Nvme0n1 lvs0)
$rpc_py construct_lvol_bdev -t -u $lvs_u lv0 100 $rpc_py bdev_lvol_create -t -u $lvs_u lv0 100
# this will force isal_pmd as some of the CI systems need a qat driver update # this will force isal_pmd as some of the CI systems need a qat driver update
$rpc_py set_compress_pmd -p 2 $rpc_py set_compress_pmd -p 2
compress_bdev=$($rpc_py bdev_compress_create -b lvs0/lv0 -p /tmp) compress_bdev=$($rpc_py bdev_compress_create -b lvs0/lv0 -p /tmp)

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

@ -51,9 +51,9 @@ ls_guid=$($rpc_py construct_lvol_store Nvme0n1 lvs_0)
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
# Using maximum 2048MiB to reduce the test time # Using maximum 2048MiB to reduce the test time
if [ $free_mb -gt 2048 ]; then if [ $free_mb -gt 2048 ]; then
$rpc_py construct_lvol_bdev -u $ls_guid lbd_0 2048 $rpc_py bdev_lvol_create -u $ls_guid lbd_0 2048
else else
$rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb $rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb
fi fi
# "lvs_0/lbd_0:0" ==> use lvs_0/lbd_0 blockdev for LUN0 # "lvs_0/lbd_0:0" ==> use lvs_0/lbd_0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2

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

@ -59,7 +59,7 @@ for i in $(seq 1 $NUM_LVS); do
ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576) ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576)
LUNs="" LUNs=""
for j in $(seq 1 $NUM_LVOL); do for j in $(seq 1 $NUM_LVOL); do
lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_$j 10) lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j 10)
LUNs+="$lb_name:$((j - 1)) " LUNs+="$lb_name:$((j - 1)) "
done done
$rpc_py construct_target_node Target$i Target${i}_alias "$LUNs" "1:$INITIATOR_TAG" 256 -d $rpc_py construct_target_node Target$i Target${i}_alias "$LUNs" "1:$INITIATOR_TAG" 256 -d

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

@ -58,7 +58,7 @@ ls_guid=$($rpc_py construct_lvol_store "Nvme0n1" "lvs0" -c 1048576)
get_lvs_free_mb $ls_guid get_lvs_free_mb $ls_guid
lvol_bdev_size=$(($free_mb / $CONNECTION_NUMBER)) lvol_bdev_size=$(($free_mb / $CONNECTION_NUMBER))
for i in $(seq 1 $CONNECTION_NUMBER); do for i in $(seq 1 $CONNECTION_NUMBER); do
$rpc_py construct_lvol_bdev -u $ls_guid lbd_$i $lvol_bdev_size $rpc_py bdev_lvol_create -u $ls_guid lbd_$i $lvol_bdev_size
done done
for i in $(seq 1 $CONNECTION_NUMBER); do for i in $(seq 1 $CONNECTION_NUMBER); do

4
test/json_config/json_config.sh
View File

@ -201,8 +201,8 @@ function create_bdev_subsystem_config() {
# If LVOLs cofniguration will be reordered (eg moved before splits or AIO/NVMe) # If LVOLs cofniguration will be reordered (eg moved before splits or AIO/NVMe)
# it should fail loading JSON config from file. # it should fail loading JSON config from file.
tgt_rpc construct_lvol_store -c 1048576 ${lvol_store_base_bdev}p0 lvs_test tgt_rpc construct_lvol_store -c 1048576 ${lvol_store_base_bdev}p0 lvs_test
tgt_rpc construct_lvol_bdev -l lvs_test lvol0 32 tgt_rpc bdev_lvol_create -l lvs_test lvol0 32
tgt_rpc construct_lvol_bdev -l lvs_test -t lvol1 32 tgt_rpc bdev_lvol_create -l lvs_test -t lvol1 32
tgt_rpc bdev_lvol_snapshot lvs_test/lvol0 snapshot0 tgt_rpc bdev_lvol_snapshot lvs_test/lvol0 snapshot0
tgt_rpc bdev_lvol_clone lvs_test/snapshot0 clone0 tgt_rpc bdev_lvol_clone lvs_test/snapshot0 clone0

10
test/lvol/lvol.sh
View File

@ -24,11 +24,11 @@ function usage() {
1: 'construct_lvs_positive', 1: 'construct_lvs_positive',
50: 'construct_logical_volume_positive', 50: 'construct_logical_volume_positive',
51: 'construct_multi_logical_volumes_positive', 51: 'construct_multi_logical_volumes_positive',
52: 'construct_lvol_bdev_using_name_positive', 52: 'bdev_lvol_create_using_name_positive',
53: 'construct_lvol_bdev_duplicate_names_positive', 53: 'bdev_lvol_create_duplicate_names_positive',
100: 'construct_logical_volume_nonexistent_lvs_uuid', 100: 'construct_logical_volume_nonexistent_lvs_uuid',
101: 'construct_lvol_bdev_on_full_lvol_store', 101: 'bdev_lvol_create_on_full_lvol_store',
102: 'construct_lvol_bdev_name_twice', 102: 'bdev_lvol_create_name_twice',
150: 'bdev_lvol_resize_positive', 150: 'bdev_lvol_resize_positive',
200: 'resize_logical_volume_nonexistent_logical_volume', 200: 'resize_logical_volume_nonexistent_logical_volume',
201: 'resize_logical_volume_with_size_out_of_range', 201: 'resize_logical_volume_with_size_out_of_range',
@ -45,7 +45,7 @@ function usage() {
450: 'construct_lvs_nonexistent_bdev', 450: 'construct_lvs_nonexistent_bdev',
451: 'construct_lvs_on_bdev_twice', 451: 'construct_lvs_on_bdev_twice',
452: 'construct_lvs_name_twice', 452: 'construct_lvs_name_twice',
500: 'nested_construct_lvol_bdev_on_full_lvol_store', 500: 'nested_bdev_lvol_create_on_full_lvol_store',
550: 'delete_bdev_positive', 550: 'delete_bdev_positive',
551: 'delete_lvol_bdev', 551: 'delete_lvol_bdev',
552: 'destroy_lvol_store_with_clones', 552: 'destroy_lvol_store_with_clones',

6
test/lvol/rpc_commands_lib.py
View File

@ -126,8 +126,8 @@ class Commands_Rpc(object):
output = self.rpc.construct_lvol_store(base_name, lvs_name)[0] output = self.rpc.construct_lvol_store(base_name, lvs_name)[0]
return output.rstrip('\n') return output.rstrip('\n')
def construct_lvol_bdev(self, uuid, lbd_name, size, thin=False): def bdev_lvol_create(self, uuid, lbd_name, size, thin=False):
print("INFO: RPC COMMAND construct_lvol_bdev") print("INFO: RPC COMMAND bdev_lvol_create")
try: try:
uuid_obj = UUID(uuid) uuid_obj = UUID(uuid)
name_opt = "-u" name_opt = "-u"
@ -136,7 +136,7 @@ class Commands_Rpc(object):
thin_provisioned = "" thin_provisioned = ""
if thin: if thin:
thin_provisioned = "-t" thin_provisioned = "-t"
output = self.rpc.construct_lvol_bdev(name_opt, uuid, lbd_name, size, thin_provisioned)[0] output = self.rpc.bdev_lvol_create(name_opt, uuid, lbd_name, size, thin_provisioned)[0]
return output.rstrip('\n') return output.rstrip('\n')
def destroy_lvol_store(self, uuid): def destroy_lvol_store(self, uuid):

158
test/lvol/test_cases.py
View File

@ -112,15 +112,15 @@ def case_message(func):
test_name = { test_name = {
# construct_lvol_store - positive tests # construct_lvol_store - positive tests
1: 'construct_lvs_positive', 1: 'construct_lvs_positive',
# construct_lvol_bdev - positive tests # bdev_lvol_create - positive tests
50: 'construct_logical_volume_positive', 50: 'construct_logical_volume_positive',
51: 'construct_multi_logical_volumes_positive', 51: 'construct_multi_logical_volumes_positive',
52: 'construct_lvol_bdev_using_name_positive', 52: 'bdev_lvol_create_using_name_positive',
53: 'construct_lvol_bdev_duplicate_names_positive', 53: 'bdev_lvol_create_duplicate_names_positive',
# construct_lvol_bdev - negative tests # bdev_lvol_create - negative tests
100: 'construct_logical_volume_nonexistent_lvs_uuid', 100: 'construct_logical_volume_nonexistent_lvs_uuid',
101: 'construct_lvol_bdev_on_full_lvol_store', 101: 'bdev_lvol_create_on_full_lvol_store',
102: 'construct_lvol_bdev_name_twice', 102: 'bdev_lvol_create_name_twice',
# resize_lvol_store - positive tests # resize_lvol_store - positive tests
150: 'bdev_lvol_resize_positive', 150: 'bdev_lvol_resize_positive',
# resize lvol store - negative tests # resize lvol store - negative tests
@ -140,8 +140,8 @@ def case_message(func):
450: 'construct_lvs_nonexistent_bdev', 450: 'construct_lvs_nonexistent_bdev',
451: 'construct_lvs_on_bdev_twice', 451: 'construct_lvs_on_bdev_twice',
452: 'construct_lvs_name_twice', 452: 'construct_lvs_name_twice',
# nested construct_lvol_bdev - test negative # nested bdev_lvol_create - test negative
500: 'nested_construct_lvol_bdev_on_full_lvol_store', 500: 'nested_bdev_lvol_create_on_full_lvol_store',
550: 'delete_bdev_positive', 550: 'delete_bdev_positive',
551: 'delete_lvol_bdev', 551: 'delete_lvol_bdev',
552: 'destroy_lvol_store_with_clones', 552: 'destroy_lvol_store_with_clones',
@ -350,7 +350,7 @@ class TestCases(object):
construct_logical_volume_positive construct_logical_volume_positive
Positive test for constructing a new logical volume. Positive test for constructing a new logical volume.
Call construct_lvol_bdev with correct lvol store UUID and size in MiB for this bdev Call bdev_lvol_create with correct lvol store UUID and size in MiB for this bdev
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
@ -364,7 +364,7 @@ class TestCases(object):
lvs_size = self.get_lvs_size() lvs_size = self.get_lvs_size()
# Construct lvol bdev on correct lvs_uuid and size # Construct lvol bdev on correct lvs_uuid and size
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
# Check correct uuid values in response get_bdevs command # Check correct uuid values in response get_bdevs command
@ -376,7 +376,7 @@ class TestCases(object):
# Expected result: # Expected result:
# - call successful, return code = 0 # - call successful, return code = 0
# - get_lvol_store: backend used for construct_lvol_bdev has name # - get_lvol_store: backend used for bdev_lvol_create has name
# field set with the same name as returned from RPC call for all repeat # field set with the same name as returned from RPC call for all repeat
# - no other operation fails # - no other operation fails
return fail_count return fail_count
@ -387,7 +387,7 @@ class TestCases(object):
construct_multi_logical_volumes_positive construct_multi_logical_volumes_positive
Positive test for constructing a multi logical volumes. Positive test for constructing a multi logical volumes.
Call construct_lvol_bdev with correct lvol store UUID and Call bdev_lvol_create with correct lvol store UUID and
size is equal one quarter of the this bdev size. size is equal one quarter of the this bdev size.
""" """
# Create malloc bdev # Create malloc bdev
@ -408,7 +408,7 @@ class TestCases(object):
for j in range(2): for j in range(2):
uuid_bdevs = [] uuid_bdevs = []
for i in range(4): for i in range(4):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name + str(i), self.lbd_name + str(i),
size) size)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -428,7 +428,7 @@ class TestCases(object):
@case_message @case_message
def test_case52(self): def test_case52(self):
""" """
construct_lvol_bdev_using_name_positive bdev_lvol_create_using_name_positive
Positive test for constructing a logical volume using friendly names. Positive test for constructing a logical volume using friendly names.
Verify that logical volumes can be created by using a friendly name Verify that logical volumes can be created by using a friendly name
@ -446,7 +446,7 @@ class TestCases(object):
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
# as a reference # as a reference
uuid_bdev = self.c.construct_lvol_bdev(self.lvs_name, uuid_bdev = self.c.bdev_lvol_create(self.lvs_name,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
# Verify logical volume was correctly created # Verify logical volume was correctly created
@ -465,7 +465,7 @@ class TestCases(object):
@case_message @case_message
def test_case53(self): def test_case53(self):
""" """
construct_lvol_bdev_duplicate_names_positive bdev_lvol_create_duplicate_names_positive
Positive test for constructing a logical volumes using friendly names. Positive test for constructing a logical volumes using friendly names.
Verify that logical volumes can use the same argument for friendly names Verify that logical volumes can use the same argument for friendly names
@ -489,12 +489,12 @@ class TestCases(object):
lvs_size = self.get_lvs_size(self.lvs_name + "1") lvs_size = self.get_lvs_size(self.lvs_name + "1")
# Create logical volume on first lvol store # Create logical volume on first lvol store
uuid_bdev_1 = self.c.construct_lvol_bdev(uuid_store_1, uuid_bdev_1 = self.c.bdev_lvol_create(uuid_store_1,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
# Using the same friendly name argument create logical volume on second # Using the same friendly name argument create logical volume on second
# lvol store # lvol store
uuid_bdev_2 = self.c.construct_lvol_bdev(uuid_store_2, uuid_bdev_2 = self.c.bdev_lvol_create(uuid_store_2,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
# Verify two lvol bdevs were correctly created # Verify two lvol bdevs were correctly created
@ -519,12 +519,12 @@ class TestCases(object):
construct_logical_volume_nonexistent_lvs_uuid construct_logical_volume_nonexistent_lvs_uuid
Negative test for constructing a new logical_volume. Negative test for constructing a new logical_volume.
Call construct_lvol_bdev with lvs_uuid which does not Call bdev_lvol_create with lvs_uuid which does not
exist in configuration. exist in configuration.
""" """
fail_count = 0 fail_count = 0
# Try to call construct_lvol_bdev with lvs_uuid which does not exist # Try to call bdev_lvol_create with lvs_uuid which does not exist
if self.c.construct_lvol_bdev(self._gen_lvs_uuid(), if self.c.bdev_lvol_create(self._gen_lvs_uuid(),
self.lbd_name, self.lbd_name,
32) == 0: 32) == 0:
fail_count += 1 fail_count += 1
@ -537,10 +537,10 @@ class TestCases(object):
@case_message @case_message
def test_case101(self): def test_case101(self):
""" """
construct_lvol_bdev_on_full_lvol_store bdev_lvol_create_on_full_lvol_store
Negative test for constructing a new lvol bdev. Negative test for constructing a new lvol bdev.
Call construct_lvol_bdev on a full lvol store. Call bdev_lvol_create on a full lvol store.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
@ -553,7 +553,7 @@ class TestCases(object):
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
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
# Verify if lvol bdev was correctly created # Verify if lvol bdev was correctly created
@ -562,7 +562,7 @@ class TestCases(object):
# Try construct lvol bdev on the same lvs_uuid as in last step # Try construct lvol bdev on the same lvs_uuid as in last step
# This call should fail as lvol store space is taken by previously # This call should fail as lvol store space is taken by previously
# created bdev # created bdev
if self.c.construct_lvol_bdev(uuid_store, if self.c.bdev_lvol_create(uuid_store,
self.lbd_name + "_1", self.lbd_name + "_1",
lvs_size) == 0: lvs_size) == 0:
fail_count += 1 fail_count += 1
@ -573,7 +573,7 @@ class TestCases(object):
# Expected result: # Expected result:
# - first call successful # - first call successful
# - second construct_lvol_bdev call return code != 0 # - second bdev_lvol_create call return code != 0
# - EEXIST response printed to stdout # - EEXIST response printed to stdout
# - no other operation fails # - no other operation fails
return fail_count return fail_count
@ -581,7 +581,7 @@ class TestCases(object):
@case_message @case_message
def test_case102(self): def test_case102(self):
""" """
construct_lvol_bdev_name_twice bdev_lvol_create_name_twice
Negative test for constructing lvol bdev using the same Negative test for constructing lvol bdev using the same
friendly name twice on the same logical volume store. friendly name twice on the same logical volume store.
@ -597,7 +597,7 @@ class TestCases(object):
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
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
size) size)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
@ -605,7 +605,7 @@ class TestCases(object):
# Try to create another logical volume on the same lvol store using # Try to create another logical volume on the same lvol store using
# the same friendly name as in previous step # the same friendly name as in previous step
# This step should fail # This step should fail
if self.c.construct_lvol_bdev(uuid_store, if self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
size) == 0: size) == 0:
fail_count += 1 fail_count += 1
@ -641,7 +641,7 @@ class TestCases(object):
# 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
size = self.get_lvs_divided_size(4) size = self.get_lvs_divided_size(4)
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size) uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size)
# Check size of the lvol bdev by rpc command get_bdevs # Check size of the lvol bdev by rpc command get_bdevs
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size)
@ -714,7 +714,7 @@ class TestCases(object):
# 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
lvs_size = self.get_lvs_size() lvs_size = self.get_lvs_size()
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
@ -817,7 +817,7 @@ class TestCases(object):
# 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
lvs_size = self.get_lvs_size() lvs_size = self.get_lvs_size()
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
lvs_size) lvs_size)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, fail_count += self.c.check_get_bdevs_methods(uuid_bdev,
@ -844,7 +844,7 @@ class TestCases(object):
Positive test for destroying a logical volume store with multiple lvol Positive test for destroying a logical volume store with multiple lvol
bdevs created on top. bdevs created on top.
Call construct_lvol_bdev with correct lvol store UUID and Call bdev_lvol_create with correct lvol store UUID and
size is equal to one quarter of the this bdev size. size is equal to one quarter of the this bdev size.
""" """
# Create malloc bdev # Create malloc bdev
@ -860,7 +860,7 @@ class TestCases(object):
# Construct four lvol bdevs on correct lvs_uuid and # Construct four lvol bdevs on correct lvs_uuid and
# size is equal to one quarter of the lvol size # size is equal to one quarter of the lvol size
for i in range(4): for i in range(4):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name + str(i), self.lbd_name + str(i),
size) size)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size)
@ -874,7 +874,7 @@ class TestCases(object):
# Expected result: # Expected result:
# - call successful, return code = 0 # - call successful, return code = 0
# - get_lvol_store: backend used for construct_lvol_bdev has name # - get_lvol_store: backend used for bdev_lvol_create has name
# field set with the same name as returned from RPC call for all repeat # field set with the same name as returned from RPC call for all repeat
# - no other operation fails # - no other operation fails
return fail_count return fail_count
@ -897,9 +897,9 @@ class TestCases(object):
fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store,
self.cluster_size) self.cluster_size)
size = self.get_lvs_divided_size(4) size = self.get_lvs_divided_size(4)
# construct_lvol_bdev on correct lvs_uuid and size is # bdev_lvol_create on correct lvs_uuid and size is
# equal to one quarter of size malloc bdev # equal to one quarter of size malloc bdev
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, self.lbd_name,
size) size)
# check size of the lvol bdev # check size of the lvol bdev
@ -1123,10 +1123,10 @@ class TestCases(object):
@case_message @case_message
def test_case500(self): def test_case500(self):
""" """
nested_construct_lvol_bdev_on_full_lvol_store nested_bdev_lvol_create_on_full_lvol_store
Negative test for constructing a new nested lvol bdev. Negative test for constructing a new nested lvol bdev.
Call construct_lvol_bdev on a full lvol store. Call bdev_lvol_create on a full lvol store.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.bdev_malloc_create(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
@ -1139,7 +1139,7 @@ class TestCases(object):
self.cluster_size) self.cluster_size)
# Construct lvol bdev # Construct lvol bdev
size = self.get_lvs_size() size = self.get_lvs_size()
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size) self.lbd_name, size)
# Construct nested lvol store on created lvol_bdev # Construct nested lvol store on created lvol_bdev
nested_lvs_name = self.lvs_name + "_nested" nested_lvs_name = self.lvs_name + "_nested"
@ -1152,20 +1152,20 @@ class TestCases(object):
# with size equal to size of nested lvol store # with size equal to size of nested lvol store
nested_size = self.get_lvs_size(nested_lvs_name) nested_size = self.get_lvs_size(nested_lvs_name)
nested_lbd_name = self.lbd_name + "_nested" nested_lbd_name = self.lbd_name + "_nested"
nested_uuid_bdev = self.c.construct_lvol_bdev(nested_lvs_uuid, nested_uuid_bdev = self.c.bdev_lvol_create(nested_lvs_uuid,
nested_lbd_name, nested_size) nested_lbd_name, nested_size)
fail_count += self.c.check_get_bdevs_methods(nested_uuid_bdev, nested_size) fail_count += self.c.check_get_bdevs_methods(nested_uuid_bdev, nested_size)
# Try construct another lvol bdev as in previous step; this call should fail # Try construct another lvol bdev as in previous step; this call should fail
# as nested lvol store space is already claimed by lvol bdev # as nested lvol store space is already claimed by lvol bdev
nested_lbd_name = self.lbd_name + "_nested2" nested_lbd_name = self.lbd_name + "_nested2"
if self.c.construct_lvol_bdev(nested_lvs_uuid, nested_lbd_name, nested_size) == 0: if self.c.bdev_lvol_create(nested_lvs_uuid, nested_lbd_name, nested_size) == 0:
fail_count += 1 fail_count += 1
fail_count += self.c.delete_malloc_bdev(base_name) fail_count += self.c.delete_malloc_bdev(base_name)
# Expected result: # Expected result:
# - second construct_lvol_bdev call on nested lvol store return code != 0 # - second bdev_lvol_create call on nested lvol store return code != 0
# - EEXIST response printed to stdout # - EEXIST response printed to stdout
# - no other operation fails # - no other operation fails
return fail_count return fail_count
@ -1225,7 +1225,7 @@ class TestCases(object):
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
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size, thin=True) self.lbd_name, size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
@ -1290,7 +1290,7 @@ class TestCases(object):
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
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size, thin=True) uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name)
@ -1351,7 +1351,7 @@ class TestCases(object):
size = int(int(lvs[0]['free_clusters'] * lvs[0]['cluster_size']) / 4 / MEGABYTE) 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
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, size, thin=True) uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, self.lbd_name, size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name)
@ -1482,7 +1482,7 @@ class TestCases(object):
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.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size, thin=True) bdev_size, thin=True)
lvs = self.c.bdev_lvol_get_lvstores(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'])
@ -1565,10 +1565,10 @@ class TestCases(object):
# calculate bdev size in megabytes # calculate bdev size in megabytes
bdev_size = self.get_lvs_size() bdev_size = self.get_lvs_size()
# create thick provisioned lvol bvdev with size equal to lvol store # create thick provisioned lvol bvdev with size equal to lvol store
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0,
bdev_size, thin=False) bdev_size, thin=False)
# create thin provisioned lvol bdev with the same size # create thin provisioned lvol bdev with the same size
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1,
bdev_size, thin=True) bdev_size, thin=True)
lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0) lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)
lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1) lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1)
@ -1620,7 +1620,7 @@ class TestCases(object):
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
bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size, thin=True) bdev_size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
@ -1660,7 +1660,7 @@ class TestCases(object):
# 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
size = self.get_lvs_divided_size(2) size = self.get_lvs_divided_size(2)
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size, thin=True) self.lbd_name, size, thin=True)
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size)
# Fill all free space of lvol bdev with data # Fill all free space of lvol bdev with data
@ -1738,9 +1738,9 @@ class TestCases(object):
bdev_size = self.get_lvs_size() bdev_size = self.get_lvs_size()
# construct two thin provisioned lvol bdevs on created lvol store # construct two thin provisioned lvol bdevs on created lvol store
# with size equals to free lvs size # with size equals to free lvs size
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0,
bdev_size, thin=True) bdev_size, thin=True)
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1,
bdev_size, thin=True) bdev_size, thin=True)
lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0] lvs = self.c.bdev_lvol_get_lvstores(self.lvs_name)[0]
@ -1810,9 +1810,9 @@ class TestCases(object):
bdev_size = int(lvs_size * 0.7) bdev_size = int(lvs_size * 0.7)
# construct two thin provisioned lvol bdevs on created lvol store # construct two thin provisioned lvol bdevs on created lvol store
# with size equal to 70% of lvs size # with size equal to 70% of lvs size
bdev_name0 = self.c.construct_lvol_bdev(uuid_store, lbd_name0, bdev_name0 = self.c.bdev_lvol_create(uuid_store, lbd_name0,
bdev_size, thin=True) bdev_size, thin=True)
bdev_name1 = self.c.construct_lvol_bdev(uuid_store, lbd_name1, bdev_name1 = self.c.bdev_lvol_create(uuid_store, lbd_name1,
bdev_size, thin=True) bdev_size, thin=True)
lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0) lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)
@ -1878,7 +1878,7 @@ class TestCases(object):
size = self.get_lvs_divided_size(10) size = self.get_lvs_divided_size(10)
for i in range(5): for i in range(5):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name + str(i), self.lbd_name + str(i),
size) size)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -1927,7 +1927,7 @@ class TestCases(object):
# Add some lvol bdevs to existing lvol store then # Add some lvol bdevs to existing lvol store then
# remove all lvol configuration and re-create it again # remove all lvol configuration and re-create it again
for i in range(5, 10): for i in range(5, 10):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name + str(i), self.lbd_name + str(i),
size) size)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -1950,7 +1950,7 @@ class TestCases(object):
self.cluster_size) self.cluster_size)
for i in range(10): for i in range(10):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
self.lbd_name + str(i), self.lbd_name + str(i),
size) size)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -2048,7 +2048,7 @@ class TestCases(object):
size_32M = self.get_lvs_divided_size(5, self.lvs_name + "_32M") size_32M = self.get_lvs_divided_size(5, self.lvs_name + "_32M")
for i in range(5): for i in range(5):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store_1M, uuid_bdev = self.c.bdev_lvol_create(uuid_store_1M,
self.lbd_name + str(i) + "_1M", self.lbd_name + str(i) + "_1M",
size_1M) size_1M)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -2056,7 +2056,7 @@ class TestCases(object):
fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size_1M) fail_count += self.c.check_get_bdevs_methods(uuid_bdev, size_1M)
for i in range(5): for i in range(5):
uuid_bdev = self.c.construct_lvol_bdev(uuid_store_32M, uuid_bdev = self.c.bdev_lvol_create(uuid_store_32M,
self.lbd_name + str(i) + "_32M", self.lbd_name + str(i) + "_32M",
size_32M) size_32M)
uuid_bdevs.append(uuid_bdev) uuid_bdevs.append(uuid_bdev)
@ -2144,7 +2144,7 @@ class TestCases(object):
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
bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size) bdev_size)
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
# Create snapshot of lvol bdev # Create snapshot of lvol bdev
@ -2197,10 +2197,10 @@ class TestCases(object):
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)
# Create thin provisioned lvol bdev with size less than 25% of lvs # Create thin provisioned lvol bdev with size less than 25% of lvs
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
lbd_name0, size, thin=True) lbd_name0, size, thin=True)
# Create thick provisioned lvol bdev with size less than 25% of lvs # Create thick provisioned lvol bdev with size less than 25% of lvs
uuid_bdev1 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev1 = self.c.bdev_lvol_create(uuid_store,
lbd_name1, size, thin=False) lbd_name1, size, thin=False)
lvol_bdev0 = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev0 = self.c.get_lvol_bdev_with_name(uuid_bdev0)
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name[0]) fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name[0])
@ -2270,7 +2270,7 @@ class TestCases(object):
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)
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name,
size, thin=True) size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
@ -2325,7 +2325,7 @@ class TestCases(object):
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)
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, self.lbd_name, uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name,
size, thin=False) size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
@ -2373,7 +2373,7 @@ class TestCases(object):
lvs = self.c.bdev_lvol_get_lvstores() 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.bdev_lvol_create(uuid_store, self.lbd_name,
size, thin=False) size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
@ -2436,7 +2436,7 @@ class TestCases(object):
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)
# Construct thick provisioned lvol bdev # Construct thick provisioned lvol bdev
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
lbd_name0, size, thin=False) lbd_name0, size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
# Install lvol bdev on /dev/nbd0 # Install lvol bdev on /dev/nbd0
@ -2509,7 +2509,7 @@ class TestCases(object):
size = self.get_lvs_divided_size(6) size = self.get_lvs_divided_size(6)
# Construct thick provisioned lvol bdev # Construct thick provisioned lvol bdev
uuid_bdev = self.c.construct_lvol_bdev(uuid_store, uuid_bdev = self.c.bdev_lvol_create(uuid_store,
lbd_name, size, thin=False) lbd_name, size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
@ -2599,7 +2599,7 @@ class TestCases(object):
size = self.get_lvs_divided_size(4) size = self.get_lvs_divided_size(4)
# Construct thick provisioned lvol bdev # Construct thick provisioned lvol bdev
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size, thin=False) self.lbd_name, size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
@ -2690,7 +2690,7 @@ class TestCases(object):
size = self.get_lvs_divided_size(4) size = self.get_lvs_divided_size(4)
# Construct thin provisioned lvol bdev # Construct thin provisioned lvol bdev
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size, thin=True) self.lbd_name, size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
@ -2762,7 +2762,7 @@ class TestCases(object):
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
uuid_bdev0 = self.c.construct_lvol_bdev(uuid_store, uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,
self.lbd_name, size, thin=True) self.lbd_name, size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
@ -2862,7 +2862,7 @@ class TestCases(object):
lvs = self.c.bdev_lvol_get_lvstores()[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.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size) bdev_size)
# Set lvol bdev as read only # Set lvol bdev as read only
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
@ -2925,7 +2925,7 @@ class TestCases(object):
# Create lvol bdev with 50% of lvol store space # Create lvol bdev with 50% of lvol store space
lvs = self.c.bdev_lvol_get_lvstores()[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.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size) bdev_size)
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
@ -3005,7 +3005,7 @@ class TestCases(object):
# Create lvol bdev with one third of lvol store space # Create lvol bdev with one third of lvol store space
lvs = self.c.bdev_lvol_get_lvstores()[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.bdev_lvol_create(uuid_store, self.lbd_name,
bdev_size) bdev_size)
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
@ -3127,7 +3127,7 @@ class TestCases(object):
# Create 4 lvol bdevs on top of previously created lvol store # Create 4 lvol bdevs on top of previously created lvol store
bdev_size = self.get_lvs_divided_size(4) bdev_size = self.get_lvs_divided_size(4)
for name, alias in zip(bdev_names, bdev_aliases): for name, alias in zip(bdev_names, bdev_aliases):
uuid = self.c.construct_lvol_bdev(lvs_uuid, uuid = self.c.bdev_lvol_create(lvs_uuid,
name, name,
bdev_size) bdev_size)
fail_count += self.c.check_get_bdevs_methods(uuid, fail_count += self.c.check_get_bdevs_methods(uuid,
@ -3250,7 +3250,7 @@ class TestCases(object):
bdev_size_1 = self.get_lvs_divided_size(4, lvs_name_1) bdev_size_1 = self.get_lvs_divided_size(4, lvs_name_1)
bdev_size_2 = self.get_lvs_divided_size(4, lvs_name_2) bdev_size_2 = self.get_lvs_divided_size(4, lvs_name_2)
for name, alias in zip(bdev_names_1, bdev_aliases_1): for name, alias in zip(bdev_names_1, bdev_aliases_1):
uuid = self.c.construct_lvol_bdev(lvs_uuid_1, uuid = self.c.bdev_lvol_create(lvs_uuid_1,
name, name,
bdev_size_1) bdev_size_1)
fail_count += self.c.check_get_bdevs_methods(uuid, fail_count += self.c.check_get_bdevs_methods(uuid,
@ -3258,7 +3258,7 @@ class TestCases(object):
alias) alias)
bdev_uuids_1.append(uuid) bdev_uuids_1.append(uuid)
for name, alias in zip(bdev_names_2, bdev_aliases_2): for name, alias in zip(bdev_names_2, bdev_aliases_2):
uuid = self.c.construct_lvol_bdev(lvs_uuid_2, uuid = self.c.bdev_lvol_create(lvs_uuid_2,
name, name,
bdev_size_2) bdev_size_2)
fail_count += self.c.check_get_bdevs_methods(uuid, fail_count += self.c.check_get_bdevs_methods(uuid,
@ -3347,12 +3347,12 @@ class TestCases(object):
self.lvs_name) self.lvs_name)
# Construct 2 lvol bdevs on lvol store # Construct 2 lvol bdevs on lvol store
bdev_size = self.get_lvs_divided_size(2) bdev_size = self.get_lvs_divided_size(2)
bdev_uuid_1 = self.c.construct_lvol_bdev(lvs_uuid, bdev_uuid_1 = self.c.bdev_lvol_create(lvs_uuid,
self.lbd_name + "1", self.lbd_name + "1",
bdev_size) bdev_size)
fail_count += self.c.check_get_bdevs_methods(bdev_uuid_1, fail_count += self.c.check_get_bdevs_methods(bdev_uuid_1,
bdev_size) bdev_size)
bdev_uuid_2 = self.c.construct_lvol_bdev(lvs_uuid, bdev_uuid_2 = self.c.bdev_lvol_create(lvs_uuid,
self.lbd_name + "2", self.lbd_name + "2",
bdev_size) bdev_size)
fail_count += self.c.check_get_bdevs_methods(bdev_uuid_2, fail_count += self.c.check_get_bdevs_methods(bdev_uuid_2,

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

@ -49,7 +49,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
$rpc_py construct_nvme_bdev -b Nvme0 -t PCIe -a $(echo $bdfs | awk '{ print $1 }') -i $NVMF_FIRST_TARGET_IP $rpc_py construct_nvme_bdev -b Nvme0 -t PCIe -a $(echo $bdfs | awk '{ print $1 }') -i $NVMF_FIRST_TARGET_IP
ls_guid=$($rpc_py construct_lvol_store -c 1073741824 Nvme0n1 lvs_0) ls_guid=$($rpc_py construct_lvol_store -c 1073741824 Nvme0n1 lvs_0)
get_lvs_free_mb $ls_guid get_lvs_free_mb $ls_guid
$rpc_py construct_lvol_bdev -l lvs_0 lbd_0 $free_mb $rpc_py bdev_lvol_create -l lvs_0 lbd_0 $free_mb
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode2 -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode2 -a -s SPDK00000000000001
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode2 lvs_0/lbd_0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode2 lvs_0/lbd_0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode2 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode2 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT
@ -60,7 +60,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
# Test fio_plugin as host with nvme lvol nested backend # Test fio_plugin as host with nvme lvol nested backend
ls_nested_guid=$($rpc_py construct_lvol_store --clear-method none lvs_0/lbd_0 lvs_n_0) ls_nested_guid=$($rpc_py construct_lvol_store --clear-method none lvs_0/lbd_0 lvs_n_0)
get_lvs_free_mb $ls_nested_guid get_lvs_free_mb $ls_nested_guid
$rpc_py construct_lvol_bdev -l lvs_n_0 lbd_nest_0 $free_mb $rpc_py bdev_lvol_create -l lvs_n_0 lbd_nest_0 $free_mb
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode3 -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode3 -a -s SPDK00000000000001
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode3 lvs_n_0/lbd_nest_0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode3 lvs_n_0/lbd_nest_0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode3 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode3 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

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

@ -52,7 +52,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
if [ $free_mb -gt 20480 ]; then if [ $free_mb -gt 20480 ]; then
free_mb=20480 free_mb=20480
fi fi
lb_guid=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb) lb_guid=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb)
# Create lvol bdev for nested lvol stores # Create lvol bdev for nested lvol stores
ls_nested_guid=$($rpc_py construct_lvol_store $lb_guid lvs_n_0) ls_nested_guid=$($rpc_py construct_lvol_store $lb_guid lvs_n_0)
@ -60,7 +60,7 @@ if [ $RUN_NIGHTLY -eq 1 ]; then
if [ $free_mb -gt 20480 ]; then if [ $free_mb -gt 20480 ]; then
free_mb=20480 free_mb=20480
fi fi
lb_nested_guid=$($rpc_py construct_lvol_bdev -u $ls_nested_guid lbd_nest_0 $free_mb) lb_nested_guid=$($rpc_py bdev_lvol_create -u $ls_nested_guid lbd_nest_0 $free_mb)
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001
for bdev in $lb_nested_guid; do for bdev in $lb_nested_guid; do
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 $bdev $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 $bdev

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

@ -35,7 +35,7 @@ $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs"
lvs=$($rpc_py construct_lvol_store raid0 lvs) lvs=$($rpc_py construct_lvol_store raid0 lvs)
# Create a logical volume on the logical volume store # Create a logical volume on the logical volume store
lvol=$($rpc_py construct_lvol_bdev -u $lvs lvol $LVOL_BDEV_INIT_SIZE) lvol=$($rpc_py bdev_lvol_create -u $lvs lvol $LVOL_BDEV_INIT_SIZE)
# Create an NVMe-oF subsystem and add the logical volume as a namespace # Create an NVMe-oF subsystem and add the logical volume as a namespace
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode0 -a -s SPDK0 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode0 -a -s SPDK0

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

@ -118,7 +118,7 @@ for vm_conf in ${vms[@]}; do
if [[ $disk == "RaidBdev2" ]]; then if [[ $disk == "RaidBdev2" ]]; then
ls_guid=$($rpc_py construct_lvol_store RaidBdev2 lvs_0 -c 4194304) ls_guid=$($rpc_py construct_lvol_store RaidBdev2 lvs_0 -c 4194304)
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
based_disk=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_0 $free_mb) based_disk=$($rpc_py bdev_lvol_create -u $ls_guid lbd_0 $free_mb)
else else
based_disk="$disk" based_disk="$disk"
fi fi

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

@ -67,7 +67,7 @@ notice "..."
trap 'clean_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' SIGTERM SIGABRT ERR trap 'clean_lvol_cfg; error_exit "${FUNCNAME}" "${LINENO}"' SIGTERM SIGABRT ERR
notice "Constructing lvol store and lvol bdev on top of Nvme0n1" notice "Constructing lvol store and lvol bdev on top of Nvme0n1"
lvs_uuid=$($rpc_py construct_lvol_store Nvme0n1 lvol_store) lvs_uuid=$($rpc_py construct_lvol_store Nvme0n1 lvol_store)
$rpc_py construct_lvol_bdev lvol_bdev 10000 -l lvol_store $rpc_py bdev_lvol_create lvol_bdev 10000 -l lvol_store
if [[ "$ctrl_type" == "spdk_vhost_scsi" ]]; then if [[ "$ctrl_type" == "spdk_vhost_scsi" ]]; then
$rpc_py construct_vhost_scsi_controller naa.Nvme0n1.0 $rpc_py construct_vhost_scsi_controller naa.Nvme0n1.0

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

@ -144,7 +144,7 @@ for (( i=0; i<$max_disks; i++ ));do
size=$((free_mb / (vm_count+1) )) size=$((free_mb / (vm_count+1) ))
notice "Creating lvol bdev on lvol store: $ls_guid" notice "Creating lvol bdev on lvol store: $ls_guid"
lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_nest $size $thin) lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_nest $size $thin)
notice "Creating nested lvol store on lvol bdev: $lb_name" notice "Creating nested lvol store on lvol bdev: $lb_name"
nest_ls_guid=$($rpc_py construct_lvol_store $lb_name lvs_n_$i -c 4194304) nest_ls_guid=$($rpc_py construct_lvol_store $lb_name lvs_n_$i -c 4194304)
@ -154,7 +154,7 @@ for (( i=0; i<$max_disks; i++ ));do
notice "Creating nested lvol bdev for VM $i on lvol store $nest_ls_guid" notice "Creating nested lvol bdev for VM $i on lvol store $nest_ls_guid"
free_mb=$(get_lvs_free_mb "$nest_ls_guid") free_mb=$(get_lvs_free_mb "$nest_ls_guid")
nest_size=$((free_mb / (vm_count-j) )) nest_size=$((free_mb / (vm_count-j) ))
lb_name=$($rpc_py construct_lvol_bdev -u $nest_ls_guid lbd_vm_$j $nest_size $thin) lb_name=$($rpc_py bdev_lvol_create -u $nest_ls_guid lbd_vm_$j $nest_size $thin)
nest_lvol_bdevs+=("$lb_name") nest_lvol_bdevs+=("$lb_name")
done done
fi fi
@ -164,7 +164,7 @@ for (( i=0; i<$max_disks; i++ ));do
notice "Creating lvol bdev for VM $i on lvol store $ls_guid" notice "Creating lvol bdev for VM $i on lvol store $ls_guid"
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
size=$((free_mb / (vm_count-j) )) size=$((free_mb / (vm_count-j) ))
lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_vm_$j $size $thin) lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_vm_$j $size $thin)
lvol_bdevs+=("$lb_name") lvol_bdevs+=("$lb_name")
done done
done done

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

@ -268,7 +268,7 @@ else
for (( j=0; j<${splits[$i]}; j++)); do for (( j=0; j<${splits[$i]}; j++)); do
free_mb=$(get_lvs_free_mb "$ls_guid") free_mb=$(get_lvs_free_mb "$ls_guid")
size=$((free_mb / (${splits[$i]}-j) )) size=$((free_mb / (${splits[$i]}-j) ))
lb_name=$($rpc_py construct_lvol_bdev -u $ls_guid lbd_$j $size --clear-method none) lb_name=$($rpc_py bdev_lvol_create -u $ls_guid lbd_$j $size --clear-method none)
lvol_bdevs+=("$lb_name") lvol_bdevs+=("$lb_name")
done done
done done

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

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