]>
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 | */ |
fdf756f7 | 98 | if (unlikely(READ_ONCE(t->__state) & TASK_FROZEN)) |
f5d39b02 | 99 | return; |
f9fab10b MSB |
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) { |
5aec788a PZ |
194 | unsigned int state; |
195 | ||
e5af0226 | 196 | if (!max_count--) |
e162b39a | 197 | goto unlock; |
304ae427 | 198 | if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) { |
6027ce49 | 199 | if (!rcu_lock_break(g, t)) |
ce9dbe24 | 200 | goto unlock; |
304ae427 | 201 | last_break = jiffies; |
ce9dbe24 | 202 | } |
fdf756f7 PZ |
203 | /* |
204 | * skip the TASK_KILLABLE tasks -- these can be killed | |
205 | * skip the TASK_IDLE tasks -- those are genuinely idle | |
206 | */ | |
5aec788a PZ |
207 | state = READ_ONCE(t->__state); |
208 | if ((state & TASK_UNINTERRUPTIBLE) && | |
fdf756f7 PZ |
209 | !(state & TASK_WAKEKILL) && |
210 | !(state & TASK_NOLOAD)) | |
17406b82 | 211 | check_hung_task(t, timeout); |
972fae69 | 212 | } |
e162b39a | 213 | unlock: |
94be52dc | 214 | rcu_read_unlock(); |
07a22b61 | 215 | if (hung_task_show_lock) |
780cbcf2 | 216 | debug_show_all_locks(); |
0ec9dc9b GP |
217 | |
218 | if (hung_task_show_all_bt) { | |
219 | hung_task_show_all_bt = false; | |
401c636a | 220 | trigger_all_cpu_backtrace(); |
401c636a | 221 | } |
0ec9dc9b GP |
222 | |
223 | if (hung_task_call_panic) | |
224 | panic("hung_task: blocked tasks"); | |
e162b39a MSB |
225 | } |
226 | ||
b4aa14a6 TH |
227 | static long hung_timeout_jiffies(unsigned long last_checked, |
228 | unsigned long timeout) | |
e162b39a MSB |
229 | { |
230 | /* timeout of 0 will disable the watchdog */ | |
b4aa14a6 TH |
231 | return timeout ? last_checked - jiffies + timeout * HZ : |
232 | MAX_SCHEDULE_TIMEOUT; | |
e162b39a MSB |
233 | } |
234 | ||
bbe7a10e | 235 | #ifdef CONFIG_SYSCTL |
e162b39a MSB |
236 | /* |
237 | * Process updating of timeout sysctl | |
238 | */ | |
bbe7a10e | 239 | static int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, |
591c32bd | 240 | void *buffer, |
bbe7a10e | 241 | size_t *lenp, loff_t *ppos) |
e162b39a MSB |
242 | { |
243 | int ret; | |
244 | ||
8d65af78 | 245 | ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); |
e162b39a MSB |
246 | |
247 | if (ret || !write) | |
248 | goto out; | |
249 | ||
e162b39a MSB |
250 | wake_up_process(watchdog_task); |
251 | ||
252 | out: | |
253 | return ret; | |
254 | } | |
255 | ||
bbe7a10e XN |
256 | /* |
257 | * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs | |
258 | * and hung_task_check_interval_secs | |
259 | */ | |
260 | static const unsigned long hung_task_timeout_max = (LONG_MAX / HZ); | |
261 | static struct ctl_table hung_task_sysctls[] = { | |
262 | #ifdef CONFIG_SMP | |
263 | { | |
264 | .procname = "hung_task_all_cpu_backtrace", | |
265 | .data = &sysctl_hung_task_all_cpu_backtrace, | |
266 | .maxlen = sizeof(int), | |
267 | .mode = 0644, | |
268 | .proc_handler = proc_dointvec_minmax, | |
269 | .extra1 = SYSCTL_ZERO, | |
270 | .extra2 = SYSCTL_ONE, | |
271 | }, | |
272 | #endif /* CONFIG_SMP */ | |
273 | { | |
274 | .procname = "hung_task_panic", | |
275 | .data = &sysctl_hung_task_panic, | |
276 | .maxlen = sizeof(int), | |
277 | .mode = 0644, | |
278 | .proc_handler = proc_dointvec_minmax, | |
279 | .extra1 = SYSCTL_ZERO, | |
280 | .extra2 = SYSCTL_ONE, | |
281 | }, | |
282 | { | |
283 | .procname = "hung_task_check_count", | |
284 | .data = &sysctl_hung_task_check_count, | |
285 | .maxlen = sizeof(int), | |
286 | .mode = 0644, | |
287 | .proc_handler = proc_dointvec_minmax, | |
288 | .extra1 = SYSCTL_ZERO, | |
289 | }, | |
290 | { | |
291 | .procname = "hung_task_timeout_secs", | |
292 | .data = &sysctl_hung_task_timeout_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_check_interval_secs", | |
300 | .data = &sysctl_hung_task_check_interval_secs, | |
301 | .maxlen = sizeof(unsigned long), | |
302 | .mode = 0644, | |
303 | .proc_handler = proc_dohung_task_timeout_secs, | |
304 | .extra2 = (void *)&hung_task_timeout_max, | |
305 | }, | |
306 | { | |
307 | .procname = "hung_task_warnings", | |
308 | .data = &sysctl_hung_task_warnings, | |
309 | .maxlen = sizeof(int), | |
310 | .mode = 0644, | |
311 | .proc_handler = proc_dointvec_minmax, | |
312 | .extra1 = SYSCTL_NEG_ONE, | |
313 | }, | |
314 | {} | |
315 | }; | |
316 | ||
317 | static void __init hung_task_sysctl_init(void) | |
318 | { | |
319 | register_sysctl_init("kernel", hung_task_sysctls); | |
320 | } | |
321 | #else | |
322 | #define hung_task_sysctl_init() do { } while (0) | |
323 | #endif /* CONFIG_SYSCTL */ | |
324 | ||
325 | ||
8b414521 MT |
326 | static atomic_t reset_hung_task = ATOMIC_INIT(0); |
327 | ||
328 | void reset_hung_task_detector(void) | |
329 | { | |
330 | atomic_set(&reset_hung_task, 1); | |
331 | } | |
332 | EXPORT_SYMBOL_GPL(reset_hung_task_detector); | |
333 | ||
a1c6ca3c VK |
334 | static bool hung_detector_suspended; |
335 | ||
336 | static int hungtask_pm_notify(struct notifier_block *self, | |
337 | unsigned long action, void *hcpu) | |
338 | { | |
339 | switch (action) { | |
340 | case PM_SUSPEND_PREPARE: | |
341 | case PM_HIBERNATION_PREPARE: | |
342 | case PM_RESTORE_PREPARE: | |
343 | hung_detector_suspended = true; | |
344 | break; | |
345 | case PM_POST_SUSPEND: | |
346 | case PM_POST_HIBERNATION: | |
347 | case PM_POST_RESTORE: | |
348 | hung_detector_suspended = false; | |
349 | break; | |
350 | default: | |
351 | break; | |
352 | } | |
353 | return NOTIFY_OK; | |
354 | } | |
355 | ||
e162b39a MSB |
356 | /* |
357 | * kthread which checks for tasks stuck in D state | |
358 | */ | |
359 | static int watchdog(void *dummy) | |
360 | { | |
b4aa14a6 TH |
361 | unsigned long hung_last_checked = jiffies; |
362 | ||
e162b39a | 363 | set_user_nice(current, 0); |
e162b39a MSB |
364 | |
365 | for ( ; ; ) { | |
17406b82 | 366 | unsigned long timeout = sysctl_hung_task_timeout_secs; |
a2e51445 DV |
367 | unsigned long interval = sysctl_hung_task_check_interval_secs; |
368 | long t; | |
603a148f | 369 | |
a2e51445 DV |
370 | if (interval == 0) |
371 | interval = timeout; | |
372 | interval = min_t(unsigned long, interval, timeout); | |
373 | t = hung_timeout_jiffies(hung_last_checked, interval); | |
b4aa14a6 | 374 | if (t <= 0) { |
a1c6ca3c VK |
375 | if (!atomic_xchg(&reset_hung_task, 0) && |
376 | !hung_detector_suspended) | |
b4aa14a6 TH |
377 | check_hung_uninterruptible_tasks(timeout); |
378 | hung_last_checked = jiffies; | |
8b414521 | 379 | continue; |
b4aa14a6 TH |
380 | } |
381 | schedule_timeout_interruptible(t); | |
e162b39a MSB |
382 | } |
383 | ||
384 | return 0; | |
385 | } | |
386 | ||
387 | static int __init hung_task_init(void) | |
388 | { | |
389 | atomic_notifier_chain_register(&panic_notifier_list, &panic_block); | |
a1c6ca3c VK |
390 | |
391 | /* Disable hung task detector on suspend */ | |
392 | pm_notifier(hungtask_pm_notify, 0); | |
393 | ||
e162b39a | 394 | watchdog_task = kthread_run(watchdog, NULL, "khungtaskd"); |
bbe7a10e | 395 | hung_task_sysctl_init(); |
e162b39a MSB |
396 | |
397 | return 0; | |
398 | } | |
c96d6660 | 399 | subsys_initcall(hung_task_init); |