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/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>
20#include <trace/events/power.h>
21
22/*
23 * Timeout for stopping processes
24 */
25unsigned int __read_mostly freeze_timeout_msecs = 20 * MSEC_PER_SEC;
26
27static int try_to_freeze_tasks(bool user_only)
28{
29	struct task_struct *g, *p;
30	unsigned long end_time;
31	unsigned int todo;
32	bool wq_busy = false;
33	struct timeval start, end;
34	u64 elapsed_msecs64;
35	unsigned int elapsed_msecs;
36	bool wakeup = false;
37	int sleep_usecs = USEC_PER_MSEC;
38
39	do_gettimeofday(&start);
40
41	end_time = jiffies + msecs_to_jiffies(freeze_timeout_msecs);
42
43	if (!user_only)
44		freeze_workqueues_begin();
45
46	while (true) {
47		todo = 0;
48		read_lock(&tasklist_lock);
49		for_each_process_thread(g, p) {
50			if (p == current || !freeze_task(p))
51				continue;
52
53			if (!freezer_should_skip(p))
54				todo++;
55		}
56		read_unlock(&tasklist_lock);
57
58		if (!user_only) {
59			wq_busy = freeze_workqueues_busy();
60			todo += wq_busy;
61		}
62
63		if (!todo || time_after(jiffies, end_time))
64			break;
65
66		if (pm_wakeup_pending()) {
67			wakeup = true;
68			break;
69		}
70
71		/*
72		 * We need to retry, but first give the freezing tasks some
73		 * time to enter the refrigerator.  Start with an initial
74		 * 1 ms sleep followed by exponential backoff until 8 ms.
75		 */
76		usleep_range(sleep_usecs / 2, sleep_usecs);
77		if (sleep_usecs < 8 * USEC_PER_MSEC)
78			sleep_usecs *= 2;
79	}
80
81	do_gettimeofday(&end);
82	elapsed_msecs64 = timeval_to_ns(&end) - timeval_to_ns(&start);
83	do_div(elapsed_msecs64, NSEC_PER_MSEC);
84	elapsed_msecs = elapsed_msecs64;
85
86	if (todo) {
87		pr_cont("\n");
88		pr_err("Freezing of tasks %s after %d.%03d seconds "
89		       "(%d tasks refusing to freeze, wq_busy=%d):\n",
90		       wakeup ? "aborted" : "failed",
91		       elapsed_msecs / 1000, elapsed_msecs % 1000,
92		       todo - wq_busy, wq_busy);
93
94		if (!wakeup) {
95			read_lock(&tasklist_lock);
96			for_each_process_thread(g, p) {
97				if (p != current && !freezer_should_skip(p)
98				    && freezing(p) && !frozen(p))
99					sched_show_task(p);
100			}
101			read_unlock(&tasklist_lock);
102		}
103	} else {
104		pr_cont("(elapsed %d.%03d seconds) ", elapsed_msecs / 1000,
105			elapsed_msecs % 1000);
106	}
107
108	return todo ? -EBUSY : 0;
109}
110
111/**
112 * freeze_processes - Signal user space processes to enter the refrigerator.
113 * The current thread will not be frozen.  The same process that calls
114 * freeze_processes must later call thaw_processes.
115 *
116 * On success, returns 0.  On failure, -errno and system is fully thawed.
117 */
118int freeze_processes(void)
119{
120	int error;
121
122	error = __usermodehelper_disable(UMH_FREEZING);
123	if (error)
124		return error;
125
126	/* Make sure this task doesn't get frozen */
127	current->flags |= PF_SUSPEND_TASK;
128
129	if (!pm_freezing)
130		atomic_inc(&system_freezing_cnt);
131
132	pm_wakeup_clear();
133	pr_info("Freezing user space processes ... ");
134	pm_freezing = true;
135	error = try_to_freeze_tasks(true);
136	if (!error) {
137		__usermodehelper_set_disable_depth(UMH_DISABLED);
138		pr_cont("done.");
139	}
140	pr_cont("\n");
141	BUG_ON(in_atomic());
142
143	/*
144	 * Now that the whole userspace is frozen we need to disbale
145	 * the OOM killer to disallow any further interference with
146	 * killable tasks.
147	 */
148	if (!error && !oom_killer_disable())
149		error = -EBUSY;
150
151	if (error)
152		thaw_processes();
153	return error;
154}
155
156/**
157 * freeze_kernel_threads - Make freezable kernel threads go to the refrigerator.
158 *
159 * On success, returns 0.  On failure, -errno and only the kernel threads are
160 * thawed, so as to give a chance to the caller to do additional cleanups
161 * (if any) before thawing the userspace tasks. So, it is the responsibility
162 * of the caller to thaw the userspace tasks, when the time is right.
163 */
164int freeze_kernel_threads(void)
165{
166	int error;
167
168	pr_info("Freezing remaining freezable tasks ... ");
169
170	pm_nosig_freezing = true;
171	error = try_to_freeze_tasks(false);
172	if (!error)
173		pr_cont("done.");
174
175	pr_cont("\n");
176	BUG_ON(in_atomic());
177
178	if (error)
179		thaw_kernel_threads();
180	return error;
181}
182
183void thaw_processes(void)
184{
185	struct task_struct *g, *p;
186	struct task_struct *curr = current;
187
188	trace_suspend_resume(TPS("thaw_processes"), 0, true);
189	if (pm_freezing)
190		atomic_dec(&system_freezing_cnt);
191	pm_freezing = false;
192	pm_nosig_freezing = false;
193
194	oom_killer_enable();
195
196	pr_info("Restarting tasks ... ");
197
198	__usermodehelper_set_disable_depth(UMH_FREEZING);
199	thaw_workqueues();
200
201	read_lock(&tasklist_lock);
202	for_each_process_thread(g, p) {
203		/* No other threads should have PF_SUSPEND_TASK set */
204		WARN_ON((p != curr) && (p->flags & PF_SUSPEND_TASK));
205		__thaw_task(p);
206	}
207	read_unlock(&tasklist_lock);
208
209	WARN_ON(!(curr->flags & PF_SUSPEND_TASK));
210	curr->flags &= ~PF_SUSPEND_TASK;
211
212	usermodehelper_enable();
213
214	schedule();
215	pr_cont("done.\n");
216	trace_suspend_resume(TPS("thaw_processes"), 0, false);
217}
218
219void thaw_kernel_threads(void)
220{
221	struct task_struct *g, *p;
222
223	pm_nosig_freezing = false;
224	pr_info("Restarting kernel threads ... ");
225
226	thaw_workqueues();
227
228	read_lock(&tasklist_lock);
229	for_each_process_thread(g, p) {
230		if (p->flags & (PF_KTHREAD | PF_WQ_WORKER))
231			__thaw_task(p);
232	}
233	read_unlock(&tasklist_lock);
234
235	schedule();
236	pr_cont("done.\n");
237}
238