From b5de4adfd7f78dc1ed4d672955496a96fcd65356 Mon Sep 17 00:00:00 2001 From: Pawel Kaminski Date: Fri, 6 Dec 2019 17:38:43 -0500 Subject: [PATCH] test/lvol: rewrite delete_snapshot_with_snapshot to bash Change-Id: I568066322369d192953885617ed11304a36ad4d2 Signed-off-by: Pawel Kaminski Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/698 Tested-by: SPDK CI Jenkins Reviewed-by: Jim Harris Reviewed-by: Tomasz Zawadzki Reviewed-by: Michal Berger --- test/lvol/lvol.sh | 1 - test/lvol/snapshot_clone.sh | 86 +++++++++++++++++++++++++ test/lvol/test_cases.py | 123 ------------------------------------ 3 files changed, 86 insertions(+), 124 deletions(-) diff --git a/test/lvol/lvol.sh b/test/lvol/lvol.sh index 68ea6cdcb..77abb5059 100755 --- a/test/lvol/lvol.sh +++ b/test/lvol/lvol.sh @@ -35,7 +35,6 @@ function usage() { 653: 'thin_provisioning_resize', 654: 'thin_overprovisioning', 655: 'thin_provisioning_filling_disks_less_than_lvs_size', - 762: 'delete_snapshot_with_snapshot', 800: 'rename_positive', 801: 'rename_lvs_nonexistent', 802: 'rename_lvs_EEXIST', diff --git a/test/lvol/snapshot_clone.sh b/test/lvol/snapshot_clone.sh index 17853770f..94b3fc127 100755 --- a/test/lvol/snapshot_clone.sh +++ b/test/lvol/snapshot_clone.sh @@ -457,6 +457,91 @@ function test_delete_snapshot_with_clone() { check_leftover_devices } +# Check if it is possible to delete snapshot with one snapshot on it +function test_delete_snapshot_with_snapshot() { + malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS) + lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test) + + # Calculate size and create lvol bdev + lvol_size_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB / 5 )) ) + lvol_size=$(( lvol_size_mb * 1024 * 1024 )) + + lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb") + lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid") + + # Perform write operation on lvol + nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0 + run_fio_test /dev/nbd0 0 $lvol_size "write" "0xcc" + + # Create snapshot of lvol bdev + snapshot_uuid=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot) + lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid") + [ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$lvol")" = '"lvol_snapshot"' ] + + # Fill second 1/3 of lvol bdev + first_part=$(( lvol_size / 3 )) + second_part=$(( lvol_size * 2 / 3 )) + run_fio_test /dev/nbd0 $first_part $(( second_part - first_part )) "write" "0xee" + + # Check if snapshot was unchanged + nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid" /dev/nbd1 + run_fio_test /dev/nbd1 0 $lvol_size "read" "0xcc" + + # Create second snapshot of lvol_bdev + # First snapshot becomes snapshot of second snapshot + snapshot_uuid2=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot2) + lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid") + snapshot=$(rpc_cmd bdev_get_bdevs -b "$snapshot_uuid") + snapshot2=$(rpc_cmd bdev_get_bdevs -b "$snapshot_uuid2") + [ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$snapshot2")" = '"lvol_snapshot"' ] + [ "$(jq '.[].driver_specific.lvol.clones|sort' <<< "$snapshot2")" = "$(jq '.|sort' <<< '["lvol_test"]')" ] + [ "$(jq '.[].driver_specific.lvol.clone' <<< "$snapshot2")" = "true" ] + [ "$(jq '.[].driver_specific.lvol.snapshot' <<< "$snapshot2")" = "true" ] + [ "$(jq '.[].driver_specific.lvol.clones|sort' <<< "$snapshot")" = "$(jq '.|sort' <<< '["lvol_snapshot2"]')" ] + + # Verify snapshots + run_fio_test /dev/nbd1 0 $size "read" "0xcc" + nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid2" /dev/nbd2 + run_fio_test /dev/nbd2 0 $(( first_part - 1 )) "read" "0xcc" + run_fio_test /dev/nbd2 $first_part $(( second_part - first_part )) "read" "0xee" + run_fio_test /dev/nbd2 $second_part $(( lvol_size - second_part )) "read" "0xcc" + + # Verify lvol bdev + run_fio_test /dev/nbd0 $first_part $(( second_part - first_part )) "read" "0xee" + run_fio_test /dev/nbd0 $second_part $(( lvol_size - second_part )) "read" "0xcc" + [ "$(jq '.[].driver_specific.lvol.clone' <<< "$lvol")" = "true" ] + [ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$lvol")" = '"lvol_snapshot2"' ] + + # Fill third part of lvol bdev + run_fio_test /dev/nbd0 $second_part $(( lvol_size - second_part )) "write" "0xdd" + + # Verify snapshots + run_fio_test /dev/nbd1 0 $size "read" "0xcc" + run_fio_test /dev/nbd0 $second_part $(( lvol_size - second_part )) "read" "0xdd" + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd2 + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1 + + # Delete snapshot - should succeed + rpc_cmd bdev_lvol_delete "$snapshot_uuid2" + + # Check data consistency + lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid") + snapshot=$(rpc_cmd bdev_get_bdevs -b "$snapshot_uuid") + [ "$(jq '.[].driver_specific.lvol.clone' <<< "$lvol")" = "true" ] + [ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$lvol")" = '"lvol_snapshot"' ] + [ "$(jq '.[].driver_specific.lvol.clones|sort' <<< "$snapshot")" = "$(jq '.|sort' <<< '["lvol_test"]')" ] + run_fio_test /dev/nbd0 $first_part $(( second_part - first_part )) "read" "0xee" + run_fio_test /dev/nbd0 $second_part $(( lvol_size - second_part )) "read" "0xdd" + + # Clean up + nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0 + rpc_cmd bdev_lvol_delete "$snapshot_uuid" + rpc_cmd bdev_lvol_delete "$lvol_uuid" + rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid" + 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 @@ -471,6 +556,7 @@ run_test "test_clone_inflate" test_clone_inflate run_test "test_clone_decouple_parent" test_clone_decouple_parent run_test "test_lvol_bdev_readonly" test_lvol_bdev_readonly run_test "test_delete_snapshot_with_clone" test_delete_snapshot_with_clone +run_test "test_delete_snapshot_with_snapshot" test_delete_snapshot_with_snapshot trap - SIGINT SIGTERM EXIT killprocess $spdk_pid diff --git a/test/lvol/test_cases.py b/test/lvol/test_cases.py index 8b4505b2c..7379d4afc 100644 --- a/test/lvol/test_cases.py +++ b/test/lvol/test_cases.py @@ -125,8 +125,6 @@ def case_message(func): 653: 'thin_provisioning_resize', 654: 'thin_overprovisioning', 655: 'thin_provisioning_filling_disks_less_than_lvs_size', - # snapshot and clone - 762: 'delete_snapshot_with_snapshot', # logical volume rename tests 800: 'rename_positive', 801: 'rename_lvs_nonexistent', @@ -976,127 +974,6 @@ class TestCases(object): # - no other operation fails return fail_count - @case_message - def test_case762(self): - """ - delete_snapshot_with_snapshot - - Check if it is possible to delete snapshot with one snapshot on it - """ - fail_count = 0 - nbd_name0 = "/dev/nbd0" - nbd_name1 = "/dev/nbd1" - nbd_name2 = "/dev/nbd2" - snapshot_name = "snapshot" - snapshot_name2 = "snapshot2" - # 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) - - # Create lvol bdev with one third of lvol store space - lvs = self.c.bdev_lvol_get_lvstores()[0] - bdev_size = self.get_lvs_divided_size(3) - 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) - - # Perform write operation on lvol - 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") - - # 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) - lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) - if lvol_bdev['driver_specific']['lvol']['base_snapshot'] != snapshot_name: - fail_count += 1 - - # Fill second 1/3 of lvol bdev - first_part = int(size / 3) - second_part = int(size / 3 * 2) - 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.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 - # First snapshot becomes snapshot of second snapshot - fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name2) - snapshot_bdev2 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name2) - snapshot_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name) - if snapshot_bdev2['driver_specific']['lvol']['base_snapshot'] != snapshot_name: - fail_count += 1 - if self.lbd_name not in snapshot_bdev2['driver_specific']['lvol']['clones']: - fail_count += 1 - if snapshot_bdev2['driver_specific']['lvol']['clone'] is not True\ - or snapshot_bdev2['driver_specific']['lvol']['snapshot'] is not True: - fail_count += 1 - if snapshot_name2 not in snapshot_bdev['driver_specific']['lvol']['clones']: - fail_count += 1 - - # Verify snapshots - fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc") - 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") - - # Verify lvol bdev - fail_count += self.run_fio_test(nbd_name0, first_part, second_part-first_part, "read", "0xee") - fail_count += self.run_fio_test(nbd_name0, second_part, size-second_part, "read", "0xcc") - lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) - if lvol_bdev['driver_specific']['lvol']['clone'] is not True: - fail_count += 1 - if lvol_bdev['driver_specific']['lvol']['base_snapshot'] != snapshot_name2: - fail_count += 1 - - # Fill third part of lvol bdev - fail_count += self.run_fio_test(nbd_name0, second_part, size-second_part, "write", "0xdd") - - # Verify snapshots - fail_count += self.run_fio_test(nbd_name1, 0, size-1, "read", "0xcc") - fail_count += self.c.nbd_stop_disk(nbd_name1) - fail_count += self.run_fio_test(nbd_name2, second_part, size-second_part, "read", "0xcc") - fail_count += self.c.nbd_stop_disk(nbd_name2) - - # Delete snapshot - should succeed - fail_count += self.c.bdev_lvol_delete(snapshot_bdev2['name']) - - # Check data consistency - snapshot_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name) - lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name) - if lvol_bdev['driver_specific']['lvol']['clone'] is not True: - fail_count += 1 - if lvol_bdev['driver_specific']['lvol']['base_snapshot'] != snapshot_name: - fail_count += 1 - if self.lbd_name not in snapshot_bdev['driver_specific']['lvol']['clones']: - fail_count += 1 - fail_count += self.run_fio_test(nbd_name0, first_part, second_part-first_part, "read", "0xee") - fail_count += self.run_fio_test(nbd_name0, second_part, size-second_part, "read", "0xdd") - fail_count += self.c.nbd_stop_disk(nbd_name0) - - # Destroy snapshot - fail_count += self.c.bdev_lvol_delete(snapshot_bdev['name']) - # Destroy lvol bdev - fail_count += self.c.bdev_lvol_delete(lvol_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_case800(self): """