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

scripts/rpc: Change rpc construct_malloc_bdev to bdev_malloc_create

Browse Source 
This is patch that implements changes according to proposal
submitted in https://review.gerrithub.io/c/spdk/spdk/+/453036

Change-Id: I5423cd34cb5fc111b34cab2b7f7c6c5f11898af8
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/464677
Reviewed-by: Broadcom SPDK FC-NVMe CI <spdk-ci.pdl@broadcom.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
This commit is contained in:
Pawel Kaminski 2019-08-09 07:15:35 -04:00 committed by Jim Harris
parent 6fdd36e100
commit 7964f1df90
62 changed files with 239 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
doc/iscsi.md
View File

@ -233,8 +233,8 @@ $ ./app/iscsi_tgt/iscsi_tgt
Construct two 64MB Malloc block devices with 512B sector size "Malloc0" and "Malloc1": Construct two 64MB Malloc block devices with 512B sector size "Malloc0" and "Malloc1":
``` ```
$ ./scripts/rpc.py construct_malloc_bdev -b Malloc0 64 512 $ ./scripts/rpc.py bdev_malloc_create -b Malloc0 64 512
$ ./scripts/rpc.py construct_malloc_bdev -b Malloc1 64 512 $ ./scripts/rpc.py bdev_malloc_create -b Malloc1 64 512
``` ```
Create new portal group with id 1, and address 10.0.0.1:3260: Create new portal group with id 1, and address 10.0.0.1:3260:

10
doc/jsonrpc.md
View File

@ -296,7 +296,7 @@ Example response:
"construct_nvme_bdev", "construct_nvme_bdev",
"construct_null_bdev", "construct_null_bdev",
"delete_malloc_bdev", "delete_malloc_bdev",
"construct_malloc_bdev", "bdev_malloc_create",
"delete_ftl_bdev", "delete_ftl_bdev",
"construct_ftl_bdev", "construct_ftl_bdev",
"get_lvol_stores", "get_lvol_stores",
@ -469,7 +469,7 @@ Example response:
"name": "Malloc0", "name": "Malloc0",
"uuid": "913fc008-79a7-447f-b2c4-c73543638c31" "uuid": "913fc008-79a7-447f-b2c4-c73543638c31"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -478,7 +478,7 @@ Example response:
"name": "Malloc1", "name": "Malloc1",
"uuid": "dd5b8f6e-b67a-4506-b606-7fff5a859920" "uuid": "dd5b8f6e-b67a-4506-b606-7fff5a859920"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
} }
] ]
} }
@ -1151,7 +1151,7 @@ Example response:
} }
~~~ ~~~
## construct_malloc_bdev {#rpc_construct_malloc_bdev} ## bdev_malloc_create {#rpc_bdev_malloc_create}
Construct @ref bdev_config_malloc Construct @ref bdev_config_malloc
@ -1181,7 +1181,7 @@ Example request:
"uuid": "2b6601ba-eada-44fb-9a83-a20eb9eb9e90" "uuid": "2b6601ba-eada-44fb-9a83-a20eb9eb9e90"
}, },
"jsonrpc": "2.0", "jsonrpc": "2.0",
"method": "construct_malloc_bdev", "method": "bdev_malloc_create",
"id": 1 "id": 1
} }
~~~ ~~~

2
doc/nvmf.md
View File

@ -170,7 +170,7 @@ NQN, serial number, and IP address with RDMA transport to your own circumstances
"rdma" with "TCP", then the subsystem will add a listener with TCP transport. "rdma" with "TCP", then the subsystem will add a listener with TCP transport.
~~~{.sh} ~~~{.sh}
scripts/rpc.py construct_malloc_bdev -b Malloc0 512 512 scripts/rpc.py bdev_malloc_create -b Malloc0 512 512
scripts/rpc.py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1 scripts/rpc.py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1
scripts/rpc.py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 scripts/rpc.py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
scripts/rpc.py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a 192.168.100.8 -s 4420 scripts/rpc.py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a 192.168.100.8 -s 4420

6
doc/vhost.md
View File

@ -118,7 +118,7 @@ This guide will use a malloc bdev (ramdisk) named Malloc0. The following RPC
will create a 64MB malloc bdev with 512-byte block size. will create a 64MB malloc bdev with 512-byte block size.
~~~{.sh} ~~~{.sh}
scripts/rpc.py construct_malloc_bdev 64 512 -b Malloc0 scripts/rpc.py bdev_malloc_create 64 512 -b Malloc0
~~~ ~~~
## Create a vhost device {#vhost_vdev_create} ## Create a vhost device {#vhost_vdev_create}
@ -267,7 +267,7 @@ EAL: using IOMMU type 1 (Type 1)
~~~ ~~~
~~~{.sh} ~~~{.sh}
host:~# ./scripts/rpc.py construct_malloc_bdev 128 4096 Malloc0 host:~# ./scripts/rpc.py bdev_malloc_create 128 4096 Malloc0
Malloc0 Malloc0
~~~ ~~~
@ -290,7 +290,7 @@ vhost_scsi.c: 840:spdk_vhost_scsi_dev_add_tgt: *NOTICE*: Controller vhost.0: def
~~~ ~~~
~~~{.sh} ~~~{.sh}
host:~# ./scripts/rpc.py construct_malloc_bdev 64 512 -b Malloc1 host:~# ./scripts/rpc.py bdev_malloc_create 64 512 -b Malloc1
Malloc1 Malloc1
~~~ ~~~

2
lib/bdev/malloc/bdev_malloc.c
View File

@ -368,7 +368,7 @@ bdev_malloc_write_json_config(struct spdk_bdev *bdev, struct spdk_json_write_ctx
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "construct_malloc_bdev"); spdk_json_write_named_string(w, "method", "bdev_malloc_create");
spdk_json_write_named_object_begin(w, "params"); spdk_json_write_named_object_begin(w, "params");
spdk_json_write_named_string(w, "name", bdev->name); spdk_json_write_named_string(w, "name", bdev->name);

7
lib/bdev/malloc/bdev_malloc_rpc.c
View File

