]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - kernel/power/process.c
2 * drivers/power/process.c - Functions for starting/stopping processes on
5 * Originally from swsusp.
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>
18 * Timeout for stopping processes
20 #define TIMEOUT (20 * HZ)
22 #define FREEZER_KERNEL_THREADS 0
23 #define FREEZER_USER_SPACE 1
25 static inline int freezeable(struct task_struct
* p
)
28 (p
->flags
& PF_NOFREEZE
) ||
35 * freezing is complete, mark current process as frozen
37 static inline void frozen_process(void)
39 if (!unlikely(current
->flags
& PF_NOFREEZE
)) {
40 current
->flags
|= PF_FROZEN
;
43 clear_freeze_flag(current
);
46 /* Refrigerator is place where frozen processes are stored :-). */
47 void refrigerator(void)
49 /* Hmm, should we be allowed to suspend when there are realtime
54 if (freezing(current
)) {
61 save
= current
->state
;
62 pr_debug("%s entered refrigerator\n", current
->comm
);
64 spin_lock_irq(¤t
->sighand
->siglock
);
65 recalc_sigpending(); /* We sent fake signal, clean it up */
66 spin_unlock_irq(¤t
->sighand
->siglock
);
69 set_current_state(TASK_UNINTERRUPTIBLE
);
74 pr_debug("%s left refrigerator\n", current
->comm
);
75 __set_current_state(save
);
78 static void fake_signal_wake_up(struct task_struct
*p
, int resume
)
82 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
83 signal_wake_up(p
, resume
);
84 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
87 static void send_fake_signal(struct task_struct
*p
)
89 if (p
->state
== TASK_STOPPED
)
90 force_sig_specific(SIGSTOP
, p
);
91 fake_signal_wake_up(p
, p
->state
== TASK_STOPPED
);
94 static int has_mm(struct task_struct
*p
)
96 return (p
->mm
&& !(p
->flags
& PF_BORROWED_MM
));
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
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
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.
113 * The task_lock() is necessary to prevent races with exit_mm() or
114 * use_mm()/unuse_mm() from occuring.
116 static int freeze_task(struct task_struct
*p
, int with_mm_only
)
123 if (!signal_pending(p
))
124 fake_signal_wake_up(p
, 0);
129 wake_up_state(p
, TASK_INTERRUPTIBLE
);
144 wake_up_state(p
, TASK_INTERRUPTIBLE
);
153 static void cancel_freezing(struct task_struct
*p
)
158 pr_debug(" clean up: %s\n", p
->comm
);
159 clear_freeze_flag(p
);
160 spin_lock_irqsave(&p
->sighand
->siglock
, flags
);
161 recalc_sigpending_and_wake(p
);
162 spin_unlock_irqrestore(&p
->sighand
->siglock
, flags
);
166 static int try_to_freeze_tasks(int freeze_user_space
)
168 struct task_struct
*g
, *p
;
169 unsigned long end_time
;
171 struct timeval start
, end
;
173 unsigned int elapsed_csecs
;
175 do_gettimeofday(&start
);
177 end_time
= jiffies
+ TIMEOUT
;
180 read_lock(&tasklist_lock
);
181 do_each_thread(g
, p
) {
182 if (frozen(p
) || !freezeable(p
))
185 if (p
->state
== TASK_TRACED
&& frozen(p
->parent
)) {
190 if (!freeze_task(p
, freeze_user_space
))
193 if (!freezer_should_skip(p
))
195 } while_each_thread(g
, p
);
196 read_unlock(&tasklist_lock
);
197 yield(); /* Yield is okay here */
198 if (time_after(jiffies
, end_time
))
202 do_gettimeofday(&end
);
203 elapsed_csecs64
= timeval_to_ns(&end
) - timeval_to_ns(&start
);
204 do_div(elapsed_csecs64
, NSEC_PER_SEC
/ 100);
205 elapsed_csecs
= elapsed_csecs64
;
208 /* This does not unfreeze processes that are already frozen
209 * (we have slightly ugly calling convention in that respect,
210 * and caller must call thaw_processes() if something fails),
211 * but it cleans up leftover PF_FREEZE requests.
214 printk(KERN_ERR
"Freezing of tasks failed after %d.%02d seconds "
215 "(%d tasks refusing to freeze):\n",
216 elapsed_csecs
/ 100, elapsed_csecs
% 100, todo
);
218 read_lock(&tasklist_lock
);
219 do_each_thread(g
, p
) {
221 if (freezing(p
) && !freezer_should_skip(p
))
222 printk(KERN_ERR
" %s\n", p
->comm
);
225 } while_each_thread(g
, p
);
226 read_unlock(&tasklist_lock
);
228 printk("(elapsed %d.%02d seconds) ", elapsed_csecs
/ 100,
229 elapsed_csecs
% 100);
232 return todo
? -EBUSY
: 0;
236 * freeze_processes - tell processes to enter the refrigerator
238 int freeze_processes(void)
242 printk("Freezing user space processes ... ");
243 error
= try_to_freeze_tasks(FREEZER_USER_SPACE
);
248 printk("Freezing remaining freezable tasks ... ");
249 error
= try_to_freeze_tasks(FREEZER_KERNEL_THREADS
);
259 static void thaw_tasks(int thaw_user_space
)
261 struct task_struct
*g
, *p
;
263 read_lock(&tasklist_lock
);
264 do_each_thread(g
, p
) {
268 if (!p
->mm
== thaw_user_space
)
272 } while_each_thread(g
, p
);
273 read_unlock(&tasklist_lock
);
276 void thaw_processes(void)
278 printk("Restarting tasks ... ");
279 thaw_tasks(FREEZER_KERNEL_THREADS
);
280 thaw_tasks(FREEZER_USER_SPACE
);
285 EXPORT_SYMBOL(refrigerator
);