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/module.h> 17#include <linux/sysctl.h> 18 19/* 20 * The number of tasks checked: 21 */ 22unsigned 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 */ 36unsigned long __read_mostly sysctl_hung_task_timeout_secs = 120; 37 38unsigned long __read_mostly sysctl_hung_task_warnings = 10; 39 40static int __read_mostly did_panic; 41 42static 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 */ 48unsigned int __read_mostly sysctl_hung_task_panic = 49 CONFIG_BOOTPARAM_HUNG_TASK_PANIC_VALUE; 50 51static 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 59static int 60hung_task_panic(struct notifier_block *this, unsigned long event, void *ptr) 61{ 62 did_panic = 1; 63 64 return NOTIFY_DONE; 65} 66 67static struct notifier_block panic_block = { 68 .notifier_call = hung_task_panic, 69}; 70 71static 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, when a freshly created task is scheduled once, changes 78 * its state to TASK_UNINTERRUPTIBLE without having ever been 79 * switched out once, it musn't be checked. 80 */ 81 if (unlikely(t->flags & PF_FROZEN || !switch_count)) 82 return; 83 84 if (switch_count != t->last_switch_count) { 85 t->last_switch_count = switch_count; 86 return; 87 } 88 if (!sysctl_hung_task_warnings) 89 return; 90 sysctl_hung_task_warnings--; 91 92 /* 93 * Ok, the task did not get scheduled for more than 2 minutes, 94 * complain: 95 */ 96 printk(KERN_ERR "INFO: task %s:%d blocked for more than " 97 "%ld seconds.\n", t->comm, t->pid, timeout); 98 printk(KERN_ERR "\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\"" 99 " disables this message.\n"); 100 sched_show_task(t); 101 __debug_show_held_locks(t); 102 103 touch_nmi_watchdog(); 104 105 if (sysctl_hung_task_panic) 106 panic("hung_task: blocked tasks"); 107} 108 109/* 110 * To avoid extending the RCU grace period for an unbounded amount of time, 111 * periodically exit the critical section and enter a new one. 112 * 113 * For preemptible RCU it is sufficient to call rcu_read_unlock in order 114 * exit the grace period. For classic RCU, a reschedule is required. 115 */ 116static void rcu_lock_break(struct task_struct *g, struct task_struct *t) 117{ 118 get_task_struct(g); 119 get_task_struct(t); 120 rcu_read_unlock(); 121 cond_resched(); 122 rcu_read_lock(); 123 put_task_struct(t); 124 put_task_struct(g); 125} 126 127/* 128 * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for 129 * a really long time (120 seconds). If that happens, print out 130 * a warning. 131 */ 132static void check_hung_uninterruptible_tasks(unsigned long timeout) 133{ 134 int max_count = sysctl_hung_task_check_count; 135 int batch_count = HUNG_TASK_BATCHING; 136 struct task_struct *g, *t; 137 138 /* 139 * If the system crashed already then all bets are off, 140 * do not report extra hung tasks: 141 */ 142 if (test_taint(TAINT_DIE) || did_panic) 143 return; 144 145 rcu_read_lock(); 146 do_each_thread(g, t) { 147 if (!max_count--) 148 goto unlock; 149 if (!--batch_count) { 150 batch_count = HUNG_TASK_BATCHING; 151 rcu_lock_break(g, t); 152 /* Exit if t or g was unhashed during refresh. */ 153 if (t->state == TASK_DEAD || g->state == TASK_DEAD) 154 goto unlock; 155 } 156 /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */ 157 if (t->state == TASK_UNINTERRUPTIBLE) 158 check_hung_task(t, timeout); 159 } while_each_thread(g, t); 160 unlock: 161 rcu_read_unlock(); 162} 163 164static unsigned long timeout_jiffies(unsigned long timeout) 165{ 166 /* timeout of 0 will disable the watchdog */ 167 return timeout ? timeout * HZ : MAX_SCHEDULE_TIMEOUT; 168} 169 170/* 171 * Process updating of timeout sysctl 172 */ 173int proc_dohung_task_timeout_secs(struct ctl_table *table, int write, 174 void __user *buffer, 175 size_t *lenp, loff_t *ppos) 176{ 177 int ret; 178 179 ret = proc_doulongvec_minmax(table, write, buffer, lenp, ppos); 180 181 if (ret || !write) 182 goto out; 183 184 wake_up_process(watchdog_task); 185 186 out: 187 return ret; 188} 189 190/* 191 * kthread which checks for tasks stuck in D state 192 */ 193static int watchdog(void *dummy) 194{ 195 set_user_nice(current, 0); 196 197 for ( ; ; ) { 198 unsigned long timeout = sysctl_hung_task_timeout_secs; 199 200 while (schedule_timeout_interruptible(timeout_jiffies(timeout))) 201 timeout = sysctl_hung_task_timeout_secs; 202 203 check_hung_uninterruptible_tasks(timeout); 204 } 205 206 return 0; 207} 208 209static int __init hung_task_init(void) 210{ 211 atomic_notifier_chain_register(&panic_notifier_list, &panic_block); 212 watchdog_task = kthread_run(watchdog, NULL, "khungtaskd"); 213 214 return 0; 215} 216 217module_init(hung_task_init); 218