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_RAW_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 * The watchdog thread - runs every second and touches the timestamp.
171 static int watchdog(void *__bind_cpu
)
173 struct sched_param param
= { .sched_priority
= MAX_RT_PRIO
-1 };
175 sched_setscheduler(current
, SCHED_FIFO
, ¶m
);
177 /* initialize timestamp */
178 __touch_softlockup_watchdog();
180 set_current_state(TASK_INTERRUPTIBLE
);
182 * Run briefly once per second to reset the softlockup timestamp.
183 * If this gets delayed for more than 60 seconds then the
184 * debug-printout triggers in softlockup_tick().
186 while (!kthread_should_stop()) {
187 __touch_softlockup_watchdog();
190 if (kthread_should_stop())
193 set_current_state(TASK_INTERRUPTIBLE
);
195 __set_current_state(TASK_RUNNING
);
201 * Create/destroy watchdog threads as CPUs come and go:
204 cpu_callback(struct notifier_block
*nfb
, unsigned long action
, void *hcpu
)
206 int hotcpu
= (unsigned long)hcpu
;
207 struct task_struct
*p
;
211 case CPU_UP_PREPARE_FROZEN
:
212 BUG_ON(per_cpu(watchdog_task
, hotcpu
));
213 p
= kthread_create(watchdog
, hcpu
, "watchdog/%d", hotcpu
);
215 printk(KERN_ERR
"watchdog for %i failed\n", hotcpu
);
218 per_cpu(touch_timestamp
, hotcpu
) = 0;
219 per_cpu(watchdog_task
, hotcpu
) = p
;
220 kthread_bind(p
, hotcpu
);
223 case CPU_ONLINE_FROZEN
:
224 wake_up_process(per_cpu(watchdog_task
, hotcpu
));
226 #ifdef CONFIG_HOTPLUG_CPU
227 case CPU_UP_CANCELED
:
228 case CPU_UP_CANCELED_FROZEN
:
229 if (!per_cpu(watchdog_task
, hotcpu
))
231 /* Unbind so it can run. Fall thru. */
232 kthread_bind(per_cpu(watchdog_task
, hotcpu
),
233 cpumask_any(cpu_online_mask
));
235 case CPU_DEAD_FROZEN
:
236 p
= per_cpu(watchdog_task
, hotcpu
);
237 per_cpu(watchdog_task
, hotcpu
) = NULL
;
240 #endif /* CONFIG_HOTPLUG_CPU */
245 static struct notifier_block __cpuinitdata cpu_nfb
= {
246 .notifier_call
= cpu_callback
249 static int __initdata nosoftlockup
;
251 static int __init
nosoftlockup_setup(char *str
)
256 __setup("nosoftlockup", nosoftlockup_setup
);
258 static int __init
spawn_softlockup_task(void)
260 void *cpu
= (void *)(long)smp_processor_id();
266 err
= cpu_callback(&cpu_nfb
, CPU_UP_PREPARE
, cpu
);
267 if (err
== NOTIFY_BAD
) {
271 cpu_callback(&cpu_nfb
, CPU_ONLINE
, cpu
);
272 register_cpu_notifier(&cpu_nfb
);
274 atomic_notifier_chain_register(&panic_notifier_list
, &panic_block
);
278 early_initcall(spawn_softlockup_task
);