Commit 60b36002 authored by Pawel Kaminski's avatar Pawel Kaminski Committed by Ben Walker
Browse files

test/lvol: Check if snapshot with one clone/lvol can be deleted 



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


Tested-by: default avatarSPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: default avatarBen Walker <benjamin.walker@intel.com>
Reviewed-by: default avatarShuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: default avatarJim Harris <james.r.harris@intel.com>
Reviewed-by: default avatarTomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: default avatarMaciej Szwed <maciej.szwed@intel.com>
parent 3c006fe1

test/lvol/lvol.sh

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

                                    759: 'clone_decouple_parent_rw',

                                    760: 'set_read_only',

                                    761: 'delete_snapshot',

                                    800: 'rename_positive',

                                    801: 'rename_lvs_nonexistent',

                                    802: 'rename_lvs_EEXIST',

test/lvol/test_cases.py

+79 −0
Original line number Diff line number Diff line
@@ -172,6 +172,7 @@ def case_message(func): 
            758: 'decouple_parent',

            759: 'decouple_parent_rw',

            760: 'set_read_only',

            761: 'delete_snapshot',

            # logical volume rename tests

            800: 'rename_positive',

            801: 'rename_lvs_nonexistent',
@@ -2900,6 +2901,84 @@ class TestCases(object): 
        # - no other operation fails

        return fail_count



    @case_message

    def test_case761(self):

        """

        delete_snapshot



        Check if it is possible to delete snapshot with clone

        """

        fail_count = 0

        nbd_name0 = "/dev/nbd0"

        nbd_name1 = "/dev/nbd1"

        snapshot_name = "snapshot"

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



        # Create lvol bdev with 50% of lvol store space

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

        bdev_size = self.get_lvs_divided_size(2)

        bdev_name = self.c.construct_lvol_bdev(uuid_store, self.lbd_name,

                                               bdev_size)

        lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)



        # Perform write operation on lvol

        fail_count += self.c.start_nbd_disk(lvol_bdev['name'], nbd_name0)

        size = bdev_size * MEGABYTE

        fail_count += self.run_fio_test(nbd_name0, 0, size, "write", "0xcc")



        # Create snapshot of lvol bdev

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

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

        if snapshot_bdev['driver_specific']['lvol']['clone'] is not False\

                or snapshot_bdev['driver_specific']['lvol']['snapshot'] is not True:

            fail_count += 1



        # Fill first half of lvol bdev

        half_size = bdev_size * MEGABYTE / 2

        lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)

        fail_count += self.run_fio_test(nbd_name0, 0, half_size-1, "write", "0xee")



        # Check if snapshot was unchanged

        fail_count += self.c.start_nbd_disk(snapshot_bdev['name'], nbd_name1)

        fail_count += self.run_fio_test(nbd_name1, 0, half_size-1, "read", "0xcc")



        # Verify lvol bdev

        fail_count += self.run_fio_test(nbd_name0, 0, half_size-1, "read", "0xee")

        if lvol_bdev['driver_specific']['lvol']['clone'] is not True:

            fail_count += 1



        # Delete snapshot - should succeed

        fail_count += self.c.stop_nbd_disk(nbd_name1)

        fail_count += self.c.destroy_lvol_bdev(snapshot_bdev['name'])



        # Check data consistency

        lvol_bdev = self.c.get_lvol_bdev_with_name(bdev_name)

        if lvol_bdev['driver_specific']['lvol']['clone'] is not False:

            fail_count += 1

        fail_count += self.run_fio_test(nbd_name0, 0, half_size-1, "read", "0xee")

        fail_count += self.run_fio_test(nbd_name0, half_size, size-1, "read", "0xcc")



        # Destroy lvol bdev

        fail_count += self.c.stop_nbd_disk(nbd_name0)

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



        # Destroy lvol store

        fail_count += self.c.destroy_lvol_store(uuid_store)

        # Delete malloc bdev

        fail_count += self.c.delete_malloc_bdev(base_name)



        # Expected result:

        # - calls successful, return code = 0

        # - no other operation fails

        return fail_count



    @case_message

    def test_case800(self):

        """