From 94435f38767443121049a9e77dbc639b626f708d Mon Sep 17 00:00:00 2001 From: Pawel Kaminski Date: Sun, 1 Dec 2019 16:43:50 -0500 Subject: [PATCH] test/lvol: rewrite snapshot_readonly and snapshot_compare_with_lvol_bdev to bash Change-Id: I27e58b05c3c8e55b06ea64f1640c2a5702449b26 Signed-off-by: Pawel Kaminski Signed-off-by: Michal Berger Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/684 Tested-by: SPDK CI Jenkins Reviewed-by: Darek Stojaczyk Reviewed-by: Tomasz Zawadzki --- test/lvol/lvol.sh | 2 - test/lvol/lvol2.sh | 1 + test/lvol/snapshot_clone.sh | 90 +++++++++++++++++++++++++ test/lvol/test_cases.py | 129 ------------------------------------ 4 files changed, 91 insertions(+), 131 deletions(-) create mode 100755 test/lvol/snapshot_clone.sh diff --git a/test/lvol/lvol.sh b/test/lvol/lvol.sh index 106ec9fb1..b972ca7d2 100755 --- a/test/lvol/lvol.sh +++ b/test/lvol/lvol.sh @@ -35,8 +35,6 @@ function usage() { 653: 'thin_provisioning_resize', 654: 'thin_overprovisioning', 655: 'thin_provisioning_filling_disks_less_than_lvs_size', - 750: 'snapshot_readonly', - 751: 'snapshot_compare_with_lvol_bdev', 752: 'snapshot_during_io_traffic', 753: 'snapshot_of_snapshot', 754: 'clone_bdev_only', diff --git a/test/lvol/lvol2.sh b/test/lvol/lvol2.sh index 37ad15794..54fd7194b 100755 --- a/test/lvol/lvol2.sh +++ b/test/lvol/lvol2.sh @@ -11,6 +11,7 @@ run_test "lvol_basic" test/lvol/basic.sh run_test "lvol_resize" test/lvol/resize.sh run_test "lvol_hotremove" test/lvol/hotremove.sh run_test "lvol_tasting" test/lvol/tasting.sh +run_test "lvol_snapshot_clone" test/lvol/snapshot_clone.sh timing_exit basic timing_exit lvol diff --git a/test/lvol/snapshot_clone.sh b/test/lvol/snapshot_clone.sh new file mode 100755 index 000000000..7ecc1f94c --- /dev/null +++ b/test/lvol/snapshot_clone.sh @@ -0,0 +1,90 @@ +#!/usr/bin/env bash + +testdir=$(readlink -f $(dirname $0)) +rootdir=$(readlink -f $testdir/../..) +source $rootdir/test/common/autotest_common.sh +source $rootdir/test/lvol/common.sh +source $rootdir/test/bdev/nbd_common.sh + +function test_snapshot_compare_with_lvol_bdev() { + malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS) + lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test) + + # Create two lvol bdevs + lvol_size_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB / 6 )) ) + lvol_size=$(( lvol_size_mb * 1024 * 1024 )) + + lvol_uuid1=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test1 "$lvol_size_mb" -t) + lvol_uuid2=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test2 "$lvol_size_mb") + + # Fill thin provisoned lvol bdev with 50% of its space + nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" /dev/nbd0 + count=$(( lvol_size / LVS_DEFAULT_CLUSTER_SIZE / 2 )) + dd if=/dev/urandom of=/dev/nbd0 oflag=direct bs="$LVS_DEFAULT_CLUSTER_SIZE" count=$count + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0 + # Fill whole thick provisioned lvol bdev + nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid2" /dev/nbd0 + count=$(( lvol_size / LVS_DEFAULT_CLUSTER_SIZE )) + dd if=/dev/urandom of=/dev/nbd0 oflag=direct bs="$LVS_DEFAULT_CLUSTER_SIZE" count=$count + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0 + + # Create snapshots of lvol bdevs + snapshot_uuid1=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test1 lvol_snapshot1) + snapshot_uuid2=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test2 lvol_snapshot2) + + nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid1" /dev/nbd0 + # Try to perform write operation on created snapshot + # Check if filling snapshot of lvol bdev fails + count=$(( lvol_size / LVS_DEFAULT_CLUSTER_SIZE )) + dd if=/dev/urandom of=/dev/nbd0 oflag=direct bs="$LVS_DEFAULT_CLUSTER_SIZE" count=$count && false + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0 + + # Declare nbd devices as vars for an easy cross-reference + local lvol_nbd1=/dev/nbd0 lvol_nbd2=/dev/nbd1 + local snapshot_nbd1=/dev/nbd2 snapshot_nbd2=/dev/nbd3 + + nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid1" "$lvol_nbd1" + nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid2" "$lvol_nbd2" + nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid1" "$snapshot_nbd1" + nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid2" "$snapshot_nbd2" + # Compare every lvol bdev with corresponding snapshot and check that data are the same + cmp "$lvol_nbd1" "$snapshot_nbd1" + cmp "$lvol_nbd2" "$snapshot_nbd2" + + # Fill second half of thin provisioned lvol bdev + count=$(( lvol_size / LVS_DEFAULT_CLUSTER_SIZE / 2 )) + dd if=/dev/urandom of="$lvol_nbd1" oflag=direct seek=$count bs="$LVS_DEFAULT_CLUSTER_SIZE" count=$count + + # Compare thin provisioned lvol bdev with its snapshot and check if it fails + cmp "$lvol_nbd1" "$snapshot_nbd1" && false + + # clean up + for bdev in "${!lvol_nbd@}" "${!snapshot_nbd@}"; do + nbd_stop_disks "$DEFAULT_RPC_ADDR" "${!bdev}" + done + + rpc_cmd bdev_lvol_delete "$lvol_uuid1" + rpc_cmd bdev_get_bdevs -b "$lvol_uuid1" && false + rpc_cmd bdev_lvol_delete "$snapshot_uuid1" + rpc_cmd bdev_get_bdevs -b "$snapshot_uuid1" && false + rpc_cmd bdev_lvol_delete "$lvol_uuid2" + rpc_cmd bdev_get_bdevs -b "$lvol_uuid2" && false + rpc_cmd bdev_lvol_delete "$snapshot_uuid2" + rpc_cmd bdev_get_bdevs -b "$snapshot_uuid2" && false + rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid" + rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid" && false + rpc_cmd bdev_malloc_delete "$malloc_name" + check_leftover_devices +} + + +$rootdir/app/spdk_tgt/spdk_tgt & +spdk_pid=$! +trap 'killprocess "$spdk_pid"; exit 1' SIGINT SIGTERM EXIT +waitforlisten $spdk_pid +modprobe nbd + +run_test "test_snapshot_compare_with_lvol_bdev" test_snapshot_compare_with_lvol_bdev + +trap - SIGINT SIGTERM EXIT +killprocess $spdk_pid diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py index c9cf8dbc3..e142d68c2 100644 --- a/test/lvol/test_cases.py +++ b/test/lvol/test_cases.py @@ -126,8 +126,6 @@ def case_message(func): 654: 'thin_overprovisioning', 655: 'thin_provisioning_filling_disks_less_than_lvs_size', # snapshot and clone - 750: 'snapshot_readonly', - 751: 'snapshot_compare_with_lvol_bdev', 752: 'snapshot_during_io_traffic', 753: 'snapshot_of_snapshot', 754: 'clone_bdev_only', @@ -988,133 +986,6 @@ class TestCases(object): # - no other operation fails return fail_count - @case_message - def test_case750(self): - """ - snapshot readonly - - Create snaphot of lvol bdev and check if it is readonly. - """ - fail_count = 0 - nbd_name0 = "/dev/nbd0" - snapshot_name = "snapshot0" - # Construct malloc bdev - base_name = self.c.bdev_malloc_create(self.total_size, - self.block_size) - # Construct lvol store on malloc bdev - uuid_store = self.c.bdev_lvol_create_lvstore(base_name, - self.lvs_name) - fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, - self.cluster_size) - - lvs = self.c.bdev_lvol_get_lvstores()[0] - free_clusters_start = int(lvs['free_clusters']) - bdev_size = self.get_lvs_divided_size(3) - # Create lvol bdev with 33% of lvol store space - bdev_name = self.c.bdev_lvol_create(uuid_store, self.lbd_name, - bdev_size) - lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) - # Create snapshot of lvol bdev - 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.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 - fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc", 1) - - fail_count += self.c.nbd_stop_disk(nbd_name0) - # Destroy lvol bdev - fail_count += self.c.bdev_lvol_delete(lvol_bdev['name']) - # Destroy snapshot - fail_count += self.c.bdev_lvol_delete(snapshot_bdev['name']) - # Destroy lvol store - fail_count += self.c.bdev_lvol_delete_lvstore(uuid_store) - # Delete malloc bdev - fail_count += self.c.bdev_malloc_delete(base_name) - - # Expected result: - # - calls successful, return code = 0 - # - no other operation fails - return fail_count - - @case_message - def test_case751(self): - """ - snapshot_compare_with_lvol_bdev - - Check if lvol bdevs and snapshots contain the same data. - Check if lvol bdev and snapshot differ when writing to lvol bdev - after creating snapshot. - """ - fail_count = 0 - nbd_name = ["/dev/nbd0", "/dev/nbd1", "/dev/nbd2", "/dev/nbd3"] - snapshot_name0 = "snapshot0" - snapshot_name1 = "snapshot1" - # Construct mallov bdev - base_name = self.c.bdev_malloc_create(self.total_size, - self.block_size) - # Construct lvol store - uuid_store = self.c.bdev_lvol_create_lvstore(base_name, - self.lvs_name) - fail_count += self.c.check_bdev_lvol_get_lvstores(base_name, uuid_store, - self.cluster_size) - size = self.get_lvs_divided_size(6) - lbd_name0 = self.lbd_name + str(0) - lbd_name1 = self.lbd_name + str(1) - # Create thin provisioned lvol bdev with size less than 25% of lvs - uuid_bdev0 = self.c.bdev_lvol_create(uuid_store, - lbd_name0, size, thin=True) - # Create thick provisioned lvol bdev with size less than 25% of lvs - 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.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.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) - - # 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.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) - fail_count += self.compare_two_disks(nbd_name[1], nbd_name[3], 0) - - fill_size = int(size * MEGABYTE / 2) - offset = fill_size - # Fill second half of thin provisioned lvol bdev - fail_count += self.run_fio_test(nbd_name[0], offset, fill_size, "write", "0xaa", 0) - # Compare thin provisioned lvol bdev with its snapshot and check if it fails - fail_count += self.compare_two_disks(nbd_name[0], nbd_name[2], 1) - for nbd in nbd_name: - fail_count += self.c.nbd_stop_disk(nbd) - # Delete lvol bdevs - fail_count += self.c.bdev_lvol_delete(lvol_bdev0['name']) - fail_count += self.c.bdev_lvol_delete(lvol_bdev1['name']) - # Delete snapshots - fail_count += self.c.bdev_lvol_delete(self.lvs_name + "/" + snapshot_name0) - fail_count += self.c.bdev_lvol_delete(self.lvs_name + "/" + snapshot_name1) - # Destroy snapshot - fail_count += self.c.bdev_lvol_delete_lvstore(uuid_store) - # Delete malloc bdev - fail_count += self.c.bdev_malloc_delete(base_name) - - # Expected result: - # - calls successful, return code = 0 - # - removing snapshot should always end with success - # - no other operation fails - return fail_count - @case_message def test_case752(self): """