linux/kernel/softlockup.c
<<
>>
Prefs
   1/*
   2 * Detect Soft Lockups
   3 *
   4 * started by Ingo Molnar, Copyright (C) 2005, 2006 Red Hat, Inc.
   5 *
   6 * this code detects soft lockups: incidents in where on a CPU
   7 * the kernel does not reschedule for 10 seconds or more.
   8 */
   9#include <linux/mm.h>
  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>
  20
  21#include <asm/irq_regs.h>
  22
  23static DEFINE_SPINLOCK(print_lock);
  24
  25static DEFINE_PER_CPU(unsigned long, touch_timestamp);
  26static DEFINE_PER_CPU(unsigned long, print_timestamp);
  27static DEFINE_PER_CPU(struct task_struct *, watchdog_task);
  28
  29static int __read_mostly did_panic;
  30int __read_mostly softlockup_thresh = 60;
  31
  32/*
  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
  47static int
  48softlock_panic(struct notifier_block *this, unsigned long event, void *ptr)
  49{
  50        did_panic = 1;
  51
  52        return NOTIFY_DONE;
  53}
  54
  55static struct notifier_block panic_block = {
  56        .notifier_call = softlock_panic,
  57};
  58
  59/*
  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 */
  64static unsigned long get_timestamp(int this_cpu)
  65{
  66        return cpu_clock(this_cpu) >> 30LL;  /* 2^30 ~= 10^9 */
  67}
  68
  69static void __touch_softlockup_watchdog(void)
  70{
  71        int this_cpu = raw_smp_processor_id();
  72
  73        __raw_get_cpu_var(touch_timestamp) = get_timestamp(this_cpu);
  74}
  75
  76void touch_softlockup_watchdog(void)
  77{
  78        __raw_get_cpu_var(touch_timestamp) = 0;
  79}
  80EXPORT_SYMBOL(touch_softlockup_watchdog);
  81
  82void 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
  92int 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
 100/*
 101 * This callback runs from the timer interrupt, and checks
 102 * whether the watchdog thread has hung or not:
 103 */
 104void softlockup_tick(void)
 105{
 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();
 110        unsigned long now;
 111
 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 */
 115                if (touch_timestamp)
 116                        per_cpu(touch_timestamp, this_cpu) = 0;
 117                return;
 118        }
 119
 120        if (touch_timestamp == 0) {
 121                __touch_softlockup_watchdog();
 122                return;
 123        }
 124
 125        print_timestamp = per_cpu(print_timestamp, this_cpu);
 126
 127        /* report at most once a second */
 128        if (print_timestamp == touch_timestamp || did_panic)
 129                return;
 130
 131        /* do not print during early bootup: */
 132        if (unlikely(system_state != SYSTEM_RUNNING)) {
 133                __touch_softlockup_watchdog();
 134                return;
 135        }
 136
 137        now = get_timestamp(this_cpu);
 138
 139        /*
 140         * Wake up the high-prio watchdog task twice per
 141         * threshold timespan.
 142         */
 143        if (now > touch_timestamp + softlockup_thresh/2)
 144                wake_up_process(per_cpu(watchdog_task, this_cpu));
 145
 146        /* Warn about unreasonable delays: */
 147        if (now <= (touch_timestamp + softlockup_thresh))
 148                return;
 149
 150        per_cpu(print_timestamp, this_cpu) = touch_timestamp;
 151
 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));
 156        print_modules();
 157        print_irqtrace_events(current);
 158        if (regs)
 159                show_regs(regs);
 160        else
 161                dump_stack();
 162        spin_unlock(&print_lock);
 163
 164        if (softlockup_panic)
 165                panic("softlockup: hung tasks");
 166}
 167
 168/*
 169 * The watchdog thread - runs every second and touches the timestamp.
 170 */
 171static int watchdog(void *__bind_cpu)
 172{
 173        struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };
 174
 175        sched_setscheduler(current, SCHED_FIFO, &param);
 176
 177        /* initialize timestamp */
 178        __touch_softlockup_watchdog();
 179
 180        set_current_state(TASK_INTERRUPTIBLE);
 181        /*
 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().
 185         */
 186        while (!kthread_should_stop()) {
 187                __touch_softlockup_watchdog();
 188                schedule();
 189
 190                if (kthread_should_stop())
 191                        break;
 192
 193                set_current_state(TASK_INTERRUPTIBLE);
 194        }
 195        __set_current_state(TASK_RUNNING);
 196
 197        return 0;
 198}
 199
 200/*
 201 * Create/destroy watchdog threads as CPUs come and go:
 202 */
 203static int __cpuinit
 204cpu_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:
 211        case CPU_UP_PREPARE_FROZEN:
 212                BUG_ON(per_cpu(watchdog_task, hotcpu));
 213                p = kthread_create(watchdog, hcpu, "watchdog/%d", hotcpu);
 214                if (IS_ERR(p)) {
 215                        printk(KERN_ERR "watchdog for %i failed\n", hotcpu);
 216                        return NOTIFY_BAD;
 217                }
 218                per_cpu(touch_timestamp, hotcpu) = 0;
 219                per_cpu(watchdog_task, hotcpu) = p;
 220                kthread_bind(p, hotcpu);
 221                break;
 222        case CPU_ONLINE:
 223        case CPU_ONLINE_FROZEN:
 224                wake_up_process(per_cpu(watchdog_task, hotcpu));
 225                break;
 226#ifdef CONFIG_HOTPLUG_CPU
 227        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),
 233                             cpumask_any(cpu_online_mask));
 234        case CPU_DEAD:
 235        case CPU_DEAD_FROZEN:
 236                p = per_cpu(watchdog_task, hotcpu);
 237                per_cpu(watchdog_task, hotcpu) = NULL;
 238                kthread_stop(p);
 239                break;
 240#endif /* CONFIG_HOTPLUG_CPU */
 241        }
 242        return NOTIFY_OK;
 243}
 244
 245static struct notifier_block __cpuinitdata cpu_nfb = {
 246        .notifier_call = cpu_callback
 247};
 248
 249static 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)
 259{
 260        void *cpu = (void *)(long)smp_processor_id();
 261        int err;
 262
 263        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        }
 271        cpu_callback(&cpu_nfb, CPU_ONLINE, cpu);
 272        register_cpu_notifier(&cpu_nfb);
 273
 274        atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 275
 276        return 0;
 277}
 278early_initcall(spawn_softlockup_task);
 279