linux 内核笔记之watchdog

watchdog

简而言之,watchdog是为了保证系统正常运行,或者从死循环,死锁等一场状态退出的一种机制。

看门狗分硬件看门狗和软件看门狗。硬件看门狗是利用一个定时器电路,其定时输出连接到电路的复位端,程序在一定时间范围内对定时器清零(俗称“喂狗”),因此程序正常工作时,定时器总不能溢出,也就不能产生复位信号。如果程序出现故障,不在定时周期内复位看门狗,就使得看门狗定时器溢出产生复位信号并重启系统。软件看门狗原理上一样,只是将硬件电路上的定时器用处理器的内部定时器代替,这样可以简化硬件电路设计,但在可靠性方面不如硬件定时器,比如系统内部定时器自身发生故障就无法检测到。

软件看门狗分为两种,用于检测soft lockup的普通软狗(基于时钟中断),以及检测hard lockup的NMI狗(基于NMI中断)。

注1:时钟中断优先级小于NMI中断
注2:lockup,是指某段内核代码占着CPU不放。Lockup严重的情况下会导致整个系统失去响应。
soft lockup 和 hard lockup,它们的唯一区别是 hard lockup 发生在CPU屏蔽中断的情况下。

软狗

单个cpu检测线程是否正常调度。

一般软狗的正常流程如下(假设软狗触发的时间为20s)

linux 内核笔记之watchdog_第1张图片

可能产生软狗的原因:
1.频繁处理硬中断以至于没有时间正常调度
2.长期处理软中断
3.对于非抢占式内核,某个线程长时间执行而不触发调度
4.以上all

NMI watchdog

单个CPU检测中断是否能够正常上报
当CPU处于关中断状态达到一定时间会被判定进入hard lockup

NMI检测流程:

linux 内核笔记之watchdog_第2张图片

可能产生NMI狗的原因:
1.长期处理某个硬中断
2.长时间在禁用本地中断下处理

NMI狗机制也是用一个percpu的hrtimer来喂狗,为了能够及时检测到hard lockup状态,在比中断优先级更高的NMI上下文进行检测。

硬狗

用于检测所有CPU是否正常运行
任何一个CPU都可以喂硬狗,当在一定时间内没有核喂狗,触发硬狗复位

硬狗检测流程:

linux 内核笔记之watchdog_第3张图片

可能产生硬狗的原因:
1.CPU(没有软狗,NMI狗触发条件)全部挂死
2.CPU之间存在硬件依赖关系,某一个CPU挂死,有软件层面的共享资源

基于内核代码watchdog.c分析soft lockup以及hard lockup的实现机制(kernel/watchdog.c)

soft lockup

  1. 每一个CPU上都有一个watchdog线程(线程名为watchdog/0,watchdog/1 …)
static struct smp_hotplug_thread watchdog_threads = {
    .store          = &softlockup_watchdog,
    .thread_should_run  = watchdog_should_run,
    .thread_fn      = watchdog,
    .thread_comm        = "watchdog/%u",
    .setup          = watchdog_enable,
    .park           = watchdog_disable,
    .unpark         = watchdog_enble,
};

2.该线程定期调用watchdog函数

static void __touch_watchdog(void)
{   
    /*更新watchdog运行时间戳*/
    __this_cpu_write(watchdog_touch_ts, get_timestamp());
}

static void watchdog(unsigned int cpu)
{
    /*更新softlock hrtimer cnt = hrtimer interrupts*/
    __this_cpu_write(soft_lockup_hrtimer_cnt,
             __this_cpu_read(hrtimer_interrupts));
    __touch_watchdog();
}

3.时间中断

static void watchdog_enable(unsigned int cpu)
{
    struct hrtimer *hrtimer = &__raw_get_cpu_var(watchdog_hrtimer);

    /* kick off the timer for the hardlockup detector */
    hrtimer_init(hrtimer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
    hrtimer->function = watchdog_timer_fn;

    /* done here because hrtimer_start can only pin to smp_processor_id() */
    hrtimer_start(hrtimer, ns_to_ktime(sample_period),
              HRTIMER_MODE_REL_PINNED);
}
}

该函数主要功能就是初始化一个高精度timer,唤醒watchdog 喂狗线程。
hrtimer的时间处理函数为:

static enum hrtimer_restart watchdog_timer_fn(struct hrtimer *hrtimer)
{
    //watchdog上次运行的时间戳
    unsigned long touch_ts = __this_cpu_read(watchdog_touch_ts);
    struct pt_regs *regs = get_irq_regs();
    int duration;
    //在唤醒watchdog kthread之前递增hrtimer_interrupts,保证kthread更新其时间戳
    watchdog_interrupt_count();
    //唤醒watchdog kthread,保证kthread与timer相同的运行频率
    wake_up_process(__this_cpu_read(softlockup_watchdog));
    //再次调度hrtimer下一个周期运行
    hrtimer_forward_now(hrtimer, ns_to_ktime(sample_period));

