Commit b5de4adf authored by Pawel Kaminski's avatar Pawel Kaminski Committed by Tomasz Zawadzki
Browse files

test/lvol: rewrite delete_snapshot_with_snapshot to bash 



Change-Id: I568066322369d192953885617ed11304a36ad4d2
Signed-off-by: default avatarPawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/698


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarMichal Berger <michalx.berger@intel.com>
parent dbf57935

test/lvol/lvol.sh

+0 −1
Original line number Diff line number Diff line
@@ -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',

test/lvol/snapshot_clone.sh

+86 −0
Original line number Diff line number Diff line
@@ -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

test/lvol/test_cases.py

+0 −123
Original line number Diff line number Diff line
@@ -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):

        """