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/init.h>
12 #include <linux/delay.h>
13 #include <linux/freezer.h>
14 #include <linux/kthread.h>
15 #include <linux/notifier.h>
16 #include <linux/module.h>
18 static DEFINE_SPINLOCK(print_lock
);
20 static DEFINE_PER_CPU(unsigned long, touch_timestamp
);
21 static DEFINE_PER_CPU(unsigned long, print_timestamp
);
22 static DEFINE_PER_CPU(struct task_struct
*, watchdog_task
);
24 static int did_panic
= 0;
27 softlock_panic(struct notifier_block
*this, unsigned long event
, void *ptr
)
34 static struct notifier_block panic_block
= {
35 .notifier_call
= softlock_panic
,
39 * Returns seconds, approximately. We don't need nanosecond
40 * resolution, and we don't need to waste time with a big divide when
43 static unsigned long get_timestamp(int this_cpu
)
45 return cpu_clock(this_cpu
) >> 30; /* 2^30 ~= 10^9 */
48 void touch_softlockup_watchdog(void)
50 int this_cpu
= raw_smp_processor_id();
52 __raw_get_cpu_var(touch_timestamp
) = get_timestamp(this_cpu
);
54 EXPORT_SYMBOL(touch_softlockup_watchdog
);
56 void touch_all_softlockup_watchdogs(void)
60 /* Cause each CPU to re-update its timestamp rather than complain */
61 for_each_online_cpu(cpu
)
62 per_cpu(touch_timestamp
, cpu
) = 0;
64 EXPORT_SYMBOL(touch_all_softlockup_watchdogs
);
67 * This callback runs from the timer interrupt, and checks
68 * whether the watchdog thread has hung or not:
70 void softlockup_tick(void)
72 int this_cpu
= smp_processor_id();
73 unsigned long touch_timestamp
= per_cpu(touch_timestamp
, this_cpu
);
74 unsigned long print_timestamp
;
77 if (touch_timestamp
== 0) {
78 touch_softlockup_watchdog();
82 print_timestamp
= per_cpu(print_timestamp
, this_cpu
);
84 /* report at most once a second */
85 if ((print_timestamp
>= touch_timestamp
&&
86 print_timestamp
< (touch_timestamp
+ 1)) ||
87 did_panic
|| !per_cpu(watchdog_task
, this_cpu
)) {
91 /* do not print during early bootup: */
92 if (unlikely(system_state
!= SYSTEM_RUNNING
)) {
93 touch_softlockup_watchdog();
97 now
= get_timestamp(this_cpu
);
99 /* Wake up the high-prio watchdog task every second: */
100 if (now
> (touch_timestamp
+ 1))
101 wake_up_process(per_cpu(watchdog_task
, this_cpu
));
103 /* Warn about unreasonable 10+ seconds delays: */
104 if (now
> (touch_timestamp
+ 10)) {
105 per_cpu(print_timestamp
, this_cpu
) = touch_timestamp
;
107 spin_lock(&print_lock
);
108 printk(KERN_ERR
"BUG: soft lockup detected on CPU#%d!\n",
111 spin_unlock(&print_lock
);
116 * The watchdog thread - runs every second and touches the timestamp.
118 static int watchdog(void * __bind_cpu
)
120 struct sched_param param
= { .sched_priority
= MAX_RT_PRIO
-1 };
122 sched_setscheduler(current
, SCHED_FIFO
, ¶m
);
124 /* initialize timestamp */
125 touch_softlockup_watchdog();
128 * Run briefly once per second to reset the softlockup timestamp.
129 * If this gets delayed for more than 10 seconds then the
130 * debug-printout triggers in softlockup_tick().
132 while (!kthread_should_stop()) {
133 set_current_state(TASK_INTERRUPTIBLE
);
134 touch_softlockup_watchdog();
142 * Create/destroy watchdog threads as CPUs come and go:
145 cpu_callback(struct notifier_block
*nfb
, unsigned long action
, void *hcpu
)
147 int hotcpu
= (unsigned long)hcpu
;
148 struct task_struct
*p
;
152 case CPU_UP_PREPARE_FROZEN
:
153 BUG_ON(per_cpu(watchdog_task
, hotcpu
));
154 p
= kthread_create(watchdog
, hcpu
, "watchdog/%d", hotcpu
);
156 printk("watchdog for %i failed\n", hotcpu
);
159 per_cpu(touch_timestamp
, hotcpu
) = 0;
160 per_cpu(watchdog_task
, hotcpu
) = p
;
161 kthread_bind(p
, hotcpu
);
164 case CPU_ONLINE_FROZEN
:
165 wake_up_process(per_cpu(watchdog_task
, hotcpu
));
167 #ifdef CONFIG_HOTPLUG_CPU
168 case CPU_UP_CANCELED
:
169 case CPU_UP_CANCELED_FROZEN
:
170 if (!per_cpu(watchdog_task
, hotcpu
))
172 /* Unbind so it can run. Fall thru. */
173 kthread_bind(per_cpu(watchdog_task
, hotcpu
),
174 any_online_cpu(cpu_online_map
));
176 case CPU_DEAD_FROZEN
:
177 p
= per_cpu(watchdog_task
, hotcpu
);
178 per_cpu(watchdog_task
, hotcpu
) = NULL
;
181 #endif /* CONFIG_HOTPLUG_CPU */
186 static struct notifier_block __cpuinitdata cpu_nfb
= {
187 .notifier_call
= cpu_callback
190 __init
void spawn_softlockup_task(void)
192 void *cpu
= (void *)(long)smp_processor_id();
193 int err
= cpu_callback(&cpu_nfb
, CPU_UP_PREPARE
, cpu
);
195 BUG_ON(err
== NOTIFY_BAD
);
196 cpu_callback(&cpu_nfb
, CPU_ONLINE
, cpu
);
197 register_cpu_notifier(&cpu_nfb
);
199 atomic_notifier_chain_register(&panic_notifier_list
, &panic_block
);