Thomas Gleixner | 457c899 | 2019-05-19 13:08:55 +0100 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0-only |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 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> |
Paul Gortmaker | 9984de1 | 2011-05-23 14:51:41 -0400 | [diff] [blame] | 17 | #include <linux/export.h> |
Andy Shevchenko | f39650d | 2021-06-30 18:54:59 -0700 | [diff] [blame] | 18 | #include <linux/panic_notifier.h> |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 19 | #include <linux/sysctl.h> |
Vitaly Kuznetsov | a1c6ca3 | 2018-10-17 13:23:55 +0200 | [diff] [blame] | 20 | #include <linux/suspend.h> |
Oleg Nesterov | 41e85ce | 2013-08-01 18:59:41 +0200 | [diff] [blame] | 21 | #include <linux/utsname.h> |
Ingo Molnar | 3f07c01 | 2017-02-08 18:51:30 +0100 | [diff] [blame] | 22 | #include <linux/sched/signal.h> |
Ingo Molnar | b17b015 | 2017-02-08 18:51:35 +0100 | [diff] [blame] | 23 | #include <linux/sched/debug.h> |
Valdis Kletnieks | a98eb6f | 2019-03-07 16:26:46 -0800 | [diff] [blame] | 24 | #include <linux/sched/sysctl.h> |
Ingo Molnar | 3f07c01 | 2017-02-08 18:51:30 +0100 | [diff] [blame] | 25 | |
Oleg Nesterov | 6a716c9 | 2013-10-19 18:18:28 +0200 | [diff] [blame] | 26 | #include <trace/events/sched.h> |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 27 | |
| 28 | /* |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 29 | * The number of tasks checked: |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 30 | */ |
Tom Rix | 882c5b2 | 2023-03-12 12:46:45 -0400 | [diff] [blame] | 31 | static int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT; |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 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 | */ |
Tetsuo Handa | 304ae42 | 2019-01-03 15:26:31 -0800 | [diff] [blame] | 40 | #define HUNG_TASK_LOCK_BREAK (HZ / 10) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 41 | |
| 42 | /* |
| 43 | * Zero means infinite timeout - no checking done: |
| 44 | */ |
Jeff Mahoney | e11feaa | 2011-04-27 14:27:24 -0400 | [diff] [blame] | 45 | unsigned long __read_mostly sysctl_hung_task_timeout_secs = CONFIG_DEFAULT_HUNG_TASK_TIMEOUT; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 46 | |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 47 | /* |
| 48 | * Zero (default value) means use sysctl_hung_task_timeout_secs: |
| 49 | */ |
Tom Rix | 882c5b2 | 2023-03-12 12:46:45 -0400 | [diff] [blame] | 50 | static unsigned long __read_mostly sysctl_hung_task_check_interval_secs; |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 51 | |
Tom Rix | 882c5b2 | 2023-03-12 12:46:45 -0400 | [diff] [blame] | 52 | static int __read_mostly sysctl_hung_task_warnings = 10; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 53 | |
| 54 | static int __read_mostly did_panic; |
Tetsuo Handa | 780cbcf | 2017-05-08 15:55:11 -0700 | [diff] [blame] | 55 | static bool hung_task_show_lock; |
Tetsuo Handa | 401c636 | 2018-06-07 17:10:34 -0700 | [diff] [blame] | 56 | static bool hung_task_call_panic; |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 57 | static bool hung_task_show_all_bt; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 58 | |
| 59 | static struct task_struct *watchdog_task; |
| 60 | |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 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 | */ |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 66 | static unsigned int __read_mostly sysctl_hung_task_all_cpu_backtrace; |
| 67 | #else |
| 68 | #define sysctl_hung_task_all_cpu_backtrace 0 |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 69 | #endif /* CONFIG_SMP */ |
| 70 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 71 | /* |
| 72 | * Should we panic (and reboot, if panic_timeout= is set) when a |
| 73 | * hung task is detected: |
| 74 | */ |
Tom Rix | 882c5b2 | 2023-03-12 12:46:45 -0400 | [diff] [blame] | 75 | static unsigned int __read_mostly sysctl_hung_task_panic = |
| 76 | IS_ENABLED(CONFIG_BOOTPARAM_HUNG_TASK_PANIC); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 77 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 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 | |
Mandeep Singh Baines | 17406b8 | 2009-02-06 15:37:47 -0800 | [diff] [blame] | 90 | static void check_hung_task(struct task_struct *t, unsigned long timeout) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 91 | { |
| 92 | unsigned long switch_count = t->nvcsw + t->nivcsw; |
| 93 | |
Frederic Weisbecker | cf2592f | 2009-02-10 16:52:37 +0100 | [diff] [blame] | 94 | /* |
| 95 | * Ensure the task is not frozen. |
Mandeep Singh Baines | f9fab10 | 2012-01-03 14:41:13 -0800 | [diff] [blame] | 96 | * Also, skip vfork and any other user process that freezer should skip. |
Frederic Weisbecker | cf2592f | 2009-02-10 16:52:37 +0100 | [diff] [blame] | 97 | */ |
Peter Zijlstra | fdf756f | 2022-09-30 16:39:46 +0200 | [diff] [blame] | 98 | if (unlikely(READ_ONCE(t->__state) & TASK_FROZEN)) |
Peter Zijlstra | f5d39b0 | 2022-08-22 13:18:22 +0200 | [diff] [blame] | 99 | return; |
Mandeep Singh Baines | f9fab10 | 2012-01-03 14:41:13 -0800 | [diff] [blame] | 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)) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 107 | return; |
| 108 | |
Mandeep Singh Baines | 17406b8 | 2009-02-06 15:37:47 -0800 | [diff] [blame] | 109 | if (switch_count != t->last_switch_count) { |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 110 | t->last_switch_count = switch_count; |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 111 | t->last_switch_time = jiffies; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 112 | return; |
| 113 | } |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 114 | if (time_is_after_jiffies(t->last_switch_time + timeout * HZ)) |
| 115 | return; |
Oleg Nesterov | 6a716c9 | 2013-10-19 18:18:28 +0200 | [diff] [blame] | 116 | |
| 117 | trace_sched_process_hang(t); |
| 118 | |
Liu, Chuansheng | 168e06f | 2019-01-03 15:26:27 -0800 | [diff] [blame] | 119 | if (sysctl_hung_task_panic) { |
| 120 | console_verbose(); |
| 121 | hung_task_show_lock = true; |
| 122 | hung_task_call_panic = true; |
| 123 | } |
Aaron Tomlin | 270750db | 2014-01-20 17:34:13 +0000 | [diff] [blame] | 124 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 125 | /* |
| 126 | * Ok, the task did not get scheduled for more than 2 minutes, |
| 127 | * complain: |
| 128 | */ |
John Siddle | 48a6d64 | 2016-10-11 13:55:56 -0700 | [diff] [blame] | 129 | if (sysctl_hung_task_warnings) { |
Tetsuo Handa | 4ca5ede | 2016-12-12 16:45:35 -0800 | [diff] [blame] | 130 | if (sysctl_hung_task_warnings > 0) |
| 131 | sysctl_hung_task_warnings--; |
John Siddle | 48a6d64 | 2016-10-11 13:55:56 -0700 | [diff] [blame] | 132 | pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n", |
Tetsuo Handa | b014beb | 2019-03-07 16:26:50 -0800 | [diff] [blame] | 133 | t->comm, t->pid, (jiffies - t->last_switch_time) / HZ); |
John Siddle | 48a6d64 | 2016-10-11 13:55:56 -0700 | [diff] [blame] | 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); |
Tetsuo Handa | 780cbcf | 2017-05-08 15:55:11 -0700 | [diff] [blame] | 141 | hung_task_show_lock = true; |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 142 | |
| 143 | if (sysctl_hung_task_all_cpu_backtrace) |
| 144 | hung_task_show_all_bt = true; |
fuyuanli | b1f712b | 2023-02-01 21:54:33 +0800 | [diff] [blame] | 145 | if (!sysctl_hung_task_warnings) |
| 146 | pr_info("Future hung task reports are suppressed, see sysctl kernel.hung_task_warnings\n"); |
John Siddle | 48a6d64 | 2016-10-11 13:55:56 -0700 | [diff] [blame] | 147 | } |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 148 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 149 | touch_nmi_watchdog(); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 150 | } |
| 151 | |
| 152 | /* |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 153 | * To avoid extending the RCU grace period for an unbounded amount of time, |
| 154 | * periodically exit the critical section and enter a new one. |
| 155 | * |
| 156 | * For preemptible RCU it is sufficient to call rcu_read_unlock in order |
John Kacur | 6a103b0 | 2010-08-05 17:10:54 +0200 | [diff] [blame] | 157 | * to exit the grace period. For classic RCU, a reschedule is required. |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 158 | */ |
Oleg Nesterov | 6027ce4 | 2012-03-05 14:59:14 -0800 | [diff] [blame] | 159 | static bool rcu_lock_break(struct task_struct *g, struct task_struct *t) |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 160 | { |
Oleg Nesterov | 6027ce4 | 2012-03-05 14:59:14 -0800 | [diff] [blame] | 161 | bool can_cont; |
| 162 | |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 163 | get_task_struct(g); |
| 164 | get_task_struct(t); |
| 165 | rcu_read_unlock(); |
| 166 | cond_resched(); |
| 167 | rcu_read_lock(); |
Oleg Nesterov | 6027ce4 | 2012-03-05 14:59:14 -0800 | [diff] [blame] | 168 | can_cont = pid_alive(g) && pid_alive(t); |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 169 | put_task_struct(t); |
| 170 | put_task_struct(g); |
Oleg Nesterov | 6027ce4 | 2012-03-05 14:59:14 -0800 | [diff] [blame] | 171 | |
| 172 | return can_cont; |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 173 | } |
| 174 | |
| 175 | /* |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 176 | * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for |
| 177 | * a really long time (120 seconds). If that happens, print out |
| 178 | * a warning. |
| 179 | */ |
Mandeep Singh Baines | 603a148 | 2009-01-17 10:31:48 -0800 | [diff] [blame] | 180 | static void check_hung_uninterruptible_tasks(unsigned long timeout) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 181 | { |
| 182 | int max_count = sysctl_hung_task_check_count; |
Tetsuo Handa | 304ae42 | 2019-01-03 15:26:31 -0800 | [diff] [blame] | 183 | unsigned long last_break = jiffies; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 184 | struct task_struct *g, *t; |
| 185 | |
| 186 | /* |
| 187 | * If the system crashed already then all bets are off, |
| 188 | * do not report extra hung tasks: |
| 189 | */ |
| 190 | if (test_taint(TAINT_DIE) || did_panic) |
| 191 | return; |
| 192 | |
Tetsuo Handa | 780cbcf | 2017-05-08 15:55:11 -0700 | [diff] [blame] | 193 | hung_task_show_lock = false; |
Mandeep Singh Baines | 94be52d | 2009-02-05 09:56:08 -0800 | [diff] [blame] | 194 | rcu_read_lock(); |
Aaron Tomlin | 972fae69 | 2015-04-15 16:16:47 -0700 | [diff] [blame] | 195 | for_each_process_thread(g, t) { |
Peter Zijlstra | 5aec788 | 2022-09-27 21:02:34 +0200 | [diff] [blame] | 196 | unsigned int state; |
| 197 | |
Anton Blanchard | e5af022 | 2009-11-27 13:28:20 +1100 | [diff] [blame] | 198 | if (!max_count--) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 199 | goto unlock; |
Tetsuo Handa | 304ae42 | 2019-01-03 15:26:31 -0800 | [diff] [blame] | 200 | if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) { |
Oleg Nesterov | 6027ce4 | 2012-03-05 14:59:14 -0800 | [diff] [blame] | 201 | if (!rcu_lock_break(g, t)) |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 202 | goto unlock; |
Tetsuo Handa | 304ae42 | 2019-01-03 15:26:31 -0800 | [diff] [blame] | 203 | last_break = jiffies; |
Mandeep Singh Baines | ce9dbe2 | 2009-02-04 20:35:48 -0800 | [diff] [blame] | 204 | } |
Peter Zijlstra | fdf756f | 2022-09-30 16:39:46 +0200 | [diff] [blame] | 205 | /* |
| 206 | * skip the TASK_KILLABLE tasks -- these can be killed |
| 207 | * skip the TASK_IDLE tasks -- those are genuinely idle |
| 208 | */ |
Peter Zijlstra | 5aec788 | 2022-09-27 21:02:34 +0200 | [diff] [blame] | 209 | state = READ_ONCE(t->__state); |
| 210 | if ((state & TASK_UNINTERRUPTIBLE) && |
Peter Zijlstra | fdf756f | 2022-09-30 16:39:46 +0200 | [diff] [blame] | 211 | !(state & TASK_WAKEKILL) && |
| 212 | !(state & TASK_NOLOAD)) |
Mandeep Singh Baines | 17406b8 | 2009-02-06 15:37:47 -0800 | [diff] [blame] | 213 | check_hung_task(t, timeout); |
Aaron Tomlin | 972fae69 | 2015-04-15 16:16:47 -0700 | [diff] [blame] | 214 | } |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 215 | unlock: |
Mandeep Singh Baines | 94be52d | 2009-02-05 09:56:08 -0800 | [diff] [blame] | 216 | rcu_read_unlock(); |
Petr Mladek | 07a22b6 | 2022-06-23 16:51:57 +0200 | [diff] [blame] | 217 | if (hung_task_show_lock) |
Tetsuo Handa | 780cbcf | 2017-05-08 15:55:11 -0700 | [diff] [blame] | 218 | debug_show_all_locks(); |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 219 | |
| 220 | if (hung_task_show_all_bt) { |
| 221 | hung_task_show_all_bt = false; |
Tetsuo Handa | 401c636 | 2018-06-07 17:10:34 -0700 | [diff] [blame] | 222 | trigger_all_cpu_backtrace(); |
Tetsuo Handa | 401c636 | 2018-06-07 17:10:34 -0700 | [diff] [blame] | 223 | } |
Guilherme G. Piccoli | 0ec9dc9 | 2020-06-07 21:40:45 -0700 | [diff] [blame] | 224 | |
| 225 | if (hung_task_call_panic) |
| 226 | panic("hung_task: blocked tasks"); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 227 | } |
| 228 | |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 229 | static long hung_timeout_jiffies(unsigned long last_checked, |
| 230 | unsigned long timeout) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 231 | { |
| 232 | /* timeout of 0 will disable the watchdog */ |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 233 | return timeout ? last_checked - jiffies + timeout * HZ : |
| 234 | MAX_SCHEDULE_TIMEOUT; |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 235 | } |
| 236 | |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 237 | #ifdef CONFIG_SYSCTL |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 238 | /* |
| 239 | * Process updating of timeout sysctl |
| 240 | */ |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 241 | static int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, |
Ben Dooks | 591c32b | 2022-07-14 08:47:44 +0100 | [diff] [blame] | 242 | void *buffer, |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 243 | size_t *lenp, loff_t *ppos) |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 244 | { |
| 245 | int ret; |
| 246 | |
Alexey Dobriyan | 8d65af7 | 2009-09-23 15:57:19 -0700 | [diff] [blame] | 247 | ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 248 | |
| 249 | if (ret || !write) |
| 250 | goto out; |
| 251 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 252 | wake_up_process(watchdog_task); |
| 253 | |
| 254 | out: |
| 255 | return ret; |
| 256 | } |
| 257 | |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 258 | /* |
| 259 | * This is needed for proc_doulongvec_minmax of sysctl_hung_task_timeout_secs |
| 260 | * and hung_task_check_interval_secs |
| 261 | */ |
| 262 | static const unsigned long hung_task_timeout_max = (LONG_MAX / HZ); |
| 263 | static struct ctl_table hung_task_sysctls[] = { |
| 264 | #ifdef CONFIG_SMP |
| 265 | { |
| 266 | .procname = "hung_task_all_cpu_backtrace", |
| 267 | .data = &sysctl_hung_task_all_cpu_backtrace, |
| 268 | .maxlen = sizeof(int), |
| 269 | .mode = 0644, |
| 270 | .proc_handler = proc_dointvec_minmax, |
| 271 | .extra1 = SYSCTL_ZERO, |
| 272 | .extra2 = SYSCTL_ONE, |
| 273 | }, |
| 274 | #endif /* CONFIG_SMP */ |
| 275 | { |
| 276 | .procname = "hung_task_panic", |
| 277 | .data = &sysctl_hung_task_panic, |
| 278 | .maxlen = sizeof(int), |
| 279 | .mode = 0644, |
| 280 | .proc_handler = proc_dointvec_minmax, |
| 281 | .extra1 = SYSCTL_ZERO, |
| 282 | .extra2 = SYSCTL_ONE, |
| 283 | }, |
| 284 | { |
| 285 | .procname = "hung_task_check_count", |
| 286 | .data = &sysctl_hung_task_check_count, |
| 287 | .maxlen = sizeof(int), |
| 288 | .mode = 0644, |
| 289 | .proc_handler = proc_dointvec_minmax, |
| 290 | .extra1 = SYSCTL_ZERO, |
| 291 | }, |
| 292 | { |
| 293 | .procname = "hung_task_timeout_secs", |
| 294 | .data = &sysctl_hung_task_timeout_secs, |
| 295 | .maxlen = sizeof(unsigned long), |
| 296 | .mode = 0644, |
| 297 | .proc_handler = proc_dohung_task_timeout_secs, |
| 298 | .extra2 = (void *)&hung_task_timeout_max, |
| 299 | }, |
| 300 | { |
| 301 | .procname = "hung_task_check_interval_secs", |
| 302 | .data = &sysctl_hung_task_check_interval_secs, |
| 303 | .maxlen = sizeof(unsigned long), |
| 304 | .mode = 0644, |
| 305 | .proc_handler = proc_dohung_task_timeout_secs, |
| 306 | .extra2 = (void *)&hung_task_timeout_max, |
| 307 | }, |
| 308 | { |
| 309 | .procname = "hung_task_warnings", |
| 310 | .data = &sysctl_hung_task_warnings, |
| 311 | .maxlen = sizeof(int), |
| 312 | .mode = 0644, |
| 313 | .proc_handler = proc_dointvec_minmax, |
| 314 | .extra1 = SYSCTL_NEG_ONE, |
| 315 | }, |
| 316 | {} |
| 317 | }; |
| 318 | |
| 319 | static void __init hung_task_sysctl_init(void) |
| 320 | { |
| 321 | register_sysctl_init("kernel", hung_task_sysctls); |
| 322 | } |
| 323 | #else |
| 324 | #define hung_task_sysctl_init() do { } while (0) |
| 325 | #endif /* CONFIG_SYSCTL */ |
| 326 | |
| 327 | |
Marcelo Tosatti | 8b41452 | 2013-10-11 21:39:26 -0300 | [diff] [blame] | 328 | static atomic_t reset_hung_task = ATOMIC_INIT(0); |
| 329 | |
| 330 | void reset_hung_task_detector(void) |
| 331 | { |
| 332 | atomic_set(&reset_hung_task, 1); |
| 333 | } |
| 334 | EXPORT_SYMBOL_GPL(reset_hung_task_detector); |
| 335 | |
Vitaly Kuznetsov | a1c6ca3 | 2018-10-17 13:23:55 +0200 | [diff] [blame] | 336 | static bool hung_detector_suspended; |
| 337 | |
| 338 | static int hungtask_pm_notify(struct notifier_block *self, |
| 339 | unsigned long action, void *hcpu) |
| 340 | { |
| 341 | switch (action) { |
| 342 | case PM_SUSPEND_PREPARE: |
| 343 | case PM_HIBERNATION_PREPARE: |
| 344 | case PM_RESTORE_PREPARE: |
| 345 | hung_detector_suspended = true; |
| 346 | break; |
| 347 | case PM_POST_SUSPEND: |
| 348 | case PM_POST_HIBERNATION: |
| 349 | case PM_POST_RESTORE: |
| 350 | hung_detector_suspended = false; |
| 351 | break; |
| 352 | default: |
| 353 | break; |
| 354 | } |
| 355 | return NOTIFY_OK; |
| 356 | } |
| 357 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 358 | /* |
| 359 | * kthread which checks for tasks stuck in D state |
| 360 | */ |
| 361 | static int watchdog(void *dummy) |
| 362 | { |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 363 | unsigned long hung_last_checked = jiffies; |
| 364 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 365 | set_user_nice(current, 0); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 366 | |
| 367 | for ( ; ; ) { |
Mandeep Singh Baines | 17406b8 | 2009-02-06 15:37:47 -0800 | [diff] [blame] | 368 | unsigned long timeout = sysctl_hung_task_timeout_secs; |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 369 | unsigned long interval = sysctl_hung_task_check_interval_secs; |
| 370 | long t; |
Mandeep Singh Baines | 603a148 | 2009-01-17 10:31:48 -0800 | [diff] [blame] | 371 | |
Dmitry Vyukov | a2e5144 | 2018-08-21 21:55:52 -0700 | [diff] [blame] | 372 | if (interval == 0) |
| 373 | interval = timeout; |
| 374 | interval = min_t(unsigned long, interval, timeout); |
| 375 | t = hung_timeout_jiffies(hung_last_checked, interval); |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 376 | if (t <= 0) { |
Vitaly Kuznetsov | a1c6ca3 | 2018-10-17 13:23:55 +0200 | [diff] [blame] | 377 | if (!atomic_xchg(&reset_hung_task, 0) && |
| 378 | !hung_detector_suspended) |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 379 | check_hung_uninterruptible_tasks(timeout); |
| 380 | hung_last_checked = jiffies; |
Marcelo Tosatti | 8b41452 | 2013-10-11 21:39:26 -0300 | [diff] [blame] | 381 | continue; |
Tetsuo Handa | b4aa14a | 2016-03-22 14:24:39 -0700 | [diff] [blame] | 382 | } |
| 383 | schedule_timeout_interruptible(t); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 384 | } |
| 385 | |
| 386 | return 0; |
| 387 | } |
| 388 | |
| 389 | static int __init hung_task_init(void) |
| 390 | { |
| 391 | atomic_notifier_chain_register(&panic_notifier_list, &panic_block); |
Vitaly Kuznetsov | a1c6ca3 | 2018-10-17 13:23:55 +0200 | [diff] [blame] | 392 | |
| 393 | /* Disable hung task detector on suspend */ |
| 394 | pm_notifier(hungtask_pm_notify, 0); |
| 395 | |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 396 | watchdog_task = kthread_run(watchdog, NULL, "khungtaskd"); |
Xiaoming Ni | bbe7a10 | 2022-01-21 22:11:00 -0800 | [diff] [blame] | 397 | hung_task_sysctl_init(); |
Mandeep Singh Baines | e162b39 | 2009-01-15 11:08:40 -0800 | [diff] [blame] | 398 | |
| 399 | return 0; |
| 400 | } |
Paul Gortmaker | c96d666 | 2014-04-03 14:48:35 -0700 | [diff] [blame] | 401 | subsys_initcall(hung_task_init); |