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

test/lvol: Add test to check 'clear_method unmap' behaviour 



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


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarPaul Luse <paul.e.luse@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Community-CI: SPDK CI Jenkins <sys_sgci@intel.com>
parent 6fc7f49c

test/lvol/lvol.sh

+1 −0
Original line number Diff line number Diff line
@@ -73,6 +73,7 @@ function usage() { 
                                    803: 'bdev_lvol_rename_nonexistent',

                                    804: 'bdev_lvol_rename_EEXIST',

                                    850: 'clear_method_none',

                                    851: 'clear_method_unmap',

                                    10000: 'SIGTERM'

                                    or

                                    all: This parameter runs all tests

test/lvol/test_cases.py

+72 −0
Original line number Diff line number Diff line
@@ -172,6 +172,7 @@ def case_message(func): 
            804: 'bdev_lvol_rename_EEXIST',

            # logical volume clear_method test

            850: 'clear_method_none',

            851: 'clear_method_unmap',

            # SIGTERM

            10000: 'SIGTERM',

        }
@@ -3127,6 +3128,77 @@ class TestCases(object): 
        # - no other operation fails

        return fail_count



    @case_message

    def test_case851(self):

        """"

        Clear_method



        Test lvol bdev with clear_method equals to unmap

        """

        # Create malloc bdev

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

                                              self.block_size)



        nbd_name = "/dev/nbd0"

        fail_count = self.c.nbd_start_disk(base_name, nbd_name)



        # Write data to malloc bdev starting from offset 0.

        fail_count += self.run_fio_test(nbd_name, 0, self.total_size * MEGABYTE,

                                        "write", "0xdd")

        fail_count += self.c.nbd_stop_disk(nbd_name)



        # Construct lvol store on created malloc bddev

        lvs_uuid = self.c.bdev_lvol_create_lvstore(base_name,

                                                   self.lvs_name,

                                                   clear_method='none')

        # Check correct uuid values in response bdev_lvol_get_lvstores command

        fail_count = self.c.check_bdev_lvol_get_lvstores(base_name, lvs_uuid,

                                                         self.cluster_size)

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



        # Construct lvol bdev on lvol store

        lbd_size = int(lvs['cluster_size'] / MEGABYTE)

        bdev_uuid = self.c.bdev_lvol_create(lvs_uuid,

                                            self.lbd_name,

                                            lbd_size,

                                            clear_method='unmap')

        # Check that data on lvol bdev remains unchanged

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

        fail_count += self.run_fio_test(nbd_name, 0, lvs['cluster_size'],

                                        "read", "0xdd")

        fail_count += self.c.nbd_stop_disk(nbd_name)



        # Delete lvol bdev

        fail_count += self.c.bdev_lvol_delete(bdev_uuid)



        # Delete lvol store

        fail_count += self.c.bdev_lvol_delete_lvstore(lvs_uuid)



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

        metadata_pages = 1 + lvs['total_data_clusters'] + \

            (math.ceil(5 + math.ceil(lvs['total_data_clusters'] / 8) / 4096)) * 3

        last_metadata_lba = int(metadata_pages * 4096 / self.block_size)

        offset_metadata_end = int(last_metadata_lba * self.block_size)

        last_cluster_of_metadata = math.ceil(metadata_pages / lvs['cluster_size'] / 4096)

        offset = last_cluster_of_metadata * lvs['cluster_size']

        size_metadata_end = offset - offset_metadata_end



        # Check if data on area between end of metadata

        # and first cluster of lvol bdev remained unchaged

        fail_count += self.run_fio_test("/dev/nbd0", offset_metadata_end,

                                        size_metadata_end, "read", "0xdd")

        # Check if data on lvol bdev was zeroed.

        # Malloc bdev should zero any data that is unmapped.

        fail_count += self.run_fio_test("/dev/nbd0", offset, lvs['cluster_size'], "read", "0x00")



        self.c.bdev_malloc_delete(base_name)



        # Expected result:

        # - calls successful, return code = 0

        # - get_bdevs: no change

        # - no other operation fails

        return fail_count



    @case_message

    def test_case10000(self):

        """