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