blob: 88796c330838dd66c24b8628f8b56ce27d3a3d23 [file] [log] [blame]
Ingo Molnar8446f1d2005-09-06 15:16:27 -07001/*
2 * Detect Soft Lockups
3 *
Ingo Molnar6687a972006-03-24 03:18:41 -08004 * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
Ingo Molnar8446f1d2005-09-06 15:16:27 -07005 *
6 * this code detects soft lockups: incidents in where on a CPU
7 * the kernel does not reschedule for 10 seconds or more.
8 */
Ingo Molnar8446f1d2005-09-06 15:16:27 -07009#include <linux/mm.h>
10#include <linux/cpu.h>
Ingo Molnar82a1fcb2008-01-25 21:08:02 +010011#include <linux/nmi.h>
Ingo Molnar8446f1d2005-09-06 15:16:27 -070012#include <linux/init.h>
13#include <linux/delay.h>
Rafael J. Wysocki83144182007-07-17 04:03:35 -070014#include <linux/freezer.h>
Ingo Molnar8446f1d2005-09-06 15:16:27 -070015#include <linux/kthread.h>
Vegard Nossum8d5be7f2008-06-25 08:50:10 +020016#include <linux/lockdep.h>
Ingo Molnar8446f1d2005-09-06 15:16:27 -070017#include <linux/notifier.h>
18#include <linux/module.h>
Mandeep Singh Bainesbaf48f62009-01-12 21:15:17 -080019#include <linux/sysctl.h>
Ingo Molnar8446f1d2005-09-06 15:16:27 -070020
Ingo Molnar43581a12007-10-16 23:26:08 -070021#include <asm/irq_regs.h>
22
Ingo Molnar8446f1d2005-09-06 15:16:27 -070023static DEFINE_SPINLOCK(print_lock);
24
Ingo Molnar6687a972006-03-24 03:18:41 -080025static DEFINE_PER_CPU(unsigned long, touch_timestamp);
26static DEFINE_PER_CPU(unsigned long, print_timestamp);
Ingo Molnar8446f1d2005-09-06 15:16:27 -070027static DEFINE_PER_CPU(struct task_struct *, watchdog_task);
28
Ingo Molnar90739082008-01-25 21:08:34 +010029static int __read_mostly did_panic;
Dimitri Sivanich9383d962008-05-12 21:21:14 +020030int __read_mostly softlockup_thresh = 60;
Ingo Molnar6687a972006-03-24 03:18:41 -080031
Ingo Molnar9c44bc02008-05-12 21:21:04 +020032/*
33 * Should we panic (and reboot, if panic_timeout= is set) when a
34 * soft-lockup occurs:
35 */
36unsigned int __read_mostly softlockup_panic =
37 CONFIG_BOOTPARAM_SOFTLOCKUP_PANIC_VALUE;
38
39static int __init softlockup_panic_setup(char *str)
40{
41 softlockup_panic = simple_strtoul(str, NULL, 0);
42
43 return 1;
44}
45__setup("softlockup_panic=", softlockup_panic_setup);
46
Ingo Molnar6687a972006-03-24 03:18:41 -080047static int
48softlock_panic(struct notifier_block *this, unsigned long event, void *ptr)
Ingo Molnar8446f1d2005-09-06 15:16:27 -070049{
50 did_panic = 1;
51
52 return NOTIFY_DONE;
53}
54
55static struct notifier_block panic_block = {
56 .notifier_call = softlock_panic,
57};
58
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -070059/*
60 * Returns seconds, approximately. We don't need nanosecond
61 * resolution, and we don't need to waste time with a big divide when
62 * 2^30ns == 1.074s.
63 */
Ingo Molnara3b13c22007-10-16 23:26:06 -070064static unsigned long get_timestamp(int this_cpu)
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -070065{
Ingo Molnar82a1fcb2008-01-25 21:08:02 +010066 return cpu_clock(this_cpu) >> 30LL; /* 2^30 ~= 10^9 */
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -070067}
68
Jason Wessel8c2238e2008-05-27 12:23:29 -050069static void __touch_softlockup_watchdog(void)
Ingo Molnar8446f1d2005-09-06 15:16:27 -070070{
Ingo Molnara3b13c22007-10-16 23:26:06 -070071 int this_cpu = raw_smp_processor_id();
72
73 __raw_get_cpu_var(touch_timestamp) = get_timestamp(this_cpu);
Ingo Molnar8446f1d2005-09-06 15:16:27 -070074}
Jason Wessel8c2238e2008-05-27 12:23:29 -050075
76void touch_softlockup_watchdog(void)
77{
78 __raw_get_cpu_var(touch_timestamp) = 0;
79}
Ingo Molnar8446f1d2005-09-06 15:16:27 -070080EXPORT_SYMBOL(touch_softlockup_watchdog);
81
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -070082void touch_all_softlockup_watchdogs(void)
83{
84 int cpu;
85
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;
89}
90EXPORT_SYMBOL(touch_all_softlockup_watchdogs);
91
Mandeep Singh Bainesbaf48f62009-01-12 21:15:17 -080092int proc_dosoftlockup_thresh(struct ctl_table *table, int write,
93 struct file *filp, void __user *buffer,
94 size_t *lenp, loff_t *ppos)
95{
96 touch_all_softlockup_watchdogs();
97 return proc_dointvec_minmax(table, write, filp, buffer, lenp, ppos);
98}
99
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700100/*
101 * This callback runs from the timer interrupt, and checks
102 * whether the watchdog thread has hung or not:
103 */
Ingo Molnar6687a972006-03-24 03:18:41 -0800104void softlockup_tick(void)
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700105{
106 int this_cpu = smp_processor_id();
Ingo Molnar6687a972006-03-24 03:18:41 -0800107 unsigned long touch_timestamp = per_cpu(touch_timestamp, this_cpu);
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700108 unsigned long print_timestamp;
Ingo Molnar43581a12007-10-16 23:26:08 -0700109 struct pt_regs *regs = get_irq_regs();
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700110 unsigned long now;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700111
Dimitri Sivanich9383d962008-05-12 21:21:14 +0200112 /* 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 */
115 if (touch_timestamp)
116 per_cpu(touch_timestamp, this_cpu) = 0;
117 return;
118 }
119
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700120 if (touch_timestamp == 0) {
Jason Wessel8c2238e2008-05-27 12:23:29 -0500121 __touch_softlockup_watchdog();
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700122 return;
Jeremy Fitzhardinge04c91672007-05-08 00:28:05 -0700123 }
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700124
125 print_timestamp = per_cpu(print_timestamp, this_cpu);
126
127 /* report at most once a second */
Johannes Weiner3e2f69f2008-07-01 09:12:04 +0200128 if (print_timestamp == touch_timestamp || did_panic)
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700129 return;
130
Ingo Molnar6687a972006-03-24 03:18:41 -0800131 /* do not print during early bootup: */
132 if (unlikely(system_state != SYSTEM_RUNNING)) {
Jason Wessel8c2238e2008-05-27 12:23:29 -0500133 __touch_softlockup_watchdog();
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700134 return;
Ingo Molnar6687a972006-03-24 03:18:41 -0800135 }
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700136
Ingo Molnara3b13c22007-10-16 23:26:06 -0700137 now = get_timestamp(this_cpu);
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700138
Johannes Weinerdd7a1e52008-06-27 15:07:21 +0200139 /*
140 * Wake up the high-prio watchdog task twice per
141 * threshold timespan.
142 */
143 if (now > touch_timestamp + softlockup_thresh/2)
Peter Zijlstraed50d6c2008-02-02 00:23:08 +0100144 wake_up_process(per_cpu(watchdog_task, this_cpu));
145
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100146 /* Warn about unreasonable delays: */
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700147 if (now <= (touch_timestamp + softlockup_thresh))
Ingo Molnar43581a12007-10-16 23:26:08 -0700148 return;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700149
Ingo Molnar43581a12007-10-16 23:26:08 -0700150 per_cpu(print_timestamp, this_cpu) = touch_timestamp;
151
152 spin_lock(&print_lock);
Ravikiran G Thirumalaic4f3b632007-10-16 23:26:09 -0700153 printk(KERN_ERR "BUG: soft lockup - CPU#%d stuck for %lus! [%s:%d]\n",
154 this_cpu, now - touch_timestamp,
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700155 current->comm, task_pid_nr(current));
Arjan van de Ven688c9172008-06-16 15:51:08 -0700156 print_modules();
Vegard Nossum8d5be7f2008-06-25 08:50:10 +0200157 print_irqtrace_events(current);
Ingo Molnar43581a12007-10-16 23:26:08 -0700158 if (regs)
159 show_regs(regs);
160 else
Ingo Molnar6687a972006-03-24 03:18:41 -0800161 dump_stack();
Ingo Molnar43581a12007-10-16 23:26:08 -0700162 spin_unlock(&print_lock);
Ingo Molnar9c44bc02008-05-12 21:21:04 +0200163
164 if (softlockup_panic)
165 panic("softlockup: hung tasks");
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700166}
167
168/*
169 * The watchdog thread - runs every second and touches the timestamp.
170 */
Ingo Molnara5f2ce32007-10-16 23:26:08 -0700171static int watchdog(void *__bind_cpu)
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700172{
Oleg Nesterov02fb6142007-05-08 00:24:03 -0700173 struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700174
175 sched_setscheduler(current, SCHED_FIFO, &param);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700176
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700177 /* initialize timestamp */
Jason Wessel8c2238e2008-05-27 12:23:29 -0500178 __touch_softlockup_watchdog();
Jeremy Fitzhardinge966812d2007-05-08 00:28:02 -0700179
Dmitry Adamushko7be2a032008-02-08 15:41:13 +0100180 set_current_state(TASK_INTERRUPTIBLE);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700181 /*
Ingo Molnar6687a972006-03-24 03:18:41 -0800182 * Run briefly once per second to reset the softlockup timestamp.
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100183 * If this gets delayed for more than 60 seconds then the
Ingo Molnar6687a972006-03-24 03:18:41 -0800184 * debug-printout triggers in softlockup_tick().
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700185 */
186 while (!kthread_should_stop()) {
Jason Wessel8c2238e2008-05-27 12:23:29 -0500187 __touch_softlockup_watchdog();
Peter Zijlstraed50d6c2008-02-02 00:23:08 +0100188 schedule();
189
190 if (kthread_should_stop())
191 break;
Ingo Molnar82a1fcb2008-01-25 21:08:02 +0100192
Dmitry Adamushko7be2a032008-02-08 15:41:13 +0100193 set_current_state(TASK_INTERRUPTIBLE);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700194 }
Dmitry Adamushko7be2a032008-02-08 15:41:13 +0100195 __set_current_state(TASK_RUNNING);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700196
197 return 0;
198}
199
200/*
201 * Create/destroy watchdog threads as CPUs come and go:
202 */
Chandra Seetharaman8c78f302006-07-30 03:03:35 -0700203static int __cpuinit
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700204cpu_callback(struct notifier_block *nfb, unsigned long action, void *hcpu)
205{
206 int hotcpu = (unsigned long)hcpu;
207 struct task_struct *p;
208
209 switch (action) {
210 case CPU_UP_PREPARE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700211 case CPU_UP_PREPARE_FROZEN:
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700212 BUG_ON(per_cpu(watchdog_task, hotcpu));
213 p = kthread_create(watchdog, hcpu, "watchdog/%d", hotcpu);
214 if (IS_ERR(p)) {
Ingo Molnara5f2ce32007-10-16 23:26:08 -0700215 printk(KERN_ERR "watchdog for %i failed\n", hotcpu);
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700216 return NOTIFY_BAD;
217 }
Ingo Molnara5f2ce32007-10-16 23:26:08 -0700218 per_cpu(touch_timestamp, hotcpu) = 0;
219 per_cpu(watchdog_task, hotcpu) = p;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700220 kthread_bind(p, hotcpu);
Ingo Molnara5f2ce32007-10-16 23:26:08 -0700221 break;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700222 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700223 case CPU_ONLINE_FROZEN:
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700224 wake_up_process(per_cpu(watchdog_task, hotcpu));
225 break;
226#ifdef CONFIG_HOTPLUG_CPU
Peter Zijlstraed50d6c2008-02-02 00:23:08 +0100227 case CPU_UP_CANCELED:
228 case CPU_UP_CANCELED_FROZEN:
229 if (!per_cpu(watchdog_task, hotcpu))
230 break;
231 /* Unbind so it can run. Fall thru. */
232 kthread_bind(per_cpu(watchdog_task, hotcpu),
Rusty Russellf1fc0572009-01-01 10:12:23 +1030233 cpumask_any(cpu_online_mask));
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700234 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700235 case CPU_DEAD_FROZEN:
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700236 p = per_cpu(watchdog_task, hotcpu);
237 per_cpu(watchdog_task, hotcpu) = NULL;
238 kthread_stop(p);
239 break;
240#endif /* CONFIG_HOTPLUG_CPU */
Ingo Molnara5f2ce32007-10-16 23:26:08 -0700241 }
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700242 return NOTIFY_OK;
243}
244
Chandra Seetharaman8c78f302006-07-30 03:03:35 -0700245static struct notifier_block __cpuinitdata cpu_nfb = {
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700246 .notifier_call = cpu_callback
247};
248
Eduard - Gabriel Munteanu7babe8d2008-07-25 19:45:11 -0700249static int __initdata nosoftlockup;
250
251static int __init nosoftlockup_setup(char *str)
252{
253 nosoftlockup = 1;
254 return 1;
255}
256__setup("nosoftlockup", nosoftlockup_setup);
257
258static int __init spawn_softlockup_task(void)
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700259{
260 void *cpu = (void *)(long)smp_processor_id();
Eduard - Gabriel Munteanu7babe8d2008-07-25 19:45:11 -0700261 int err;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700262
Eduard - Gabriel Munteanu7babe8d2008-07-25 19:45:11 -0700263 if (nosoftlockup)
264 return 0;
265
266 err = cpu_callback(&cpu_nfb, CPU_UP_PREPARE, cpu);
267 if (err == NOTIFY_BAD) {
268 BUG();
269 return 1;
270 }
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700271 cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
272 register_cpu_notifier(&cpu_nfb);
273
Alan Sterne041c682006-03-27 01:16:30 -0800274 atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
Eduard - Gabriel Munteanu7babe8d2008-07-25 19:45:11 -0700275
276 return 0;
Ingo Molnar8446f1d2005-09-06 15:16:27 -0700277}
Eduard - Gabriel Munteanu7babe8d2008-07-25 19:45:11 -0700278early_initcall(spawn_softlockup_task);