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

rpc: Rename start_nbd_disk to nbd_start_disk

Browse Source 
Change-Id: I46722176726076fd8bbcfa681eb7316e30ecb07d
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/468580
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Paul Luse <paul.e.luse@intel.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
This commit is contained in:
Pawel Kaminski 2019-09-17 06:36:40 -04:00 committed by Ben Walker
parent 0cbf1237c7
commit 0a993323f9
12 changed files with 73 additions and 67 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
doc/bdev.md
View File

@ -258,11 +258,11 @@ The SPDK partition type GUID is `7c5222bd-8f5d-4087-9c00-bf9843c7b58c`. Existing
can be exposed as Linux block devices via NBD and then ca be partitioned with can be exposed as Linux block devices via NBD and then ca be partitioned with
standard partitioning tools. After partitioning, the bdevs will need to be deleted and standard partitioning tools. After partitioning, the bdevs will need to be deleted and
attached again for the GPT bdev module to see any changes. NBD kernel module must be attached again for the GPT bdev module to see any changes. NBD kernel module must be
loaded first. To create NBD bdev user should use `start_nbd_disk` RPC command. loaded first. To create NBD bdev user should use `nbd_start_disk` RPC command.
Example command Example command
`rpc.py start_nbd_disk Malloc0 /dev/nbd0` `rpc.py nbd_start_disk Malloc0 /dev/nbd0`
This will expose an SPDK bdev `Malloc0` under the `/dev/nbd0` block device. This will expose an SPDK bdev `Malloc0` under the `/dev/nbd0` block device.
@ -282,7 +282,7 @@ Example command
~~~ ~~~
# Expose bdev Nvme0n1 as kernel block device /dev/nbd0 by JSON-RPC # Expose bdev Nvme0n1 as kernel block device /dev/nbd0 by JSON-RPC
rpc.py start_nbd_disk Nvme0n1 /dev/nbd0 rpc.py nbd_start_disk Nvme0n1 /dev/nbd0
# Create GPT partition table. # Create GPT partition table.
parted -s /dev/nbd0 mklabel gpt parted -s /dev/nbd0 mklabel gpt

6
doc/jsonrpc.md
View File

@ -246,7 +246,7 @@ Example response:
"add_ip_address", "add_ip_address",
"get_nbd_disks", "get_nbd_disks",
"stop_nbd_disk", "stop_nbd_disk",
"start_nbd_disk", "nbd_start_disk",
"get_log_flags", "get_log_flags",
"clear_log_flag", "clear_log_flag",
"set_log_flag", "set_log_flag",
@ -5518,7 +5518,7 @@ SPDK supports exporting bdevs through Linux nbd. These devices then appear as st
In order to export a device over nbd, first make sure the Linux kernel nbd driver is loaded by running 'modprobe nbd'. In order to export a device over nbd, first make sure the Linux kernel nbd driver is loaded by running 'modprobe nbd'.
## start_nbd_disk {#rpc_start_nbd_disk} ## nbd_start_disk {#rpc_nbd_start_disk}
Start to export one SPDK bdev as NBD disk Start to export one SPDK bdev as NBD disk
@ -5544,7 +5544,7 @@ Example request:
"bdev_name": "Malloc1" "bdev_name": "Malloc1"
}, },
"jsonrpc": "2.0", "jsonrpc": "2.0",
"method": "start_nbd_disk", "method": "nbd_start_disk",
"id": 1 "id": 1
} }
~~~ ~~~

2
lib/nbd/nbd.c
View File