    ...

    //检测是否发生soft lockup
    duration = is_softlockup(touch_ts);
    if (unlikely(duration)) {
        printk(KERN_EMERG "BUG: soft lockup - CPU#%d stuck for %us! [%s:%d]\n",
            smp_processor_id(), duration,
            current->comm, task_pid_nr(current));
        print_modules();
        print_irqtrace_events(current);
        //dump 寄存器和堆栈
        if (regs)
            show_regs(regs);
        else
            dump_stack();

        if (softlockup_panic)
            panic("softlockup: hung tasks");
    } 
    return HRTIMER_RESTART;
}
//检查抢占被关闭的时间间隔
//watchdog kthread在watchdog timer的中断上下文中被唤醒,
//当中断退出时,kthread会抢占cpu上的当前进程。如果
//抢占被关闭的话,则不会发生抢占,watchdog便无法更新时
//间戳,当抢占关闭的时间超过阈值时,核心认为发生了soft
//lock up。
//注:soft lockup阈值 watchdog_thresh * 2 (20s)
3.2 static int is_softlockup(unsigned long touch_ts)
{
    //当前时间戳
    unsigned long now = get_timestamp(smp_processor_id());
    //watchdog在 watchdog_thresh * 2 时间内未被调度过
    if (time_after(now, touch_ts + get_softlockup_thresh()))
        return now - touch_ts;

    return 0;
}

函数主要任务:
(1)获取watchdog上次运行的时间戳
(2)递增watchdog timer运行次数
(3)检查watchdog时间戳,是否发生了soft lockup(如果发生了,dump堆栈,打印信息)
(4)重调度timer

lockup 检测函数:

static int is_softlockup(unsigned long touch_ts)
{
    //当前时间戳
    unsigned long now = get_timestamp(smp_processor_id());
    //watchdog在 watchdog_thresh * 2 时间内未被调度过
    if (time_after(now, touch_ts + get_softlockup_thresh()))
        return now - touch_ts;

    return 0;
}

hard lockup

hard lock主要在NMI中断中就行检测
1.初始化并使能hard lockup检测

static int watchdog_nmi_enable(unsigned int cpu)
{
    //hard lockup事件
    struct perf_event_attr *wd_attr;
    struct perf_event *event = per_cpu(watchdog_ev, cpu);
    ....
    wd_attr = &wd_hw_attr;
    //hard lockup检测周期,10s
    wd_attr->sample_period = hw_nmi_get_sample_period(watchdog_thresh);
    //向performance monitoring注册hard lockup检测事件
    event = perf_event_create_kernel_counter(wd_attr, cpu, NULL, watchdog_overflow_callback, NULL);
    ....
    //使能hard lockup的检测
    per_cpu(watchdog_ev, cpu) = event;
    perf_event_enable(per_cpu(watchdog_ev, cpu));
    return 0;
}

perf_event_create_kernel_counter函数主要是注册了一个硬件的事件。
这个硬件在x86里叫performance monitoring,这个硬件有一个功能就是在cpu clock经过了多少个周期后发出一个NMI中断出来。

2.当cpu全负荷跑完20秒后,就会有一个NMI中断发出,对应watchdog_overflow_callback。

static void watchdog_overflow_callback(struct perf_event *event,
         struct perf_sample_data *data,
         struct pt_regs *regs)
{
    //判断是否发生hard lockup
    if (is_hardlockup()) {
        int this_cpu = smp_processor_id();

        //打印hard lockup信息
        if (hardlockup_panic)
            panic("Watchdog detected hard LOCKUP on cpu %d", this_cpu);
        else
            WARN(1, "Watchdog detected hard LOCKUP on cpu %d", this_cpu);

        return;
    }
    return;
}

检测是否有hard lockup

static int is_hardlockup(void)
{
    //获取watchdog timer的运行次数
    unsigned long hrint = __this_cpu_read(hrtimer_interrupts);
    //在一个hard lockup检测时间阈值内,如果watchdog timer未运行,说明cpu中断被屏蔽时间超过阈值
    if (__this_cpu_read(hrtimer_interrupts_saved) == hrint)
        return 1;
    //记录watchdog timer运行的次数
    __this_cpu_write(hrtimer_interrupts_saved, hrint);
    return 0;
}

关闭hard lockup检测

static void watchdog_nmi_disable(unsigned int cpu)
{
    struct perf_event *event = per_cpu(watchdog_ev, cpu);
    if (event) {
        //向performance monitoring子系统注销hard lockup检测控制块
        perf_event_disable(event);
        //清空per-cpu hard lockup检测控制块
        per_cpu(watchdog_ev, cpu) = NULL;
        //释放hard lock检测控制块
        perf_event_release_kernel(event);
    }
    return;
}

你可能感兴趣的:(linux读核笔记)