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

test/lvol: rewrite clone_decouple_parent and clone_decouple_parent_rw to bash 



Change-Id: I6c21e2b3ab9cf91d8e5ab725c630173a558a5c04
Signed-off-by: default avatarPawel Kaminski <pawelx.kaminski@intel.com>
Signed-off-by: default avatarMichal Berger <michalx.berger@intel.com>
Reviewed-on: https://review.spdk.io/gerrit/c/spdk/spdk/+/695


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>
parent 4c8066a3

test/lvol/lvol.sh

+0 −2
Original line number Diff line number Diff line
@@ -35,8 +35,6 @@ function usage() { 
                                    653: 'thin_provisioning_resize',

                                    654: 'thin_overprovisioning',

                                    655: 'thin_provisioning_filling_disks_less_than_lvs_size',

                                    758: 'clone_decouple_parent',

                                    759: 'clone_decouple_parent_rw',

                                    760: 'set_read_only',

                                    761: 'delete_snapshot',

                                    762: 'delete_snapshot_with_snapshot',

test/lvol/snapshot_clone.sh

+96 −0
Original line number Diff line number Diff line
@@ -277,6 +277,101 @@ function test_clone_inflate() { 
	check_leftover_devices

}



# Create chain of snapshot<-snapshot2<-lvol_test lvol bdevs.

# Decouple lvol_test twice and delete the remaining snapshot lvol.

# Each time check consistency of snapshot-clone relations and written data.

function test_clone_decouple_parent() {

	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=$(( 5 * LVS_DEFAULT_CLUSTER_SIZE_MB ))

	lvol_uuid=$(rpc_cmd bdev_lvol_create -u "$lvs_uuid" lvol_test "$lvol_size_mb" -t)

	lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid")



	# Decouple_parent should fail on lvol bdev without a parent

	rpc_cmd bdev_lvol_decouple_parent lvs_test/lvol_test && false



	# Fill first four out of 5 clusters of clone with data of known pattern

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$lvol_uuid" /dev/nbd0

	begin_fill=0

	end_fill=$(( lvol_size_mb * 4 * 1024 * 1024 / 5 ))

	run_fio_test /dev/nbd0 $begin_fill $end_fill "write" "0xdd"



	# Create snapshot (snapshot<-lvol_bdev)

	snapshot_uuid=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot)



	# Fill second and fourth cluster of clone with data of known pattern

	start_fill=$(( lvol_size_mb * 1024 * 1024 / 5 ))

	fill_range=$start_fill

	run_fio_test /dev/nbd0 $start_fill $fill_range "write" "0xcc"

	start_fill=$(( lvol_size_mb * 3 * 1024 * 1024 / 5 ))

	run_fio_test /dev/nbd0 $start_fill $fill_range "write" "0xcc"



	# Create snapshot (snapshot<-snapshot2<-lvol_bdev)

	snapshot_uuid2=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot2)



	# Fill second cluster of clone with data of known pattern

	start_fill=$fill_range

	run_fio_test /dev/nbd0 $start_fill $fill_range "write" "0xee"



	# Check data consistency

	pattern=( "0xdd" "0xee" "0xdd" "0xcc" "0x00" )

	for i in "${!pattern[@]}"; do

		start_fill=$(( lvol_size_mb * i * 1024 * 1024 / 5 ))

		run_fio_test /dev/nbd0 $start_fill $fill_range "read" "${pattern[i]}"

	done



	# Decouple_parent of lvol bdev resulting in two relation chains:

	#  - snapshot<-lvol_bdev

	#  - snapshot<-snapshot2

	rpc_cmd bdev_lvol_decouple_parent lvs_test/lvol_test

	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.thin_provision' <<< "$lvol")" = "true" ]

	[ "$(jq '.[].driver_specific.lvol.clone' <<< "$lvol")" = "true" ]

	[ "$(jq '.[].driver_specific.lvol.snapshot' <<< "$lvol")" = "false" ]

	[ "$(jq '.[].driver_specific.lvol.clone' <<< "$snapshot")" = "false" ]

	[ "$(jq '.[].driver_specific.lvol.clone' <<< "$snapshot2")" = "true" ]

	[ "$(jq '.[].driver_specific.lvol.snapshot' <<< "$snapshot2")" = "true" ]



	# Delete second snapshot

	rpc_cmd bdev_lvol_delete "$snapshot_uuid2"



	# Check data consistency

	for i in "${!pattern[@]}"; do

		start_fill=$(( lvol_size_mb * i * 1024 * 1024 / 5 ))

		run_fio_test /dev/nbd0 $start_fill $fill_range "read" "${pattern[i]}"

	done



	# Decouple_parent of lvol bdev again resulting in two relation chains:

	#  - lvol_bdev

	#  - snapshot<-snapshot2

	rpc_cmd bdev_lvol_decouple_parent lvs_test/lvol_test

	lvol=$(rpc_cmd bdev_get_bdevs -b "$lvol_uuid")

	snapshot=$(rpc_cmd bdev_get_bdevs -b "$snapshot_uuid")

	[ "$(jq '.[].driver_specific.lvol.thin_provision' <<< "$lvol")" = "true" ]

	[ "$(jq '.[].driver_specific.lvol.clone' <<< "$lvol")" = "false" ]

	[ "$(jq '.[].driver_specific.lvol.snapshot' <<< "$lvol")" = "false" ]

	[ "$(jq '.[].driver_specific.lvol.clone' <<< "$snapshot")" = "false" ]



	# Delete first snapshot

	rpc_cmd bdev_lvol_delete "$snapshot_uuid"



	# Check data consistency

	for i in "${!pattern[@]}"; do

		start_fill=$(( lvol_size_mb * i * 1024 * 1024 / 5 ))

		run_fio_test /dev/nbd0 $start_fill $fill_range "read" "${pattern[i]}"

	done



	# Clean up

	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
