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":
```
$ ./scripts/rpc.py construct_malloc_bdev -b Malloc0 64 512
$ ./scripts/rpc.py construct_malloc_bdev -b Malloc1 64 512
$ ./scripts/rpc.py bdev_malloc_create -b Malloc0 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:

10
doc/jsonrpc.md
View File

@ -296,7 +296,7 @@ Example response:
"construct_nvme_bdev",
"construct_null_bdev",
"delete_malloc_bdev",
"construct_malloc_bdev",
"bdev_malloc_create",
"delete_ftl_bdev",
"construct_ftl_bdev",
"get_lvol_stores",
@ -469,7 +469,7 @@ Example response:
"name": "Malloc0",
"uuid": "913fc008-79a7-447f-b2c4-c73543638c31"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -478,7 +478,7 @@ Example response:
"name": "Malloc1",
"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
@ -1181,7 +1181,7 @@ Example request:
"uuid": "2b6601ba-eada-44fb-9a83-a20eb9eb9e90"
},
"jsonrpc": "2.0",
"method": "construct_malloc_bdev",
"method": "bdev_malloc_create",
"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.
~~~{.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_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

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.
~~~{.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}
@ -267,7 +267,7 @@ EAL: using IOMMU type 1 (Type 1)
~~~
~~~{.sh}
host:~# ./scripts/rpc.py construct_malloc_bdev 128 4096 Malloc0
host:~# ./scripts/rpc.py bdev_malloc_create 128 4096 Malloc0
Malloc0
~~~
@ -290,7 +290,7 @@ vhost_scsi.c: 840:spdk_vhost_scsi_dev_add_tgt: *NOTICE*: Controller vhost.0: def
~~~
~~~{.sh}
host:~# ./scripts/rpc.py construct_malloc_bdev 64 512 -b Malloc1
host:~# ./scripts/rpc.py bdev_malloc_create 64 512 -b 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_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_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
spdk_rpc_construct_malloc_bdev(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
spdk_rpc_bdev_malloc_create(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params)
{
struct rpc_construct_malloc req = {NULL};
struct spdk_json_write_ctx *w;
@ -110,7 +110,8 @@ spdk_rpc_construct_malloc_bdev(struct spdk_jsonrpc_request *request,
cleanup:
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 {
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["construct_nvme_bdev"] = []
bdev_dict["set_bdev_nvme_hotplug"] = []
bdev_dict["construct_malloc_bdev"] = []
bdev_dict["bdev_malloc_create"] = []
bdev_dict["construct_aio_bdev"] = []
bdev_dict["construct_pmem_bdev"] = []
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],
"name": "Malloc%s" % lun
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
})
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.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
print_json(rpc.bdev.construct_malloc_bdev(args.client,
num_blocks=int(num_blocks),
block_size=args.block_size,
name=args.name,
uuid=args.uuid))
p = subparsers.add_parser('construct_malloc_bdev',
print_json(rpc.bdev.bdev_malloc_create(args.client,
num_blocks=int(num_blocks),
block_size=args.block_size,
name=args.name,
uuid=args.uuid))
p = subparsers.add_parser('bdev_malloc_create', aliases=['construct_malloc_bdev'],
help='Add a bdev with malloc backend')
p.add_argument('-b', '--name', help="Name of the bdev")
p.add_argument('-u', '--uuid', help="UUID of the bdev")
p.add_argument(
'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.set_defaults(func=construct_malloc_bdev)
p.set_defaults(func=bdev_malloc_create)
def delete_malloc_bdev(args):
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):
"""Set parameters for the bdev subsystem.
@ -136,7 +139,8 @@ def get_ocf_bdevs(client, name=None):
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.
Args:
@ -153,7 +157,7 @@ def construct_malloc_bdev(client, num_blocks, block_size, name=None, uuid=None):
params['name'] = name
if uuid:
params['uuid'] = uuid
return client.call('construct_malloc_bdev', params)
return client.call('bdev_malloc_create', params)
def delete_malloc_bdev(client, name):

2
scripts/spdkcli/ui_root.py
View File

@ -127,7 +127,7 @@ class UIRoot(UINode):
@verbose
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
@verbose

4
test/bdev/bdev_raid.sh
View File

@ -61,8 +61,8 @@ function on_error_exit() {
function configure_raid_bdev() {
rm -rf $testdir/rpcs.txt
echo construct_malloc_bdev 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_1 >> $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
$rpc_py < $testdir/rpcs.txt

16
test/config_converter/spdk_config.json
View File

@ -61,7 +61,7 @@
"num_blocks": 32768,
"name": "Malloc0"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -69,7 +69,7 @@
"num_blocks": 32768,
"name": "Malloc1"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -77,7 +77,7 @@
"num_blocks": 32768,
"name": "Malloc2"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -85,7 +85,7 @@
"num_blocks": 32768,
"name": "Malloc3"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -93,7 +93,7 @@
"num_blocks": 32768,
"name": "Malloc4"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -101,7 +101,7 @@
"num_blocks": 32768,
"name": "Malloc5"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -109,7 +109,7 @@
"num_blocks": 32768,
"name": "Malloc6"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -117,7 +117,7 @@
"num_blocks": 32768,
"name": "Malloc7"
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"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
$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_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
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
# test the vhost blk controller with valid data buffers.
@ -50,11 +50,11 @@ if [ "$TEST_TRANSPORT" == "bdev" ] || [ "$TEST_TRANSPORT" == "all" ]; then
fi
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 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 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_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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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 add_portal_group $PORTAL_TAG $TARGET_IP:$ISCSI_PORT
$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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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_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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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 start_subsystem_init
$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..."
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_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
# 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 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 bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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_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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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
# $2 = Netmask
$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() {

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
if [ $i -eq 1 ]; then
# 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 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 bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$malloc_bdevs"
bdev="raid0"
else
# 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
ls_guid=$($rpc_py construct_lvol_store $bdev lvs_$i -c 1048576)
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 nvmf_create_transport -t RDMA -u 8192
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_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a $NVMF_FIRST_TARGET_IP -s $NVMF_PORT
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_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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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_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
# "1:2" ==> map PortalGroup1 to InitiatorGroup2
# "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,
"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_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,
"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_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)
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")
@ -330,7 +330,7 @@ def verify_target_nodes_rpc_methods(rpc_py, rpc_param):
verify(not jsonvalues, 1,
"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_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"
CONNECTION_NUMBER=15
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"
done
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):
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_rbd_bdev': "delete_rbd_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 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_null_bdev Null0 32 512
tgt_rpc construct_malloc_bdev 32 512 --name Malloc0
tgt_rpc construct_malloc_bdev 16 4096 --name Malloc1
tgt_rpc bdev_malloc_create 32 512 --name Malloc0
tgt_rpc bdev_malloc_create 16 4096 --name Malloc1
expected_notifications+=(
bdev_register:${lvol_store_base_bdev}
@ -215,7 +215,7 @@ function create_bdev_subsystem_config() {
fi
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
local crypto_dirver=crypto_aesni_mb
else
@ -278,7 +278,7 @@ function cleanup_bdev_subsystem_config() {
function create_vhost_subsystem_config() {
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_vhost_scsi_controller VhostScsiCtrlr0
@ -297,7 +297,7 @@ function create_vhost_subsystem_config() {
function create_iscsi_subsystem_config() {
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_initiator_group $INITIATOR_TAG $INITIATOR_NAME $NETMASK
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
fi
tgt_rpc construct_malloc_bdev 8 512 --name MallocForNvmf0
tgt_rpc construct_malloc_bdev 4 1024 --name MallocForNvmf1
tgt_rpc bdev_malloc_create 8 512 --name MallocForNvmf0
tgt_rpc bdev_malloc_create 4 1024 --name MallocForNvmf1
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
@ -375,7 +375,7 @@ function json_config_test_init()
create_virtio_initiator_config
fi
tgt_rpc construct_malloc_bdev 8 512 --name MallocBdevForConfigChangeCheck
tgt_rpc bdev_malloc_create 8 512 --name MallocBdevForConfigChangeCheck
timing_exit $FUNCNAME
}

6
test/lvol/rpc_commands_lib.py
View File

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

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

@ -27,7 +27,7 @@ waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
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_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

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

@ -24,7 +24,7 @@ waitforlisten $nvmfpid
$rpc_py nvmf_create_transport $NVMF_TRANSPORT_OPTS -u 8192
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
# NOTE: This will assign the same NGUID and EUI64 to all bdevs,
# 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
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
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 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_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

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

@ -15,7 +15,7 @@ nvmftestinit
nvmfappstart "-m 0xF"
$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_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

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
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_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 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_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

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
malloc_bdevs="$($rpc_py construct_malloc_bdev $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) "
malloc_bdevs+="$($rpc_py bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)"
# 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 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 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 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
$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_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)
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_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

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
# 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_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"

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 construct_malloc_bdev $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 Malloc0
$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_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
# 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 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 bdev_malloc_create $MALLOC_BDEV_SIZE $MALLOC_BLOCK_SIZE)
$rpc_py construct_raid_bdev -n raid0 -z 64 -r 0 -b "$base_bdevs"
# 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
# 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_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_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
$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
for i in $(seq 1 $num_subsystems)
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_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

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
$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_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

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
$rpc_py construct_malloc_bdev 101 512 -b Malloc0
$rpc_py construct_malloc_bdev 101 512 -b Malloc1
$rpc_py bdev_malloc_create 101 512 -b Malloc0
$rpc_py bdev_malloc_create 101 512 -b Malloc1
$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
$rpc_py construct_malloc_bdev 1 512 -b Core0
$rpc_py construct_malloc_bdev 1 512 -b Core1
$rpc_py bdev_malloc_create 1 512 -b Core0
$rpc_py bdev_malloc_create 1 512 -b Core1
$rpc_py construct_ocf_bdev C1 wt Cache Core0
$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 \
'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 \
'all(select(.started)) == true'
@ -57,9 +57,9 @@ stop_spdk
# Hotremove case
start_spdk
$rpc_py construct_malloc_bdev 101 512 -b Cache
$rpc_py construct_malloc_bdev 101 512 -b Malloc
$rpc_py construct_malloc_bdev 1 512 -b Core
$rpc_py bdev_malloc_create 101 512 -b Cache
$rpc_py bdev_malloc_create 101 512 -b Malloc
$rpc_py bdev_malloc_create 1 512 -b Core
$rpc_py construct_ocf_bdev C1 wt Cache Malloc
$rpc_py construct_ocf_bdev C2 wt Cache Core

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

@ -28,14 +28,14 @@
"block_size": 4096,
"num_blocks": 32768
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
"block_size": 4096,
"num_blocks": 32768
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -43,7 +43,7 @@
"num_blocks": 131072,
"block_size": 512
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -51,7 +51,7 @@
"num_blocks": 131072,
"block_size": 512
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -59,7 +59,7 @@
"num_blocks": 131072,
"block_size": 512
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -67,7 +67,7 @@
"num_blocks": 131072,
"block_size": 512
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
@ -75,7 +75,7 @@
"num_blocks": 131072,
"block_size": 512
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"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
$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_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 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 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
$rpc_py set_bdev_nvme_hotplug -e
$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 HotInNvme0n1 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_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 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 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
# 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
$rpc construct_vhost_scsi_controller $incoming_vm_ctrlr

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

@ -20,14 +20,14 @@
"block_size": 4096,
"num_blocks": 32768
},
"method": "construct_malloc_bdev"
"method": "bdev_malloc_create"
},
{
"params": {
"block_size": 4096,
"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"
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
fail "Failed to create malloc bdev"
fi

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

@ -19,7 +19,7 @@ trap 'error_exit "${FUNCNAME}" "${LINENO}"' ERR SIGTERM SIGABRT
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
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"
dd if=/dev/zero of=$aio_file bs=1M count=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
# 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
vhost_run 0
$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 get_bdevs
$rpc_py construct_vhost_scsi_controller naa.vhost.1