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

test/lvol: rewrite thin_provisioning_resize to bash 



Change-Id: I0241a4c435a3b28951edcdd7f4aa6a5120a7dc8a
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/+/706


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 661adc77

test/lvol/lvol.sh

+0 −1
Original line number Diff line number Diff line
@@ -29,7 +29,6 @@ function usage() { 
                                    552: 'bdev_lvol_delete_lvstore_with_clones',

                                    553: 'unregister_lvol_bdev',

                                    602: 'bdev_lvol_create_lvstore_with_all_clear_methods',

                                    653: 'thin_provisioning_resize',

                                    654: 'thin_overprovisioning',

                                    655: 'thin_provisioning_filling_disks_less_than_lvs_size',

                                    850: 'clear_method_none',

test/lvol/test_cases.py

+0 −73
Original line number Diff line number Diff line
@@ -119,7 +119,6 @@ def case_message(func): 
            553: 'unregister_lvol_bdev',

            602: 'bdev_lvol_create_lvstore_with_all_clear_methods',

            # Provisioning

            653: 'thin_provisioning_resize',

            654: 'thin_overprovisioning',

            655: 'thin_provisioning_filling_disks_less_than_lvs_size',

            # logical volume clear_method test
@@ -580,78 +579,6 @@ class TestCases(object): 
        # - Error code response printed to stdout

        return fail_count



    @case_message

    def test_case653(self):

        """

        thin_provisioning_resize



        Check thin provisioned bdev resize.

        """

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

        # Construct thin provisioned lvol bdevs on created lvol store

        # with size equal to 50% of lvol store

        size = self.get_lvs_divided_size(2)

        uuid_bdev = self.c.bdev_lvol_create(uuid_store,

                                            self.lbd_name, size, thin=True)

        fail_count += self.c.check_bdev_get_bdevs_methods(uuid_bdev, size)

        # Fill all free space of lvol bdev with data

        nbd_name = "/dev/nbd0"

        fail_count += self.c.nbd_start_disk(uuid_bdev, nbd_name)

        fail_count += self.run_fio_test(nbd_name, 0, size*MEGABYTE, "write", "0xcc", 0)

        fail_count += self.c.nbd_stop_disk(nbd_name)

        # Save number of free clusters for lvs

        lvs = self.c.bdev_lvol_get_lvstores()[0]

        free_clusters_start = int(lvs['free_clusters'])

        # Resize bdev to full size of lvs

        full_size = int(lvs['total_data_clusters'] * lvs['cluster_size'] / MEGABYTE)

        fail_count += self.c.bdev_lvol_resize(uuid_bdev, full_size)

        # Check if bdev size changed (total_data_clusters*cluster_size

        # equals to num_blocks*block_size)

        lvol_bdev = self.c.get_lvol_bdev_with_name(uuid_bdev)

        lbd_size = int(lvol_bdev['num_blocks'] * lvol_bdev['block_size'] / MEGABYTE)

        if full_size != lbd_size:

            fail_count += 1

        # Check if free_clusters on lvs remain unaffected

        lvs = self.c.bdev_lvol_get_lvstores()[0]

        free_clusters_resize = int(lvs['free_clusters'])

        if free_clusters_start != free_clusters_resize:

            fail_count += 1

        # Perform write operation with verification

        # to newly created free space of lvol bdev

        nbd_name = "/dev/nbd0"

        fail_count += self.c.nbd_start_disk(uuid_bdev, nbd_name)

        fail_count += self.run_fio_test(nbd_name, int(lbd_size * MEGABYTE / 2),

                                        int(lbd_size * MEGABYTE / 2), "write", "0xcc", 0)

        fail_count += self.c.nbd_stop_disk(nbd_name)

        # Check if free clusters on lvs equals to zero

        lvs = self.c.bdev_lvol_get_lvstores()[0]

        if int(lvs['free_clusters']) != 0:

            fail_count += 1

        # Resize bdev to 25% of lvs and check if it ended with success

        size = self.get_lvs_divided_size(4)

        fail_count += self.c.bdev_lvol_resize(uuid_bdev, size)

        # Check free clusters on lvs

        lvs = self.c.bdev_lvol_get_lvstores()[0]

        free_clusters_resize2 = int(lvs['free_clusters'])

        free_clusters_expected = int((full_size - size) * MEGABYTE / lvs['cluster_size'])

        if free_clusters_expected != free_clusters_resize2:

            fail_count += 1



        self.c.bdev_lvol_delete(uuid_bdev)

        self.c.bdev_lvol_delete_lvstore(uuid_store)

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

        """

test/lvol/thin_provisioning.sh

+62 −0
Original line number Diff line number Diff line
@@ -120,6 +120,67 @@ function test_thin_lvol_check_integrity() { 
	rpc_cmd bdev_malloc_delete "$malloc_name"

}



# Check thin provisioned bdev resize

function test_thin_lvol_resize() {

	malloc_name=$(rpc_cmd bdev_malloc_create $MALLOC_SIZE_MB $MALLOC_BS)

	lvs_uuid=$(rpc_cmd bdev_lvol_create_lvstore "$malloc_name" lvs_test)



	# Construct thin provisioned lvol bdevs on created lvol store

	# with size equal to 50% of lvol store

	lvol_size_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB / 2 )) )

	lvol_size=$(( lvol_size_mb * 1024 * 1024 ))

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



	# Fill all free space of lvol bdev with data

	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



	# Save number of free clusters for lvs

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")

	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"

	# Resize bdev to full size of lvs

	lvol_size_full_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB )) )

	lvol_size_full=$(( lvol_size_full_mb * 1024 * 1024 ))

	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_full_mb



	# Check if bdev size changed (total_data_clusters*cluster_size

	# equals to num_blocks*block_size)

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

	[ "$(jq -r '.[0].block_size' <<< "$lvol")" = "$MALLOC_BS" ]

	[ "$(jq -r '.[0].num_blocks' <<< "$lvol")" = $(( lvol_size_full / MALLOC_BS )) ]



	# Check if free_clusters on lvs remain unaffected

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")

	free_clusters_resize="$(jq -r '.[0].free_clusters' <<< "$lvs")"

	[ $free_clusters_start == $free_clusters_resize ]



	# Perform write operation with verification

	# to newly created free space of lvol bdev

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

	run_fio_test /dev/nbd0 0 $lvol_size_full "write" "0xcc"

	nbd_stop_disks "$DEFAULT_RPC_ADDR" /dev/nbd0



	# Check if free clusters on lvs equals to zero

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")

	free_clusters_start="$(jq -r '.[0].free_clusters' <<< "$lvs")"

	[ $free_clusters_start == 0 ]



	# Resize bdev to 25% of lvs and check if it ended with success

	lvol_size_quarter_mb=$( round_down $(( LVS_DEFAULT_CAPACITY_MB / 4 )) )

	rpc_cmd bdev_lvol_resize $lvol_uuid $lvol_size_quarter_mb



	# Check free clusters on lvs

	lvs=$(rpc_cmd bdev_lvol_get_lvstores -u "$lvs_uuid")

	free_clusters_resize_quarter="$(jq -r '.[0].free_clusters' <<< "$lvs")"

	free_clusters_expected=$(( (lvol_size_full_mb - lvol_size_quarter_mb) / LVS_DEFAULT_CLUSTER_SIZE_MB ))

	[ $free_clusters_resize_quarter == $free_clusters_expected ]



	rpc_cmd bdev_lvol_delete "$lvol_uuid"

	rpc_cmd bdev_lvol_delete_lvstore -u "$lvs_uuid"

	rpc_cmd bdev_malloc_delete "$malloc_name"

}



$rootdir/app/spdk_tgt/spdk_tgt &

spdk_pid=$!

trap 'killprocess "$spdk_pid"; exit 1' SIGINT SIGTERM EXIT
@@ -128,6 +189,7 @@ waitforlisten $spdk_pid 
run_test "test_thin_lvol_check_space" test_thin_lvol_check_space

run_test "test_thin_lvol_check_zeroes" test_thin_lvol_check_zeroes

run_test "test_thin_lvol_check_integrity" test_thin_lvol_check_integrity

run_test "test_thin_lvol_resize" test_thin_lvol_resize



trap - SIGINT SIGTERM EXIT

killprocess $spdk_pid