4 * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
6 * this code detects soft lockups: incidents in where on a CPU
7 * the kernel does not reschedule for 10 seconds or more.
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/notifier.h>
18 #include <linux/module.h>
19 #include <linux/sysctl.h>
21 #include <asm/irq_regs.h>
23 static DEFINE_SPINLOCK(print_lock
);
25 static DEFINE_PER_CPU(unsigned long, touch_timestamp
);
26 static DEFINE_PER_CPU(unsigned long, print_timestamp
);
27 static DEFINE_PER_CPU(struct task_struct
*, watchdog_task
);
29 static int __read_mostly did_panic
;
30 int __read_mostly softlockup_thresh
= 60;
33 * Should we panic (and reboot, if panic_timeout= is set) when a
36 unsigned int __read_mostly softlockup_panic
=
37 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE
;
39 static int __init
softlockup_panic_setup(char *str
)
41 softlockup_panic
= simple_strtoul(str
, NULL
, 0);
45 __setup("softlockup_panic=", softlockup_panic_setup
);
48 softlock_panic(struct notifier_block
*this, unsigned long event
, void *ptr
)
55 static struct notifier_block panic_block
= {
56 .notifier_call
= softlock_panic
,
60 * Returns seconds, approximately. We don't need nanosecond
61 * resolution, and we don't need to waste time with a big divide when
64 static unsigned long get_timestamp(int this_cpu
)
66 return cpu_clock(this_cpu
) >> 30LL; /* 2^30 ~= 10^9 */
69 static void __touch_softlockup_watchdog(void)
71 int this_cpu
= raw_smp_processor_id();
73 __raw_get_cpu_var(touch_timestamp
) = get_timestamp(this_cpu
);
76 void touch_softlockup_watchdog(void)
78 __raw_get_cpu_var(touch_timestamp
) = 0;
80 EXPORT_SYMBOL(touch_softlockup_watchdog
);
82 void touch_all_softlockup_watchdogs(void)
86 /* Cause each CPU to re-update its timestamp rather than complain */
87 for_each_online_cpu(cpu
)
88 per_cpu(touch_timestamp
, cpu
) = 0;
90 EXPORT_SYMBOL(touch_all_softlockup_watchdogs
);
92 int proc_dosoftlockup_thresh(struct ctl_table
*table
, int write
,
93 struct file
*filp
, void __user
*buffer
,
94 size_t *lenp
, loff_t
*ppos
)
96 touch_all_softlockup_watchdogs();
97 return proc_dointvec_minmax(table
, write
, filp
, buffer
, lenp
, ppos
);
101 * This callback runs from the timer interrupt, and checks
102 * whether the watchdog thread has hung or not:
104 void softlockup_tick(void)
106 int this_cpu
= smp_processor_id();
107 unsigned long touch_timestamp
= per_cpu(touch_timestamp
, this_cpu
);
108 unsigned long print_timestamp
;
109 struct pt_regs
*regs
= get_irq_regs();
112 /* Is detection switched off? */
113 if (!per_cpu(watchdog_task
, this_cpu
) || softlockup_thresh
<= 0) {
114 /* Be sure we don't false trigger if switched back on */
116 per_cpu(touch_timestamp
, this_cpu
) = 0;
120 if (touch_timestamp
== 0) {
121 __touch_softlockup_watchdog();
125 print_timestamp
= per_cpu(print_timestamp
, this_cpu
);
127 /* report at most once a second */
128 if (print_timestamp
== touch_timestamp
|| did_panic
)
131 /* do not print during early bootup: */
132 if (unlikely(system_state
!= SYSTEM_RUNNING
)) {
133 __touch_softlockup_watchdog();
137 now
= get_timestamp(this_cpu
);
140 * Wake up the high-prio watchdog task twice per
141 * threshold timespan.
143 if (now
> touch_timestamp
+ softlockup_thresh
/2)
144 wake_up_process(per_cpu(watchdog_task
, this_cpu
));
146 /* Warn about unreasonable delays: */
147 if (now
<= (touch_timestamp
+ softlockup_thresh
))
150 per_cpu(print_timestamp
, this_cpu
) = touch_timestamp
;
152 spin_lock(&print_lock
);
153 printk(KERN_ERR
"BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
154 this_cpu
, now
- touch_timestamp
,
155 current
->comm
, task_pid_nr(current
));
157 print_irqtrace_events(current
);
162 spin_unlock(&print_lock
);
164 if (softlockup_panic
)
165 panic("softlockup: hung tasks");
169 * Have a reasonable limit on the number of tasks checked:
171 unsigned long __read_mostly sysctl_hung_task_check_count
= 1024;
174 * Zero means infinite timeout - no checking done:
176 unsigned long __read_mostly sysctl_hung_task_timeout_secs
= 480;
178 unsigned long __read_mostly sysctl_hung_task_warnings
= 10;
181 * Only do the hung-tasks check on one CPU:
183 static int check_cpu __read_mostly
= -1;
185 static void check_hung_task(struct task_struct
*t
, unsigned long now
)
187 unsigned long switch_count
= t
->nvcsw
+ t
->nivcsw
;
189 if (t
->flags
& PF_FROZEN
)
192 if (switch_count
!= t
->last_switch_count
|| !t
->last_switch_timestamp
) {
193 t
->last_switch_count
= switch_count
;
194 t
->last_switch_timestamp
= now
;
197 if ((long)(now
- t
->last_switch_timestamp
) <
198 sysctl_hung_task_timeout_secs
)
200 if (!sysctl_hung_task_warnings
)
202 sysctl_hung_task_warnings
--;
205 * Ok, the task did not get scheduled for more than 2 minutes,
208 printk(KERN_ERR
"INFO: task %s:%d blocked for more than "
209 "%ld seconds.\n", t
->comm
, t
->pid
,
210 sysctl_hung_task_timeout_secs
);
211 printk(KERN_ERR
"\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
212 " disables this message.\n");
214 __debug_show_held_locks(t
);
216 t
->last_switch_timestamp
= now
;
217 touch_nmi_watchdog();
219 if (softlockup_panic
)
220 panic("softlockup: blocked tasks");
224 * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
225 * a really long time (120 seconds). If that happens, print out
228 static void check_hung_uninterruptible_tasks(int this_cpu
)
230 int max_count
= sysctl_hung_task_check_count
;
231 unsigned long now
= get_timestamp(this_cpu
);
232 struct task_struct
*g
, *t
;
235 * If the system crashed already then all bets are off,
236 * do not report extra hung tasks:
238 if (test_taint(TAINT_DIE
) || did_panic
)
241 read_lock(&tasklist_lock
);
242 do_each_thread(g
, t
) {
245 /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */
246 if (t
->state
== TASK_UNINTERRUPTIBLE
)
247 check_hung_task(t
, now
);
248 } while_each_thread(g
, t
);
250 read_unlock(&tasklist_lock
);
254 * The watchdog thread - runs every second and touches the timestamp.
256 static int watchdog(void *__bind_cpu
)
258 struct sched_param param
= { .sched_priority
= MAX_RT_PRIO
-1 };
259 int this_cpu
= (long)__bind_cpu
;
261 sched_setscheduler(current
, SCHED_FIFO
, ¶m
);
263 /* initialize timestamp */
264 __touch_softlockup_watchdog();
266 set_current_state(TASK_INTERRUPTIBLE
);
268 * Run briefly once per second to reset the softlockup timestamp.
269 * If this gets delayed for more than 60 seconds then the
270 * debug-printout triggers in softlockup_tick().
272 while (!kthread_should_stop()) {
273 __touch_softlockup_watchdog();
276 if (kthread_should_stop())
279 if (this_cpu
== check_cpu
) {
280 if (sysctl_hung_task_timeout_secs
)
281 check_hung_uninterruptible_tasks(this_cpu
);
284 set_current_state(TASK_INTERRUPTIBLE
);
286 __set_current_state(TASK_RUNNING
);
292 * Create/destroy watchdog threads as CPUs come and go:
295 cpu_callback(struct notifier_block
*nfb
, unsigned long action
, void *hcpu
)
297 int hotcpu
= (unsigned long)hcpu
;
298 struct task_struct
*p
;
302 case CPU_UP_PREPARE_FROZEN
:
303 BUG_ON(per_cpu(watchdog_task
, hotcpu
));
304 p
= kthread_create(watchdog
, hcpu
, "watchdog/%d", hotcpu
);
306 printk(KERN_ERR
"watchdog for %i failed\n", hotcpu
);
309 per_cpu(touch_timestamp
, hotcpu
) = 0;
310 per_cpu(watchdog_task
, hotcpu
) = p
;
311 kthread_bind(p
, hotcpu
);
314 case CPU_ONLINE_FROZEN
:
315 check_cpu
= cpumask_any(cpu_online_mask
);
316 wake_up_process(per_cpu(watchdog_task
, hotcpu
));
318 #ifdef CONFIG_HOTPLUG_CPU
319 case CPU_DOWN_PREPARE
:
320 case CPU_DOWN_PREPARE_FROZEN
:
321 if (hotcpu
== check_cpu
) {
322 /* Pick any other online cpu. */
323 check_cpu
= cpumask_any_but(cpu_online_mask
, hotcpu
);
327 case CPU_UP_CANCELED
:
328 case CPU_UP_CANCELED_FROZEN
:
329 if (!per_cpu(watchdog_task
, hotcpu
))
331 /* Unbind so it can run. Fall thru. */
332 kthread_bind(per_cpu(watchdog_task
, hotcpu
),
333 cpumask_any(cpu_online_mask
));
335 case CPU_DEAD_FROZEN
:
336 p
= per_cpu(watchdog_task
, hotcpu
);
337 per_cpu(watchdog_task
, hotcpu
) = NULL
;
340 #endif /* CONFIG_HOTPLUG_CPU */
345 static struct notifier_block __cpuinitdata cpu_nfb
= {
346 .notifier_call
= cpu_callback
349 static int __initdata nosoftlockup
;
351 static int __init
nosoftlockup_setup(char *str
)
356 __setup("nosoftlockup", nosoftlockup_setup
);
358 static int __init
spawn_softlockup_task(void)
360 void *cpu
= (void *)(long)smp_processor_id();
366 err
= cpu_callback(&cpu_nfb
, CPU_UP_PREPARE
, cpu
);
367 if (err
== NOTIFY_BAD
) {
371 cpu_callback(&cpu_nfb
, CPU_ONLINE
, cpu
);
372 register_cpu_notifier(&cpu_nfb
);
374 atomic_notifier_chain_register(&panic_notifier_list
, &panic_block
);
378 early_initcall(spawn_softlockup_task
);