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

test/lvol: rewrite clone_bdev_only, clone_writing_clone and clone_and_snapshot_consistency to bash 



Change-Id: I6a705557d621b758e35efd929a013918e969b91d
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/+/687


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
parent 9010c464

test/lvol/lvol.sh

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

                                    654: 'thin_overprovisioning',

                                    655: 'thin_provisioning_filling_disks_less_than_lvs_size',

                                    754: 'clone_bdev_only',

                                    755: 'clone_writing_clone',

                                    756: 'clone_and_snapshot_consistency',

                                    757: 'clone_inflate',

                                    758: 'clone_decouple_parent',

                                    759: 'clone_decouple_parent_rw',

test/lvol/snapshot_clone.sh

+83 −0
Original line number Diff line number Diff line
@@ -141,6 +141,88 @@ function test_create_snapshot_of_snapshot() { 
	check_leftover_devices

}



# Check if only clone of snapshot can be created.

# Check if writing to one clone doesn't affect other clone

# Check if relations between clones and snapshots are properly set in configuration

function test_clone_snapshot_relations() {

	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 / 6 )) )

	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")



	# Fill lvol bdev with 100% of its space

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

	run_fio_test /dev/nbd0 0 lvol_size "write" "0xcc"

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0



	# An attempt to create a clone from lvol that is rw capable should fail

	rpc_cmd bdev_lvol_clone lvs_test/lvol_test clone_test && false



	# Create snapshots of lvol bdev

	snapshot_uuid=$(rpc_cmd bdev_lvol_snapshot lvs_test/lvol_test lvol_snapshot)



	# Create again clone of lvol bdev and check if it fails

	rpc_cmd bdev_lvol_clone lvs_test/lvol_test clone_test && false



	# Create two clones of snapshot and check if it ends with success

	clone_uuid1=$(rpc_cmd bdev_lvol_clone lvs_test/lvol_snapshot clone_test1)

	clone_uuid2=$(rpc_cmd bdev_lvol_clone lvs_test/lvol_snapshot clone_test2)



	# Perform write operation to first clone

	# Change first half of its space

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$clone_uuid1" /dev/nbd0

	fill_size=$(( lvol_size / 2 ))

	run_fio_test /dev/nbd0 0 $fill_size "write" "0xaa"



	# Compare snapshot with second clone. Data on both bdevs should be the same

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$snapshot_uuid" /dev/nbd1

	nbd_start_disks "$DEFAULT_RPC_ADDR" "$clone_uuid2" /dev/nbd2

	sleep 1

	cmp /dev/nbd1 /dev/nbd2

	# Compare snapshot with first clone

	cmp /dev/nbd0 /dev/nbd1 && false



	snapshot_bdev=$(rpc_cmd bdev_get_bdevs -b "lvs_test/lvol_snapshot")

	clone_bdev1=$(rpc_cmd bdev_get_bdevs -b "lvs_test/clone_test1")

	clone_bdev2=$(rpc_cmd bdev_get_bdevs -b "lvs_test/lvol_test")



	# Check snapshot consistency

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

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

	[ "$(jq '.[].driver_specific.lvol.clones|sort' <<< "$snapshot_bdev")" = "$(jq '.|sort' <<< '["lvol_test", "clone_test1", "clone_test2"]')" ]



	# Check first clone consistency

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

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

	[ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$clone_bdev1")" = '"lvol_snapshot"' ]



	# Check second clone consistency

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

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

	[ "$(jq '.[].driver_specific.lvol.base_snapshot' <<< "$clone_bdev2")" = '"lvol_snapshot"' ]



	# Destroy first clone and check if it is deleted from snapshot

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0

	rpc_cmd bdev_lvol_delete "$clone_uuid1"

	snapshot_bdev=$(rpc_cmd bdev_get_bdevs -b "lvs_test/lvol_snapshot")

	[ "$(jq '.[].driver_specific.lvol.clones|sort' <<< "$snapshot_bdev")" = "$(jq '.|sort' <<< '["lvol_test", "clone_test2"]')" ]



	# Clean up

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd1

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd2

	rpc_cmd bdev_lvol_delete "$lvol_uuid"

	rpc_cmd bdev_lvol_delete "$clone_uuid2"

	rpc_cmd bdev_lvol_delete "$snapshot_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
@@ -150,6 +232,7 @@ modprobe nbd 
run_test "test_snapshot_compare_with_lvol_bdev" test_snapshot_compare_with_lvol_bdev

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



trap - SIGINT SIGTERM EXIT

killprocess $spdk_pid

test/lvol/test_cases.py

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

            655: 'thin_provisioning_filling_disks_less_than_lvs_size',

            # snapshot and clone

            754: 'clone_bdev_only',

            755: 'clone_writing_clone',

            756: 'clone_and_snapshot_consistency',

            757: 'clone_inflate',

            758: 'decouple_parent',

            759: 'decouple_parent_rw',
