Commit | Line | Data |
---|---|---|
457c8996 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
e162b39a MSB |
2 | /* |
3 | * Detect Hung Task | |
4 | * | |
5 | * kernel/hung_task.c - kernel thread for detecting tasks stuck in D state | |
6 | * | |
7 | */ | |
8 | ||
9 | #include <linux/mm.h> | |
10 | #include <linux/cpu.h> | |
11 | #include <linux/nmi.h> | |
12 | #include <linux/init.h> | |
13 | #include <linux/delay.h> | |
14 | #include <linux/freezer.h> | |
15 | #include <linux/kthread.h> | |
16 | #include <linux/lockdep.h> | |
9984de1a | 17 | #include <linux/export.h> |
f39650de | 18 | #include <linux/panic_notifier.h> |
e162b39a | 19 | #include <linux/sysctl.h> |
a1c6ca3c | 20 | #include <linux/suspend.h> |
41e85ce8 | 21 | #include <linux/utsname.h> |
3f07c014 | 22 | #include <linux/sched/signal.h> |
b17b0153 | 23 | #include <linux/sched/debug.h> |
a98eb6f1 | 24 | #include <linux/sched/sysctl.h> |
3f07c014 | 25 | |
6a716c90 | 26 | #include <trace/events/sched.h> |
e162b39a MSB |
27 | |
28 | /* | |
ce9dbe24 | 29 | * The number of tasks checked: |
e162b39a | 30 | */ |
cd64647f | 31 | int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT; |
ce9dbe24 MSB |
32 | |
33 | /* | |
34 | * Limit number of tasks checked in a batch. | |
35 | * | |
36 | * This value controls the preemptibility of khungtaskd since preemption | |
37 | * is disabled during the critical section. It also controls the size of | |
38 | * the RCU grace period. So it needs to be upper-bound. | |
39 | */ | |
304ae427 | 40 | #define HUNG_TASK_LOCK_BREAK (HZ / 10) |
e162b39a MSB |
41 | |
42 | /* | |
43 | * Zero means infinite timeout - no checking done: | |
44 | */ | |
e11feaa1 | 45 | unsigned long __read_mostly sysctl_hung_task_timeout_secs = CONFIG_DEFAULT_HUNG_TASK_TIMEOUT; |
e162b39a | 46 | |
a2e51445 DV |
47 | /* |
48 | * Zero (default value) means use sysctl_hung_task_timeout_secs: | |
49 | */ | |
50 | unsigned long __read_mostly sysctl_hung_task_check_interval_secs; | |
51 | ||
270750db | 52 | int __read_mostly sysctl_hung_task_warnings = 10; |
e162b39a MSB |
53 | |
54 | static int __read_mostly did_panic; | |
780cbcf2 | 55 | static bool hung_task_show_lock; |
401c636a | 56 | static bool hung_task_call_panic; |
0ec9dc9b | 57 | static bool hung_task_show_all_bt; |
e162b39a MSB |
58 | |
59 | static struct task_struct *watchdog_task; | |
60 | ||
0ec9dc9b GP |
61 | #ifdef CONFIG_SMP |
62 | /* | |
63 | * Should we dump all CPUs backtraces in a hung task event? | |
64 | * Defaults to 0, can be changed via sysctl. | |
65 | */ | |
bbe7a10e XN |
66 | static unsigned int __read_mostly sysctl_hung_task_all_cpu_backtrace; |
67 | #else | |
68 | #define sysctl_hung_task_all_cpu_backtrace 0 | |
0ec9dc9b GP |
69 | #endif /* CONFIG_SMP */ |
70 | ||
e162b39a MSB |
71 | /* |
72 | * Should we panic (and reboot, if panic_timeout= is set) when a | |
73 | * hung task is detected: | |
74 | */ | |
75 | unsigned int __read_mostly sysctl_hung_task_panic = | |
67fca000 | 76 | IS_ENABLED(CONFIG_BOOTPARAM_HUNG_TASK_PANIC); |
e162b39a | 77 | |
e162b39a MSB |
78 | static int |
79 | hung_task_panic(struct notifier_block *this, unsigned long event, void *ptr) | |
80 | { | |
81 | did_panic = 1; | |
82 | ||
83 | return NOTIFY_DONE; | |
84 | } | |
85 | ||
86 | static struct notifier_block panic_block = { | |
87 | .notifier_call = hung_task_panic, | |
88 | }; | |
89 | ||
17406b82 | 90 | static void check_hung_task(struct task_struct *t, unsigned long timeout) |
e162b39a MSB |
91 | { |
92 | unsigned long switch_count = t->nvcsw + t->nivcsw; | |
93 | ||
cf2592f5 FW |
94 | /* |
95 | * Ensure the task is not frozen. | |
f9fab10b | 96 | * Also, skip vfork and any other user process that freezer should skip. |
cf2592f5 | 97 | */ |
f9fab10b MSB |
98 | if (unlikely(t->flags & (PF_FROZEN | PF_FREEZER_SKIP))) |
99 | return; | |
100 | ||
101 | /* | |
102 | * When a freshly created task is scheduled once, changes its state to | |
103 | * TASK_UNINTERRUPTIBLE without having ever been switched out once, it | |
104 | * musn't be checked. | |
105 | */ | |
106 | if (unlikely(!switch_count)) | |
e162b39a MSB |
107 | return; |
108 | ||
17406b82 | 109 | if (switch_count != t->last_switch_count) { |
e162b39a | 110 | t->last_switch_count = switch_count; |
a2e51445 | 111 | t->last_switch_time = jiffies; |
e162b39a MSB |
112 | return; |
113 | } | |
a2e51445 DV |
114 | if (time_is_after_jiffies(t->last_switch_time + timeout * HZ)) |
115 | return; | |
6a716c90 ON |
116 | |
117 | trace_sched_process_hang(t); | |
118 | ||
168e06f7 LC |
119 | if (sysctl_hung_task_panic) { |
120 | console_verbose(); | |
121 | hung_task_show_lock = true; | |
122 | hung_task_call_panic = true; | |
123 | } | |
270750db | 124 | |
e162b39a MSB |
125 | /* |
126 | * Ok, the task did not get scheduled for more than 2 minutes, | |
127 | * complain: | |
128 | */ | |
48a6d64e | 129 | if (sysctl_hung_task_warnings) { |
4ca5ede0 TH |
130 | if (sysctl_hung_task_warnings > 0) |
131 | sysctl_hung_task_warnings--; | |
48a6d64e | 132 | pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n", |
b014beba | 133 | t->comm, t->pid, (jiffies - t->last_switch_time) / HZ); |
48a6d64e JS |
134 | pr_err(" %s %s %.*s\n", |
135 | print_tainted(), init_utsname()->release, | |
136 | (int)strcspn(init_utsname()->version, " "), | |
137 | init_utsname()->version); | |
138 | pr_err("\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\"" | |
139 | " disables this message.\n"); | |
140 | sched_show_task(t); | |
780cbcf2 | 141 | hung_task_show_lock = true; |
0ec9dc9b GP |
142 | |
143 | if (sysctl_hung_task_all_cpu_backtrace) | |
144 | hung_task_show_all_bt = true; | |
48a6d64e | 145 | } |
e162b39a | 146 | |
e162b39a | 147 | touch_nmi_watchdog(); |
e162b39a MSB |
148 | } |
149 | ||
ce9dbe24 MSB |
150 | /* |
151 | * To avoid extending the RCU grace period for an unbounded amount of time, | |
152 | * periodically exit the critical section and enter a new one. | |
153 | * | |
154 | * For preemptible RCU it is sufficient to call rcu_read_unlock in order | |
6a103b0d | 155 | * to exit the grace period. For classic RCU, a reschedule is required. |
ce9dbe24 | 156 | */ |
6027ce49 | 157 | static bool rcu_lock_break(struct task_struct *g, struct task_struct *t) |
ce9dbe24 | 158 | { |
6027ce49 ON |
159 | bool can_cont; |
160 | ||
ce9dbe24 MSB |
161 | get_task_struct(g); |
162 | get_task_struct(t); | |
163 | rcu_read_unlock(); | |
164 | cond_resched(); | |
165 | rcu_read_lock(); | |
6027ce49 | 166 | can_cont = pid_alive(g) && pid_alive(t); |
ce9dbe24 MSB |
167 | put_task_struct(t); |
168 | put_task_struct(g); | |
6027ce49 ON |
169 | |
170 | return can_cont; | |
ce9dbe24 MSB |
171 | } |
172 | ||
e162b39a MSB |
173 | /* |
174 | * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for | |
175 | * a really long time (120 seconds). If that happens, print out | |
176 | * a warning. | |
177 | */ | |
603a148f | 178 | static void check_hung_uninterruptible_tasks(unsigned long timeout) |
e162b39a MSB |
179 | { |
180 | int max_count = sysctl_hung_task_check_count; | |
304ae427 | 181 | unsigned long last_break = jiffies; |
e162b39a MSB |
182 | struct task_struct *g, *t; |
183 | ||
184 | /* | |
185 | * If the system crashed already then all bets are off, | |
186 | * do not report extra hung tasks: | |
187 | */ | |
188 | if (test_taint(TAINT_DIE) || did_panic) | |
189 | return; | |
190 | ||
780cbcf2 | 191 | hung_task_show_lock = false; |
94be52dc | 192 | rcu_read_lock(); |
972fae69 | 193 | for_each_process_thread(g, t) { |
e5af0226 | 194 | if (!max_count--) |
e162b39a | 195 | goto unlock; |
304ae427 | 196 | if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) { |
6027ce49 | 197 | if (!rcu_lock_break(g, t)) |
ce9dbe24 | 198 | goto unlock; |
304ae427 | 199 | last_break = jiffies; |
ce9dbe24 | 200 | } |
e162b39a | 201 | /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */ |
2f064a59 | 202 | if (READ_ONCE(t->__state) == TASK_UNINTERRUPTIBLE) |
17406b82 | 203 | check_hung_task(t, timeout); |
972fae69 | 204 | } |
e162b39a | 205 | unlock: |
94be52dc | 206 | rcu_read_unlock(); |
07a22b61 | 207 | if (hung_task_show_lock) |
780cbcf2 | 208 | debug_show_all_locks(); |
0ec9dc9b GP |
209 | |
210 | if (hung_task_show_all_bt) { | |
211 | hung_task_show_all_bt = false; | |
401c636a | 212 | trigger_all_cpu_backtrace(); |
401c636a | 213 | } |
0ec9dc9b GP |
214 | |
215 | if (hung_task_call_panic) | |
216 | panic("hung_task: blocked tasks"); | |
e162b39a MSB |
217 | } |
218 | ||
b4aa14a6 TH |
219 | static long hung_timeout_jiffies(unsigned long last_checked, |
220 | unsigned long timeout) | |
e162b39a MSB |
221 | { |
222 | /* timeout of 0 will disable the watchdog */ | |
b4aa14a6 TH |
223 | return timeout ? last_checked - jiffies + timeout * HZ : |
224 | MAX_SCHEDULE_TIMEOUT; | |
e162b39a MSB |
225 | } |
226 | ||
bbe7a10e | 227 | #ifdef CONFIG_SYSCTL |
e162b39a MSB |
228 | /* |
229 | * Process updating of timeout sysctl | |
230 | */ | |
bbe7a10e XN |
231 | static int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, |
232 | void __user *buffer, | |
233 | size_t *lenp, loff_t *ppos) | |
e162b39a MSB |
234 | { |
235 | int ret; | |
236 | ||
8d65af78 | 237 | ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); |
e162b39a MSB |
238 | |
239 | if (ret || !write) | |
240 | goto out; | |
241 | ||
e162b39a MSB |
242 | wake_up_process(watchdog_task); |
243 | ||
244 | out: | |
245 | return ret; | |
246 | } | |
247 | ||
bbe7a10e XN |
248 | /* |
249 | * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs | |
250 | * and hung_task_check_interval_secs | |
251 | */ | |
252 | static const unsigned long hung_task_timeout_max = (LONG_MAX / HZ); | |
253 | static struct ctl_table hung_task_sysctls[] = { | |
254 | #ifdef CONFIG_SMP | |
255 | { | |
256 | .procname = "hung_task_all_cpu_backtrace", | |
257 | .data = &sysctl_hung_task_all_cpu_backtrace, | |
258 | .maxlen = sizeof(int), | |
259 | .mode = 0644, | |
260 | .proc_handler = proc_dointvec_minmax, | |
261 | .extra1 = SYSCTL_ZERO, | |
262 | .extra2 = SYSCTL_ONE, | |
263 | }, | |
264 | #endif /* CONFIG_SMP */ | |
265 | { | |
266 | .procname = "hung_task_panic", | |
267 | .data = &sysctl_hung_task_panic, | |
268 | .maxlen = sizeof(int), | |
269 | .mode = 0644, | |
270 | .proc_handler = proc_dointvec_minmax, | |
271 | .extra1 = SYSCTL_ZERO, | |
272 | .extra2 = SYSCTL_ONE, | |
273 | }, | |
274 | { | |
275 | .procname = "hung_task_check_count", | |
276 | .data = &sysctl_hung_task_check_count, | |
277 | .maxlen = sizeof(int), | |
278 | .mode = 0644, | |
279 | .proc_handler = proc_dointvec_minmax, | |
280 | .extra1 = SYSCTL_ZERO, | |
281 | }, | |
282 | { | |
283 | .procname = "hung_task_timeout_secs", | |
284 | .data = &sysctl_hung_task_timeout_secs, | |
285 | .maxlen = sizeof(unsigned long), | |
286 | .mode = 0644, | |
287 | .proc_handler = proc_dohung_task_timeout_secs, | |
288 | .extra2 = (void *)&hung_task_timeout_max, | |
289 | }, | |
290 | { | |
291 | .procname = "hung_task_check_interval_secs", | |
292 | .data = &sysctl_hung_task_check_interval_secs, | |
293 | .maxlen = sizeof(unsigned long), | |
294 | .mode = 0644, | |
295 | .proc_handler = proc_dohung_task_timeout_secs, | |
296 | .extra2 = (void *)&hung_task_timeout_max, | |
297 | }, | |
298 | { | |
299 | .procname = "hung_task_warnings", | |
300 | .data = &sysctl_hung_task_warnings, | |
301 | .maxlen = sizeof(int), | |
302 | .mode = 0644, | |
303 | .proc_handler = proc_dointvec_minmax, | |
304 | .extra1 = SYSCTL_NEG_ONE, | |
305 | }, | |
306 | {} | |
307 | }; | |
308 | ||
309 | static void __init hung_task_sysctl_init(void) | |
310 | { | |
311 | register_sysctl_init("kernel", hung_task_sysctls); | |
312 | } | |
313 | #else | |
314 | #define hung_task_sysctl_init() do { } while (0) | |
315 | #endif /* CONFIG_SYSCTL */ | |
316 | ||
317 | ||
8b414521 MT |
318 | static atomic_t reset_hung_task = ATOMIC_INIT(0); |
319 | ||
320 | void reset_hung_task_detector(void) | |
321 | { | |
322 | atomic_set(&reset_hung_task, 1); | |
323 | } | |
324 | EXPORT_SYMBOL_GPL(reset_hung_task_detector); | |
325 | ||
a1c6ca3c VK |
326 | static bool hung_detector_suspended; |
327 | ||
328 | static int hungtask_pm_notify(struct notifier_block *self, | |
329 | unsigned long action, void *hcpu) | |
330 | { | |
331 | switch (action) { | |
332 | case PM_SUSPEND_PREPARE: | |
333 | case PM_HIBERNATION_PREPARE: | |
334 | case PM_RESTORE_PREPARE: | |
335 | hung_detector_suspended = true; | |
336 | break; | |
337 | case PM_POST_SUSPEND: | |
338 | case PM_POST_HIBERNATION: | |
339 | case PM_POST_RESTORE: | |
340 | hung_detector_suspended = false; | |
341 | break; | |
342 | default: | |
343 | break; | |
344 | } | |
345 | return NOTIFY_OK; | |
346 | } | |
347 | ||
e162b39a MSB |
348 | /* |
349 | * kthread which checks for tasks stuck in D state | |
350 | */ | |
351 | static int watchdog(void *dummy) | |
352 | { | |
b4aa14a6 TH |
353 | unsigned long hung_last_checked = jiffies; |
354 | ||
e162b39a | 355 | set_user_nice(current, 0); |
e162b39a MSB |
356 | |
357 | for ( ; ; ) { | |
17406b82 | 358 | unsigned long timeout = sysctl_hung_task_timeout_secs; |
a2e51445 DV |
359 | unsigned long interval = sysctl_hung_task_check_interval_secs; |
360 | long t; | |
603a148f | 361 | |
a2e51445 DV |
362 | if (interval == 0) |
363 | interval = timeout; | |
364 | interval = min_t(unsigned long, interval, timeout); | |
365 | t = hung_timeout_jiffies(hung_last_checked, interval); | |
b4aa14a6 | 366 | if (t <= 0) { |
a1c6ca3c VK |
367 | if (!atomic_xchg(&reset_hung_task, 0) && |
368 | !hung_detector_suspended) | |
b4aa14a6 TH |
369 | check_hung_uninterruptible_tasks(timeout); |
370 | hung_last_checked = jiffies; | |
8b414521 | 371 | continue; |
b4aa14a6 TH |
372 | } |
373 | schedule_timeout_interruptible(t); | |
e162b39a MSB |
374 | } |
375 | ||
376 | return 0; | |
377 | } | |
378 | ||
379 | static int __init hung_task_init(void) | |
380 | { | |
381 | atomic_notifier_chain_register(&panic_notifier_list, &panic_block); | |
a1c6ca3c VK |
382 | |
383 | /* Disable hung task detector on suspend */ | |
384 | pm_notifier(hungtask_pm_notify, 0); | |
385 | ||
e162b39a | 386 | watchdog_task = kthread_run(watchdog, NULL, "khungtaskd"); |
bbe7a10e | 387 | hung_task_sysctl_init(); |
e162b39a MSB |
388 | |
389 | return 0; | |
390 | } | |
c96d6660 | 391 | subsys_initcall(hung_task_init); |