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

test/lvol: rewrite snapshot_readonly and snapshot_compare_with_lvol_bdev to bash 



Change-Id: I27e58b05c3c8e55b06ea64f1640c2a5702449b26
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/+/684


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

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

                                    750: 'snapshot_readonly',

                                    751: 'snapshot_compare_with_lvol_bdev',

                                    752: 'snapshot_during_io_traffic',

                                    753: 'snapshot_of_snapshot',

                                    754: 'clone_bdev_only',

test/lvol/lvol2.sh

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

test/lvol/snapshot_clone.sh

0 → 100755
+90 −0
Original line number Diff line number Diff line 
#!/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

test/lvol/test_cases.py

+0 −129
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

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

        """