Commit 32c888e5 authored by Pawel Kaminski's avatar Pawel Kaminski Committed by Jim Harris
Browse files

test/lvol: Implement test case 653 



Test resize feature for thin provisioned lvol bdev.
Check if free size of lvol stores equals
to expected values.

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


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarDarek Stojaczyk <dariusz.stojaczyk@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
parent 6d24eeb2

autotest.sh

+1 −1
Original line number Diff line number Diff line
@@ -206,7 +206,7 @@ if [ $SPDK_RUN_FUNCTIONAL_TEST -eq 1 ]; then 
		timing_enter lvol

		test_cases="1,50,51,52,53,100,101,102,150,200,201,250,251,252,253,254,255,"

		test_cases+="300,301,450,451,452,500,550,551,552,553,"

		test_cases+="600,601,602,650,651,652,654,655,"

		test_cases+="600,601,602,650,651,652,653,654,655,"

		test_cases+="700,701,702,750,751,752,753,754,755,756,757,758,759,760,"

		test_cases+="800,801,802,803,804,10000"

		run_test suite ./test/lvol/lvol.sh --test-cases=$test_cases

test/lvol/test_cases.py

+59 −18
Original line number Diff line number Diff line
@@ -1650,27 +1650,68 @@ class TestCases(object): 
        """

        thin_provisioning_resize



        Check thin provisioned bdev resize. To be implemented.

        Check thin provisioned bdev resize.

        """

        # TODO

        # create malloc bdev

        # construct lvol store on malloc bdev

        # construct thin provisioned lvol bdevs on created lvol store

        # Create malloc bdev

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

                                                 self.block_size)

        # Construct lvol store on malloc bdev

        uuid_store = self.c.construct_lvol_store(base_name, self.lvs_name)

        fail_count = self.c.check_get_lvol_stores(base_name, uuid_store,

                                                  self.cluster_size)

        # Construct thin provisioned lvol bdevs on created lvol store

        # with size equal to 50% of lvol store

        # fill all free space of lvol bdev with data

        # save number of free clusters for lvs

        # resize bdev to full size of lvs

        # check if bdev size changed (total_data_clusters*cluster_size

        # equal to num_blocks*block_size)

        # check if free_clusters on lvs remain unaffected

        # perform write operation with verification

        size = self.get_lvs_divided_size(2)

        uuid_bdev = self.c.construct_lvol_bdev(uuid_store,

                                               self.lbd_name, size, thin=True)

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

        # Fill all free space of lvol bdev with data

        nbd_name = "/dev/nbd0"

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

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

        fail_count += self.c.stop_nbd_disk(nbd_name)

        # Save number of free clusters for lvs

        lvs = self.c.get_lvol_stores()[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.resize_lvol_bdev(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.get_lvol_stores()[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

        # resize bdev to 30M and check if it ended with success

        # check if free clusters on lvs equals to saved counter

        # destroy thin provisioned lvol bdev

        # destroy lvol store

        # destroy malloc bdev

        fail_count = 0

        nbd_name = "/dev/nbd0"

        fail_count += self.c.start_nbd_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.stop_nbd_disk(nbd_name)

        # Check if free clusters on lvs equals to zero

        lvs = self.c.get_lvol_stores()[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.resize_lvol_bdev(uuid_bdev, size)

        # Check free clusters on lvs

        lvs = self.c.get_lvol_stores()[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.destroy_lvol_bdev(uuid_bdev)

        self.c.destroy_lvol_store(uuid_store)

        self.c.delete_malloc_bdev(base_name)



        # Expected result:

        # - calls successful, return code = 0

        # - no other operation fails