2 * drivers/power/process.c - Functions for starting/stopping processes on
5 * Originally from swsusp.
11 #include <linux/interrupt.h>
12 #include <linux/oom.h>
13 #include <linux/suspend.h>
14 #include <linux/module.h>
15 #include <linux/syscalls.h>
16 #include <linux/freezer.h>
17 #include <linux/delay.h>
18 #include <linux/workqueue.h>
19 #include <linux/kmod.h>
22 * Timeout for stopping processes
24 unsigned int __read_mostly freeze_timeout_msecs = 20 * MSEC_PER_SEC;
26 static int try_to_freeze_tasks(bool user_only)
28 struct task_struct *g, *p;
29 unsigned long end_time;
32 struct timeval start, end;
34 unsigned int elapsed_csecs;
37 do_gettimeofday(&start);
39 end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs);
42 freeze_workqueues_begin();
46 read_lock(&tasklist_lock);
47 do_each_thread(g, p) {
48 if (p == current || !freeze_task(p))
51 if (!freezer_should_skip(p))
53 } while_each_thread(g, p);
54 read_unlock(&tasklist_lock);
57 wq_busy = freeze_workqueues_busy();
61 if (!todo || time_after(jiffies, end_time))
64 if (pm_wakeup_pending()) {
70 * We need to retry, but first give the freezing tasks some
71 * time to enter the refrigerator.
76 do_gettimeofday(&end);
77 elapsed_csecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
78 do_div(elapsed_csecs64, NSEC_PER_SEC / 100);
79 elapsed_csecs = elapsed_csecs64;
83 printk(KERN_ERR "Freezing of tasks %s after %d.%02d seconds "
84 "(%d tasks refusing to freeze, wq_busy=%d):\n",
85 wakeup ? "aborted" : "failed",
86 elapsed_csecs / 100, elapsed_csecs % 100,
87 todo - wq_busy, wq_busy);
90 read_lock(&tasklist_lock);
91 do_each_thread(g, p) {
92 if (p != current && !freezer_should_skip(p)
93 && freezing(p) && !frozen(p))
95 } while_each_thread(g, p);
96 read_unlock(&tasklist_lock);
99 printk("(elapsed %d.%02d seconds) ", elapsed_csecs / 100,
100 elapsed_csecs % 100);
103 return todo ? -EBUSY : 0;
107 * Returns true if all freezable tasks (except for current) are frozen already
109 static bool check_frozen_processes(void)
111 struct task_struct *g, *p;
114 read_lock(&tasklist_lock);
115 for_each_process_thread(g, p) {
116 if (p != current && !freezer_should_skip(p) &&
123 read_unlock(&tasklist_lock);
129 * freeze_processes - Signal user space processes to enter the refrigerator.
131 * On success, returns 0. On failure, -errno and system is fully thawed.
133 int freeze_processes(void)
138 error = __usermodehelper_disable(UMH_FREEZING);
143 atomic_inc(&system_freezing_cnt);
145 printk("Freezing user space processes ... ");
147 oom_kills_saved = oom_kills_count();
148 error = try_to_freeze_tasks(true);
150 __usermodehelper_set_disable_depth(UMH_DISABLED);
151 oom_killer_disable();
154 * There might have been an OOM kill while we were
155 * freezing tasks and the killed task might be still
156 * on the way out so we have to double check for race.
158 if (oom_kills_count() != oom_kills_saved &&
159 !check_frozen_processes()) {
160 __usermodehelper_set_disable_depth(UMH_ENABLED);
161 printk("OOM in progress.");
177 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
179 * On success, returns 0. On failure, -errno and only the kernel threads are
180 * thawed, so as to give a chance to the caller to do additional cleanups
181 * (if any) before thawing the userspace tasks. So, it is the responsibility
182 * of the caller to thaw the userspace tasks, when the time is right.
184 int freeze_kernel_threads(void)
188 printk("Freezing remaining freezable tasks ... ");
189 pm_nosig_freezing = true;
190 error = try_to_freeze_tasks(false);
198 thaw_kernel_threads();
202 void thaw_processes(void)
204 struct task_struct *g, *p;
207 atomic_dec(&system_freezing_cnt);
209 pm_nosig_freezing = false;
213 printk("Restarting tasks ... ");
215 __usermodehelper_set_disable_depth(UMH_FREEZING);
218 read_lock(&tasklist_lock);
219 do_each_thread(g, p) {
221 } while_each_thread(g, p);
222 read_unlock(&tasklist_lock);
224 usermodehelper_enable();
230 void thaw_kernel_threads(void)
232 struct task_struct *g, *p;
234 pm_nosig_freezing = false;
235 printk("Restarting kernel threads ... ");
239 read_lock(&tasklist_lock);
240 do_each_thread(g, p) {
241 if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
243 } while_each_thread(g, p);
244 read_unlock(&tasklist_lock);