softlockup检测(watchdog)原理(用于检测系统调度是否正常)

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);
   

4. 
   

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

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

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

8. 
   

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;
   

7. 
   

8.     /* kick the hardlockup detector */

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

10.     watchdog_interrupt_count();
    

11. 
    

12.     /* kick the softlockup detector */

13. //唤醒wathdog内核线程
    

14.     wake_up_process(__get_cpu_var(softlockup_watchdog));
    

15. 
    

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.     }
    

31. 
    

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;
    

60. 
    

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;
   

5. 
   

6.     /* enable the perf event */
   

7.     err = watchdog_nmi_enable(cpu);
   

8. 
   

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

10. 
    

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.     }
    

27. 
    

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);
   

8. 
   

9.     /* initialize timestamp */

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

11.     __touch_watchdog();
    

12. 
    

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();
    

29. 
    

30.         if (kthread_should_stop())
    

31.             break;
    

32. 
    

33.         set_current_state(TASK_INTERRUPTIBLE);
    

34.     }
    

35.     __set_current_state(TASK_RUNNING);
    

36. 
    

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());
   

4. 
   

5.     /* Warn about unreasonable delays: */

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

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

8.         return now - touch_ts;
   

9. 
   

10.     return 0;
    

11. }