[PATCH] suspend to disk fails if gdb is suspended with a traced child
[linux-2.6] / kernel / power / process.c
1 /*
2  * drivers/power/process.c - Functions for starting/stopping processes on 
3  *                           suspend transitions.
4  *
5  * Originally from swsusp.
6  */
7
8
9 #undef DEBUG
10
11 #include <linux/smp_lock.h>
12 #include <linux/interrupt.h>
13 #include <linux/suspend.h>
14 #include <linux/module.h>
15 #include <linux/syscalls.h>
16 #include <linux/freezer.h>
17
18 /* 
19  * Timeout for stopping processes
20  */
21 #define TIMEOUT (20 * HZ)
22
23
24 static inline int freezeable(struct task_struct * p)
25 {
26         if ((p == current) || 
27             (p->flags & PF_NOFREEZE) ||
28             (p->exit_state == EXIT_ZOMBIE) ||
29             (p->exit_state == EXIT_DEAD) ||
30             (p->state == TASK_STOPPED))
31                 return 0;
32         return 1;
33 }
34
35 /* Refrigerator is place where frozen processes are stored :-). */
36 void refrigerator(void)
37 {
38         /* Hmm, should we be allowed to suspend when there are realtime
39            processes around? */
40         long save;
41         save = current->state;
42         pr_debug("%s entered refrigerator\n", current->comm);
43
44         frozen_process(current);
45         spin_lock_irq(&current->sighand->siglock);
46         recalc_sigpending(); /* We sent fake signal, clean it up */
47         spin_unlock_irq(&current->sighand->siglock);
48
49         while (frozen(current)) {
50                 current->state = TASK_UNINTERRUPTIBLE;
51                 schedule();
52         }
53         pr_debug("%s left refrigerator\n", current->comm);
54         current->state = save;
55 }
56
57 static inline void freeze_process(struct task_struct *p)
58 {
59         unsigned long flags;
60
61         if (!freezing(p)) {
62                 freeze(p);
63                 spin_lock_irqsave(&p->sighand->siglock, flags);
64                 signal_wake_up(p, 0);
65                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
66         }
67 }
68
69 static void cancel_freezing(struct task_struct *p)
70 {
71         unsigned long flags;
72
73         if (freezing(p)) {
74                 pr_debug("  clean up: %s\n", p->comm);
75                 do_not_freeze(p);
76                 spin_lock_irqsave(&p->sighand->siglock, flags);
77                 recalc_sigpending_tsk(p);
78                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
79         }
80 }
81
82 /* 0 = success, else # of processes that we failed to stop */
83 int freeze_processes(void)
84 {
85         int todo, nr_user, user_frozen;
86         unsigned long start_time;
87         struct task_struct *g, *p;
88
89         printk("Stopping tasks... ");
90         start_time = jiffies;
91         user_frozen = 0;
92         do {
93                 nr_user = todo = 0;
94                 read_lock(&tasklist_lock);
95                 do_each_thread(g, p) {
96                         if (!freezeable(p))
97                                 continue;
98                         if (frozen(p))
99                                 continue;
100                         if (p->state == TASK_TRACED &&
101                             (frozen(p->parent) ||
102                              p->parent->state == TASK_STOPPED)) {
103                                 cancel_freezing(p);
104                                 continue;
105                         }
106                         if (p->mm && !(p->flags & PF_BORROWED_MM)) {
107                                 /* The task is a user-space one.
108                                  * Freeze it unless there's a vfork completion
109                                  * pending
110                                  */
111                                 if (!p->vfork_done)
112                                         freeze_process(p);
113                                 nr_user++;
114                         } else {
115                                 /* Freeze only if the user space is frozen */
116                                 if (user_frozen)
117                                         freeze_process(p);
118                                 todo++;
119                         }
120                 } while_each_thread(g, p);
121                 read_unlock(&tasklist_lock);
122                 todo += nr_user;
123                 if (!user_frozen && !nr_user) {
124                         sys_sync();
125                         start_time = jiffies;
126                 }
127                 user_frozen = !nr_user;
128                 yield();                        /* Yield is okay here */
129                 if (todo && time_after(jiffies, start_time + TIMEOUT))
130                         break;
131         } while(todo);
132
133         /* This does not unfreeze processes that are already frozen
134          * (we have slightly ugly calling convention in that respect,
135          * and caller must call thaw_processes() if something fails),
136          * but it cleans up leftover PF_FREEZE requests.
137          */
138         if (todo) {
139                 printk("\n");
140                 printk(KERN_ERR "Stopping tasks timed out "
141                         "after %d seconds (%d tasks remaining):\n",
142                         TIMEOUT / HZ, todo);
143                 read_lock(&tasklist_lock);
144                 do_each_thread(g, p) {
145                         if (freezeable(p) && !frozen(p))
146                                 printk(KERN_ERR " %s\n", p->comm);
147                         cancel_freezing(p);
148                 } while_each_thread(g, p);
149                 read_unlock(&tasklist_lock);
150                 return todo;
151         }
152
153         printk("done.\n");
154         BUG_ON(in_atomic());
155         return 0;
156 }
157
158 void thaw_some_processes(int all)
159 {
160         struct task_struct *g, *p;
161         int pass = 0; /* Pass 0 = Kernel space, 1 = Userspace */
162
163         printk("Restarting tasks... ");
164         read_lock(&tasklist_lock);
165         do {
166                 do_each_thread(g, p) {
167                         /*
168                          * is_user = 0 if kernel thread or borrowed mm,
169                          * 1 otherwise.
170                          */
171                         int is_user = !!(p->mm && !(p->flags & PF_BORROWED_MM));
172                         if (!freezeable(p) || (is_user != pass))
173                                 continue;
174                         if (!thaw_process(p))
175                                 printk(KERN_INFO
176                                         "Strange, %s not stopped\n", p->comm);
177                 } while_each_thread(g, p);
178
179                 pass++;
180         } while (pass < 2 && all);
181
182         read_unlock(&tasklist_lock);
183         schedule();
184         printk("done.\n");
185 }
186
187 EXPORT_SYMBOL(refrigerator);