blob: 3d98d7f99b1419ee8b939dcbe26346cb7a89799d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/interrupt.h>
12#include <linux/suspend.h>
13#include <linux/module.h>
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -080014#include <linux/syscalls.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080015#include <linux/freezer.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016
17/*
18 * Timeout for stopping processes
19 */
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -080020#define TIMEOUT (20 * HZ)
Linus Torvalds1da177e2005-04-16 15:20:36 -070021
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -080022#define FREEZER_KERNEL_THREADS 0
23#define FREEZER_USER_SPACE 1
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
25static inline int freezeable(struct task_struct * p)
26{
Oleg Nesterov1065d132007-05-08 00:24:01 -070027 if ((p == current) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -070028 (p->flags & PF_NOFREEZE) ||
Oleg Nesterov1065d132007-05-08 00:24:01 -070029 (p->exit_state != 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 return 0;
31 return 1;
32}
33
Gautham R Shenoy88f18ba2007-05-23 13:57:29 -070034/*
35 * freezing is complete, mark current process as frozen
36 */
37static inline void frozen_process(void)
38{
39 if (!unlikely(current->flags & PF_NOFREEZE)) {
40 current->flags |= PF_FROZEN;
41 wmb();
42 }
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -070043 clear_freeze_flag(current);
Gautham R Shenoy88f18ba2007-05-23 13:57:29 -070044}
45
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* Refrigerator is place where frozen processes are stored :-). */
Christoph Lameter3e1d1d22005-06-24 23:13:50 -070047void refrigerator(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070048{
49 /* Hmm, should we be allowed to suspend when there are realtime
50 processes around? */
51 long save;
Rafael J. Wysocki33e1c282007-05-23 13:57:24 -070052
53 task_lock(current);
54 if (freezing(current)) {
Gautham R Shenoy88f18ba2007-05-23 13:57:29 -070055 frozen_process();
Rafael J. Wysocki33e1c282007-05-23 13:57:24 -070056 task_unlock(current);
57 } else {
58 task_unlock(current);
59 return;
60 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070061 save = current->state;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 pr_debug("%s entered refrigerator\n", current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -070063
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
Oleg Nesterov433ecb42007-05-06 14:50:40 -070068 for (;;) {
69 set_current_state(TASK_UNINTERRUPTIBLE);
70 if (!frozen(current))
71 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 schedule();
Pavel Machek2a23b5d2005-09-03 15:56:53 -070073 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 pr_debug("%s left refrigerator\n", current->comm);
Rafael J. Wysockif4a3a7d2007-07-19 01:47:33 -070075 __set_current_state(save);
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -070078static void fake_signal_wake_up(struct task_struct *p, int resume)
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -080079{
80 unsigned long flags;
81
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -070082 spin_lock_irqsave(&p->sighand->siglock, flags);
83 signal_wake_up(p, resume);
84 spin_unlock_irqrestore(&p->sighand->siglock, flags);
85}
86
87static void send_fake_signal(struct task_struct *p)
88{
89 if (p->state == TASK_STOPPED)
90 force_sig_specific(SIGSTOP, p);
91 fake_signal_wake_up(p, p->state == TASK_STOPPED);
92}
93
94static int has_mm(struct task_struct *p)
95{
96 return (p->mm && !(p->flags & PF_BORROWED_MM));
97}
98
99/**
100 * freeze_task - send a freeze request to given task
101 * @p: task to send the request to
102 * @with_mm_only: if set, the request will only be sent if the task has its
103 * own mm
104 * Return value: 0, if @with_mm_only is set and the task has no mm of its
105 * own or the task is frozen, 1, otherwise
106 *
107 * The freeze request is sent by seting the tasks's TIF_FREEZE flag and
108 * either sending a fake signal to it or waking it up, depending on whether
109 * or not it has its own mm (ie. it is a user land task). If @with_mm_only
110 * is set and the task has no mm of its own (ie. it is a kernel thread),
111 * its TIF_FREEZE flag should not be set.
112 *
113 * The task_lock() is necessary to prevent races with exit_mm() or
114 * use_mm()/unuse_mm() from occuring.
115 */
116static int freeze_task(struct task_struct *p, int with_mm_only)
117{
118 int ret = 1;
119
120 task_lock(p);
121 if (freezing(p)) {
122 if (has_mm(p)) {
123 if (!signal_pending(p))
124 fake_signal_wake_up(p, 0);
125 } else {
126 if (with_mm_only)
127 ret = 0;
128 else
129 wake_up_state(p, TASK_INTERRUPTIBLE);
130 }
131 } else {
Rafael J. Wysocki8a102ee2006-12-13 00:34:30 -0800132 rmb();
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -0700133 if (frozen(p)) {
134 ret = 0;
135 } else {
136 if (has_mm(p)) {
137 set_freeze_flag(p);
138 send_fake_signal(p);
139 } else {
140 if (with_mm_only) {
141 ret = 0;
142 } else {
143 set_freeze_flag(p);
144 wake_up_state(p, TASK_INTERRUPTIBLE);
145 }
146 }
Rafael J. Wysocki8a102ee2006-12-13 00:34:30 -0800147 }
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800148 }
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -0700149 task_unlock(p);
150 return ret;
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800151}
152
Rafael J. Wysockia7ef7872006-08-05 12:13:42 -0700153static void cancel_freezing(struct task_struct *p)
154{
155 unsigned long flags;
156
157 if (freezing(p)) {
158 pr_debug(" clean up: %s\n", p->comm);
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700159 clear_freeze_flag(p);
Rafael J. Wysockia7ef7872006-08-05 12:13:42 -0700160 spin_lock_irqsave(&p->sighand->siglock, flags);
Roland McGrath7bb44ad2007-05-23 13:57:44 -0700161 recalc_sigpending_and_wake(p);
Rafael J. Wysockia7ef7872006-08-05 12:13:42 -0700162 spin_unlock_irqrestore(&p->sighand->siglock, flags);
163 }
164}
165
Rafael J. Wysockie7cd8a72007-07-19 01:47:34 -0700166static int try_to_freeze_tasks(int freeze_user_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 struct task_struct *g, *p;
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800169 unsigned long end_time;
170 unsigned int todo;
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700171
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800172 end_time = jiffies + TIMEOUT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 do {
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800174 todo = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 read_lock(&tasklist_lock);
176 do_each_thread(g, p) {
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700177 if (frozen(p) || !freezeable(p))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 continue;
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800179
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -0700180 if (p->state == TASK_TRACED && frozen(p->parent)) {
181 cancel_freezing(p);
182 continue;
Rafael J. Wysockia7ef7872006-08-05 12:13:42 -0700183 }
Rafael J. Wysockid5d8c592007-10-18 03:04:46 -0700184
185 if (!freeze_task(p, freeze_user_space))
186 continue;
187
Rafael J. Wysockiba96a0c2007-05-23 13:57:25 -0700188 if (!freezer_should_skip(p))
189 todo++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 } while_each_thread(g, p);
191 read_unlock(&tasklist_lock);
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800192 yield(); /* Yield is okay here */
Rafael J. Wysockic2cf7d82007-07-19 01:47:35 -0700193 if (time_after(jiffies, end_time))
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800194 break;
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800195 } while (todo);
Christoph Lameter3e1d1d22005-06-24 23:13:50 -0700196
Pavel Machek6161b2c2005-09-03 15:57:05 -0700197 if (todo) {
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800198 /* This does not unfreeze processes that are already frozen
199 * (we have slightly ugly calling convention in that respect,
200 * and caller must call thaw_processes() if something fails),
201 * but it cleans up leftover PF_FREEZE requests.
202 */
Nigel Cunningham14b5b7c2006-12-06 20:34:26 -0800203 printk("\n");
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700204 printk(KERN_ERR "Freezing of %s timed out after %d seconds "
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800205 "(%d tasks refusing to freeze):\n",
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700206 freeze_user_space ? "user space " : "tasks ",
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800207 TIMEOUT / HZ, todo);
Andrew Morton328616e2007-07-19 01:47:26 -0700208 show_state();
Pavel Machek6161b2c2005-09-03 15:57:05 -0700209 read_lock(&tasklist_lock);
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800210 do_each_thread(g, p) {
Rafael J. Wysocki33e1c282007-05-23 13:57:24 -0700211 task_lock(p);
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700212 if (freezing(p) && !freezer_should_skip(p))
Nigel Cunningham14b5b7c2006-12-06 20:34:26 -0800213 printk(KERN_ERR " %s\n", p->comm);
Rafael J. Wysockia7ef7872006-08-05 12:13:42 -0700214 cancel_freezing(p);
Rafael J. Wysocki33e1c282007-05-23 13:57:24 -0700215 task_unlock(p);
Rafael J. Wysocki02aaeb92006-03-23 03:00:04 -0800216 } while_each_thread(g, p);
Pavel Machek6161b2c2005-09-03 15:57:05 -0700217 read_unlock(&tasklist_lock);
Pavel Machek6161b2c2005-09-03 15:57:05 -0700218 }
219
Rafael J. Wysockie7cd8a72007-07-19 01:47:34 -0700220 return todo ? -EBUSY : 0;
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800221}
222
223/**
224 * freeze_processes - tell processes to enter the refrigerator
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800225 */
226int freeze_processes(void)
227{
Rafael J. Wysockie7cd8a72007-07-19 01:47:34 -0700228 int error;
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800229
Rafael J. Wysockib842ee52007-10-18 03:04:48 -0700230 printk("Freezing user space processes ... ");
Rafael J. Wysockie7cd8a72007-07-19 01:47:34 -0700231 error = try_to_freeze_tasks(FREEZER_USER_SPACE);
232 if (error)
Rafael J. Wysockib842ee52007-10-18 03:04:48 -0700233 goto Exit;
234 printk("done.\n");
Rafael J. Wysocki11b2ce22006-12-06 20:34:40 -0800235
Rafael J. Wysockib842ee52007-10-18 03:04:48 -0700236 printk("Freezing remaining freezable tasks ... ");
Rafael J. Wysockie7cd8a72007-07-19 01:47:34 -0700237 error = try_to_freeze_tasks(FREEZER_KERNEL_THREADS);
238 if (error)
Rafael J. Wysockib842ee52007-10-18 03:04:48 -0700239 goto Exit;
240 printk("done.");
241 Exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 BUG_ON(in_atomic());
Rafael J. Wysockib842ee52007-10-18 03:04:48 -0700243 printk("\n");
244 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245}
246
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -0800247static void thaw_tasks(int thaw_user_space)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248{
249 struct task_struct *g, *p;
250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 read_lock(&tasklist_lock);
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -0800252 do_each_thread(g, p) {
253 if (!freezeable(p))
254 continue;
Nigel Cunninghamff395932006-12-06 20:34:28 -0800255
Rafael J. Wysocki0c1eecf2007-07-19 01:47:33 -0700256 if (!p->mm == thaw_user_space)
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -0800257 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258
Rafael J. Wysockiba96a0c2007-05-23 13:57:25 -0700259 thaw_process(p);
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -0800260 } while_each_thread(g, p);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 read_unlock(&tasklist_lock);
Rafael J. Wysockia9b6f562006-12-06 20:34:37 -0800262}
263
264void thaw_processes(void)
265{
266 printk("Restarting tasks ... ");
267 thaw_tasks(FREEZER_KERNEL_THREADS);
268 thaw_tasks(FREEZER_USER_SPACE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 schedule();
Nigel Cunningham14b5b7c2006-12-06 20:34:26 -0800270 printk("done.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271}
272
273EXPORT_SYMBOL(refrigerator);