@@ -984,230 +981,6 @@ class TestCases(object): 
        # - no other operation fails

        return fail_count



    @case_message

    def test_case754(self):

        """

        clone_bdev_only



        Check that only clone of snapshot can be created.

        Creating clone of lvol bdev should fail.

        """

        fail_count = 0

        clone_name = "clone"

        snapshot_name = "snapshot"

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

        lvs = self.c.bdev_lvol_get_lvstores()

        # Create thick provisioned lvol bdev with size equal to 50% of lvs space

        size = self.get_lvs_divided_size(2)

        uuid_bdev = self.c.bdev_lvol_create(uuid_store, self.lbd_name,

                                            size, thin=False)



        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)

        # Create clone of lvol bdev and check if it fails

        rv = self.c.bdev_lvol_clone(lvol_bdev['name'], clone_name)

        if rv == 0:

            print("ERROR: Creating clone of lvol bdev ended with unexpected success")

            fail_count += 1

        # Create snapshot of lvol bdev

        fail_count += self.c.bdev_lvol_snapshot(lvol_bdev['name'], snapshot_name)

        # Create again clone of lvol bdev and check if it fails

        rv = self.c.bdev_lvol_clone(lvol_bdev['name'], clone_name)

        if rv == 0:

            print("ERROR: Creating clone of lvol bdev ended with unexpected success")

            fail_count += 1

        # Create clone of snapshot and check if it ends with success

        rv = self.c.bdev_lvol_clone(self.lvs_name + "/" + snapshot_name, clone_name)

        if rv != 0:

            print("ERROR: Creating clone of snapshot ended with unexpected failure")

            fail_count += 1

        clone_bdev = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name)



        # Delete lvol bdev

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

        # Destroy clone

        fail_count += self.c.bdev_lvol_delete(clone_bdev['name'])

        # Delete snapshot

        fail_count += self.c.bdev_lvol_delete(self.lvs_name + "/" + snapshot_name)

        # Delete lvol store

        fail_count += self.c.bdev_lvol_delete_lvstore(uuid_store)

        # Destroy malloc bdev

        fail_count += self.c.bdev_malloc_delete(base_name)



        # Expected result:

        # - calls successful, return code = 0

        # - cloning thick provisioned lvol bdev should fail

        # - no other operation fails

        return fail_count



    @case_message

    def test_case755(self):

        """

        clone_writing_to_clone





        """

        fail_count = 0

        nbd_name = ["/dev/nbd0", "/dev/nbd1", "/dev/nbd2", "/dev/nbd3"]

        snapshot_name = "snapshot"

        clone_name0 = "clone0"

        clone_name1 = "clone1"

        # 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(6)

        lbd_name0 = self.lbd_name + str(0)

        # Construct thick provisioned lvol bdev

        uuid_bdev0 = self.c.bdev_lvol_create(uuid_store,

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



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

        # Create two clones of created snapshot

        fail_count += self.c.bdev_lvol_clone(snapshot_bdev['name'], clone_name0)

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



        for nbd in nbd_name:

            fail_count += self.c.nbd_stop_disk(nbd)

        # Destroy lvol bdev

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

        # Destroy two clones

        fail_count += self.c.bdev_lvol_delete(lvol_clone0['name'])

        fail_count += self.c.bdev_lvol_delete(lvol_clone1['name'])

        # Delete 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_case756(self):

        """

        clone_and_snapshot_relations



        Check if relations between clones and snapshots

        are properly set in configuration

        """

        fail_count = 0

        snapshot_name = 'snapshot'

        clone_name0 = 'clone1'

        clone_name1 = 'clone2'

        lbd_name = clone_name1



        # 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(6)



        # Construct thick provisioned lvol bdev

        uuid_bdev = self.c.bdev_lvol_create(uuid_store,

                                            lbd_name, size, thin=False)

        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)



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



        # Create clone of created snapshot

        fail_count += self.c.bdev_lvol_clone(snapshot_bdev['name'], clone_name0)



        # Get current bdevs configuration

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

        lvol_clone0 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name0)

        lvol_clone1 = self.c.get_lvol_bdev_with_name(self.lvs_name + "/" + clone_name1)



        # Check snapshot consistency

        snapshot_lvol = snapshot_bdev['driver_specific']['lvol']

        if snapshot_lvol['snapshot'] is not True:

            fail_count += 1

        if snapshot_lvol['clone'] is not False:

            fail_count += 1

        if sorted([clone_name0, clone_name1]) != sorted(snapshot_lvol['clones']):

            fail_count += 1



        # Check first clone consistency

        lvol_clone0_lvol = lvol_clone0['driver_specific']['lvol']

        if lvol_clone0_lvol['snapshot'] is not False:

            fail_count += 1

        if lvol_clone0_lvol['clone'] is not True:

            fail_count += 1

        if lvol_clone0_lvol['base_snapshot'] != 'snapshot':

            fail_count += 1



        # Check second clone consistency

        lvol_clone1_lvol = lvol_clone1['driver_specific']['lvol']

        if lvol_clone1_lvol['snapshot'] is not False:

            fail_count += 1

        if lvol_clone1_lvol['clone'] is not True:

            fail_count += 1

        if lvol_clone1_lvol['base_snapshot'] != 'snapshot':

            fail_count += 1



        # Destroy first clone and check if it is deleted from snapshot

        fail_count += self.c.bdev_lvol_delete(lvol_clone0['name'])

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

        if [clone_name1] != snapshot_bdev['driver_specific']['lvol']['clones']:

            fail_count += 1



        # Destroy second clone

        fail_count += self.c.bdev_lvol_delete(lvol_clone1['name'])



        # Delete 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_case757(self):

        """