@ -60,8 +60,8 @@ static const struct spdk_json_object_decoder rpc_construct_malloc_decoders[] = {
}; };
static void static void
spdk_rpc_construct_malloc_bdev(struct spdk_jsonrpc_request *request, spdk_rpc_bdev_malloc_create(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_construct_malloc req = {NULL}; struct rpc_construct_malloc req = {NULL};
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
@ -110,7 +110,8 @@ spdk_rpc_construct_malloc_bdev(struct spdk_jsonrpc_request *request,
cleanup: cleanup:
free_rpc_construct_malloc(&req); free_rpc_construct_malloc(&req);
} }
SPDK_RPC_REGISTER("construct_malloc_bdev", spdk_rpc_construct_malloc_bdev, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("bdev_malloc_create", spdk_rpc_bdev_malloc_create, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(bdev_malloc_create, construct_malloc_bdev)
struct rpc_delete_malloc { struct rpc_delete_malloc {
char *name; char *name;

4
scripts/config_converter.py
View File

@ -12,7 +12,7 @@ bdev_dict["construct_split_vbdev"] = []
bdev_dict["set_bdev_nvme_options"] = [] bdev_dict["set_bdev_nvme_options"] = []
bdev_dict["construct_nvme_bdev"] = [] bdev_dict["construct_nvme_bdev"] = []
bdev_dict["set_bdev_nvme_hotplug"] = [] bdev_dict["set_bdev_nvme_hotplug"] = []
bdev_dict["construct_malloc_bdev"] = [] bdev_dict["bdev_malloc_create"] = []
bdev_dict["construct_aio_bdev"] = [] bdev_dict["construct_aio_bdev"] = []
bdev_dict["construct_pmem_bdev"] = [] bdev_dict["construct_pmem_bdev"] = []
bdev_dict["construct_virtio_dev"] = [] bdev_dict["construct_virtio_dev"] = []
@ -196,7 +196,7 @@ def get_malloc_bdev_json(config, section):
"num_blocks": params[1][3] * 1024 * 1024 / params[2][3], "num_blocks": params[1][3] * 1024 * 1024 / params[2][3],
"name": "Malloc%s" % lun "name": "Malloc%s" % lun
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}) })
return malloc_json return malloc_json

16
scripts/rpc.py
View File

@ -222,21 +222,21 @@ if __name__ == "__main__":
p.add_argument('name', nargs='?', default=None, help='name of OCF vbdev or name of cache device or name of core device (optional)') p.add_argument('name', nargs='?', default=None, help='name of OCF vbdev or name of cache device or name of core device (optional)')
p.set_defaults(func=get_ocf_bdevs) p.set_defaults(func=get_ocf_bdevs)
def construct_malloc_bdev(args): def bdev_malloc_create(args):
num_blocks = (args.total_size * 1024 * 1024) // args.block_size num_blocks = (args.total_size * 1024 * 1024) // args.block_size
print_json(rpc.bdev.construct_malloc_bdev(args.client, print_json(rpc.bdev.bdev_malloc_create(args.client,
num_blocks=int(num_blocks), num_blocks=int(num_blocks),
block_size=args.block_size, block_size=args.block_size,
name=args.name, name=args.name,
uuid=args.uuid)) uuid=args.uuid))
p = subparsers.add_parser('construct_malloc_bdev', p = subparsers.add_parser('bdev_malloc_create', aliases=['construct_malloc_bdev'],
help='Add a bdev with malloc backend') help='Add a bdev with malloc backend')
p.add_argument('-b', '--name', help="Name of the bdev") p.add_argument('-b', '--name', help="Name of the bdev")
p.add_argument('-u', '--uuid', help="UUID of the bdev") p.add_argument('-u', '--uuid', help="UUID of the bdev")
p.add_argument( p.add_argument(
'total_size', help='Size of malloc bdev in MB (float > 0)', type=float) 'total_size', help='Size of malloc bdev in MB (float > 0)', type=float)
p.add_argument('block_size', help='Block size for this bdev', type=int) p.add_argument('block_size', help='Block size for this bdev', type=int)
p.set_defaults(func=construct_malloc_bdev) p.set_defaults(func=bdev_malloc_create)
def delete_malloc_bdev(args): def delete_malloc_bdev(args):
rpc.bdev.delete_malloc_bdev(args.client, rpc.bdev.delete_malloc_bdev(args.client,

8
scripts/rpc/bdev.py
View File

@ -1,3 +1,6 @@
from .helpers import deprecated_alias
def set_bdev_options(client, bdev_io_pool_size=None, bdev_io_cache_size=None): def set_bdev_options(client, bdev_io_pool_size=None, bdev_io_cache_size=None):
"""Set parameters for the bdev subsystem. """Set parameters for the bdev subsystem.
@ -136,7 +139,8 @@ def get_ocf_bdevs(client, name=None):
return client.call('get_ocf_bdevs', params) return client.call('get_ocf_bdevs', params)
def construct_malloc_bdev(client, num_blocks, block_size, name=None, uuid=None): @deprecated_alias('construct_malloc_bdev')
def bdev_malloc_create(client, num_blocks, block_size, name=None, uuid=None):
"""Construct a malloc block device. """Construct a malloc block device.
Args: Args:
@ -153,7 +157,7 @@ def construct_malloc_bdev(client, num_blocks, block_size, name=None, uuid=None):
params['name'] = name params['name'] = name
if uuid: if uuid:
params['uuid'] = uuid params['uuid'] = uuid
return client.call('construct_malloc_bdev', params) return client.call('bdev_malloc_create', params)
def delete_malloc_bdev(client, name): def delete_malloc_bdev(client, name):

2
scripts/spdkcli/ui_root.py
View File

@ -127,7 +127,7 @@ class UIRoot(UINode):
@verbose @verbose
def create_malloc_bdev(self, **kwargs): def create_malloc_bdev(self, **kwargs):
response = rpc.bdev.construct_malloc_bdev(self.client, **kwargs) response = rpc.bdev.bdev_malloc_create(self.client, **kwargs)
return response return response
@verbose @verbose

4
test/bdev/bdev_raid.sh
View File

@ -61,8 +61,8 @@ function on_error_exit() {
function configure_raid_bdev() { function configure_raid_bdev() {
rm -rf $testdir/rpcs.txt rm -rf $testdir/rpcs.txt
echo construct_malloc_bdev 32 512 -b Base_1 >> $testdir/rpcs.txt echo bdev_malloc_create 32 512 -b Base_1 >> $testdir/rpcs.txt
echo construct_malloc_bdev 32 512 -b Base_2 >> $testdir/rpcs.txt echo bdev_malloc_create 32 512 -b Base_2 >> $testdir/rpcs.txt
echo construct_raid_bdev -z 64 -r 0 -b \"Base_1 Base_2\" -n raid0 >> $testdir/rpcs.txt echo construct_raid_bdev -z 64 -r 0 -b \"Base_1 Base_2\" -n raid0 >> $testdir/rpcs.txt
$rpc_py < $testdir/rpcs.txt $rpc_py < $testdir/rpcs.txt

16
test/config_converter/spdk_config.json
View File

@ -61,7 +61,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc0" "name": "Malloc0"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -69,7 +69,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc1" "name": "Malloc1"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -77,7 +77,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc2" "name": "Malloc2"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -85,7 +85,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc3" "name": "Malloc3"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -93,7 +93,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc4" "name": "Malloc4"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -101,7 +101,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc5" "name": "Malloc5"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -109,7 +109,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc6" "name": "Malloc6"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -117,7 +117,7 @@
"num_blocks": 32768, "num_blocks": 32768,
"name": "Malloc7" "name": "Malloc7"
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {

2
test/fuzz/autofuzz_nvmf.sh
View File

@ -32,7 +32,7 @@ trap 'process_shm --id $NVMF_APP_SHM_ID; rm -f $testdir/nvmf_fuzz.conf; killproc
waitforlisten $nvmfpid waitforlisten $nvmfpid
$rpc_py nvmf_create_transport -t $TEST_TRANSPORT -u 8192 $rpc_py nvmf_create_transport -t $TEST_TRANSPORT -u 8192
$rpc_py construct_malloc_bdev -b Malloc0 64 512 $rpc_py bdev_malloc_create -b Malloc0 64 512
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0

6
test/fuzz/autofuzz_vhost.sh
View File

@ -42,7 +42,7 @@ waitforlisten $fuzzpid $FUZZ_RPC_SOCK
trap 'killprocess $vhostpid; killprocess $fuzzpid; exit 1' SIGINT SIGTERM exit trap 'killprocess $vhostpid; killprocess $fuzzpid; exit 1' SIGINT SIGTERM exit
if [ "$TEST_TRANSPORT" == "bdev" ] || [ "$TEST_TRANSPORT" == "all" ]; then if [ "$TEST_TRANSPORT" == "bdev" ] || [ "$TEST_TRANSPORT" == "all" ]; then
$vhost_rpc_py construct_malloc_bdev -b Malloc0 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc0 64 512
$vhost_rpc_py construct_vhost_blk_controller Vhost.1 Malloc0 $vhost_rpc_py construct_vhost_blk_controller Vhost.1 Malloc0
# test the vhost blk controller with valid data buffers. # test the vhost blk controller with valid data buffers.
@ -50,11 +50,11 @@ if [ "$TEST_TRANSPORT" == "bdev" ] || [ "$TEST_TRANSPORT" == "all" ]; then
fi fi
if [ "$TEST_TRANSPORT" == "scsi" ] || [ "$TEST_TRANSPORT" == "all" ]; then if [ "$TEST_TRANSPORT" == "scsi" ] || [ "$TEST_TRANSPORT" == "all" ]; then
$vhost_rpc_py construct_malloc_bdev -b Malloc1 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc1 64 512
$vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.1 $vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.1
$vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.1 0 Malloc1 $vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.1 0 Malloc1
$vhost_rpc_py construct_malloc_bdev -b Malloc2 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc2 64 512
$vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.2 $vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.2
$vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.2 0 Malloc2 $vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.2 0 Malloc2

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

@ -31,7 +31,7 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "Malloc0:0" ==> use Malloc0 blockdev for LUN0 # "Malloc0:0" ==> use Malloc0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -47,7 +47,7 @@ $rpc_py add_iscsi_auth_group 1 -c 'user:root secret:tester'
$rpc_py set_iscsi_discovery_auth -g 1 $rpc_py set_iscsi_discovery_auth -g 1
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev -b MyBdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create -b MyBdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "MyBdev:0" ==> use MyBdev blockdev for LUN0 # "MyBdev:0" ==> use MyBdev blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -82,7 +82,7 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "Malloc0:0" ==> use Malloc0 blockdev for LUN0 # "Malloc0:0" ==> use Malloc0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -26,7 +26,7 @@ waitforlisten $pid
$rpc_py set_iscsi_options -o 30 -a 4 -b $node_base $rpc_py set_iscsi_options -o 30 -a 4 -b $node_base
$rpc_py start_subsystem_init $rpc_py start_subsystem_init
$rootdir/scripts/gen_nvme.sh --json | $rpc_py load_subsystem_config $rootdir/scripts/gen_nvme.sh --json | $rpc_py load_subsystem_config
$rpc_py construct_malloc_bdev 512 4096 --name Malloc0 $rpc_py bdev_malloc_create 512 4096 --name Malloc0
echo "iscsi_tgt is listening. Running tests..." echo "iscsi_tgt is listening. Running tests..."
timing_exit start_iscsi_tgt timing_exit start_iscsi_tgt

6
test/iscsi_tgt/fio/fio.sh
View File

@ -81,10 +81,10 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
# Create a RAID-0 bdev from two malloc bdevs # Create a RAID-0 bdev from two malloc bdevs
malloc_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) " malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs" $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
bdev=$( $rpc_py construct_malloc_bdev 1024 512 ) bdev=$( $rpc_py bdev_malloc_create 1024 512 )
# "raid0:0" ==> use raid0 blockdev for LUN0 # "raid0:0" ==> use raid0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -31,7 +31,7 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "Malloc0:0" ==> use Malloc0 blockdev for LUN0 # "Malloc0:0" ==> use Malloc0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -29,7 +29,7 @@ function rpc_config() {
# $1 = RPC server address # $1 = RPC server address
# $2 = Netmask # $2 = Netmask
$rpc_py -s $1 add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $2 $rpc_py -s $1 add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $2
$rpc_py -s $1 construct_malloc_bdev 64 512 $rpc_py -s $1 bdev_malloc_create 64 512
} }
function rpc_add_target_node() { function rpc_add_target_node() {

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

@ -48,13 +48,13 @@ for i in $(seq 1 $NUM_LVS); do
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
if [ $i -eq 1 ]; then if [ $i -eq 1 ]; then
# construct RAID bdev and put its name in $bdev # construct RAID bdev and put its name in $bdev
malloc_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) " malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs" $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
bdev="raid0" bdev="raid0"
else else
# construct malloc bdev and put its name in $bdev # construct malloc bdev and put its name in $bdev
bdev=$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) bdev=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
fi fi
ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576) ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576)
LUNs="" LUNs=""

2
test/iscsi_tgt/nvme_remote/fio_remote_nvme.sh
View File

@ -65,7 +65,7 @@ waitforlisten $nvmfpid
$rpc_py start_subsystem_init $rpc_py start_subsystem_init
$rpc_py nvmf_create_transport -t RDMA -u 8192 $rpc_py nvmf_create_transport -t RDMA -u 8192
echo "NVMf target has started." echo "NVMf target has started."
bdevs=$($rpc_py construct_malloc_bdev 64 512) bdevs=$($rpc_py bdev_malloc_create 64 512)
$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
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT
for bdev in $bdevs; do for bdev in $bdevs; do

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

@ -67,7 +67,7 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "Malloc0:0" ==> use Malloc0 blockdev for LUN0 # "Malloc0:0" ==> use Malloc0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

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

@ -38,7 +38,7 @@ timing_exit start_iscsi_tgt
$rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT $rpc_py add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK $rpc_py add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE
# "Malloc0:0" ==> use Malloc0 blockdev for LUN0 # "Malloc0:0" ==> use Malloc0 blockdev for LUN0
# "1:2" ==> map PortalGroup1 to InitiatorGroup2 # "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "64" ==> iSCSI queue depth 64 # "64" ==> iSCSI queue depth 64

8
test/iscsi_tgt/rpc_config/rpc_config.py
View File

@ -101,7 +101,7 @@ def verify_iscsi_connection_rpc_methods(rpc_py):
verify(not jsonvalue, 1, verify(not jsonvalue, 1,
"get_iscsi_connections returned {}, expected empty".format(jsonvalue)) "get_iscsi_connections returned {}, expected empty".format(jsonvalue))
rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size']) rpc.bdev_malloc_create(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port']))) rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask']) rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])
@ -142,7 +142,7 @@ def verify_scsi_devices_rpc_methods(rpc_py):
verify(not jsonvalue, 1, verify(not jsonvalue, 1,
"get_scsi_devices returned {}, expected empty".format(jsonvalue)) "get_scsi_devices returned {}, expected empty".format(jsonvalue))
rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size']) rpc.bdev_malloc_create(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port']))) rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask']) rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])
@ -179,7 +179,7 @@ def create_malloc_bdevs_rpc_methods(rpc_py, rpc_param):
rpc = spdk_rpc(rpc_py) rpc = spdk_rpc(rpc_py)
for i in range(1, rpc_param['lun_total'] + 1): for i in range(1, rpc_param['lun_total'] + 1):
rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size']) rpc.bdev_malloc_create(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
print("create_malloc_bdevs_rpc_methods passed") print("create_malloc_bdevs_rpc_methods passed")
@ -330,7 +330,7 @@ def verify_target_nodes_rpc_methods(rpc_py, rpc_param):
verify(not jsonvalues, 1, verify(not jsonvalues, 1,
"get_target_nodes returned {}, expected empty".format(jsonvalues)) "get_target_nodes returned {}, expected empty".format(jsonvalues))
rpc.construct_malloc_bdev(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size']) rpc.bdev_malloc_create(rpc_param['malloc_bdev_size'], rpc_param['malloc_block_size'])
rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port']))) rpc.add_portal_group(portal_tag, "{}:{}".format(rpc_param['target_ip'], str(rpc_param['port'])))
rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask']) rpc.add_initiator_group(initiator_tag, rpc_param['initiator_name'], rpc_param['netmask'])

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

@ -59,7 +59,7 @@ RPCS+="add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK\n"
echo "Create bdevs and target nodes" echo "Create bdevs and target nodes"
CONNECTION_NUMBER=15 CONNECTION_NUMBER=15
for i in $(seq 0 $CONNECTION_NUMBER); do for i in $(seq 0 $CONNECTION_NUMBER); do
RPCS+="construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i\n" RPCS+="bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i\n"
RPCS+="construct_target_node Target$i Target${i}_alias "Malloc$i:0" $PORTAL_TAG:$INITIATOR_TAG 256 -d\n" RPCS+="construct_target_node Target$i Target${i}_alias "Malloc$i:0" $PORTAL_TAG:$INITIATOR_TAG 256 -d\n"
done done
echo -e $RPCS | $rpc_py echo -e $RPCS | $rpc_py

2
test/json_config/clear_config.py
View File

@ -31,7 +31,7 @@ def get_bdev_name(bdev):
def get_bdev_destroy_method(bdev): def get_bdev_destroy_method(bdev):
destroy_method_map = {'construct_malloc_bdev': "delete_malloc_bdev", destroy_method_map = {'bdev_malloc_create': "delete_malloc_bdev",
'construct_null_bdev': "delete_null_bdev", 'construct_null_bdev': "delete_null_bdev",
'construct_rbd_bdev': "delete_rbd_bdev", 'construct_rbd_bdev': "delete_rbd_bdev",
'construct_pmem_bdev': "delete_pmem_bdev", 'construct_pmem_bdev': "delete_pmem_bdev",

18
test/json_config/json_config.sh
View File

@ -168,13 +168,13 @@ function create_bdev_subsystem_config() {
tgt_rpc construct_split_vbdev $lvol_store_base_bdev 2 tgt_rpc construct_split_vbdev $lvol_store_base_bdev 2
tgt_rpc construct_split_vbdev Malloc0 3 tgt_rpc construct_split_vbdev Malloc0 3
tgt_rpc construct_malloc_bdev 8 4096 --name Malloc3 tgt_rpc bdev_malloc_create 8 4096 --name Malloc3
tgt_rpc construct_passthru_bdev -b Malloc3 -p PTBdevFromMalloc3 tgt_rpc construct_passthru_bdev -b Malloc3 -p PTBdevFromMalloc3
tgt_rpc construct_null_bdev Null0 32 512 tgt_rpc construct_null_bdev Null0 32 512
tgt_rpc construct_malloc_bdev 32 512 --name Malloc0 tgt_rpc bdev_malloc_create 32 512 --name Malloc0
tgt_rpc construct_malloc_bdev 16 4096 --name Malloc1 tgt_rpc bdev_malloc_create 16 4096 --name Malloc1
expected_notifications+=( expected_notifications+=(
bdev_register:${lvol_store_base_bdev} bdev_register:${lvol_store_base_bdev}
@ -215,7 +215,7 @@ function create_bdev_subsystem_config() {
fi fi
if [[ $SPDK_TEST_CRYPTO -eq 1 ]]; then if [[ $SPDK_TEST_CRYPTO -eq 1 ]]; then
tgt_rpc construct_malloc_bdev 8 1024 --name MallocForCryptoBdev tgt_rpc bdev_malloc_create 8 1024 --name MallocForCryptoBdev
if [[ $(lspci -d:37c8 | wc -l) -eq 0 ]]; then if [[ $(lspci -d:37c8 | wc -l) -eq 0 ]]; then
local crypto_dirver=crypto_aesni_mb local crypto_dirver=crypto_aesni_mb
else else
@ -278,7 +278,7 @@ function cleanup_bdev_subsystem_config() {
function create_vhost_subsystem_config() { function create_vhost_subsystem_config() {
timing_enter $FUNCNAME timing_enter $FUNCNAME
tgt_rpc construct_malloc_bdev 64 1024 --name MallocForVhost0 tgt_rpc bdev_malloc_create 64 1024 --name MallocForVhost0
tgt_rpc construct_split_vbdev MallocForVhost0 8 tgt_rpc construct_split_vbdev MallocForVhost0 8
tgt_rpc construct_vhost_scsi_controller VhostScsiCtrlr0 tgt_rpc construct_vhost_scsi_controller VhostScsiCtrlr0
@ -297,7 +297,7 @@ function create_vhost_subsystem_config() {
function create_iscsi_subsystem_config() { function create_iscsi_subsystem_config() {
timing_enter $FUNCNAME timing_enter $FUNCNAME
tgt_rpc construct_malloc_bdev 64 1024 --name MallocForIscsi0 tgt_rpc bdev_malloc_create 64 1024 --name MallocForIscsi0
tgt_rpc add_portal_group $PORTAL_TAG 127.0.0.1:$ISCSI_PORT tgt_rpc add_portal_group $PORTAL_TAG 127.0.0.1:$ISCSI_PORT
tgt_rpc add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK tgt_rpc add_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
tgt_rpc construct_target_node Target3 Target3_alias 'MallocForIscsi0:0' $PORTAL_TAG:$INITIATOR_TAG 64 -d tgt_rpc construct_target_node Target3 Target3_alias 'MallocForIscsi0:0' $PORTAL_TAG:$INITIATOR_TAG 64 -d
@ -314,8 +314,8 @@ function create_nvmf_subsystem_config() {
return 1 return 1
fi fi
tgt_rpc construct_malloc_bdev 8 512 --name MallocForNvmf0 tgt_rpc bdev_malloc_create 8 512 --name MallocForNvmf0
tgt_rpc construct_malloc_bdev 4 1024 --name MallocForNvmf1 tgt_rpc bdev_malloc_create 4 1024 --name MallocForNvmf1
tgt_rpc nvmf_create_transport -t RDMA -u 8192 -c 0 tgt_rpc nvmf_create_transport -t RDMA -u 8192 -c 0
tgt_rpc nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 tgt_rpc nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001
@ -375,7 +375,7 @@ function json_config_test_init()
create_virtio_initiator_config create_virtio_initiator_config
fi fi
tgt_rpc construct_malloc_bdev 8 512 --name MallocBdevForConfigChangeCheck tgt_rpc bdev_malloc_create 8 512 --name MallocBdevForConfigChangeCheck
timing_exit $FUNCNAME timing_exit $FUNCNAME
} }

6
test/lvol/rpc_commands_lib.py
View File

@ -107,9 +107,9 @@ class Commands_Rpc(object):
return 2 return 2
return 0 return 0
def construct_malloc_bdev(self, total_size, block_size): def bdev_malloc_create(self, total_size, block_size):
print("INFO: RPC COMMAND construct_malloc_bdev") print("INFO: RPC COMMAND bdev_malloc_create")
output = self.rpc.construct_malloc_bdev(total_size, block_size)[0] output = self.rpc.bdev_malloc_create(total_size, block_size)[0]
return output.rstrip('\n') return output.rstrip('\n')
def construct_lvol_store(self, base_name, lvs_name, cluster_size=None, clear_method=None): def construct_lvol_store(self, base_name, lvs_name, cluster_size=None, clear_method=None):

212
test/lvol/test_cases.py
View File

@ -324,8 +324,8 @@ class TestCases(object):
Call construct_lvol_store with correct base bdev name. Call construct_lvol_store with correct base bdev name.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -353,8 +353,8 @@ class TestCases(object):
Call construct_lvol_bdev with correct lvol store UUID and size in MiB for this bdev Call construct_lvol_bdev with correct lvol store UUID and size in MiB for this bdev
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on correct, exisitng malloc bdev # Create lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -391,8 +391,8 @@ class TestCases(object):
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
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on correct, exisitng malloc bdev # Construct lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -435,8 +435,8 @@ class TestCases(object):
instead of uuid when referencing to lvol store. instead of uuid when referencing to lvol store.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -472,10 +472,10 @@ class TestCases(object):
if they are created on separate logical volume stores. if they are created on separate logical volume stores.
""" """
# Construct two malloc bdevs # Construct two malloc bdevs
base_name_1 = self.c.construct_malloc_bdev(self.total_size, base_name_1 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
base_name_2 = self.c.construct_malloc_bdev(self.total_size, base_name_2 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume stores on created malloc bdevs # Create logical volume stores on created malloc bdevs
uuid_store_1 = self.c.construct_lvol_store(base_name_1, uuid_store_1 = self.c.construct_lvol_store(base_name_1,
self.lvs_name + "1") self.lvs_name + "1")
@ -543,8 +543,8 @@ class TestCases(object):
Call construct_lvol_bdev on a full lvol store. Call construct_lvol_bdev on a full lvol store.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume store on malloc bdev # Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -587,8 +587,8 @@ class TestCases(object):
friendly name twice on the same logical volume store. friendly name twice on the same logical volume store.
""" """
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create logical volume store on malloc bdev # Create logical volume store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -630,8 +630,8 @@ class TestCases(object):
Call resize_lvol_bdev with correct logical_volumes name and new size. Call resize_lvol_bdev with correct logical_volumes name and new size.
""" """
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -703,8 +703,8 @@ class TestCases(object):
Call resize_lvol_store with size argument bigger than size of base bdev. Call resize_lvol_store with size argument bigger than size of base bdev.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -744,8 +744,8 @@ class TestCases(object):
Call destroy_lvol_store with correct logical_volumes name Call destroy_lvol_store with correct logical_volumes name
""" """
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on created malloc bdev # Create lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -775,8 +775,8 @@ class TestCases(object):
Call destroy_lvol_store with correct logical volume name Call destroy_lvol_store with correct logical volume name
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -806,8 +806,8 @@ class TestCases(object):
Call destroy_lvol_store with correct logical_volumes name Call destroy_lvol_store with correct logical_volumes name
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -848,8 +848,8 @@ class TestCases(object):
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
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on correct, exisitng malloc bdev # Construct lvol store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -888,8 +888,8 @@ class TestCases(object):
Call destroy_lvol_store with correct logical_volumes name. Call destroy_lvol_store with correct logical_volumes name.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on create malloc bdev # Construct lvol store on create malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1015,8 +1015,8 @@ class TestCases(object):
Lvol store should be automatically removed on deleting underlying bdev. Lvol store should be automatically removed on deleting underlying bdev.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1067,8 +1067,8 @@ class TestCases(object):
Call construct_lvol_store with base bdev name twice. Call construct_lvol_store with base bdev name twice.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1094,11 +1094,11 @@ class TestCases(object):
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name_1 = self.c.construct_malloc_bdev(self.total_size, base_name_1 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct second malloc bdev # Construct second malloc bdev
base_name_2 = self.c.construct_malloc_bdev(self.total_size, base_name_2 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on first malloc # Construct lvol store on first malloc
uuid_store_1 = self.c.construct_lvol_store(base_name_1, uuid_store_1 = self.c.construct_lvol_store(base_name_1,
self.lvs_name) self.lvs_name)
@ -1129,8 +1129,8 @@ class TestCases(object):
Call construct_lvol_bdev on a full lvol store. Call construct_lvol_bdev on a full lvol store.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1179,8 +1179,8 @@ class TestCases(object):
Call construct_lvol_store with correct base bdev name. Call construct_lvol_store with correct base bdev name.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1212,8 +1212,8 @@ class TestCases(object):
clone_name = "clone" clone_name = "clone"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name, self.lvs_name,
@ -1277,8 +1277,8 @@ class TestCases(object):
clone_name = "clone" clone_name = "clone"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name, self.lvs_name,
@ -1338,8 +1338,8 @@ class TestCases(object):
clone_name = "clone" clone_name = "clone"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev # Construct_lvol_store on correct, exisitng malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name, self.lvs_name,
@ -1385,8 +1385,8 @@ class TestCases(object):
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct_lvol_store on correct, exisitng malloc bdev and cluster size equal # Construct_lvol_store on correct, exisitng malloc bdev and cluster size equal
# malloc bdev size in bytes + 1B # malloc bdev size in bytes + 1B
lvol_uuid = self.c.construct_lvol_store(base_name, lvol_uuid = self.c.construct_lvol_store(base_name,
@ -1411,8 +1411,8 @@ class TestCases(object):
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Try construct lvol store on malloc bdev with cluster size 8191 # Try construct lvol store on malloc bdev with cluster size 8191
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, 8191) lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, 8191)
# Verify that lvol store was not created # Verify that lvol store was not created
@ -1434,24 +1434,24 @@ class TestCases(object):
""" """
fail_count = 0 fail_count = 0
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'none' # Construct lvol store with clear method 'none'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="none") lvol_uuid = self.c.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_get_lvol_stores(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
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'unmap' # Construct lvol store with clear method 'unmap'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="unmap") lvol_uuid = self.c.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_get_lvol_stores(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
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store with clear method 'write_zeroes' # Construct lvol store with clear method 'write_zeroes'
lvol_uuid = self.c.construct_lvol_store(base_name, self.lvs_name, clear_method="write_zeroes") lvol_uuid = self.c.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_get_lvol_stores(base_name, lvol_uuid)
@ -1471,8 +1471,8 @@ class TestCases(object):
if we write to created thin provisioned lvol bdev if we write to created thin provisioned lvol bdev
""" """
# create malloc bdev # create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# create lvol store on mamloc bdev # create lvol store on mamloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1551,8 +1551,8 @@ class TestCases(object):
and check if we can read from this device and it returns zeroes. and check if we can read from this device and it returns zeroes.
""" """
# create malloc bdev # create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1609,8 +1609,8 @@ class TestCases(object):
were properly written (fio test with verification). were properly written (fio test with verification).
""" """
# create malloc bdev # create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -1651,8 +1651,8 @@ class TestCases(object):
Check thin provisioned bdev resize. Check thin provisioned bdev resize.
""" """
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.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_get_lvol_stores(base_name, uuid_store,
@ -1725,8 +1725,8 @@ class TestCases(object):
will cause failures. will cause failures.
""" """
# create malloc bdev # create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.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_get_lvol_stores(base_name, uuid_store,
@ -1796,8 +1796,8 @@ class TestCases(object):
less than total size of lvol store will end with success less than total size of lvol store will end with success
""" """
# create malloc bdev # create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# construct lvol store on malloc bdev # construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name) uuid_store = self.c.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_get_lvol_stores(base_name, uuid_store,
@ -2132,8 +2132,8 @@ class TestCases(object):
nbd_name0 = "/dev/nbd0" nbd_name0 = "/dev/nbd0"
snapshot_name = "snapshot0" snapshot_name = "snapshot0"
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2186,8 +2186,8 @@ class TestCases(object):
snapshot_name0 = "snapshot0" snapshot_name0 = "snapshot0"
snapshot_name1 = "snapshot1" snapshot_name1 = "snapshot1"
# Construct mallov bdev # Construct mallov bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2261,8 +2261,8 @@ class TestCases(object):
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
snapshot_name = "snapshot" snapshot_name = "snapshot"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2316,8 +2316,8 @@ class TestCases(object):
snapshot_name0 = "snapshot0" snapshot_name0 = "snapshot0"
snapshot_name1 = "snapshot1" snapshot_name1 = "snapshot1"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2363,8 +2363,8 @@ class TestCases(object):
clone_name = "clone" clone_name = "clone"
snapshot_name = "snapshot" snapshot_name = "snapshot"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store # Construct lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2426,8 +2426,8 @@ class TestCases(object):
clone_name0 = "clone0" clone_name0 = "clone0"
clone_name1 = "clone1" clone_name1 = "clone1"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2499,8 +2499,8 @@ class TestCases(object):
lbd_name = clone_name1 lbd_name = clone_name1
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2588,8 +2588,8 @@ class TestCases(object):
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
@ -2679,8 +2679,8 @@ class TestCases(object):
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
@ -2750,8 +2750,8 @@ class TestCases(object):
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store # Create lvol store
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
@ -2850,8 +2850,8 @@ class TestCases(object):
nbd_name1 = "/dev/nbd1" nbd_name1 = "/dev/nbd1"
clone_name = "clone0" clone_name = "clone0"
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2914,8 +2914,8 @@ class TestCases(object):
nbd_name1 = "/dev/nbd1" nbd_name1 = "/dev/nbd1"
snapshot_name = "snapshot" snapshot_name = "snapshot"
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -2994,8 +2994,8 @@ class TestCases(object):
snapshot_name = "snapshot" snapshot_name = "snapshot"
snapshot_name2 = "snapshot2" snapshot_name2 = "snapshot2"
# Construct malloc bdev # Construct malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on malloc bdev # Construct lvol store on malloc bdev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -3115,8 +3115,8 @@ class TestCases(object):
bdev_aliases = ["/".join([self.lvs_name, name]) for name in bdev_names] bdev_aliases = ["/".join([self.lvs_name, name]) for name in bdev_names]
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bdev # Construct lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_name, lvs_uuid = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)
@ -3227,10 +3227,10 @@ class TestCases(object):
bdev_uuids_2 = [] bdev_uuids_2 = []
# Construct two malloc bdevs # Construct two malloc bdevs
base_bdev_1 = self.c.construct_malloc_bdev(self.total_size, base_bdev_1 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
base_bdev_2 = self.c.construct_malloc_bdev(self.total_size, base_bdev_2 = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on each malloc bdev # Create lvol store on each malloc bdev
lvs_uuid_1 = self.c.construct_lvol_store(base_bdev_1, lvs_uuid_1 = self.c.construct_lvol_store(base_bdev_1,
@ -3336,8 +3336,8 @@ class TestCases(object):
fail_count = 0 fail_count = 0
# Construt malloc bdev # Construt malloc bdev
base_bdev = self.c.construct_malloc_bdev(self.total_size, base_bdev = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Create lvol store on created malloc bdev # Create lvol store on created malloc bdev
lvs_uuid = self.c.construct_lvol_store(base_bdev, lvs_uuid = self.c.construct_lvol_store(base_bdev,
self.lvs_name) self.lvs_name)
@ -3387,8 +3387,8 @@ class TestCases(object):
""" """
pid_path = path.join(self.path, 'vhost.pid') pid_path = path.join(self.path, 'vhost.pid')
# Create malloc bdev # Create malloc bdev
base_name = self.c.construct_malloc_bdev(self.total_size, base_name = self.c.bdev_malloc_create(self.total_size,
self.block_size) self.block_size)
# Construct lvol store on created malloc bddev # Construct lvol store on created malloc bddev
uuid_store = self.c.construct_lvol_store(base_name, uuid_store = self.c.construct_lvol_store(base_name,
self.lvs_name) self.lvs_name)

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

@ -13,7 +13,7 @@ nvmfappstart "-m 0xF"
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
$rpc_py construct_malloc_bdev 64 512 --name Malloc0 $rpc_py bdev_malloc_create 64 512 --name Malloc0
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -m 2 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -m 2
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT
@ -36,7 +36,7 @@ aerpid=$!
waitforfile $AER_TOUCH_FILE waitforfile $AER_TOUCH_FILE
# Add a new namespace # Add a new namespace
$rpc_py construct_malloc_bdev 64 4096 --name Malloc1 $rpc_py bdev_malloc_create 64 4096 --name Malloc1
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1 -n 2 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1 -n 2
$rpc_py get_nvmf_subsystems $rpc_py get_nvmf_subsystems

2
test/nvmf/host/bdevperf.sh
View File

@ -24,7 +24,7 @@ waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
timing_exit start_nvmf_tgt timing_exit start_nvmf_tgt
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

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

@ -27,7 +27,7 @@ waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
timing_exit start_nvmf_tgt timing_exit start_nvmf_tgt
$rpc_py construct_malloc_bdev 64 512 -b Malloc1 $rpc_py bdev_malloc_create 64 512 -b Malloc1
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

2
test/nvmf/host/identify.sh
View File

@ -24,7 +24,7 @@ waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
timing_exit start_nvmf_tgt timing_exit start_nvmf_tgt
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$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
# NOTE: This will assign the same NGUID and EUI64 to all bdevs, # NOTE: This will assign the same NGUID and EUI64 to all bdevs,
# but currently we only have one (see above), so this is OK. # but currently we only have one (see above), so this is OK.

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

@ -18,7 +18,7 @@ nvmfappstart "-m 0xF"
$rootdir/scripts/gen_nvme.sh --json | $rpc_py load_subsystem_config $rootdir/scripts/gen_nvme.sh --json | $rpc_py load_subsystem_config
local_nvme_trid="trtype:PCIe traddr:"$($rpc_py get_subsystem_config bdev | jq -r '.[].params | select(.name=="Nvme0").traddr') local_nvme_trid="trtype:PCIe traddr:"$($rpc_py get_subsystem_config bdev | jq -r '.[].params | select(.name=="Nvme0").traddr')
bdevs="$bdevs $($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" bdevs="$bdevs $($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
if [ -n "$local_nvme_trid" ]; then if [ -n "$local_nvme_trid" ]; then
bdevs="$bdevs Nvme0n1" bdevs="$bdevs Nvme0n1"

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

@ -19,7 +19,7 @@ $rpc_py set_bdev_options -p 5 -c 1
$rpc_py start_subsystem_init $rpc_py start_subsystem_init
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

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

@ -15,7 +15,7 @@ nvmftestinit
nvmfappstart "-m 0xF" nvmfappstart "-m 0xF"
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

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

@ -18,7 +18,7 @@ nvmfappstart "-m 0xF"
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -c 0 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -c 0
bdev="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" bdev="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$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
$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/filesystem.sh
View File

@ -19,7 +19,7 @@ for incapsule in 0 4096; do
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -c $incapsule $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -c $incapsule
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc1
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

8
test/nvmf/target/fio.sh
View File

@ -16,11 +16,11 @@ nvmfappstart "-m 0xF"
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
malloc_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) " malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
malloc_bdevs+="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
# Create a RAID-0 bdev from two malloc bdevs # Create a RAID-0 bdev from two malloc bdevs
raid_malloc_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) " raid_malloc_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
raid_malloc_bdevs+="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" raid_malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$raid_malloc_bdevs" $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$raid_malloc_bdevs"
$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

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

@ -19,7 +19,7 @@ trap 'process_shm --id $NVMF_APP_SHM_ID; rm -f $testdir/nvmf_fuzz.conf; killproc
waitforlisten $nvmfpid waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
$rpc_py construct_malloc_bdev -b Malloc0 64 512 $rpc_py bdev_malloc_create -b Malloc0 64 512
$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
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0

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

@ -28,7 +28,7 @@ $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
for i in $(seq 1 $NVMF_SUBSYS) for i in $(seq 1 $NVMF_SUBSYS)
do do
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK$i $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK$i
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT

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

@ -19,7 +19,7 @@ NVMF_SECOND_TARGET_IP=$(echo "$RDMA_IP_LIST" | sed -n 2p)
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
# Create subsystems # Create subsystems
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK1 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK1
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s "$NVMF_PORT" $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s "$NVMF_PORT"

4
test/nvmf/target/nvme_cli.sh
View File

@ -23,8 +23,8 @@ nvmfappstart "-m 0xF"
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc0
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0 $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 Malloc0

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

@ -27,8 +27,8 @@ fi
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
# Construct a RAID volume for the logical volume store # Construct a RAID volume for the logical volume store
base_bdevs="$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) " base_bdevs="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) "
base_bdevs+=$($rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE) base_bdevs+=$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs" $rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs"
# Create the logical volume store on the RAID volume # Create the logical volume store on the RAID volume

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

@ -40,7 +40,7 @@ waitforlisten $vhostpid $NVMF_SOCK
trap 'process_shm --id $NVMF_APP_SHM_ID; killprocess $vhostpid nvmftestfini; exit 1' SIGINT SIGTERM EXIT trap 'process_shm --id $NVMF_APP_SHM_ID; killprocess $vhostpid nvmftestfini; exit 1' SIGINT SIGTERM EXIT
# Configure NVMF tgt on host machine # Configure NVMF tgt on host machine
malloc_bdev="$($NVMF_RPC construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)" malloc_bdev="$($NVMF_RPC bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$NVMF_RPC nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -p 4 $NVMF_RPC nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -p 4
$NVMF_RPC nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 $NVMF_RPC nvmf_subsystem_create nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001

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

@ -53,7 +53,7 @@ fi
MALLOC_BDEV_SIZE=64 MALLOC_BDEV_SIZE=64
MALLOC_BLOCK_SIZE=512 MALLOC_BLOCK_SIZE=512
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1 $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc1
# Disallow host NQN and make sure connect fails # Disallow host NQN and make sure connect fails
$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

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

@ -56,7 +56,7 @@ timing_enter create_subsystems
rm -rf $testdir/rpcs.txt rm -rf $testdir/rpcs.txt
for i in $(seq 1 $num_subsystems) for i in $(seq 1 $num_subsystems)
do do
echo construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i >> $testdir/rpcs.txt echo bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i >> $testdir/rpcs.txt
echo nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK$i >> $testdir/rpcs.txt echo nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK$i >> $testdir/rpcs.txt
echo nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i >> $testdir/rpcs.txt echo nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i >> $testdir/rpcs.txt
echo nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT >> $testdir/rpcs.txt echo nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT >> $testdir/rpcs.txt

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

@ -25,7 +25,7 @@ $rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192 -s 1024
for i in $(seq 0 5); do for i in $(seq 0 5); do
$rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK00000000000001 $rpc_py nvmf_subsystem_create nqn.2016-06.io.spdk:cnode$i -a -s SPDK00000000000001
$rpc_py construct_malloc_bdev $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i $rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE -b Malloc$i
$rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i $rpc_py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode$i Malloc$i
$rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT $rpc_py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode$i -t $TEST_TRANSPORT -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT
nvme connect -t $TEST_TRANSPORT -n "nqn.2016-06.io.spdk:cnode${i}" -a "$NVMF_FIRST_TARGET_IP" -s "$NVMF_PORT" -i 16 nvme connect -t $TEST_TRANSPORT -n "nqn.2016-06.io.spdk:cnode${i}" -a "$NVMF_FIRST_TARGET_IP" -s "$NVMF_PORT" -i 16

4
test/ocf/management/create-destruct.sh
View File

@ -22,8 +22,8 @@ trap 'killprocess $spdk_pid; exit 1' SIGINT SIGTERM EXIT
waitforlisten $spdk_pid waitforlisten $spdk_pid
$rpc_py construct_malloc_bdev 101 512 -b Malloc0 $rpc_py bdev_malloc_create 101 512 -b Malloc0
$rpc_py construct_malloc_bdev 101 512 -b Malloc1 $rpc_py bdev_malloc_create 101 512 -b Malloc1
$rpc_py construct_ocf_bdev PartCache wt Malloc0 NonExisting $rpc_py construct_ocf_bdev PartCache wt Malloc0 NonExisting

12
test/ocf/management/multicore.sh
View File

@ -24,8 +24,8 @@ start_spdk
# Hotplug case # Hotplug case
$rpc_py construct_malloc_bdev 1 512 -b Core0 $rpc_py bdev_malloc_create 1 512 -b Core0
$rpc_py construct_malloc_bdev 1 512 -b Core1 $rpc_py bdev_malloc_create 1 512 -b Core1
$rpc_py construct_ocf_bdev C1 wt Cache Core0 $rpc_py construct_ocf_bdev C1 wt Cache Core0
$rpc_py construct_ocf_bdev C2 wt Cache Core1 $rpc_py construct_ocf_bdev C2 wt Cache Core1
@ -33,7 +33,7 @@ $rpc_py construct_ocf_bdev C2 wt Cache Core1
$rpc_py get_ocf_bdevs | jq -e \ $rpc_py get_ocf_bdevs | jq -e \
'any(select(.started)) == false' 'any(select(.started)) == false'
$rpc_py construct_malloc_bdev 101 512 -b Cache $rpc_py bdev_malloc_create 101 512 -b Cache
$rpc_py get_ocf_bdevs | jq -e \ $rpc_py get_ocf_bdevs | jq -e \
'all(select(.started)) == true' 'all(select(.started)) == true'
@ -57,9 +57,9 @@ stop_spdk
# Hotremove case # Hotremove case
start_spdk start_spdk
$rpc_py construct_malloc_bdev 101 512 -b Cache $rpc_py bdev_malloc_create 101 512 -b Cache
$rpc_py construct_malloc_bdev 101 512 -b Malloc $rpc_py bdev_malloc_create 101 512 -b Malloc
$rpc_py construct_malloc_bdev 1 512 -b Core $rpc_py bdev_malloc_create 1 512 -b Core
$rpc_py construct_ocf_bdev C1 wt Cache Malloc $rpc_py construct_ocf_bdev C1 wt Cache Malloc
$rpc_py construct_ocf_bdev C2 wt Cache Core $rpc_py construct_ocf_bdev C2 wt Cache Core

14
test/vhost/fiotest/conf.json
View File

@ -28,14 +28,14 @@
"block_size": 4096, "block_size": 4096,
"num_blocks": 32768 "num_blocks": 32768
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
"block_size": 4096, "block_size": 4096,
"num_blocks": 32768 "num_blocks": 32768
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -43,7 +43,7 @@
"num_blocks": 131072, "num_blocks": 131072,
"block_size": 512 "block_size": 512
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -51,7 +51,7 @@
"num_blocks": 131072, "num_blocks": 131072,
"block_size": 512 "block_size": 512
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -59,7 +59,7 @@
"num_blocks": 131072, "num_blocks": 131072,
"block_size": 512 "block_size": 512
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -67,7 +67,7 @@
"num_blocks": 131072, "num_blocks": 131072,
"block_size": 512 "block_size": 512
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
@ -75,7 +75,7 @@
"num_blocks": 131072, "num_blocks": 131072,
"block_size": 512 "block_size": 512
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"method": "construct_raid_bdev", "method": "construct_raid_bdev",

6
test/vhost/fuzz/fuzz.sh
View File

@ -27,14 +27,14 @@ waitforlisten $fuzzpid $FUZZ_RPC_SOCK
trap 'killprocess $vhostpid; killprocess $fuzzpid; exit 1' SIGINT SIGTERM exit trap 'killprocess $vhostpid; killprocess $fuzzpid; exit 1' SIGINT SIGTERM exit
$vhost_rpc_py construct_malloc_bdev -b Malloc0 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc0 64 512
$vhost_rpc_py construct_vhost_blk_controller Vhost.1 Malloc0 $vhost_rpc_py construct_vhost_blk_controller Vhost.1 Malloc0
$vhost_rpc_py construct_malloc_bdev -b Malloc1 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc1 64 512
$vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.1 $vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.1
$vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.1 0 Malloc1 $vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.1 0 Malloc1
$vhost_rpc_py construct_malloc_bdev -b Malloc2 64 512 $vhost_rpc_py bdev_malloc_create -b Malloc2 64 512
$vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.2 $vhost_rpc_py construct_vhost_scsi_controller naa.VhostScsi0.2
$vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.2 0 Malloc2 $vhost_rpc_py add_vhost_scsi_lun naa.VhostScsi0.2 0 Malloc2

2
test/vhost/hotplug/scsi_hotplug.sh
View File

@ -64,7 +64,7 @@ notice ""
vhost_run 0 vhost_run 0
$rpc_py set_bdev_nvme_hotplug -e $rpc_py set_bdev_nvme_hotplug -e
$rpc_py construct_split_vbdev Nvme0n1 16 $rpc_py construct_split_vbdev Nvme0n1 16
$rpc_py construct_malloc_bdev 128 512 -b Malloc $rpc_py bdev_malloc_create 128 512 -b Malloc
$rpc_py construct_split_vbdev Malloc 4 $rpc_py construct_split_vbdev Malloc 4
$rpc_py construct_split_vbdev HotInNvme0n1 2 $rpc_py construct_split_vbdev HotInNvme0n1 2
$rpc_py construct_split_vbdev HotInNvme1n1 2 $rpc_py construct_split_vbdev HotInNvme1n1 2

4
test/vhost/initiator/blockdev.sh
View File

@ -74,11 +74,11 @@ function create_bdev_config()
$RPC_PY construct_vhost_blk_controller naa.Nvme0n1_blk0.0 Nvme0n1p4 $RPC_PY construct_vhost_blk_controller naa.Nvme0n1_blk0.0 Nvme0n1p4
$RPC_PY construct_vhost_blk_controller naa.Nvme0n1_blk1.0 Nvme0n1p5 $RPC_PY construct_vhost_blk_controller naa.Nvme0n1_blk1.0 Nvme0n1p5
$RPC_PY construct_malloc_bdev 128 512 --name Malloc0 $RPC_PY bdev_malloc_create 128 512 --name Malloc0
$RPC_PY construct_vhost_scsi_controller naa.Malloc0.0 $RPC_PY construct_vhost_scsi_controller naa.Malloc0.0
$RPC_PY add_vhost_scsi_lun naa.Malloc0.0 0 Malloc0 $RPC_PY add_vhost_scsi_lun naa.Malloc0.0 0 Malloc0
$RPC_PY construct_malloc_bdev 128 4096 --name Malloc1 $RPC_PY bdev_malloc_create 128 4096 --name Malloc1
$RPC_PY construct_vhost_scsi_controller naa.Malloc1.0 $RPC_PY construct_vhost_scsi_controller naa.Malloc1.0
$RPC_PY add_vhost_scsi_lun naa.Malloc1.0 0 Malloc1 $RPC_PY add_vhost_scsi_lun naa.Malloc1.0 0 Malloc1

2
test/vhost/migration/migration-tc1.sh
View File

@ -26,7 +26,7 @@ function migration_tc1_configure_vhost()
trap 'migration_tc1_error_handler; error_exit "${FUNCNAME}" "${LINENO}"' INT ERR EXIT trap 'migration_tc1_error_handler; error_exit "${FUNCNAME}" "${LINENO}"' INT ERR EXIT
# Construct shared Malloc Bdev # Construct shared Malloc Bdev
$rpc construct_malloc_bdev -b Malloc0 128 4096 $rpc bdev_malloc_create -b Malloc0 128 4096
# And two controllers - one for each VM. Both are using the same Malloc Bdev as LUN 0 # And two controllers - one for each VM. Both are using the same Malloc Bdev as LUN 0
$rpc construct_vhost_scsi_controller $incoming_vm_ctrlr $rpc construct_vhost_scsi_controller $incoming_vm_ctrlr

4
test/vhost/other/conf.json
View File

@ -20,14 +20,14 @@
"block_size": 4096, "block_size": 4096,
"num_blocks": 32768 "num_blocks": 32768
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
}, },
{ {
"params": { "params": {
"block_size": 4096, "block_size": 4096,
"num_blocks": 32768 "num_blocks": 32768
}, },
"method": "construct_malloc_bdev" "method": "bdev_malloc_create"
} }
] ]
}, },

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

@ -69,7 +69,7 @@ function blk_ro_tc1()
local vm_dir="$VHOST_DIR/vms/$vm_no" local vm_dir="$VHOST_DIR/vms/$vm_no"
if [[ $disk =~ .*malloc.* ]]; then if [[ $disk =~ .*malloc.* ]]; then
disk_name=$($rpc_py construct_malloc_bdev 512 4096) disk_name=$($rpc_py bdev_malloc_create 512 4096)
if [ $? != 0 ]; then if [ $? != 0 ]; then
fail "Failed to create malloc bdev" fail "Failed to create malloc bdev"
fi fi

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

@ -19,7 +19,7 @@ trap 'error_exit "${FUNCNAME}" "${LINENO}"' ERR SIGTERM SIGABRT
vhost_run 0 vhost_run 0
$rpc_py construct_malloc_bdev -b Malloc 124 4096 $rpc_py bdev_malloc_create -b Malloc 124 4096
$rpc_py construct_vhost_blk_controller Malloc.0 Malloc $rpc_py construct_vhost_blk_controller Malloc.0 Malloc
run_spdk_fio --size=50% --offset=0 --filename=VirtioBlk0 & run_spdk_fio --size=50% --offset=0 --filename=VirtioBlk0 &

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

@ -96,7 +96,7 @@ notice "..."
aio_file="$testdir/aio_disk" aio_file="$testdir/aio_disk"
dd if=/dev/zero of=$aio_file bs=1M count=512 dd if=/dev/zero of=$aio_file bs=1M count=512
$rpc_py construct_aio_bdev $aio_file Aio0 512 $rpc_py construct_aio_bdev $aio_file Aio0 512
$rpc_py construct_malloc_bdev -b Malloc0 256 512 $rpc_py bdev_malloc_create -b Malloc0 256 512
$rpc_py get_bdevs $rpc_py get_bdevs
# Construct vhost controllers # Construct vhost controllers

2
test/vhost/windows/windows_scsi_compliance.sh
View File

@ -51,7 +51,7 @@ dd if=/dev/zero of=$aio_file bs=1M count=512
timing_enter vhost_run timing_enter vhost_run
vhost_run 0 vhost_run 0
$rpc_py set_bdev_nvme_hotplug -e $rpc_py set_bdev_nvme_hotplug -e
$rpc_py construct_malloc_bdev 256 4096 -b Malloc0 $rpc_py bdev_malloc_create 256 4096 -b Malloc0
$rpc_py construct_aio_bdev $aio_file Aio0 512 $rpc_py construct_aio_bdev $aio_file Aio0 512
$rpc_py get_bdevs $rpc_py get_bdevs
$rpc_py construct_vhost_scsi_controller naa.vhost.1 $rpc_py construct_vhost_scsi_controller naa.vhost.1