recalc_sigpending_tsk fixes
[sfrench/cifs-2.6.git] / 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/interrupt.h>
12 #include <linux/suspend.h>
13 #include <linux/module.h>
14 #include <linux/syscalls.h>
15 #include <linux/freezer.h>
16
17 /* 
18  * Timeout for stopping processes
19  */
20 #define TIMEOUT (20 * HZ)
21
22 #define FREEZER_KERNEL_THREADS 0
23 #define FREEZER_USER_SPACE 1
24
25 static inline int freezeable(struct task_struct * p)
26 {
27         if ((p == current) ||
28             (p->flags & PF_NOFREEZE) ||
29             (p->exit_state != 0))
30                 return 0;
31         return 1;
32 }
33
34 /*
35  * freezing is complete, mark current process as frozen
36  */
37 static inline void frozen_process(void)
38 {
39         if (!unlikely(current->flags & PF_NOFREEZE)) {
40                 current->flags |= PF_FROZEN;
41                 wmb();
42         }
43         clear_tsk_thread_flag(current, TIF_FREEZE);
44 }
45
46 /* Refrigerator is place where frozen processes are stored :-). */
47 void refrigerator(void)
48 {
49         /* Hmm, should we be allowed to suspend when there are realtime
50            processes around? */
51         long save;
52
53         task_lock(current);
54         if (freezing(current)) {
55                 frozen_process();
56                 task_unlock(current);
57         } else {
58                 task_unlock(current);
59                 return;
60         }
61         save = current->state;
62         pr_debug("%s entered refrigerator\n", current->comm);
63
64         spin_lock_irq(&current->sighand->siglock);
65         recalc_sigpending(); /* We sent fake signal, clean it up */
66         spin_unlock_irq(&current->sighand->siglock);
67
68         for (;;) {
69                 set_current_state(TASK_UNINTERRUPTIBLE);
70                 if (!frozen(current))
71                         break;
72                 schedule();
73         }
74         pr_debug("%s left refrigerator\n", current->comm);
75         current->state = save;
76 }
77
78 static inline void freeze_process(struct task_struct *p)
79 {
80         unsigned long flags;
81
82         if (!freezing(p)) {
83                 rmb();
84                 if (!frozen(p)) {
85                         if (p->state == TASK_STOPPED)
86                                 force_sig_specific(SIGSTOP, p);
87
88                         freeze(p);
89                         spin_lock_irqsave(&p->sighand->siglock, flags);
90                         signal_wake_up(p, p->state == TASK_STOPPED);
91                         spin_unlock_irqrestore(&p->sighand->siglock, flags);
92                 }
93         }
94 }
95
96 static void cancel_freezing(struct task_struct *p)
97 {
98         unsigned long flags;
99
100         if (freezing(p)) {
101                 pr_debug("  clean up: %s\n", p->comm);
102                 do_not_freeze(p);
103                 spin_lock_irqsave(&p->sighand->siglock, flags);
104                 recalc_sigpending_and_wake(p);
105                 spin_unlock_irqrestore(&p->sighand->siglock, flags);
106         }
107 }
108
109 static inline int is_user_space(struct task_struct *p)
110 {
111         return p->mm && !(p->flags & PF_BORROWED_MM);
112 }
113
114 static unsigned int try_to_freeze_tasks(int freeze_user_space)
115 {
116         struct task_struct *g, *p;
117         unsigned long end_time;
118         unsigned int todo;
119
120         end_time = jiffies + TIMEOUT;
121         do {
122                 todo = 0;
123                 read_lock(&tasklist_lock);
124                 do_each_thread(g, p) {
125                         if (!freezeable(p))
126                                 continue;
127
128                         if (frozen(p))
129                                 continue;
130
131                         if (p->state == TASK_TRACED && frozen(p->parent)) {
132                                 cancel_freezing(p);
133                                 continue;
134                         }
135                         if (freeze_user_space && !is_user_space(p))
136                                 continue;
137
138                         freeze_process(p);
139                         if (!freezer_should_skip(p))
140                                 todo++;
141                 } while_each_thread(g, p);
142                 read_unlock(&tasklist_lock);
143                 yield();                        /* Yield is okay here */
144                 if (todo && time_after(jiffies, end_time))
145                         break;
146         } while (todo);
147
148         if (todo) {
149                 /* This does not unfreeze processes that are already frozen
150                  * (we have slightly ugly calling convention in that respect,
151                  * and caller must call thaw_processes() if something fails),
152                  * but it cleans up leftover PF_FREEZE requests.
153                  */
154                 printk("\n");
155                 printk(KERN_ERR "Stopping %s timed out after %d seconds "
156                                 "(%d tasks refusing to freeze):\n",
157                                 freeze_user_space ? "user space processes" :
158                                         "kernel threads",
159                                 TIMEOUT / HZ, todo);
160                 read_lock(&tasklist_lock);
161                 do_each_thread(g, p) {
162                         if (freeze_user_space && !is_user_space(p))
163                                 continue;
164
165                         task_lock(p);
166                         if (freezeable(p) && !frozen(p) &&
167                             !freezer_should_skip(p))
168                                 printk(KERN_ERR " %s\n", p->comm);
169
170                         cancel_freezing(p);
171                         task_unlock(p);
172                 } while_each_thread(g, p);
173                 read_unlock(&tasklist_lock);
174         }
175
176         return todo;
177 }
178
179 /**
180  *      freeze_processes - tell processes to enter the refrigerator
181  *
182  *      Returns 0 on success, or the number of processes that didn't freeze,
183  *      although they were told to.
184  */
185 int freeze_processes(void)
186 {
187         unsigned int nr_unfrozen;
188
189         printk("Stopping tasks ... ");
190         nr_unfrozen = try_to_freeze_tasks(FREEZER_USER_SPACE);
191         if (nr_unfrozen)
192                 return nr_unfrozen;
193
194         sys_sync();
195         nr_unfrozen = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
196         if (nr_unfrozen)
197                 return nr_unfrozen;
198
199         printk("done.\n");
200         BUG_ON(in_atomic());
201         return 0;
202 }
203
204 static void thaw_tasks(int thaw_user_space)
205 {
206         struct task_struct *g, *p;
207
208         read_lock(&tasklist_lock);
209         do_each_thread(g, p) {
210                 if (!freezeable(p))
211                         continue;
212
213                 if (is_user_space(p) == !thaw_user_space)
214                         continue;
215
216                 thaw_process(p);
217         } while_each_thread(g, p);
218         read_unlock(&tasklist_lock);
219 }
220
221 void thaw_processes(void)
222 {
223         printk("Restarting tasks ... ");
224         thaw_tasks(FREEZER_KERNEL_THREADS);
225         thaw_tasks(FREEZER_USER_SPACE);
226         schedule();
227         printk("done.\n");
228 }
229
230 EXPORT_SYMBOL(refrigerator);