module: neaten __find_symbol, rename to find_symbol

[linux-2.6] / kernel / power / process.c

diff --git a/kernel/power/process.c b/kernel/power/process.c
index 4da125ee533de0fecd5652b6518b2b8730d7dbf9..f1d0b345c9ba86a24ac48ee29cc4cb6f800b1c94 100644 (file)
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -75,22 +75,15 @@ void refrigerator(void)
        __set_current_state(save);
 }
 
-static void fake_signal_wake_up(struct task_struct *p, int resume)
+static void fake_signal_wake_up(struct task_struct *p)
 {
        unsigned long flags;
 
        spin_lock_irqsave(&p->sighand->siglock, flags);
-       signal_wake_up(p, resume);
+       signal_wake_up(p, 0);
        spin_unlock_irqrestore(&p->sighand->siglock, flags);
 }
 
-static void send_fake_signal(struct task_struct *p)
-{
-       if (p->state == TASK_STOPPED)
-               force_sig_specific(SIGSTOP, p);
-       fake_signal_wake_up(p, p->state == TASK_STOPPED);
-}
-
 static int has_mm(struct task_struct *p)
 {
        return (p->mm && !(p->flags & PF_BORROWED_MM));
@@ -121,7 +114,7 @@ static int freeze_task(struct task_struct *p, int with_mm_only)
        if (freezing(p)) {
                if (has_mm(p)) {
                        if (!signal_pending(p))
-                               fake_signal_wake_up(p, 0);
+                               fake_signal_wake_up(p);
                } else {
                        if (with_mm_only)
                                ret = 0;
@@ -135,7 +128,7 @@ static int freeze_task(struct task_struct *p, int with_mm_only)
                } else {
                        if (has_mm(p)) {
                                set_freeze_flag(p);
-                               send_fake_signal(p);
+                               fake_signal_wake_up(p);
                        } else {
                                if (with_mm_only) {
                                        ret = 0;
@@ -168,6 +161,11 @@ static int try_to_freeze_tasks(int freeze_user_space)
        struct task_struct *g, *p;
        unsigned long end_time;
        unsigned int todo;
+       struct timeval start, end;
+       s64 elapsed_csecs64;
+       unsigned int elapsed_csecs;
+
+       do_gettimeofday(&start);
 
        end_time = jiffies + TIMEOUT;
        do {
@@ -177,15 +175,17 @@ static int try_to_freeze_tasks(int freeze_user_space)
                        if (frozen(p) || !freezeable(p))
                                continue;
 
-                       if (p->state == TASK_TRACED && frozen(p->parent)) {
-                               cancel_freezing(p);
-                               continue;
-                       }
-
                        if (!freeze_task(p, freeze_user_space))
                                continue;
 
-                       if (!freezer_should_skip(p))
+                       /*
+                        * Now that we've done set_freeze_flag, don't
+                        * perturb a task in TASK_STOPPED or TASK_TRACED.
+                        * It is "frozen enough".  If the task does wake
+                        * up, it will immediately call try_to_freeze.
+                        */
+                       if (!task_is_stopped_or_traced(p) &&
+                           !freezer_should_skip(p))
                                todo++;
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);
@@ -194,6 +194,11 @@ static int try_to_freeze_tasks(int freeze_user_space)
                        break;
        } while (todo);
 
+       do_gettimeofday(&end);
+       elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
+       do_div(elapsed_csecs64, NSEC_PER_SEC / 100);
+       elapsed_csecs = elapsed_csecs64;
+
        if (todo) {
                /* This does not unfreeze processes that are already frozen
                 * (we have slightly ugly calling convention in that respect,
@@ -201,10 +206,9 @@ static int try_to_freeze_tasks(int freeze_user_space)
                 * but it cleans up leftover PF_FREEZE requests.
                 */
                printk("\n");
-               printk(KERN_ERR "Freezing of %s timed out after %d seconds "
+               printk(KERN_ERR "Freezing of tasks failed after %d.%02d seconds "
                                "(%d tasks refusing to freeze):\n",
-                               freeze_user_space ? "user space " : "tasks ",
-                               TIMEOUT / HZ, todo);
+                               elapsed_csecs / 100, elapsed_csecs % 100, todo);
                show_state();
                read_lock(&tasklist_lock);
                do_each_thread(g, p) {
@@ -215,6 +219,9 @@ static int try_to_freeze_tasks(int freeze_user_space)
                        task_unlock(p);
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);
+       } else {
+               printk("(elapsed %d.%02d seconds) ", elapsed_csecs / 100,
+                       elapsed_csecs % 100);
        }
 
        return todo ? -EBUSY : 0;
@@ -227,18 +234,21 @@ int freeze_processes(void)
 {
        int error;
 
-       printk("Stopping tasks ... ");
+       printk("Freezing user space processes ... ");
        error = try_to_freeze_tasks(FREEZER_USER_SPACE);
        if (error)
-               return error;
+               goto Exit;
+       printk("done.\n");
 
+       printk("Freezing remaining freezable tasks ... ");
        error = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
        if (error)
-               return error;
-
-       printk("done.\n");
+               goto Exit;
+       printk("done.");
+ Exit:
        BUG_ON(in_atomic());
-       return 0;
+       printk("\n");
+       return error;
 }
 
 static void thaw_tasks(int thaw_user_space)