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>
20 #include <asm/irq_regs.h>
22 static DEFINE_SPINLOCK(print_lock
);
24 static DEFINE_PER_CPU(unsigned long, touch_timestamp
);
25 static DEFINE_PER_CPU(unsigned long, print_timestamp
);
26 static DEFINE_PER_CPU(struct task_struct
*, watchdog_task
);
28 static int __read_mostly did_panic
;
29 int __read_mostly softlockup_thresh
= 60;
32 * Should we panic (and reboot, if panic_timeout= is set) when a
35 unsigned int __read_mostly softlockup_panic
=
36 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE
;
38 static int __init
softlockup_panic_setup(char *str
)
40 softlockup_panic
= simple_strtoul(str
, NULL
, 0);
44 __setup("softlockup_panic=", softlockup_panic_setup
);
47 softlock_panic(struct notifier_block
*this, unsigned long event
, void *ptr
)
54 static struct notifier_block panic_block
= {
55 .notifier_call
= softlock_panic
,
59 * Returns seconds, approximately. We don't need nanosecond
60 * resolution, and we don't need to waste time with a big divide when
63 static unsigned long get_timestamp(int this_cpu
)
65 return cpu_clock(this_cpu
) >> 30LL; /* 2^30 ~= 10^9 */
68 static void __touch_softlockup_watchdog(void)
70 int this_cpu
= raw_smp_processor_id();
72 __raw_get_cpu_var(touch_timestamp
) = get_timestamp(this_cpu
);
75 void touch_softlockup_watchdog(void)
77 __raw_get_cpu_var(touch_timestamp
) = 0;
79 EXPORT_SYMBOL(touch_softlockup_watchdog
);
81 void touch_all_softlockup_watchdogs(void)
85 /* Cause each CPU to re-update its timestamp rather than complain */
86 for_each_online_cpu(cpu
)
87 per_cpu(touch_timestamp
, cpu
) = 0;
89 EXPORT_SYMBOL(touch_all_softlockup_watchdogs
);
92 * This callback runs from the timer interrupt, and checks
93 * whether the watchdog thread has hung or not:
95 void softlockup_tick(void)
97 int this_cpu
= smp_processor_id();
98 unsigned long touch_timestamp
= per_cpu(touch_timestamp
, this_cpu
);
99 unsigned long print_timestamp
;
100 struct pt_regs
*regs
= get_irq_regs();
103 /* Is detection switched off? */
104 if (!per_cpu(watchdog_task
, this_cpu
) || softlockup_thresh
<= 0) {
105 /* Be sure we don't false trigger if switched back on */
107 per_cpu(touch_timestamp
, this_cpu
) = 0;
111 if (touch_timestamp
== 0) {
112 __touch_softlockup_watchdog();
116 print_timestamp
= per_cpu(print_timestamp
, this_cpu
);
118 /* report at most once a second */
119 if (print_timestamp
== touch_timestamp
|| did_panic
)
122 /* do not print during early bootup: */
123 if (unlikely(system_state
!= SYSTEM_RUNNING
)) {
124 __touch_softlockup_watchdog();
128 now
= get_timestamp(this_cpu
);
131 * Wake up the high-prio watchdog task twice per
132 * threshold timespan.
134 if (now
> touch_timestamp
+ softlockup_thresh
/2)
135 wake_up_process(per_cpu(watchdog_task
, this_cpu
));
137 /* Warn about unreasonable delays: */
138 if (now
<= (touch_timestamp
+ softlockup_thresh
))
141 per_cpu(print_timestamp
, this_cpu
) = touch_timestamp
;
143 spin_lock(&print_lock
);
144 printk(KERN_ERR
"BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
145 this_cpu
, now
- touch_timestamp
,
146 current
->comm
, task_pid_nr(current
));
148 print_irqtrace_events(current
);
153 spin_unlock(&print_lock
);
155 if (softlockup_panic
)
156 panic("softlockup: hung tasks");
160 * Have a reasonable limit on the number of tasks checked:
162 unsigned long __read_mostly sysctl_hung_task_check_count
= 1024;
165 * Zero means infinite timeout - no checking done:
167 unsigned long __read_mostly sysctl_hung_task_timeout_secs
= 120;
169 unsigned long __read_mostly sysctl_hung_task_warnings
= 10;
172 * Only do the hung-tasks check on one CPU:
174 static int check_cpu __read_mostly
= -1;
176 static void check_hung_task(struct task_struct
*t
, unsigned long now
)
178 unsigned long switch_count
= t
->nvcsw
+ t
->nivcsw
;
180 if (t
->flags
& PF_FROZEN
)
183 if (switch_count
!= t
->last_switch_count
|| !t
->last_switch_timestamp
) {
184 t
->last_switch_count
= switch_count
;
185 t
->last_switch_timestamp
= now
;
188 if ((long)(now
- t
->last_switch_timestamp
) <
189 sysctl_hung_task_timeout_secs
)
191 if (sysctl_hung_task_warnings
< 0)
193 sysctl_hung_task_warnings
--;
196 * Ok, the task did not get scheduled for more than 2 minutes,
199 printk(KERN_ERR
"INFO: task %s:%d blocked for more than "
200 "%ld seconds.\n", t
->comm
, t
->pid
,
201 sysctl_hung_task_timeout_secs
);
202 printk(KERN_ERR
"\"echo 0 > /proc/sys/kernel/hung_task_timeout_secs\""
203 " disables this message.\n");
205 __debug_show_held_locks(t
);
207 t
->last_switch_timestamp
= now
;
208 touch_nmi_watchdog();
210 if (softlockup_panic
)
211 panic("softlockup: blocked tasks");
215 * Check whether a TASK_UNINTERRUPTIBLE does not get woken up for
216 * a really long time (120 seconds). If that happens, print out
219 static void check_hung_uninterruptible_tasks(int this_cpu
)
221 int max_count
= sysctl_hung_task_check_count
;
222 unsigned long now
= get_timestamp(this_cpu
);
223 struct task_struct
*g
, *t
;
226 * If the system crashed already then all bets are off,
227 * do not report extra hung tasks:
229 if (test_taint(TAINT_DIE
) || did_panic
)
232 read_lock(&tasklist_lock
);
233 do_each_thread(g
, t
) {
236 /* use "==" to skip the TASK_KILLABLE tasks waiting on NFS */
237 if (t
->state
== TASK_UNINTERRUPTIBLE
)
238 check_hung_task(t
, now
);
239 } while_each_thread(g
, t
);
241 read_unlock(&tasklist_lock
);
245 * The watchdog thread - runs every second and touches the timestamp.
247 static int watchdog(void *__bind_cpu
)
249 struct sched_param param
= { .sched_priority
= MAX_RT_PRIO
-1 };
250 int this_cpu
= (long)__bind_cpu
;
252 sched_setscheduler(current
, SCHED_FIFO
, ¶m
);
254 /* initialize timestamp */
255 __touch_softlockup_watchdog();
257 set_current_state(TASK_INTERRUPTIBLE
);
259 * Run briefly once per second to reset the softlockup timestamp.
260 * If this gets delayed for more than 60 seconds then the
261 * debug-printout triggers in softlockup_tick().
263 while (!kthread_should_stop()) {
264 __touch_softlockup_watchdog();
267 if (kthread_should_stop())
270 if (this_cpu
== check_cpu
) {
271 if (sysctl_hung_task_timeout_secs
)
272 check_hung_uninterruptible_tasks(this_cpu
);
275 set_current_state(TASK_INTERRUPTIBLE
);
277 __set_current_state(TASK_RUNNING
);
283 * Create/destroy watchdog threads as CPUs come and go:
286 cpu_callback(struct notifier_block
*nfb
, unsigned long action
, void *hcpu
)
288 int hotcpu
= (unsigned long)hcpu
;
289 struct task_struct
*p
;
293 case CPU_UP_PREPARE_FROZEN
:
294 BUG_ON(per_cpu(watchdog_task
, hotcpu
));
295 p
= kthread_create(watchdog
, hcpu
, "watchdog/%d", hotcpu
);
297 printk(KERN_ERR
"watchdog for %i failed\n", hotcpu
);
300 per_cpu(touch_timestamp
, hotcpu
) = 0;
301 per_cpu(watchdog_task
, hotcpu
) = p
;
302 kthread_bind(p
, hotcpu
);
305 case CPU_ONLINE_FROZEN
:
306 check_cpu
= any_online_cpu(cpu_online_map
);
307 wake_up_process(per_cpu(watchdog_task
, hotcpu
));
309 #ifdef CONFIG_HOTPLUG_CPU
310 case CPU_DOWN_PREPARE
:
311 case CPU_DOWN_PREPARE_FROZEN
:
312 if (hotcpu
== check_cpu
) {
313 cpumask_t temp_cpu_online_map
= cpu_online_map
;
315 cpu_clear(hotcpu
, temp_cpu_online_map
);
316 check_cpu
= any_online_cpu(temp_cpu_online_map
);
320 case CPU_UP_CANCELED
:
321 case CPU_UP_CANCELED_FROZEN
:
322 if (!per_cpu(watchdog_task
, hotcpu
))
324 /* Unbind so it can run. Fall thru. */
325 kthread_bind(per_cpu(watchdog_task
, hotcpu
),
326 any_online_cpu(cpu_online_map
));
328 case CPU_DEAD_FROZEN
:
329 p
= per_cpu(watchdog_task
, hotcpu
);
330 per_cpu(watchdog_task
, hotcpu
) = NULL
;
333 #endif /* CONFIG_HOTPLUG_CPU */
338 static struct notifier_block __cpuinitdata cpu_nfb
= {
339 .notifier_call
= cpu_callback
342 static int __initdata nosoftlockup
;
344 static int __init
nosoftlockup_setup(char *str
)
349 __setup("nosoftlockup", nosoftlockup_setup
);
351 static int __init
spawn_softlockup_task(void)
353 void *cpu
= (void *)(long)smp_processor_id();
359 err
= cpu_callback(&cpu_nfb
, CPU_UP_PREPARE
, cpu
);
360 if (err
== NOTIFY_BAD
) {
364 cpu_callback(&cpu_nfb
, CPU_ONLINE
, cpu
);
365 register_cpu_notifier(&cpu_nfb
);
367 atomic_notifier_chain_register(&panic_notifier_list
, &panic_block
);
371 early_initcall(spawn_softlockup_task
);