@@ -288,6 +383,7 @@ run_test "test_create_snapshot_with_io" test_create_snapshot_with_io 
run_test "test_create_snapshot_of_snapshot" test_create_snapshot_of_snapshot

run_test "test_clone_snapshot_relations" test_clone_snapshot_relations

run_test "test_clone_inflate" test_clone_inflate

run_test "test_clone_decouple_parent" test_clone_decouple_parent



trap - SIGINT SIGTERM EXIT

killprocess $spdk_pid

test/lvol/test_cases.py

+0 −175
Original line number Diff line number Diff line
@@ -126,8 +126,6 @@ def case_message(func): 
            654: 'thin_overprovisioning',

            655: 'thin_provisioning_filling_disks_less_than_lvs_size',

            # snapshot and clone

            758: 'decouple_parent',

            759: 'decouple_parent_rw',

            760: 'set_read_only',

            761: 'delete_snapshot',

            762: 'delete_snapshot_with_snapshot',
@@ -980,179 +978,6 @@ class TestCases(object): 
        # - no other operation fails

        return fail_count



    @case_message

    def test_case758(self):

        """

        clone_decouple_parent



        Detach parent from clone and check if parent can be safely removed.

        Check data consistency.

        """



        fail_count = 0

        snapshot_name = "snapshot"

        nbd_name = "/dev/nbd0"



        # Create malloc bdev

        base_name = self.c.bdev_malloc_create(self.total_size,

                                              self.block_size)



        # Create 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(4)



        # Construct thin provisioned lvol bdev

        uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,

                                             self.lbd_name, size, thin=True)

        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)



        # Decouple parent lvol bdev and check if it fails

        ret_value = self.c.bdev_lvol_decouple_parent(lvol_bdev['name'])

        if ret_value == 0:

            print("ERROR: Decouple parent on bdev without parent should "

                  "fail but didn't")

            fail_count += 1



        # Create snapshot of thin provisioned 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)



        # Decouple parent lvol bdev

        fail_count += self.c.bdev_lvol_decouple_parent(lvol_bdev['name'])

        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)

        snapshot_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + snapshot_name)

        if lvol_bdev['driver_specific']['lvol']['thin_provision'] is not True:

            fail_count += 1

        if lvol_bdev['driver_specific']['lvol']['clone'] is not False:

            fail_count += 1

        if lvol_bdev['driver_specific']['lvol']['snapshot'] is not False:

            fail_count += 1

        if snapshot_bdev['driver_specific']['lvol']['clone'] is not False:

            fail_count += 1



        # 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

        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_case759(self):

        """

        clone_decouple_parent_rw



        Create tree level snaphot-snapshot2-clone structure.

        Detach snapshot2 from clone. Check if snapshot2 can be safely removed.

        Each time check consistency of snapshot-clone relations and written data.

        """

        fail_count = 0

        snapshot_name = "snapshot"

        snapshot_name2 = "snapshot2"

        nbd_name = "/dev/nbd0"



        # Create malloc bdev

        base_name = self.c.bdev_malloc_create(self.total_size,

                                              self.block_size)



        # Create 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)

        lvs = self.c.bdev_lvol_get_lvstores()

        size = int(5 * lvs[0]['cluster_size'] / MEGABYTE)



        # Construct thin provisioned lvol bdev

        uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,

                                             self.lbd_name, size, thin=True)

        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.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,

                                        end_fill * MEGABYTE, "write", "0xdd", 0)



        # Create snapshot of thin provisioned 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)



        # Fill second and fourth cluster of clone with data of known pattern

        start_fill = int(size / 5)

        fill_range = int(size / 5)

        fail_count += self.run_fio_test(nbd_name, start_fill * MEGABYTE,

                                        fill_range * MEGABYTE, "write", "0xcc", 0)

        start_fill = int(size * 3 / 5)

        fail_count += self.run_fio_test(nbd_name, start_fill * MEGABYTE,

                                        fill_range * MEGABYTE, "write", "0xcc", 0)



        # Create second snapshot of thin provisioned lvol bdev

        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)



        # Fill second cluster of clone with data of known pattern

        start_fill = int(size / 5)

        fail_count += self.run_fio_test(nbd_name, start_fill * MEGABYTE,

                                        fill_range * MEGABYTE, "write", "0xee", 0)



        # Check data consistency

        pattern = ["0xdd", "0xee", "0xdd", "0xcc", "0x00"]

        for i in range(0, 5):

            begin_fill = int(size * i / 5)

            fail_count += self.run_fio_test(nbd_name, begin_fill * MEGABYTE,

                                            fill_range * MEGABYTE, "read", pattern[i])



        # Decouple parent

        fail_count += self.c.bdev_lvol_decouple_parent(lvol_bdev['name'])

        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev0)



        # Check data consistency

        for i in range(0, 5):

            begin_fill = int(size * i / 5)

            fail_count += self.run_fio_test(nbd_name, begin_fill * MEGABYTE,

                                            fill_range * MEGABYTE, "read", pattern[i])



        # Delete second snapshot

        ret_value = self.c.bdev_lvol_delete(snapshot_bdev2['name'])



        # Check data consistency

        for i in range(0, 5):

            begin_fill = int(size * i / 5)

            fail_count += self.run_fio_test(nbd_name, begin_fill * MEGABYTE,

                                            fill_range * MEGABYTE, "read", pattern[i])



        # 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

        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_case760(self):

        """