[PATCH] Make suspend possible with a traced process at a breakpoint

It should be possible to suspend, either to RAM or to disk, if there's a
traced process that has just reached a breakpoint.  However, this is a
special case, because its parent process might have been frozen already and
then we are unable to deliver the "freeze" signal to the traced process.
If this happens, it's better to cancel the freezing of the traced process.

Ref. http://bugzilla.kernel.org/show_bug.cgi?id=6787

Signed-off-by: Rafael J. Wysocki <rjw@sisk.pl>
Acked-by: Pavel Machek <pavel@ucw.cz>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6afa72e080cb7665bc4be600db1b4fe382460ccd..6674fc1e51bf3dfe0677633e489231a91c271dac 100644 (file)
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1557,6 +1557,14 @@ static inline void freeze(struct task_struct *p)
        p->flags |= PF_FREEZE;
 }
 
+/*
+ * Sometimes we may need to cancel the previous 'freeze' request
+ */
+static inline void do_not_freeze(struct task_struct *p)
+{
+       p->flags &= ~PF_FREEZE;
+}
+
 /*
  * Wake up a frozen process
  */

diff --git a/kernel/power/process.c b/kernel/power/process.c
index b2a5f671d6cd3f2d164e44ad20ad7780a7e00377..72e72d2c61e6e412106c2e58733087b9ba16ac81 100644 (file)
--- a/kernel/power/process.c
+++ b/kernel/power/process.c
@@ -66,13 +66,25 @@ static inline void freeze_process(struct task_struct *p)
        }
 }
 
+static void cancel_freezing(struct task_struct *p)
+{
+       unsigned long flags;
+
+       if (freezing(p)) {
+               pr_debug("  clean up: %s\n", p->comm);
+               do_not_freeze(p);
+               spin_lock_irqsave(&p->sighand->siglock, flags);
+               recalc_sigpending_tsk(p);
+               spin_unlock_irqrestore(&p->sighand->siglock, flags);
+       }
+}
+
 /* 0 = success, else # of processes that we failed to stop */
 int freeze_processes(void)
 {
        int todo, nr_user, user_frozen;
        unsigned long start_time;
        struct task_struct *g, *p;
-       unsigned long flags;
 
        printk( "Stopping tasks: " );
        start_time = jiffies;
@@ -85,6 +97,10 @@ int freeze_processes(void)
                                continue;
                        if (frozen(p))
                                continue;
+                       if (p->state == TASK_TRACED && frozen(p->parent)) {
+                               cancel_freezing(p);
+                               continue;
+                       }
                        if (p->mm && !(p->flags & PF_BORROWED_MM)) {
                                /* The task is a user-space one.
                                 * Freeze it unless there's a vfork completion
@@ -126,13 +142,7 @@ int freeze_processes(void)
                do_each_thread(g, p) {
                        if (freezeable(p) && !frozen(p))
                                printk(KERN_ERR "  %s\n", p->comm);
-                       if (freezing(p)) {
-                               pr_debug("  clean up: %s\n", p->comm);
-                               p->flags &= ~PF_FREEZE;
-                               spin_lock_irqsave(&p->sighand->siglock, flags);
-                               recalc_sigpending_tsk(p);
-                               spin_unlock_irqrestore(&p->sighand->siglock, flags);
-                       }
+                       cancel_freezing(p);
                } while_each_thread(g, p);
                read_unlock(&tasklist_lock);
                return todo;