Freezer: Introduce PF_FREEZER_NOSIG

[linux-2.6-omap-h63xx.git] / kernel / power / process.c

diff --git a/kernel/power/process.c b/kernel/power/process.c
index f1d0b345c9ba86a24ac48ee29cc4cb6f800b1c94..5fb87652f2149dd3a34f94e61e9a961303611e59 100644 (file)
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -19,9 +19,6 @@
  */
 #define TIMEOUT        (20 * HZ)
 
-#define FREEZER_KERNEL_THREADS 0
-#define FREEZER_USER_SPACE 1
-
 static inline int freezeable(struct task_struct * p)
 {
        if ((p == current) ||
@@ -84,63 +81,53 @@ static void fake_signal_wake_up(struct task_struct *p)
        spin_unlock_irqrestore(&p->sighand->siglock, flags);
 }
 
-static int has_mm(struct task_struct *p)
+static inline bool should_send_signal(struct task_struct *p)
 {
-       return (p->mm && !(p->flags & PF_BORROWED_MM));
+       return !(p->flags & PF_FREEZER_NOSIG);
 }
 
 /**
  *     freeze_task - send a freeze request to given task
  *     @p: task to send the request to
- *     @with_mm_only: if set, the request will only be sent if the task has its
- *             own mm
- *     Return value: 0, if @with_mm_only is set and the task has no mm of its
- *             own or the task is frozen, 1, otherwise
+ *     @sig_only: if set, the request will only be sent if the task has the
+ *             PF_FREEZER_NOSIG flag unset
+ *     Return value: 'false', if @sig_only is set and the task has
+ *             PF_FREEZER_NOSIG set or the task is frozen, 'true', otherwise
  *
- *     The freeze request is sent by seting the tasks's TIF_FREEZE flag and
+ *     The freeze request is sent by setting the tasks's TIF_FREEZE flag and
  *     either sending a fake signal to it or waking it up, depending on whether
- *     or not it has its own mm (ie. it is a user land task).  If @with_mm_only
- *     is set and the task has no mm of its own (ie. it is a kernel thread),
- *     its TIF_FREEZE flag should not be set.
- *
- *     The task_lock() is necessary to prevent races with exit_mm() or
- *     use_mm()/unuse_mm() from occuring.
+ *     or not it has PF_FREEZER_NOSIG set.  If @sig_only is set and the task
+ *     has PF_FREEZER_NOSIG set (ie. it is a typical kernel thread), its
+ *     TIF_FREEZE flag will not be set.
  */
-static int freeze_task(struct task_struct *p, int with_mm_only)
+static bool freeze_task(struct task_struct *p, bool sig_only)
 {
-       int ret = 1;
+       /*
+        * We first check if the task is freezing and next if it has already
+        * been frozen to avoid the race with frozen_process() which first marks
+        * the task as frozen and next clears its TIF_FREEZE.
+        */
+       if (!freezing(p)) {
+               rmb();
+               if (frozen(p))
+                       return false;
 
-       task_lock(p);
-       if (freezing(p)) {
-               if (has_mm(p)) {
-                       if (!signal_pending(p))
-                               fake_signal_wake_up(p);
-               } else {
-                       if (with_mm_only)
-                               ret = 0;
-                       else
-                               wake_up_state(p, TASK_INTERRUPTIBLE);
-               }
+               if (!sig_only || should_send_signal(p))
+                       set_freeze_flag(p);
+               else
+                       return false;
+       }
+
+       if (should_send_signal(p)) {
+               if (!signal_pending(p))
+                       fake_signal_wake_up(p);
+       } else if (sig_only) {
+               return false;
        } else {
-               rmb();
-               if (frozen(p)) {
-                       ret = 0;
-               } else {
-                       if (has_mm(p)) {
-                               set_freeze_flag(p);
-                               fake_signal_wake_up(p);
-                       } else {
-                               if (with_mm_only) {
-                                       ret = 0;
-                               } else {
-                                       set_freeze_flag(p);
-                                       wake_up_state(p, TASK_INTERRUPTIBLE);
-                               }
-                       }
-               }
+               wake_up_state(p, TASK_INTERRUPTIBLE);
        }
-       task_unlock(p);
-       return ret;
+
+       return true;
 }
 
 static void cancel_freezing(struct task_struct *p)
@@ -156,7 +143,7 @@ static void cancel_freezing(struct task_struct *p)
        }
 }
 
-static int try_to_freeze_tasks(int freeze_user_space)
+static int try_to_freeze_tasks(bool sig_only)
 {
        struct task_struct *g, *p;
        unsigned long end_time;
@@ -175,7 +162,7 @@ static int try_to_freeze_tasks(int freeze_user_space)
                        if (frozen(p) || !freezeable(p))
                                continue;
 
-                       if (!freeze_task(p, freeze_user_space))
+                       if (!freeze_task(p, sig_only))
                                continue;
 
                        /*
@@ -235,13 +222,13 @@ int freeze_processes(void)
        int error;
 
        printk("Freezing user space processes ... ");
-       error = try_to_freeze_tasks(FREEZER_USER_SPACE);
+       error = try_to_freeze_tasks(true);
        if (error)
                goto Exit;
        printk("done.\n");
 
        printk("Freezing remaining freezable tasks ... ");
-       error = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
+       error = try_to_freeze_tasks(false);
        if (error)
                goto Exit;
        printk("done.");
@@ -251,7 +238,7 @@ int freeze_processes(void)
        return error;
 }
 
-static void thaw_tasks(int thaw_user_space)
+static void thaw_tasks(bool nosig_only)
 {
        struct task_struct *g, *p;
 
@@ -260,7 +247,7 @@ static void thaw_tasks(int thaw_user_space)
                if (!freezeable(p))
                        continue;
 
-               if (!p->mm == thaw_user_space)
+               if (nosig_only && should_send_signal(p))
                        continue;
 
                thaw_process(p);
@@ -271,8 +258,8 @@ static void thaw_tasks(int thaw_user_space)
 void thaw_processes(void)
 {
        printk("Restarting tasks ... ");
-       thaw_tasks(FREEZER_KERNEL_THREADS);
-       thaw_tasks(FREEZER_USER_SPACE);
+       thaw_tasks(true);
+       thaw_tasks(false);
        schedule();
        printk("done.\n");
 }