diff --git a/doc/bdev.md b/doc/bdev.md index 5a33808d6..64bfe30a5 100644 --- a/doc/bdev.md +++ b/doc/bdev.md @@ -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 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 -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 -`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. @@ -282,7 +282,7 @@ Example command ~~~ # 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. parted -s /dev/nbd0 mklabel gpt diff --git a/doc/jsonrpc.md b/doc/jsonrpc.md index 070600a6b..777a22c71 100644 --- a/doc/jsonrpc.md +++ b/doc/jsonrpc.md @@ -246,7 +246,7 @@ Example response: "add_ip_address", "get_nbd_disks", "stop_nbd_disk", - "start_nbd_disk", + "nbd_start_disk", "get_log_flags", "clear_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'. -## start_nbd_disk {#rpc_start_nbd_disk} +## nbd_start_disk {#rpc_nbd_start_disk} Start to export one SPDK bdev as NBD disk @@ -5544,7 +5544,7 @@ Example request: "bdev_name": "Malloc1" }, "jsonrpc": "2.0", - "method": "start_nbd_disk", + "method": "nbd_start_disk", "id": 1 } ~~~ diff --git a/lib/nbd/nbd.c b/lib/nbd/nbd.c index ad37e9e5e..67a66eeb5 100644 --- a/lib/nbd/nbd.c +++ b/lib/nbd/nbd.c @@ -228,7 +228,7 @@ spdk_nbd_write_config_json(struct spdk_json_write_ctx *w) TAILQ_FOREACH(nbd, &g_spdk_nbd.disk_head, tailq) { 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_string(w, "nbd_device", spdk_nbd_disk_get_nbd_path(nbd)); diff --git a/lib/nbd/nbd_rpc.c b/lib/nbd/nbd_rpc.c index ae89325a6..a03455d7c 100644 --- a/lib/nbd/nbd_rpc.c +++ b/lib/nbd/nbd_rpc.c @@ -41,7 +41,7 @@ #include "nbd_internal.h" #include "spdk_internal/log.h" -struct rpc_start_nbd_disk { +struct rpc_nbd_start_disk { char *bdev_name; char *nbd_device; /* Used to search one available nbd device */ @@ -51,16 +51,16 @@ struct rpc_start_nbd_disk { }; 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->nbd_device); free(req); } -static const struct spdk_json_object_decoder rpc_start_nbd_disk_decoders[] = { - {"bdev_name", offsetof(struct rpc_start_nbd_disk, bdev_name), spdk_json_decode_string}, - {"nbd_device", offsetof(struct rpc_start_nbd_disk, nbd_device), spdk_json_decode_string, true}, +static const struct spdk_json_object_decoder rpc_nbd_start_disk_decoders[] = { + {"bdev_name", offsetof(struct rpc_nbd_start_disk, bdev_name), spdk_json_decode_string}, + {"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, @@ -138,7 +138,7 @@ find_available_nbd_disk(int nbd_idx, int *next_nbd_idx) static void 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_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_jsonrpc_end_result(request, w); - free_rpc_start_nbd_disk(req); + free_rpc_nbd_start_disk(req); } 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) { - struct rpc_start_nbd_disk *req; + struct rpc_nbd_start_disk *req; int rc; req = calloc(1, sizeof(*req)); 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"); return; } - if (spdk_json_decode_object(params, rpc_start_nbd_disk_decoders, - SPDK_COUNTOF(rpc_start_nbd_disk_decoders), + if (spdk_json_decode_object(params, rpc_nbd_start_disk_decoders, + SPDK_COUNTOF(rpc_nbd_start_disk_decoders), req)) { SPDK_ERRLOG("spdk_json_decode_object failed\n"); 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; 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 { char *nbd_device; diff --git a/scripts/rpc.py b/scripts/rpc.py index 7afe94ff3..ce7dde402 100755 --- a/scripts/rpc.py +++ b/scripts/rpc.py @@ -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) # nbd - def start_nbd_disk(args): - print(rpc.nbd.start_nbd_disk(args.client, + def nbd_start_disk(args): + print(rpc.nbd.nbd_start_disk(args.client, bdev_name=args.bdev_name, 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('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): rpc.nbd.stop_nbd_disk(args.client, diff --git a/scripts/rpc/nbd.py b/scripts/rpc/nbd.py index f0c294874..5912fbadb 100644 --- a/scripts/rpc/nbd.py +++ b/scripts/rpc/nbd.py @@ -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 = { 'bdev_name': bdev_name } if 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): diff --git a/test/bdev/nbd_common.sh b/test/bdev/nbd_common.sh index 428dea314..a3189ca22 100644 --- a/test/bdev/nbd_common.sh +++ b/test/bdev/nbd_common.sh @@ -7,7 +7,7 @@ function nbd_start_disks() { local i 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 waitfornbd $(basename ${nbd_list[$i]}) done @@ -20,7 +20,7 @@ function nbd_start_disks_without_nbd_idx() { local nbd_device 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 waitfornbd $(basename ${nbd_device}) done diff --git a/test/ftl/dirty_shutdown.sh b/test/ftl/dirty_shutdown.sh index ac7ac2eb1..70b7c3875 100755 --- a/test/ftl/dirty_shutdown.sh +++ b/test/ftl/dirty_shutdown.sh @@ -54,7 +54,7 @@ $rpc_py $ftl_construct_args # Load the nbd driver modprobe nbd -$rpc_py start_nbd_disk nvme0 /dev/nbd0 +$rpc_py nbd_start_disk nvme0 /dev/nbd0 waitfornbd nbd0 $rpc_py save_config > $testdir/config/ftl.json diff --git a/test/ftl/restore.sh b/test/ftl/restore.sh index 7abba477e..fe64650c7 100755 --- a/test/ftl/restore.sh +++ b/test/ftl/restore.sh @@ -54,7 +54,7 @@ $rpc_py $ftl_construct_args # Load the nbd driver modprobe nbd -$rpc_py start_nbd_disk nvme0 /dev/nbd0 +$rpc_py nbd_start_disk nvme0 /dev/nbd0 waitfornbd nbd0 $rpc_py save_config > $testdir/config/ftl.json diff --git a/test/json_config/clear_config.py b/test/json_config/clear_config.py index 9ae8bf314..40a59bb7b 100755 --- a/test/json_config/clear_config.py +++ b/test/json_config/clear_config.py @@ -116,7 +116,7 @@ def clear_iscsi_subsystem(args, iscsi_config): 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']] diff --git a/test/lvol/rpc_commands_lib.py b/test/lvol/rpc_commands_lib.py index 8d723deef..ce3b95cb2 100644 --- a/test/lvol/rpc_commands_lib.py +++ b/test/lvol/rpc_commands_lib.py @@ -169,9 +169,9 @@ class Commands_Rpc(object): output, rc = self.rpc.bdev_lvol_set_read_only(uuid) return rc - def start_nbd_disk(self, bdev_name, nbd_name): - print("INFO: RPC COMMAND start_nbd_disk") - output, rc = self.rpc.start_nbd_disk(bdev_name, nbd_name) + def nbd_start_disk(self, bdev_name, nbd_name): + print("INFO: RPC COMMAND nbd_start_disk") + output, rc = self.rpc.nbd_start_disk(bdev_name, nbd_name) return rc def stop_nbd_disk(self, nbd_name): diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py index 5efda9147..72fdb6c8b 100644 --- a/test/lvol/test_cases.py +++ b/test/lvol/test_cases.py @@ -38,7 +38,7 @@ current_fio_pid = -1 # results. # # 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. @@ -1491,7 +1491,7 @@ class TestCases(object): fail_count += 1 lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) 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']) # 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_bdev1 = self.c.get_lvol_bdev_with_name(bdev_name1) 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" - 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 # 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) 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 # on the whole lvol bdev perform write operation with verification 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) # Fill all free space of lvol bdev with data 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.c.stop_nbd_disk(nbd_name) # Save number of free clusters for lvs @@ -1688,7 +1688,7 @@ class TestCases(object): # Perform write operation with verification # to newly created free space of lvol bdev 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), int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0) fail_count += self.c.stop_nbd_disk(nbd_name) @@ -1752,8 +1752,8 @@ class TestCases(object): nbd_name0 = "/dev/nbd0" nbd_name1 = "/dev/nbd1" - fail_count += self.c.start_nbd_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_bdev0['name'], nbd_name0) + fail_count += self.c.nbd_start_disk(lvol_bdev1['name'], nbd_name1) size = "75%" # 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 nbd_name0 = "/dev/nbd0" nbd_name1 = "/dev/nbd1" - fail_count += self.c.start_nbd_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_bdev0['name'], nbd_name0) + 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) # fill first disk with 70% of its size # 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) 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 # Try to perform write operation on created snapshot # Check if filling snapshot of lvol bdev fails @@ -2203,12 +2203,12 @@ class TestCases(object): uuid_bdev1 = self.c.bdev_lvol_create(uuid_store, lbd_name1, size, thin=False) 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 thin provisoned lvol bdev with 50% of its space 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) - 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 whole thic provisioned lvol bdev 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 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.start_nbd_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_name0, nbd_name[2]) + fail_count += self.c.nbd_start_disk(self.lvs_name + "/" + snapshot_name1, nbd_name[3]) # Compare every lvol bdev with corresponding snapshot # and check that data are the same fail_count += self.compare_two_disks(nbd_name[0], nbd_name[2], 0) @@ -2274,7 +2274,7 @@ class TestCases(object): size, thin=True) 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) # Create thread that will run fio in background thread = FioThread(nbd_name, 0, fill_size, "write", "0xcc", 0, @@ -2440,7 +2440,7 @@ class TestCases(object): lbd_name0, size, thin=False) lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0) # 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 lvol bdev with 100% of its space 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) 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) # Perform write operation to first clone # Change first half of its space 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) - 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 time.sleep(1) 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) # 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 fail_count += self.run_fio_test(nbd_name, 0, fill_size, "write", "0xcc", 0) self.c.stop_nbd_disk(nbd_name) @@ -2619,7 +2619,7 @@ class TestCases(object): fail_count += 1 # 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 second_fill = int(size * 3 / 4) 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']) # 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, MEGABYTE, "read", "0xdd") 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) # 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 end_fill = int(size * 4 / 5) 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']) # 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 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) # 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 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) # 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 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") # 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") # Verify lvol bdev @@ -3010,7 +3010,7 @@ class TestCases(object): lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) # 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 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") # 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") # Create second snapshot of lvol_bdev @@ -3047,7 +3047,7 @@ class TestCases(object): # Verify snapshots 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, first_part, second_part-first_part, "read", "0xee") fail_count += self.run_fio_test(nbd_name2, second_part, size-second_part, "read", "0xcc")