freezer: clean up freeze_processes() failure path

freeze_processes() failure path is rather messy.  Freezing is canceled
for workqueues and tasks which aren't frozen yet but frozen tasks are
left alone and should be thawed by the caller and of course some
callers (xen and kexec) didn't do it.

This patch updates __thaw_task() to handle cancelation correctly and
makes freeze_processes() and freeze_kernel_threads() call
thaw_processes() on failure instead so that the system is fully thawed
on failure.  Unnecessary [suspend_]thaw_processes() calls are removed
from kernel/power/hibernate.c, suspend.c and user.c.

While at it, restructure error checking if clause in suspend_prepare()
to be less weird.

-v2: Srivatsa spotted missing removal of suspend_thaw_processes() in
     suspend_prepare() and error in commit message.  Updated.

Signed-off-by: Tejun Heo <tj@kernel.org>
Acked-by: Srivatsa S. Bhat <srivatsa.bhat@linux.vnet.ibm.com>

diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index 253bcfe91f687d1d3f58a2c647ce057a059f988e..e665777883244d6051414d4b16c0ef78d0bd4c30 100644 (file)
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -61,7 +61,6 @@ static inline bool try_to_freeze(void)
 }
 
 extern bool freeze_task(struct task_struct *p, bool sig_only);
-extern void cancel_freezing(struct task_struct *p);
 
 #ifdef CONFIG_CGROUP_FREEZER
 extern int cgroup_freezing_or_frozen(struct task_struct *task);

diff --git a/kernel/freezer.c b/kernel/freezer.c
index 3be1e361569c7b58bab13dd8e3b3d2a1f587cba1..7a9f706e9575f92b4ea5f815003f478f5265f7c2 100644 (file)
--- a/kernel/freezer.c
+++ b/kernel/freezer.c
@@ -129,21 +129,6 @@ out_unlock:
        return ret;
 }
 
-void cancel_freezing(struct task_struct *p)
-{
-       unsigned long flags;
-
-       spin_lock_irqsave(&freezer_lock, flags);
-       if (freezing(p)) {
-               pr_debug("  clean up: %s\n", p->comm);
-               clear_freeze_flag(p);
-               spin_lock(&p->sighand->siglock);
-               recalc_sigpending_and_wake(p);
-               spin_unlock(&p->sighand->siglock);
-       }
-       spin_unlock_irqrestore(&freezer_lock, flags);
-}
-
 void __thaw_task(struct task_struct *p)
 {
        unsigned long flags;
@@ -153,10 +138,18 @@ void __thaw_task(struct task_struct *p)
         * be visible to @p as waking up implies wmb.  Waking up inside
         * freezer_lock also prevents wakeups from leaking outside
         * refrigerator.
+        *
+        * If !FROZEN, @p hasn't reached refrigerator, recalc sigpending to
+        * avoid leaving dangling TIF_SIGPENDING behind.
         */
        spin_lock_irqsave(&freezer_lock, flags);
        clear_freeze_flag(p);
-       if (frozen(p))
+       if (frozen(p)) {
                wake_up_process(p);
+       } else {
+               spin_lock(&p->sighand->siglock);
+               recalc_sigpending_and_wake(p);
+               spin_unlock(&p->sighand->siglock);
+       }
        spin_unlock_irqrestore(&freezer_lock, flags);
 }

diff --git a/kernel/power/hibernate.c b/kernel/power/hibernate.c
index 1c53f7fad5f7ba9e4fd20cd85e5021755c71ada8..def6406b2517f598901fd8b22b903e09311830c1 100644 (file)
--- a/kernel/power/hibernate.c
+++ b/kernel/power/hibernate.c
@@ -593,17 +593,6 @@ static void power_down(void)
        while(1);
 }
 
-static int prepare_processes(void)
-{
-       int error = 0;
-
-       if (freeze_processes()) {
-               error = -EBUSY;
-               thaw_processes();
-       }
-       return error;
-}
-
 /**
  * hibernate - Carry out system hibernation, including saving the image.
  */
