dm: add presuspend_undo hook to target_type

The DM thin-pool target now must undo the changes performed during
pool_presuspend() so introduce presuspend_undo hook in target_type.

Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Acked-by: Joe Thornber <ejt@redhat.com>

3 files changed, 38 insertions, 9 deletions

diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c
index b2bd1ebf4562..3afae9e062f8 100644
--- a/drivers/md/dm-table.c
+++ b/drivers/md/dm-table.c
@@ -1521,18 +1521,32 @@ fmode_t dm_table_get_mode(struct dm_table *t)
 }
 EXPORT_SYMBOL(dm_table_get_mode);
 
-static void suspend_targets(struct dm_table *t, unsigned postsuspend)
+enum suspend_mode {
+        PRESUSPEND,
+        PRESUSPEND_UNDO,
+        POSTSUSPEND,
+};
+
+static void suspend_targets(struct dm_table *t, enum suspend_mode mode)
 {
         int i = t->num_targets;
         struct dm_target *ti = t->targets;
 
         while (i--) {
-                if (postsuspend) {
+                switch (mode) {
+                case PRESUSPEND:
+                        if (ti->type->presuspend)
+                                ti->type->presuspend(ti);
+                        break;
+                case PRESUSPEND_UNDO:
+                        if (ti->type->presuspend_undo)
+                                ti->type->presuspend_undo(ti);
+                        break;
+                case POSTSUSPEND:
                         if (ti->type->postsuspend)
                                 ti->type->postsuspend(ti);
-                } else if (ti->type->presuspend)
-                        ti->type->presuspend(ti);
-
+                        break;
+                }
                 ti++;
         }
 }
@@ -1542,7 +1556,15 @@ void dm_table_presuspend_targets(struct dm_table *t)
         if (!t)
                 return;
 
-        suspend_targets(t, 0);
+        suspend_targets(t, PRESUSPEND);
+}
+
+void dm_table_presuspend_undo_targets(struct dm_table *t)
+{
+        if (!t)
+                return;
+
+        suspend_targets(t, PRESUSPEND_UNDO);
 }
 
 void dm_table_postsuspend_targets(struct dm_table *t)
@@ -1550,7 +1572,7 @@ void dm_table_postsuspend_targets(struct dm_table *t)
         if (!t)
                 return;
 
-        suspend_targets(t, 1);
+        suspend_targets(t, POSTSUSPEND);
 }
 
 int dm_table_resume_targets(struct dm_table *t)
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index f8cdd97c28a7..f84de3215982 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -2756,7 +2756,10 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
         if (noflush)
                 set_bit(DMF_NOFLUSH_SUSPENDING, &md->flags);
 
-        /* This does not get reverted if there's an error later. */
+        /*
+         * This gets reverted if there's an error later and the targets
+         * provide the .presuspend_undo hook.
+         */
         dm_table_presuspend_targets(map);
 
         /*
@@ -2767,8 +2770,10 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
          */
         if (!noflush && do_lockfs) {
                 r = lock_fs(md);
-                if (r)
+                if (r) {
+                        dm_table_presuspend_undo_targets(map);
                         goto out_unlock;
+                }
         }
 
         /*
@@ -2816,6 +2821,7 @@ int dm_suspend(struct mapped_device *md, unsigned suspend_flags)
                         start_queue(md->queue);
 
                 unlock_fs(md);
+                dm_table_presuspend_undo_targets(map);
                 goto out_unlock; /* pushback list is already flushed, so skip flush */
         }
 
diff --git a/drivers/md/dm.h b/drivers/md/dm.h
index 988c7fb7b145..781994093bf5 100644
--- a/drivers/md/dm.h
+++ b/drivers/md/dm.h
@@ -65,6 +65,7 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q,
                                struct queue_limits *limits);
 struct list_head *dm_table_get_devices(struct dm_table *t);
 void dm_table_presuspend_targets(struct dm_table *t);
+void dm_table_presuspend_undo_targets(struct dm_table *t);
 void dm_table_postsuspend_targets(struct dm_table *t);
 int dm_table_resume_targets(struct dm_table *t);
 int dm_table_any_congested(struct dm_table *t, int bdi_bits);