Hibernation: Add PM_RESTORE_PREPARE and PM_POST_RESTORE notifiers (rev. 2)

Add PM_RESTORE_PREPARE and PM_POST_RESTORE notifiers to the PM core, to be used
in analogy with the existing PM_HIBERNATION_PREPARE and PM_POST_HIBERNATION
notifiers.

Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: "Rafael J. Wysocki" <rjw@sisk.pl>
Signed-off-by: Len Brown <len.brown@intel.com>

2 files changed, 24 insertions, 12 deletions

diff --git a/kernel/power/disk.c b/kernel/power/disk.c
index b138b431e271..659736508239 100644
--- a/kernel/power/disk.c
+++ b/kernel/power/disk.c
@@ -499,6 +499,10 @@ static int software_resume(void)
                 goto Unlock;
         }
 
+        error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
+        if (error)
+                goto Finish;
+
         error = create_basic_memory_bitmaps();
         if (error)
                 goto Finish;
@@ -522,6 +526,7 @@ static int software_resume(void)
  Done:
         free_basic_memory_bitmaps();
  Finish:
+        pm_notifier_call_chain(PM_POST_RESTORE);
         atomic_inc(&snapshot_device_available);
         /* For success case, the suspend path will release the lock */
  Unlock:
diff --git a/kernel/power/user.c b/kernel/power/user.c
index b902a7e3bd12..f5512cb3aa86 100644
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -67,6 +67,7 @@ atomic_t snapshot_device_available = ATOMIC_INIT(1);
 static int snapshot_open(struct inode *inode, struct file *filp)
 {
         struct snapshot_data *data;
+        int error;
 
         if (!atomic_add_unless(&snapshot_device_available, -1, 0))
                 return -EBUSY;
@@ -87,9 +88,19 @@ static int snapshot_open(struct inode *inode, struct file *filp)
                 data->swap = swsusp_resume_device ?
                         swap_type_of(swsusp_resume_device, 0, NULL) : -1;
                 data->mode = O_RDONLY;
+                error = pm_notifier_call_chain(PM_RESTORE_PREPARE);
+                if (error)
+                        pm_notifier_call_chain(PM_POST_RESTORE);
         } else {
                 data->swap = -1;
                 data->mode = O_WRONLY;
+                error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
+                if (error)
+                        pm_notifier_call_chain(PM_POST_HIBERNATION);
+        }
+        if (error) {
+                atomic_inc(&snapshot_device_available);
+                return error;
         }
         data->frozen = 0;
         data->ready = 0;
@@ -111,6 +122,8 @@ static int snapshot_release(struct inode *inode, struct file *filp)
                 thaw_processes();
                 mutex_unlock(&pm_mutex);
         }
+        pm_notifier_call_chain(data->mode == O_WRONLY ?
+                        PM_POST_HIBERNATION : PM_POST_RESTORE);
         atomic_inc(&snapshot_device_available);
         return 0;
 }
@@ -174,18 +187,13 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                 if (data->frozen)
                         break;
                 mutex_lock(&pm_mutex);
-                error = pm_notifier_call_chain(PM_HIBERNATION_PREPARE);
-                if (!error) {
-                        printk("Syncing filesystems ... ");
-                        sys_sync();
-                        printk("done.\n");
-
-                        error = freeze_processes();
-                        if (error)
-                                thaw_processes();
-                }
+                printk("Syncing filesystems ... ");
+                sys_sync();
+                printk("done.\n");
+
+                error = freeze_processes();
                 if (error)
-                        pm_notifier_call_chain(PM_POST_HIBERNATION);
+                        thaw_processes();
                 mutex_unlock(&pm_mutex);
                 if (!error)
                         data->frozen = 1;
@@ -196,7 +204,6 @@ static int snapshot_ioctl(struct inode *inode, struct file *filp,
                         break;
                 mutex_lock(&pm_mutex);
                 thaw_processes();
-                pm_notifier_call_chain(PM_POST_HIBERNATION);
                 mutex_unlock(&pm_mutex);
                 data->frozen = 0;
                 break;