@@ -636,7 +625,7 @@ int hibernate(void)
        sys_sync();
        printk("done.\n");
 
-       error = prepare_processes();
+       error = freeze_processes();
        if (error)
                goto Finish;
 
@@ -799,7 +788,7 @@ static int software_resume(void)
                goto close_finish;
 
        pr_debug("PM: Preparing processes for restore.\n");
-       error = prepare_processes();
+       error = freeze_processes();
        if (error) {
                swsusp_close(FMODE_READ);
                goto Done;

diff --git a/kernel/power/process.c b/kernel/power/process.c
index e59676f5811d85f1d03a4934e36c2c56d48436c4..ce643838a00c687ec3ede41eb4ec3f6efb717fc9 100644 (file)
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -91,11 +91,6 @@ static int try_to_freeze_tasks(bool sig_only)
        elapsed_csecs = elapsed_csecs64;
 
        if (todo) {
-               /* This does not unfreeze processes that are already frozen
-                * (we have slightly ugly calling convention in that respect,
-                * and caller must call thaw_processes() if something fails),
-                * but it cleans up leftover PF_FREEZE requests.
-                */
                printk("\n");
                printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds "
                       "(%d tasks refusing to freeze, wq_busy=%d):\n",
@@ -103,14 +98,11 @@ static int try_to_freeze_tasks(bool sig_only)
                       elapsed_csecs / 100, elapsed_csecs % 100,
                       todo - wq_busy, wq_busy);
 
-               thaw_workqueues();
-
                read_lock(&tasklist_lock);
                do_each_thread(g, p) {
                        if (!wakeup && !freezer_should_skip(p) &&
                            freezing(p) && !frozen(p))
                                sched_show_task(p);
-                       cancel_freezing(p);
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);
        } else {
@@ -123,6 +115,8 @@ static int try_to_freeze_tasks(bool sig_only)
 
 /**
  * freeze_processes - Signal user space processes to enter the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
  */
 int freeze_processes(void)
 {
@@ -137,11 +131,15 @@ int freeze_processes(void)
        printk("\n");
        BUG_ON(in_atomic());
 
+       if (error)
+               thaw_processes();
        return error;
 }
 
 /**
  * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
+ *
+ * On success, returns 0.  On failure, -errno and system is fully thawed.
  */
 int freeze_kernel_threads(void)
 {
@@ -155,6 +153,8 @@ int freeze_kernel_threads(void)
        printk("\n");
        BUG_ON(in_atomic());
 
+       if (error)
+               thaw_processes();
        return error;
 }
 

diff --git a/kernel/power/suspend.c b/kernel/power/suspend.c
index fdd4263b995d4c1e15f26188b3dacf47d30dec08..633e9f9021eb5ed4183e6ea2f6c3ede1167a2949 100644 (file)
--- a/kernel/power/suspend.c
+++ b/kernel/power/suspend.c
@@ -104,13 +104,11 @@ static int suspend_prepare(void)
                goto Finish;
 
        error = suspend_freeze_processes();
-       if (error) {
-               suspend_stats.failed_freeze++;
-               dpm_save_failed_step(SUSPEND_FREEZE);
-       } else
+       if (!error)
                return 0;
 
-       suspend_thaw_processes();
+       suspend_stats.failed_freeze++;
+       dpm_save_failed_step(SUSPEND_FREEZE);
        usermodehelper_enable();
  Finish:
        pm_notifier_call_chain(PM_POST_SUSPEND);

diff --git a/kernel/power/user.c b/kernel/power/user.c
index 42ddbc6f0de6ffcf2d245dd9c8ec253c2780ffab..afe7737a0eda459891affba67dcc8ed4da908d86 100644 (file)
--- a/kernel/power/user.c
+++ b/kernel/power/user.c
@@ -256,10 +256,8 @@ static long snapshot_ioctl(struct file *filp, unsigned int cmd,
                        break;
 
                error = freeze_processes();
-               if (error) {
-                       thaw_processes();
+               if (error)
                        usermodehelper_enable();
-               }
                if (!error)
                        data->frozen = 1;
                break;