softlockup(watchdog)用于检测系统调度是否正常，即软锁的情况，当发生softlockup时，内核不能调度，但还能响应中断，对用户的表现可能为：能ping通，但无法登陆系统，无法进行正常操作。
其基本原理为：为每个CPU启动一个内核线程(watchdog/x)，此线程为优先级最高的实时线程，在该线程得到调度时，会更新相应的计数(时间戳)，同时会启动定时器，当定时器到期时检查相应的时间戳，如果超过指定时间，都没有更新，则说明这段时间内都没有发生调度(因为此线程优先级最高)，则打印相应告警或根据配置可以进入panic流程。
基本代码分析(2.6.32)
rest_init->kernel_init->lockup_detector_init->cpu_callback->watchdog_prepare_cpu(初始化watchdog定时器):

点击(此处)折叠或打开

  1. static int watchdog_prepare_cpu(int cpu)

  2. {

  3.     struct hrtimer *hrtimer = &per_cpu(watchdog_hrtimer, cpu);


  5.     WARN_ON(per_cpu(softlockup_watchdog, cpu));

  6.     hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);//初始化高精度定时器

  7.     hrtimer->function = watchdog_timer_fn;//设置定时器处理函数


  9.     return 0;

  10. }

看门狗定时器处理函数：

点击(此处)折叠或打开

  1. static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)

  2. {

  3. //获取计数watchdog_touch_ts，该计数在watchdog内核线程被调度时更新

  4.     unsigned long touch_ts = __get_cpu_var(watchdog_touch_ts);

  5.     struct pt_regs *regs = get_irq_regs();

  6.     int duration;


  8.     /* kick the hardlockup detector */

  9. //增加中断计数，证明没有发生硬锁(关中断死锁)

  10.     watchdog_interrupt_count();


  12.     /* kick the softlockup detector */

  13. //唤醒wathdog内核线程

  14.     wake_up_process(__get_cpu_var(softlockup_watchdog));


  16.     /* .. and repeat */

  17. //重启定时器

  18.     hrtimer_forward_now(hrtimer, ns_to_ktime(get_sample_period()));

  19.     if (touch_ts == 0) {

  20.         if (unlikely(__get_cpu_var(softlockup_touch_sync))) {

  21.             /*

  22.              * If the time stamp was touched atomically

  23.              * make sure the scheduler tick is up to date.

  24.              */

  25.             __get_cpu_var(softlockup_touch_sync) = false;

  26.             sched_clock_tick();

  27.         }

  28.         __touch_watchdog();

  29.         return HRTIMER_RESTART;

  30.     }


  32.     /* check for a softlockup

  33.      * This is done by making sure a high priority task is

  34.      * being scheduled. The task touches the watchdog to

  35.      * indicate it is getting cpu time. If it hasn't then

  36.      * this is a good indication some task is hogging the cpu

  37.      */

  38. //判断是否发生了软锁，原理是判断touch_ts(时间戳)是否超过一定时间没有更新

  39.     duration = is_softlockup(touch_ts);

  40.     if (unlikely(duration)) {

  41.         /* only warn once */

  42.         if (__get_cpu_var(soft_watchdog_warn) == true)

  43.             return HRTIMER_RESTART;

  44. //发生了软锁后，进行一些列的信息记录和告警。

  45.         printk(KERN_EMERG "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",

  46.             smp_processor_id(), duration,

  47.             current->comm, task_pid_nr(current));

  48.         print_modules();

  49.         print_irqtrace_events(current);

  50.         if (regs)

  51.             show_regs(regs);

  52.         else

  53.             dump_stack();

  54. //如果配置了softlockup_panic(proc中配置)，则panic

  55.         if (softlockup_panic)

  56.             panic("softlockup: hung tasks");

  57.         __get_cpu_var(soft_watchdog_warn) = true;

  58.     } else

  59.         __get_cpu_var(soft_watchdog_warn) = false;


  61.     return HRTIMER_RESTART;

  62. }


启动看门狗，即创建watchdog内核线程。

点击(此处)折叠或打开

  1. static int watchdog_enable(int cpu)

  2. {

  3.     struct task_struct *p = per_cpu(softlockup_watchdog, cpu);

  4.     int err = 0;


  6.     /* enable the perf event */

  7.     err = watchdog_nmi_enable(cpu);


  9.     /* Regardless of err above, fall through and start softlockup */


  11.     /* create the watchdog thread */

  12.     if (!p) {

  13. //创建watchdog内核线程

  14.         p = kthread_create(watchdog, (void *)(unsigned long)cpu, "watchdog/%d", cpu);

  15.         if (IS_ERR(p)) {

  16.             printk(KERN_ERR "softlockup watchdog for %i failed\n", cpu);

  17.             if (!err)

  18.                 /* if hardlockup hasn't already set this */

  19.                 err = PTR_ERR(p);

  20.             goto out;

  21.         }

  22.         kthread_bind(p, cpu);

  23.         per_cpu(watchdog_touch_ts, cpu) = 0;

  24.         per_cpu(softlockup_watchdog, cpu) = p;

  25.         wake_up_process(p);

  26.     }


  28. out:

  29.     return err;

  30. }


watchdog内核线程执行主函数，主要是要更新计数(时间戳)

点击(此处)折叠或打开

  1. static int watchdog(void *unused)

  2. {

  3. //设置为最高优先级

  4.     struct sched_param param = { .sched_priority = MAX_RT_PRIO-1 };

  5.     struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer);

  6. //设置为实时线程

  7.     sched_setscheduler(current, SCHED_FIFO, &param);


  9.     /* initialize timestamp */

  10. //初始化计数(时间戳)

  11.     __touch_watchdog();


  13.     /* kick off the timer for the hardlockup detector */

  14.     /* done here because hrtimer_start can only pin to smp_processor_id() */

  15. //启动定时器，用于检测是否发生软锁

  16.     hrtimer_start(hrtimer, ns_to_ktime(get_sample_period()),

  17.          HRTIMER_MODE_REL_PINNED);

  18. //睡眠

  19.     set_current_state(TASK_INTERRUPTIBLE);

  20.     /*

  21.      * Run briefly once per second to reset the softlockup timestamp.

  22.      * If this gets delayed for more than 60 seconds then the

  23.      * debug-printout triggers in watchdog_timer_fn().

  24.      */

  25.     while (!kthread_should_stop()) {

  26. //更新计数

  27.         __touch_watchdog();

  28.         schedule();


  30.         if (kthread_should_stop())

  31.             break;


  33.         set_current_state(TASK_INTERRUPTIBLE);

  34.     }

  35.     __set_current_state(TASK_RUNNING);


  37.     return 0;

  38. }


判断是否发生软锁：is_softlockup

点击(此处)折叠或打开

  1. static int is_softlockup(unsigned long touch_ts)

  2. {

  3.     unsigned long now = get_timestamp(smp_processor_id());


  5.     /* Warn about unreasonable delays: */

  6. //检测计数多久没有更新了，如果超过了60s，则表示发生了软锁

  7.     if (time_after(now, touch_ts + softlockup_thresh))

  8.         return now - touch_ts;


  10.     return 0;

  11. }