@ -228,7 +228,7 @@ spdk_nbd_write_config_json(struct spdk_json_write_ctx *w)
TAILQ_FOREACH(nbd, &g_spdk_nbd.disk_head, tailq) { TAILQ_FOREACH(nbd, &g_spdk_nbd.disk_head, tailq) {
spdk_json_write_object_begin(w); spdk_json_write_object_begin(w);
spdk_json_write_named_string(w, "method", "start_nbd_disk"); spdk_json_write_named_string(w, "method", "nbd_start_disk");
spdk_json_write_named_object_begin(w, "params"); spdk_json_write_named_object_begin(w, "params");
spdk_json_write_named_string(w, "nbd_device", spdk_nbd_disk_get_nbd_path(nbd)); spdk_json_write_named_string(w, "nbd_device", spdk_nbd_disk_get_nbd_path(nbd));

29
lib/nbd/nbd_rpc.c
View File

@ -41,7 +41,7 @@
#include "nbd_internal.h" #include "nbd_internal.h"
#include "spdk_internal/log.h" #include "spdk_internal/log.h"
struct rpc_start_nbd_disk { struct rpc_nbd_start_disk {
char *bdev_name; char *bdev_name;
char *nbd_device; char *nbd_device;
/* Used to search one available nbd device */ /* Used to search one available nbd device */
@ -51,16 +51,16 @@ struct rpc_start_nbd_disk {
}; };
static void static void
free_rpc_start_nbd_disk(struct rpc_start_nbd_disk *req) free_rpc_nbd_start_disk(struct rpc_nbd_start_disk *req)
{ {
free(req->bdev_name); free(req->bdev_name);
free(req->nbd_device); free(req->nbd_device);
free(req); free(req);
} }
static const struct spdk_json_object_decoder rpc_start_nbd_disk_decoders[] = { static const struct spdk_json_object_decoder rpc_nbd_start_disk_decoders[] = {
{"bdev_name", offsetof(struct rpc_start_nbd_disk, bdev_name), spdk_json_decode_string}, {"bdev_name", offsetof(struct rpc_nbd_start_disk, bdev_name), spdk_json_decode_string},
{"nbd_device", offsetof(struct rpc_start_nbd_disk, nbd_device), spdk_json_decode_string, true}, {"nbd_device", offsetof(struct rpc_nbd_start_disk, nbd_device), spdk_json_decode_string, true},
}; };
/* Return 0 to indicate the nbd_device might be available, /* Return 0 to indicate the nbd_device might be available,
@ -138,7 +138,7 @@ find_available_nbd_disk(int nbd_idx, int *next_nbd_idx)
static void static void
spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc) spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc)
{ {
struct rpc_start_nbd_disk *req = cb_arg; struct rpc_nbd_start_disk *req = cb_arg;
struct spdk_jsonrpc_request *request = req->request; struct spdk_jsonrpc_request *request = req->request;
struct spdk_json_write_ctx *w; struct spdk_json_write_ctx *w;
@ -165,25 +165,25 @@ spdk_rpc_start_nbd_done(void *cb_arg, struct spdk_nbd_disk *nbd, int rc)
spdk_json_write_string(w, spdk_nbd_get_path(nbd)); spdk_json_write_string(w, spdk_nbd_get_path(nbd));
spdk_jsonrpc_end_result(request, w); spdk_jsonrpc_end_result(request, w);
free_rpc_start_nbd_disk(req); free_rpc_nbd_start_disk(req);
} }
static void static void
spdk_rpc_start_nbd_disk(struct spdk_jsonrpc_request *request, spdk_rpc_nbd_start_disk(struct spdk_jsonrpc_request *request,
const struct spdk_json_val *params) const struct spdk_json_val *params)
{ {
struct rpc_start_nbd_disk *req; struct rpc_nbd_start_disk *req;
int rc; int rc;
req = calloc(1, sizeof(*req)); req = calloc(1, sizeof(*req));
if (req == NULL) { if (req == NULL) {
SPDK_ERRLOG("could not allocate start_nbd_disk request.\n"); SPDK_ERRLOG("could not allocate nbd_start_disk request.\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory"); spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, "Out of memory");
return; return;
} }
if (spdk_json_decode_object(params, rpc_start_nbd_disk_decoders, if (spdk_json_decode_object(params, rpc_nbd_start_disk_decoders,
SPDK_COUNTOF(rpc_start_nbd_disk_decoders), SPDK_COUNTOF(rpc_nbd_start_disk_decoders),
req)) { req)) {
SPDK_ERRLOG("spdk_json_decode_object failed\n"); SPDK_ERRLOG("spdk_json_decode_object failed\n");
spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR, spdk_jsonrpc_send_error_response(request, SPDK_JSONRPC_ERROR_INTERNAL_ERROR,
@ -228,10 +228,11 @@ spdk_rpc_start_nbd_disk(struct spdk_jsonrpc_request *request,
return; return;
invalid: invalid:
free_rpc_start_nbd_disk(req); free_rpc_nbd_start_disk(req);
} }
SPDK_RPC_REGISTER("start_nbd_disk", spdk_rpc_start_nbd_disk, SPDK_RPC_RUNTIME) SPDK_RPC_REGISTER("nbd_start_disk", spdk_rpc_nbd_start_disk, SPDK_RPC_RUNTIME)
SPDK_RPC_REGISTER_ALIAS_DEPRECATED(nbd_start_disk, start_nbd_disk)
struct rpc_stop_nbd_disk { struct rpc_stop_nbd_disk {
char *nbd_device; char *nbd_device;

9
scripts/rpc.py
View File

@ -1461,15 +1461,16 @@ Format: 'user:u1 secret:s1 muser:mu1 msecret:ms1,user:u2 secret:s2 muser:mu2 mse
p.set_defaults(func=enable_vmd) p.set_defaults(func=enable_vmd)
# nbd # nbd
def start_nbd_disk(args): def nbd_start_disk(args):
print(rpc.nbd.start_nbd_disk(args.client, print(rpc.nbd.nbd_start_disk(args.client,
bdev_name=args.bdev_name, bdev_name=args.bdev_name,
nbd_device=args.nbd_device)) nbd_device=args.nbd_device))
p = subparsers.add_parser('start_nbd_disk', help='Export a bdev as a nbd disk') p = subparsers.add_parser('nbd_start_disk', aliases=['start_nbd_disk'],
help='Export a bdev as a nbd disk')
p.add_argument('bdev_name', help='Blockdev name to be exported. Example: Malloc0.') p.add_argument('bdev_name', help='Blockdev name to be exported. Example: Malloc0.')
p.add_argument('nbd_device', help='Nbd device name to be assigned. Example: /dev/nbd0.', nargs='?') p.add_argument('nbd_device', help='Nbd device name to be assigned. Example: /dev/nbd0.', nargs='?')
p.set_defaults(func=start_nbd_disk) p.set_defaults(func=nbd_start_disk)
def stop_nbd_disk(args): def stop_nbd_disk(args):
rpc.nbd.stop_nbd_disk(args.client, rpc.nbd.stop_nbd_disk(args.client,

8
scripts/rpc/nbd.py
View File

@ -1,10 +1,14 @@
def start_nbd_disk(client, bdev_name, nbd_device): from .helpers import deprecated_alias
@deprecated_alias('start_nbd_disk')
def nbd_start_disk(client, bdev_name, nbd_device):
params = { params = {
'bdev_name': bdev_name 'bdev_name': bdev_name
} }
if nbd_device: if nbd_device:
params['nbd_device'] = nbd_device params['nbd_device'] = nbd_device
return client.call('start_nbd_disk', params) return client.call('nbd_start_disk', params)
def stop_nbd_disk(client, nbd_device): def stop_nbd_disk(client, nbd_device):

4
test/bdev/nbd_common.sh
View File

@ -7,7 +7,7 @@ function nbd_start_disks() {
local i local i
for (( i=0; i<${#nbd_list[@]}; i++ )); do for (( i=0; i<${#nbd_list[@]}; i++ )); do
$rootdir/scripts/rpc.py -s $rpc_server start_nbd_disk ${bdev_list[$i]} ${nbd_list[$i]} $rootdir/scripts/rpc.py -s $rpc_server nbd_start_disk ${bdev_list[$i]} ${nbd_list[$i]}
# Wait for nbd device ready # Wait for nbd device ready
waitfornbd $(basename ${nbd_list[$i]}) waitfornbd $(basename ${nbd_list[$i]})
done done
@ -20,7 +20,7 @@ function nbd_start_disks_without_nbd_idx() {
local nbd_device local nbd_device
for (( i=0; i<${#bdev_list[@]}; i++ )); do for (( i=0; i<${#bdev_list[@]}; i++ )); do
nbd_device=$($rootdir/scripts/rpc.py -s $rpc_server start_nbd_disk ${bdev_list[$i]}) nbd_device=$($rootdir/scripts/rpc.py -s $rpc_server nbd_start_disk ${bdev_list[$i]})
# Wait for nbd device ready # Wait for nbd device ready
waitfornbd $(basename ${nbd_device}) waitfornbd $(basename ${nbd_device})
done done

2
test/ftl/dirty_shutdown.sh
View File

@ -54,7 +54,7 @@ $rpc_py $ftl_construct_args
# Load the nbd driver # Load the nbd driver
modprobe nbd modprobe nbd
$rpc_py start_nbd_disk nvme0 /dev/nbd0 $rpc_py nbd_start_disk nvme0 /dev/nbd0
waitfornbd nbd0 waitfornbd nbd0
$rpc_py save_config > $testdir/config/ftl.json $rpc_py save_config > $testdir/config/ftl.json

2
test/ftl/restore.sh
View File

@ -54,7 +54,7 @@ $rpc_py $ftl_construct_args
# Load the nbd driver # Load the nbd driver
modprobe nbd modprobe nbd
$rpc_py start_nbd_disk nvme0 /dev/nbd0 $rpc_py nbd_start_disk nvme0 /dev/nbd0
waitfornbd nbd0 waitfornbd nbd0
$rpc_py save_config > $testdir/config/ftl.json $rpc_py save_config > $testdir/config/ftl.json

2
test/json_config/clear_config.py
View File

@ -116,7 +116,7 @@ def clear_iscsi_subsystem(args, iscsi_config):
def get_nbd_destroy_method(nbd): def get_nbd_destroy_method(nbd):
delete_method_map = {'start_nbd_disk': "stop_nbd_disk" delete_method_map = {'nbd_start_disk': "stop_nbd_disk"
} }
return delete_method_map[nbd['method']] return delete_method_map[nbd['method']]

6
test/lvol/rpc_commands_lib.py
View File

@ -169,9 +169,9 @@ class Commands_Rpc(object):
output, rc = self.rpc.bdev_lvol_set_read_only(uuid) output, rc = self.rpc.bdev_lvol_set_read_only(uuid)
return rc return rc
def start_nbd_disk(self, bdev_name, nbd_name): def nbd_start_disk(self, bdev_name, nbd_name):
print("INFO: RPC COMMAND start_nbd_disk") print("INFO: RPC COMMAND nbd_start_disk")
output, rc = self.rpc.start_nbd_disk(bdev_name, nbd_name) output, rc = self.rpc.nbd_start_disk(bdev_name, nbd_name)
return rc return rc
def stop_nbd_disk(self, nbd_name): def stop_nbd_disk(self, nbd_name):

64
test/lvol/test_cases.py
View File

@ -38,7 +38,7 @@ current_fio_pid = -1
# results. # results.
# #
# Tests with thin provisioned lvol bdevs, snapshots and clones are using nbd devices. # Tests with thin provisioned lvol bdevs, snapshots and clones are using nbd devices.
# Before writing/reading to lvol bdev, bdev is installed with rpc start_nbd_disk. # Before writing/reading to lvol bdev, bdev is installed with rpc nbd_start_disk.
# After finishing writing/reading, rpc stop_nbd_disk is used. # After finishing writing/reading, rpc stop_nbd_disk is used.
@ -1491,7 +1491,7 @@ class TestCases(object):
fail_count += 1 fail_count += 1
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(bdev_name, nbd_name) fail_count += self.c.nbd_start_disk(bdev_name, nbd_name)
size = int(lvs['cluster_size']) size = int(lvs['cluster_size'])
# write data (lvs cluster size) to created lvol bdev starting from offset 0. # write data (lvs cluster size) to created lvol bdev starting from offset 0.
@ -1573,9 +1573,9 @@ class TestCases(object):
lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0) lvol_bdev0 = self.c.get_lvol_bdev_with_name(bdev_name0)
lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1) lvol_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1)
nbd_name0 = "/dev/nbd0" nbd_name0 = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev0['name'], nbd_name0)
nbd_name1 = "/dev/nbd1" nbd_name1 = "/dev/nbd1"
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name1) fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name1)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
# fill the whole thick provisioned lvol bdev # fill the whole thick provisioned lvol bdev
@ -1625,7 +1625,7 @@ class TestCases(object):
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
# on the whole lvol bdev perform write operation with verification # on the whole lvol bdev perform write operation with verification
fail_count += self.run_fio_test(nbd_name, 0, size, "write", "0xcc") fail_count += self.run_fio_test(nbd_name, 0, size, "write", "0xcc")
@ -1665,7 +1665,7 @@ class TestCases(object):
fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, size) fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, size)
# Fill all free space of lvol bdev with data # Fill all free space of lvol bdev with data
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(uuid_bdev, nbd_name) fail_count += self.c.nbd_start_disk(uuid_bdev, nbd_name)
fail_count += self.run_fio_test(nbd_name, 0, size*MEGABYTE, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name, 0, size*MEGABYTE, "write", "0xcc", 0)
fail_count += self.c.stop_nbd_disk(nbd_name) fail_count += self.c.stop_nbd_disk(nbd_name)
# Save number of free clusters for lvs # Save number of free clusters for lvs
@ -1688,7 +1688,7 @@ class TestCases(object):
# Perform write operation with verification # Perform write operation with verification
# to newly created free space of lvol bdev # to newly created free space of lvol bdev
nbd_name = "/dev/nbd0" nbd_name = "/dev/nbd0"
fail_count += self.c.start_nbd_disk(uuid_bdev, nbd_name) fail_count += self.c.nbd_start_disk(uuid_bdev, nbd_name)
fail_count += self.run_fio_test(nbd_name, int(lbd_size * MEGABYTE / 2), fail_count += self.run_fio_test(nbd_name, int(lbd_size * MEGABYTE / 2),
int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0) int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0)
fail_count += self.c.stop_nbd_disk(nbd_name) fail_count += self.c.stop_nbd_disk(nbd_name)
@ -1752,8 +1752,8 @@ class TestCases(object):
nbd_name0 = "/dev/nbd0" nbd_name0 = "/dev/nbd0"
nbd_name1 = "/dev/nbd1" nbd_name1 = "/dev/nbd1"
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev0['name'], nbd_name0)
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name1) fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name1)
size = "75%" size = "75%"
# fill first bdev to 75% of its space with specific pattern # fill first bdev to 75% of its space with specific pattern
@ -1820,8 +1820,8 @@ class TestCases(object):
# check if bdevs are available and size of every disk is equal to 70% of lvs size # check if bdevs are available and size of every disk is equal to 70% of lvs size
nbd_name0 = "/dev/nbd0" nbd_name0 = "/dev/nbd0"
nbd_name1 = "/dev/nbd1" nbd_name1 = "/dev/nbd1"
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev0['name'], nbd_name0)
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name1) fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name1)
size = int(int(lvol_bdev0['num_blocks']) * int(lvol_bdev0['block_size']) * 0.7) size = int(int(lvol_bdev0['num_blocks']) * int(lvol_bdev0['block_size']) * 0.7)
# fill first disk with 70% of its size # fill first disk with 70% of its size
# check if operation didn't fail # check if operation didn't fail
@ -2151,7 +2151,7 @@ class TestCases(object):
fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name) fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name)
snapshot_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name) snapshot_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name)
fail_count += self.c.start_nbd_disk(snapshot_bdev['name'], nbd_name0) fail_count += self.c.nbd_start_disk(snapshot_bdev['name'], nbd_name0)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
# Try to perform write operation on created snapshot # Try to perform write operation on created snapshot
# Check if filling snapshot of lvol bdev fails # Check if filling snapshot of lvol bdev fails
@ -2203,12 +2203,12 @@ class TestCases(object):
uuid_bdev1 = self.c.bdev_lvol_create(uuid_store, uuid_bdev1 = self.c.bdev_lvol_create(uuid_store,
lbd_name1, size, thin=False) lbd_name1, size, thin=False)
lvol_bdev0 = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev0 = self.c.get_lvol_bdev_with_name(uuid_bdev0)
fail_count += self.c.start_nbd_disk(lvol_bdev0['name'], nbd_name[0]) fail_count += self.c.nbd_start_disk(lvol_bdev0['name'], nbd_name[0])
fill_size = int(size * MEGABYTE / 2) fill_size = int(size * MEGABYTE / 2)
# Fill thin provisoned lvol bdev with 50% of its space # Fill thin provisoned lvol bdev with 50% of its space
fail_count += self.run_fio_test(nbd_name[0], 0, fill_size, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name[0], 0, fill_size, "write", "0xcc", 0)
lvol_bdev1 = self.c.get_lvol_bdev_with_name(uuid_bdev1) lvol_bdev1 = self.c.get_lvol_bdev_with_name(uuid_bdev1)
fail_count += self.c.start_nbd_disk(lvol_bdev1['name'], nbd_name[1]) fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name[1])
fill_size = int(size * MEGABYTE) fill_size = int(size * MEGABYTE)
# Fill whole thic provisioned lvol bdev # Fill whole thic provisioned lvol bdev
fail_count += self.run_fio_test(nbd_name[1], 0, fill_size, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name[1], 0, fill_size, "write", "0xcc", 0)
@ -2216,8 +2216,8 @@ class TestCases(object):
# Create snapshots of lvol bdevs # Create snapshots of lvol bdevs
fail_count += self.c.bdev_lvol_snapshot(uuid_bdev0, snapshot_name0) fail_count += self.c.bdev_lvol_snapshot(uuid_bdev0, snapshot_name0)
fail_count += self.c.bdev_lvol_snapshot(uuid_bdev1, snapshot_name1) fail_count += self.c.bdev_lvol_snapshot(uuid_bdev1, snapshot_name1)
fail_count += self.c.start_nbd_disk(self.lvs_name + "/" + snapshot_name0, nbd_name[2]) fail_count += self.c.nbd_start_disk(self.lvs_name + "/" + snapshot_name0, nbd_name[2])
fail_count += self.c.start_nbd_disk(self.lvs_name + "/" + snapshot_name1, nbd_name[3]) fail_count += self.c.nbd_start_disk(self.lvs_name + "/" + snapshot_name1, nbd_name[3])
# Compare every lvol bdev with corresponding snapshot # Compare every lvol bdev with corresponding snapshot
# and check that data are the same # and check that data are the same
fail_count += self.compare_two_disks(nbd_name[0], nbd_name[2], 0) fail_count += self.compare_two_disks(nbd_name[0], nbd_name[2], 0)
@ -2274,7 +2274,7 @@ class TestCases(object):
size, thin=True) size, thin=True)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name)
fill_size = int(size * MEGABYTE) fill_size = int(size * MEGABYTE)
# Create thread that will run fio in background # Create thread that will run fio in background
thread = FioThread(nbd_name, 0, fill_size, "write", "0xcc", 0, thread = FioThread(nbd_name, 0, fill_size, "write", "0xcc", 0,
@ -2440,7 +2440,7 @@ class TestCases(object):
lbd_name0, size, thin=False) lbd_name0, size, thin=False)
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
# Install lvol bdev on /dev/nbd0 # Install lvol bdev on /dev/nbd0
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name[0]) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name[0])
fill_size = size * MEGABYTE fill_size = size * MEGABYTE
# Fill lvol bdev with 100% of its space # Fill lvol bdev with 100% of its space
fail_count += self.run_fio_test(nbd_name[0], 0, fill_size, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name[0], 0, fill_size, "write", "0xcc", 0)
@ -2453,14 +2453,14 @@ class TestCases(object):
fail_count += self.c.bdev_lvol_clone(snapshot_bdev['name'], clone_name1) fail_count += self.c.bdev_lvol_clone(snapshot_bdev['name'], clone_name1)
lvol_clone0 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name0) lvol_clone0 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name0)
fail_count += self.c.start_nbd_disk(lvol_clone0['name'], nbd_name[1]) fail_count += self.c.nbd_start_disk(lvol_clone0['name'], nbd_name[1])
fill_size = int(size * MEGABYTE / 2) fill_size = int(size * MEGABYTE / 2)
# Perform write operation to first clone # Perform write operation to first clone
# Change first half of its space # Change first half of its space
fail_count += self.run_fio_test(nbd_name[1], 0, fill_size, "write", "0xaa", 0) fail_count += self.run_fio_test(nbd_name[1], 0, fill_size, "write", "0xaa", 0)
fail_count += self.c.start_nbd_disk(self.lvs_name + "/" + snapshot_name, nbd_name[2]) fail_count += self.c.nbd_start_disk(self.lvs_name + "/" + snapshot_name, nbd_name[2])
lvol_clone1 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name1) lvol_clone1 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name1)
fail_count += self.c.start_nbd_disk(lvol_clone1['name'], nbd_name[3]) fail_count += self.c.nbd_start_disk(lvol_clone1['name'], nbd_name[3])
# Compare snapshot with second clone. Data on both bdevs should be the same # Compare snapshot with second clone. Data on both bdevs should be the same
time.sleep(1) time.sleep(1)
fail_count += self.compare_two_disks(nbd_name[2], nbd_name[3], 0) fail_count += self.compare_two_disks(nbd_name[2], nbd_name[3], 0)
@ -2604,7 +2604,7 @@ class TestCases(object):
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
# Fill bdev with data of knonw pattern # Fill bdev with data of knonw pattern
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name)
fill_size = size * MEGABYTE fill_size = size * MEGABYTE
fail_count += self.run_fio_test(nbd_name, 0, fill_size, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name, 0, fill_size, "write", "0xcc", 0)
self.c.stop_nbd_disk(nbd_name) self.c.stop_nbd_disk(nbd_name)
@ -2619,7 +2619,7 @@ class TestCases(object):
fail_count += 1 fail_count += 1
# Fill part of clone with data of known pattern # Fill part of clone with data of known pattern
fail_count += self.c.start_nbd_disk(lvol_clone['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_clone['name'], nbd_name)
first_fill = 0 first_fill = 0
second_fill = int(size * 3 / 4) second_fill = int(size * 3 / 4)
fail_count += self.run_fio_test(nbd_name, first_fill * MEGABYTE, fail_count += self.run_fio_test(nbd_name, first_fill * MEGABYTE,
@ -2638,7 +2638,7 @@ class TestCases(object):
fail_count += self.c.bdev_lvol_delete(snapshot_bdev['name']) fail_count += self.c.bdev_lvol_delete(snapshot_bdev['name'])
# Check data consistency # Check data consistency
fail_count += self.c.start_nbd_disk(lvol_clone['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_clone['name'], nbd_name)
fail_count += self.run_fio_test(nbd_name, first_fill * MEGABYTE, fail_count += self.run_fio_test(nbd_name, first_fill * MEGABYTE,
MEGABYTE, "read", "0xdd") MEGABYTE, "read", "0xdd")
fail_count += self.run_fio_test(nbd_name, (first_fill + 1) * MEGABYTE, fail_count += self.run_fio_test(nbd_name, (first_fill + 1) * MEGABYTE,
@ -2767,7 +2767,7 @@ class TestCases(object):
lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)
# Fill first four out of 5 culsters of clone with data of known pattern # Fill first four out of 5 culsters of clone with data of known pattern
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name)
begin_fill = 0 begin_fill = 0
end_fill = int(size * 4 / 5) end_fill = int(size * 4 / 5)
fail_count += self.run_fio_test(nbd_name, begin_fill * MEGABYTE, fail_count += self.run_fio_test(nbd_name, begin_fill * MEGABYTE,
@ -2869,7 +2869,7 @@ class TestCases(object):
fail_count += self.c.bdev_lvol_set_read_only(lvol_bdev['name']) fail_count += self.c.bdev_lvol_set_read_only(lvol_bdev['name'])
# Try to perform write operation on lvol marked as read only # Try to perform write operation on lvol marked as read only
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name0)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc", 1) fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc", 1)
@ -2881,7 +2881,7 @@ class TestCases(object):
clone_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name) clone_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name)
# Try to perform write operation on lvol clone # Try to perform write operation on lvol clone
fail_count += self.c.start_nbd_disk(clone_bdev['name'], nbd_name1) fail_count += self.c.nbd_start_disk(clone_bdev['name'], nbd_name1)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
fail_count += self.run_fio_test(nbd_name1, 0, size, "write", "0xcc", 0) fail_count += self.run_fio_test(nbd_name1, 0, size, "write", "0xcc", 0)
@ -2930,7 +2930,7 @@ class TestCases(object):
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
# Perform write operation on lvol # Perform write operation on lvol
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name0)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc") fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc")
@ -2947,7 +2947,7 @@ class TestCases(object):
fail_count += self.run_fio_test(nbd_name0, 0, half_size-1, "write", "0xee") fail_count += self.run_fio_test(nbd_name0, 0, half_size-1, "write", "0xee")
# Check if snapshot was unchanged # Check if snapshot was unchanged
fail_count += self.c.start_nbd_disk(snapshot_bdev['name'], nbd_name1) fail_count += self.c.nbd_start_disk(snapshot_bdev['name'], nbd_name1)
fail_count += self.run_fio_test(nbd_name1, 0, half_size-1, "read", "0xcc") fail_count += self.run_fio_test(nbd_name1, 0, half_size-1, "read", "0xcc")
# Verify lvol bdev # Verify lvol bdev
@ -3010,7 +3010,7 @@ class TestCases(object):
lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)
# Perform write operation on lvol # Perform write operation on lvol
fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name0) fail_count += self.c.nbd_start_disk(lvol_bdev['name'], nbd_name0)
size = bdev_size * MEGABYTE size = bdev_size * MEGABYTE
fail_count += self.run_fio_test(nbd_name0, 0, size-1, "write", "0xcc") fail_count += self.run_fio_test(nbd_name0, 0, size-1, "write", "0xcc")
@ -3027,7 +3027,7 @@ class TestCases(object):
fail_count += self.run_fio_test(nbd_name0, first_part, second_part-first_part, "write", "0xee") fail_count += self.run_fio_test(nbd_name0, first_part, second_part-first_part, "write", "0xee")
# Check if snapshot was unchanged # Check if snapshot was unchanged
fail_count += self.c.start_nbd_disk(snapshot_bdev['name'], nbd_name1) fail_count += self.c.nbd_start_disk(snapshot_bdev['name'], nbd_name1)
fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc") fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc")
# Create second snapshot of lvol_bdev # Create second snapshot of lvol_bdev
@ -3047,7 +3047,7 @@ class TestCases(object):
# Verify snapshots # Verify snapshots
fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc") fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc")
fail_count += self.c.start_nbd_disk(snapshot_bdev2['name'], nbd_name2) fail_count += self.c.nbd_start_disk(snapshot_bdev2['name'], nbd_name2)
fail_count += self.run_fio_test(nbd_name2, 0, first_part-1, "read", "0xcc") fail_count += self.run_fio_test(nbd_name2, 0, first_part-1, "read", "0xcc")
fail_count += self.run_fio_test(nbd_name2, first_part, second_part-first_part, "read", "0xee") fail_count += self.run_fio_test(nbd_name2, first_part, second_part-first_part, "read", "0xee")
fail_count += self.run_fio_test(nbd_name2, second_part, size-second_part, "read", "0xcc") fail_count += self.run_fio_test(nbd_name2, second_part, size-second_part, "read", "0xcc")