Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0-only
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>
17 : : #include <linux/export.h>
18 : : #include <linux/sysctl.h>
19 : : #include <linux/suspend.h>
20 : : #include <linux/utsname.h>
21 : : #include <linux/sched/signal.h>
22 : : #include <linux/sched/debug.h>
23 : : #include <linux/sched/sysctl.h>
24 : :
25 : : #include <trace/events/sched.h>
26 : :
27 : : /*
28 : : * The number of tasks checked:
29 : : */
30 : : int __read_mostly sysctl_hung_task_check_count = PID_MAX_LIMIT;
31 : :
32 : : /*
33 : : * Limit number of tasks checked in a batch.
34 : : *
35 : : * This value controls the preemptibility of khungtaskd since preemption
36 : : * is disabled during the critical section. It also controls the size of
37 : : * the RCU grace period. So it needs to be upper-bound.
38 : : */
39 : : #define HUNG_TASK_LOCK_BREAK (HZ / 10)
40 : :
41 : : /*
42 : : * Zero means infinite timeout - no checking done:
43 : : */
44 : : unsigned long __read_mostly sysctl_hung_task_timeout_secs = CONFIG_DEFAULT_HUNG_TASK_TIMEOUT;
45 : :
46 : : /*
47 : : * Zero (default value) means use sysctl_hung_task_timeout_secs:
48 : : */
49 : : unsigned long __read_mostly sysctl_hung_task_check_interval_secs;
50 : :
51 : : int __read_mostly sysctl_hung_task_warnings = 10;
52 : :
53 : : static int __read_mostly did_panic;
54 : : static bool hung_task_show_lock;
55 : : static bool hung_task_call_panic;
56 : :
57 : : static struct task_struct *watchdog_task;
58 : :
59 : : /*
60 : : * Should we panic (and reboot, if panic_timeout= is set) when a
61 : : * hung task is detected:
62 : : */
63 : : unsigned int __read_mostly sysctl_hung_task_panic =
64 : : CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE;
65 : :
66 : 0 : static int __init hung_task_panic_setup(char *str)
67 : : {
68 : 0 : int rc = kstrtouint(str, 0, &sysctl_hung_task_panic);
69 : :
70 [ # # ]: 0 : if (rc)
71 : 0 : return rc;
72 : : return 1;
73 : : }
74 : : __setup("hung_task_panic=", hung_task_panic_setup);
75 : :
76 : : static int
77 : 0 : hung_task_panic(struct notifier_block *this, unsigned long event, void *ptr)
78 : : {
79 : 0 : did_panic = 1;
80 : :
81 : 0 : return NOTIFY_DONE;
82 : : }
83 : :
84 : : static struct notifier_block panic_block = {
85 : : .notifier_call = hung_task_panic,
86 : : };
87 : :
88 : 0 : static void check_hung_task(struct task_struct *t, unsigned long timeout)
89 : : {
90 : 0 : unsigned long switch_count = t->nvcsw + t->nivcsw;
91 : :
92 : : /*
93 : : * Ensure the task is not frozen.
94 : : * Also, skip vfork and any other user process that freezer should skip.
95 : : */
96 [ # # ]: 0 : if (unlikely(t->flags & (PF_FROZEN | PF_FREEZER_SKIP)))
97 : : return;
98 : :
99 : : /*
100 : : * When a freshly created task is scheduled once, changes its state to
101 : : * TASK_UNINTERRUPTIBLE without having ever been switched out once, it
102 : : * musn't be checked.
103 : : */
104 [ # # ]: 0 : if (unlikely(!switch_count))
105 : : return;
106 : :
107 [ # # ]: 0 : if (switch_count != t->last_switch_count) {
108 : 0 : t->last_switch_count = switch_count;
109 : 0 : t->last_switch_time = jiffies;
110 : 0 : return;
111 : : }
112 [ # # ]: 0 : if (time_is_after_jiffies(t->last_switch_time + timeout * HZ))
113 : : return;
114 : :
115 : 0 : trace_sched_process_hang(t);
116 : :
117 [ # # ]: 0 : if (sysctl_hung_task_panic) {
118 : : console_verbose();
119 : 0 : hung_task_show_lock = true;
120 : 0 : hung_task_call_panic = true;
121 : : }
122 : :
123 : : /*
124 : : * Ok, the task did not get scheduled for more than 2 minutes,
125 : : * complain:
126 : : */
127 [ # # ]: 0 : if (sysctl_hung_task_warnings) {
128 [ # # ]: 0 : if (sysctl_hung_task_warnings > 0)
129 : 0 : sysctl_hung_task_warnings--;
130 : 0 : pr_err("INFO: task %s:%d blocked for more than %ld seconds.\n",
131 : : t->comm, t->pid, (jiffies - t->last_switch_time) / HZ);
132 : 0 : pr_err(" %s %s %.*s\n",
133 : : print_tainted(), init_utsname()->release,
134 : : (int)strcspn(init_utsname()->version, " "),
135 : : init_utsname()->version);
136 : 0 : pr_err("\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
137 : : " disables this message.\n");
138 : 0 : sched_show_task(t);
139 : 0 : hung_task_show_lock = true;
140 : : }
141 : :
142 : : touch_nmi_watchdog();
143 : : }
144 : :
145 : : /*
146 : : * To avoid extending the RCU grace period for an unbounded amount of time,
147 : : * periodically exit the critical section and enter a new one.
148 : : *
149 : : * For preemptible RCU it is sufficient to call rcu_read_unlock in order
150 : : * to exit the grace period. For classic RCU, a reschedule is required.
151 : : */
152 : 0 : static bool rcu_lock_break(struct task_struct *g, struct task_struct *t)
153 : : {
154 : : bool can_cont;
155 : :
156 : : get_task_struct(g);
157 : : get_task_struct(t);
158 : : rcu_read_unlock();
159 : 0 : cond_resched();
160 : : rcu_read_lock();
161 [ # # # # ]: 0 : can_cont = pid_alive(g) && pid_alive(t);
162 : 0 : put_task_struct(t);
163 : 0 : put_task_struct(g);
164 : :
165 : 0 : return can_cont;
166 : : }
167 : :
168 : : /*
169 : : * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
170 : : * a really long time (120 seconds). If that happens, print out
171 : : * a warning.
172 : : */
173 : 0 : static void check_hung_uninterruptible_tasks(unsigned long timeout)
174 : : {
175 : 0 : int max_count = sysctl_hung_task_check_count;
176 : 0 : unsigned long last_break = jiffies;
177 : : struct task_struct *g, *t;
178 : :
179 : : /*
180 : : * If the system crashed already then all bets are off,
181 : : * do not report extra hung tasks:
182 : : */
183 [ # # # # ]: 0 : if (test_taint(TAINT_DIE) || did_panic)
184 : 0 : return;
185 : :
186 : 0 : hung_task_show_lock = false;
187 : : rcu_read_lock();
188 [ # # # # ]: 0 : for_each_process_thread(g, t) {
189 [ # # ]: 0 : if (!max_count--)
190 : : goto unlock;
191 [ # # ]: 0 : if (time_after(jiffies, last_break + HUNG_TASK_LOCK_BREAK)) {
192 [ # # ]: 0 : if (!rcu_lock_break(g, t))
193 : : goto unlock;
194 : 0 : last_break = jiffies;
195 : : }
196 : : /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */
197 [ # # ]: 0 : if (t->state == TASK_UNINTERRUPTIBLE)
198 : 0 : check_hung_task(t, timeout);
199 : : }
200 : : unlock:
201 : : rcu_read_unlock();
202 : : if (hung_task_show_lock)
203 : : debug_show_all_locks();
204 [ # # ]: 0 : if (hung_task_call_panic) {
205 : : trigger_all_cpu_backtrace();
206 : 0 : panic("hung_task: blocked tasks");
207 : : }
208 : : }
209 : :
210 : : static long hung_timeout_jiffies(unsigned long last_checked,
211 : : unsigned long timeout)
212 : : {
213 : : /* timeout of 0 will disable the watchdog */
214 [ + - ]: 207 : return timeout ? last_checked - jiffies + timeout * HZ :
215 : : MAX_SCHEDULE_TIMEOUT;
216 : : }
217 : :
218 : : /*
219 : : * Process updating of timeout sysctl
220 : : */
221 : 0 : int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
222 : : void __user *buffer,
223 : : size_t *lenp, loff_t *ppos)
224 : : {
225 : : int ret;
226 : :
227 : 0 : ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
228 : :
229 [ # # ]: 0 : if (ret || !write)
230 : : goto out;
231 : :
232 : 0 : wake_up_process(watchdog_task);
233 : :
234 : : out:
235 : 0 : return ret;
236 : : }
237 : :
238 : : static atomic_t reset_hung_task = ATOMIC_INIT(0);
239 : :
240 : 0 : void reset_hung_task_detector(void)
241 : : {
242 : : atomic_set(&reset_hung_task, 1);
243 : 0 : }
244 : : EXPORT_SYMBOL_GPL(reset_hung_task_detector);
245 : :
246 : : static bool hung_detector_suspended;
247 : :
248 : : static int hungtask_pm_notify(struct notifier_block *self,
249 : : unsigned long action, void *hcpu)
250 : : {
251 : : switch (action) {
252 : : case PM_SUSPEND_PREPARE:
253 : : case PM_HIBERNATION_PREPARE:
254 : : case PM_RESTORE_PREPARE:
255 : : hung_detector_suspended = true;
256 : : break;
257 : : case PM_POST_SUSPEND:
258 : : case PM_POST_HIBERNATION:
259 : : case PM_POST_RESTORE:
260 : : hung_detector_suspended = false;
261 : : break;
262 : : default:
263 : : break;
264 : : }
265 : : return NOTIFY_OK;
266 : : }
267 : :
268 : : /*
269 : : * kthread which checks for tasks stuck in D state
270 : : */
271 : 207 : static int watchdog(void *dummy)
272 : : {
273 : 207 : unsigned long hung_last_checked = jiffies;
274 : :
275 : 207 : set_user_nice(current, 0);
276 : :
277 : : for ( ; ; ) {
278 : 207 : unsigned long timeout = sysctl_hung_task_timeout_secs;
279 : 207 : unsigned long interval = sysctl_hung_task_check_interval_secs;
280 : : long t;
281 : :
282 [ + - ]: 207 : if (interval == 0)
283 : : interval = timeout;
284 : 207 : interval = min_t(unsigned long, interval, timeout);
285 : : t = hung_timeout_jiffies(hung_last_checked, interval);
286 [ - + ]: 207 : if (t <= 0) {
287 [ # # # # ]: 0 : if (!atomic_xchg(&reset_hung_task, 0) &&
288 : 0 : !hung_detector_suspended)
289 : 0 : check_hung_uninterruptible_tasks(timeout);
290 : 0 : hung_last_checked = jiffies;
291 : 0 : continue;
292 : : }
293 : 207 : schedule_timeout_interruptible(t);
294 : : }
295 : :
296 : : return 0;
297 : : }
298 : :
299 : 207 : static int __init hung_task_init(void)
300 : : {
301 : 207 : atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
302 : :
303 : : /* Disable hung task detector on suspend */
304 : : pm_notifier(hungtask_pm_notify, 0);
305 : :
306 [ + - ]: 414 : watchdog_task = kthread_run(watchdog, NULL, "khungtaskd");
307 : :
308 : 207 : return 0;
309 : : }
310 : : subsys_initcall(hung_task_init);
|
