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