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