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

Change-Id: I8bebb48db9254d82597e6bdda967f99446dd951c
Signed-off-by: Pawel Kaminski <pawelx.kaminski@intel.com>
Reviewed-on: https://review.gerrithub.io/c/spdk/spdk/+/450509
Tested-by: SPDK CI Jenkins <sys_sgci@intel.com>
Reviewed-by: Ben Walker <benjamin.walker@intel.com>
Reviewed-by: Shuhei Matsumoto <shuhei.matsumoto.xt@hitachi.com>
Reviewed-by: Jim Harris <james.r.harris@intel.com>
Reviewed-by: Tomasz Zawadzki <tomasz.zawadzki@intel.com>
Reviewed-by: Maciej Szwed <maciej.szwed@intel.com>

test/lvol/lvol.sh

@@ -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

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