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