定时器的框架

http://blog.chinaunix.net/uid-25942458-id-3412140.html
linux2.6.22之前没有引入高精度定时器的框架，系统中的各个架构都有一套自己的时间和定时器管理框架，这样就带来几个麻烦：1、重复代码太多 2、原来的框架不适于高精度定时器的加入，精度不够等。所以，linux后面通过引入clocksource和clockevent对时钟源和定时器进行了抽象，有了一个统一的抽象框架，而各个架构只需要适配这个框架即可，同时，又可以引入高精度定时器。

一、介绍几个基本概念

时钟源：定义如下：

struct clocksource {
    /*
     * First part of structure is read mostly
     */
    char *name; //时钟源的名字
    struct list_head list;//时钟源链表，系统中的时钟源都是挂在一个链表上的
    int rating;//时钟源的质量或者精度，数字越大越好，通常300~399是精度比较高的
    cycle_t (*read)(struct clocksource *cs);//对时钟源操作的函数
    int (*enable)(struct clocksource *cs);
    void (*disable)(struct clocksource *cs);
    cycle_t mask;
    u32 mult;
    u32 shift;
    u64 max_idle_ns;
    unsigned long flags;
    cycle_t (*vread)(void);
    void (*suspend)(struct clocksource *cs);
    void (*resume)(struct clocksource *cs);
#ifdef CONFIG_IA64
    void *fsys_mmio; /* used by fsyscall asm code */
#define CLKSRC_FSYS_MMIO_SET(mmio, addr) ((mmio) = (addr))
#else
#define CLKSRC_FSYS_MMIO_SET(mmio, addr) do { } while (0)
#endif

    /*
     * Second part is written at each timer interrupt
     * Keep it in a different cache line to dirty no
     * more than one cache line.
     */
    cycle_t cycle_last ____cacheline_aligned_in_smp;

#ifdef CONFIG_CLOCKSOURCE_WATCHDOG
    /* Watchdog related data, used by the framework */
    struct list_head wd_list;
    cycle_t wd_last;
#endif
}

时钟时间设备：定义如下：

struct clock_event_device {
    const char        *name;//时钟时间设备的名称
    unsigned int        features;
    u64            max_delta_ns;//这个和下一个域指定了当前时间和下一次时间的触发时间之间的差值，分别为最小值和最大值
    u64            min_delta_ns;
    u32            mult;//和下面的域分别是乘数和位移数，用于在时钟周期数和纳秒值之间转换。
    u32            shift;
    int            rating;
    int            irq;//指定时间设备使用的irq号，只有全局设备才使用这个号
    const struct cpumask    *cpumask;
    int            (*set_next_event)(unsigned long evt,
                         struct clock_event_device *);
    void            (*set_mode)(enum clock_event_mode mode,
                     struct clock_event_device *);
    void            (*event_handler)(struct clock_event_device *);//时钟时间设备的处理函数
    void            (*broadcast)(const struct cpumask *mask);
    struct list_head    list;
    enum clock_event_mode    mode;
    ktime_t            next_event;
    unsigned long        retries;
}

时钟设备：定义如下：

enum tick_device_mode {
    TICKDEV_MODE_PERIODIC,
    TICKDEV_MODE_ONESHOT,
};

struct tick_device {
    struct clock_event_device *evtdev;//从这里可以看出时钟设备就是时钟事件设备的一个封装
    enum tick_device_mode mode;//时钟设备的模式，分为一次性模式和周期性模式，如上面枚举定义所示
};

二、低精度定时器的运作

系统启动之初运作的就是低精度定时器，后面到一定的时机就会切换到高精度定时器。低精度定时器主要相关的步骤为：tick_init --> time_init -->每个时钟周期（HZ）调用timer_interrupt

1、tick_init定义如下，主要完成的功能就是注册一个添加设备的时间通知链，当注册一个新设备时：

发送CLOCK_EVT_NOTIFY_ADD事件 --》调用tick_check_new_device --》调用tick_setup_device安装设备（当然，先判断是否比当前现有的设备好） --》判断，若是首次安装设备，设置TICKDEV_MODE_PERIODIC标志 --》若上一步设置了周期模式，则调用tick_setup_periodic --》tick_set_periodic_handler --》安装tick_handle_periodic函数

static int tick_notify(struct notifier_block *nb, unsigned long reason,
             void *dev)
{
    switch (reason) {

    case CLOCK_EVT_NOTIFY_ADD://最关键的就是这一步，添加一个事件设备就会进入这一步
        return tick_check_new_device(dev);

    case CLOCK_EVT_NOTIFY_BROADCAST_ON:
    case CLOCK_EVT_NOTIFY_BROADCAST_OFF:
    case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:
        tick_broadcast_on_off(reason, dev);
        break;

    case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:
    case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:
        tick_broadcast_oneshot_control(reason);
        break;

    case CLOCK_EVT_NOTIFY_CPU_DYING:
        tick_handover_do_timer(dev);
        break;

    case CLOCK_EVT_NOTIFY_CPU_DEAD:
        tick_shutdown_broadcast_oneshot(dev);
        tick_shutdown_broadcast(dev);
        tick_shutdown(dev);
        break;

    case CLOCK_EVT_NOTIFY_SUSPEND:
        tick_suspend();
        tick_suspend_broadcast();
        break;

    case CLOCK_EVT_NOTIFY_RESUME:
        tick_resume();
        break;

    default:
        break;
    }

    return NOTIFY_OK;
}

static struct notifier_block tick_notifier = {
    .notifier_call = tick_notify,
};

/**
 * tick_init - initialize the tick control
 *
 * Register the notifier with the clockevents framework
 */
void __init tick_init(void)
{
    clockevents_register_notifier(&tick_notifier);
}

2、time_init定义如下，从下面的注释大意应当可以理解，在这一步就利用上了第一步的时钟时间设备添加时间，最终注册了高精度定时器设备，同时，把timer_interrupt要用的全局事件处理函数tick_handle_periodic也注册上去后，最后调用中断注册，将timer_interrupt与0号中断绑定，一切都是那么顺利成章。

static irqreturn_t timer_interrupt(int irq, void *dev_id)
{
 /* Keep nmi watchdog up to date */
 inc_irq_stat(irq0_irqs);
 /* Optimized out for !IO_APIC and x86_64 */
 if (timer_ack) {
  /*
   * Subtle, when I/O APICs are used we have to ack timer IRQ
   * manually to deassert NMI lines for the watchdog if run
   * on an 82489DX-based system.
   */
  raw_spin_lock(&i8259A_lock);
  outb(0x0c, PIC_MASTER_OCW3);
  /* Ack the IRQ; AEOI will end it automatically. */
  inb(PIC_MASTER_POLL);
  raw_spin_unlock(&i8259A_lock);
 }
 global_clock_event->event_handler(global_clock_event);//最终注册了tick_handle_periodic函数
 /* MCA bus quirk: Acknowledge irq0 by setting bit 7 in port 0x61 */
 if (MCA_bus)
  outb_p(inb_p(0x61)| 0x80, 0x61);
 return IRQ_HANDLED;
}

static struct irqaction irq0 = {
    .handler = timer_interrupt,
    .flags = IRQF_DISABLED | IRQF_NOBALANCING | IRQF_IRQPOLL | IRQF_TIMER,
    .name = "timer"
};

void __init setup_default_timer_irq(void)
{
    setup_irq(0, &irq0);
}

/* Default timer init function */
void __init hpet_time_init(void)
{
    if (!hpet_enable())//注册一个高精度定时器事件设备，根据第一步的分析，也就是把tick_handle_periodic函数注册到全局事件处理函数上去，便于timer_interrupt的最终调用
        setup_pit_timer();
    setup_default_timer_irq();//将timer_interrupt注册到0号中断上去
}

static __init void x86_late_time_init(void)
{
    x86_init.timers.timer_init();//最终调用hpet_time_init
    tsc_init();
}

/*
 * Initialize TSC and delay the periodic timer init to
 * late x86_late_time_init() so ioremap works.
 */
void __init time_init(void)
{
    late_time_init = x86_late_time_init;
}

3、之后，在每个时钟周期，timer_interrupt就会被调用一次，也就是tick_handle_periodic被调用一次，最终，也就是jiffy值不断的增加，进程统计及低精度定时器和部分高精度定时器链表上的定时器被处理。

三、高精度定时器

高精度定时器基于红黑树来实现，且基于两种时钟：单调时钟和实际时钟。每个cpu都提供两种时钟基础，每个时钟基础都有一颗红黑树，用来排序待决的高精度定时器。

时钟基础hrtimer_clock_base，定义如下：

struct hrtimer_clock_base {
    struct hrtimer_cpu_base    *cpu_base;//指向该时钟基础所属的各cpu的时候基础结构
    clockid_t        index;//用来区分是哪种时钟基础
    struct rb_root        active;//红黑树结构
    struct rb_node        *first;//指向第一个到期的定时器
    ktime_t            resolution;//定时器分辨率纳秒
    ktime_t            (*get_time)(void);
    ktime_t            softirq_time;
#ifdef CONFIG_HIGH_RES_TIMERS
    ktime_t            offset;
#endif
}

每个cpu建立两个时钟基础的结构，定义如下

struct hrtimer_cpu_base {
    raw_spinlock_t            lock;
    struct hrtimer_clock_base    clock_base[HRTIMER_MAX_CLOCK_BASES];//包含两个时钟基础结构
#ifdef CONFIG_HIGH_RES_TIMERS
    ktime_t                expires_next;//将要到期的下一个时间的绝对时间
    int                hres_active;//高分辨率模式是否已经使用
    int                hang_detected;
    unsigned long            nr_events;
    unsigned long            nr_retries;
    unsigned long            nr_hangs;
    ktime_t                max_hang_time;
#endif
}

从上面可以看到，每个cpu有一个base，这个base包含两个clockbase，两个clockbase又各自包含一个红黑树用来管理高精度定时器。那么，每个红黑树上的高精度定时器是怎么定义的呢？如下：

struct hrtimer {
    struct rb_node            node;//将高精度定时器维持在红黑树上
    ktime_t                _expires;
    ktime_t                _softexpires;
    enum hrtimer_restart        (*function)(struct hrtimer *);//高精度定时器回调函数
    struct hrtimer_clock_base    *base;//指向时钟基础
    unsigned long            state;
#ifdef CONFIG_TIMER_STATS
    int                start_pid;
    void                *start_site;
    char                start_comm[16];
#endif
}

那么高精度定时器如何被处理的呢？分两种情况：一个是高分辨率模式下高精度定时器的处理；二个是低分辨率模式下高精度定时器的处理。为什么会有低分辨率模式下高精度定时器处理呢？主要是因为避免在不启动高精度定时器时候，高精度定时器由一个低分辨率时钟驱动，而不用提供额外版本支持。

1、高分辨率模式下高精度定时器的处理：主要是通过高精度时钟中断中回调hrtimer_interrupt来实现，而其大概原理如下：

void hrtimer_interrupt(struct clock_event_device *dev)
{
    struct hrtimer_cpu_base *cpu_base = &__get_cpu_var(hrtimer_bases);//获取所在cpu的时钟基础
。。。。。。

    base = cpu_base->clock_base;//获取cpu上的时钟基础

    for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {//遍历两个时钟基础
        ktime_t basenow;
        struct rb_node *node;

        basenow = ktime_add(now, base->offset);

        while ((node = base->first)) {//获取到期的定时器
            struct hrtimer *timer;

            timer = rb_entry(node, struct hrtimer, node);//获取相应的节点


            if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {
                ktime_t expires;
               //判断是否过期
                expires = ktime_sub(hrtimer_get_expires(timer),
                         base->offset);
                if (expires.tv64 < expires_next.tv64)
                    expires_next = expires;
                break;//没过期直接退出
            }

            __run_hrtimer(timer, &basenow);//处理过期的定时器
        }
        base++;
    }
。。。。。。
//重新编程时钟时间，便于下一次到期
    /* Reprogramming necessary ? */
    if (expires_next.tv64 == KTIME_MAX ||
     !tick_program_event(expires_next, 0)) {
        cpu_base->hang_detected = 0;
        return;
    }
。。。。。。
    if (delta.tv64 > 100 * NSEC_PER_MSEC)
        expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);
    else
        expires_next = ktime_add(now, delta);
    tick_program_event(expires_next, 1);//重新编程下一次超时事件
    printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns\n",
         ktime_to_ns(delta));
}

处理超期的定时器：

static void __run_hrtimer(struct hrtimer *timer, ktime_t *now)
{
。。。。。。

    debug_deactivate(timer);
    __remove_hrtimer(timer, base, HRTIMER_STATE_CALLBACK, 0);
    timer_stats_account_hrtimer(timer);
    fn = timer->function;

//具体回调超期的定时器
    trace_hrtimer_expire_entry(timer, now);
    restart = fn(timer);
    trace_hrtimer_expire_exit(timer);
    raw_spin_lock(&cpu_base->lock);
//取消回调标志
    timer->state &= ~HRTIMER_STATE_CALLBACK;
}

低分辨率下的高分辨率定时器hrtimer_run_queues，其主要被调用两个时机：一个是低分辨率时钟中断处理函数tick_handle_periodic中会调用，二是在周期时钟仿真中tick_sched_timer调用。

void hrtimer_run_queues(void)
{
    。。。。。。
//判断高精度定时器是否已经开启，若是开启，则不执行，直接返回。
    if (hrtimer_hres_active())
        return;
//遍历两个时钟基础
    for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {
        base = &cpu_base->clock_base[index];

        if (!base->first)
            continue;

        if (gettime) {
            hrtimer_get_softirq_time(cpu_base);
            gettime = 0;
        }

        raw_spin_lock(&cpu_base->lock);
//找到到期的高精度定时器
        while ((node = base->first)) {
            struct hrtimer *timer;

            timer = rb_entry(node, struct hrtimer, node);
            if (base->softirq_time.tv64 <=
                    hrtimer_get_expires_tv64(timer))
                break;
//处理高精度定时器
            __run_hrtimer(timer, &base->softirq_time);
        }
        raw_spin_unlock(&cpu_base->lock);
    }
}

这里我们会发现一个问题，就是到了高精度定时器后，tick_handle_periodic就不再提供周期时钟信号，而高精度定时器也要提供一个同样功能的函数，这个时候就要提到了周期时钟仿真的概念。

周期时钟仿真：当切换到高精度定时器时，tick_setup_sched_timer来激活时钟仿真层，为每个cpu安装一个高分辨率定时器。

void tick_setup_sched_timer(void)
{
    struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);
    ktime_t now = ktime_get();
    u64 offset;

    /*
     * Emulate tick processing via per-CPU hrtimers:
     */
    hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);
    ts->sched_timer.function = tick_sched_timer;//该定时器的回调函数选择了tick_sched_timer
。。。。。。

    for (;;) {
        hrtimer_forward(&ts->sched_timer, now, tick_period);//重新定时
        hrtimer_start_expires(&ts->sched_timer,
                 HRTIMER_MODE_ABS_PINNED);
        /* Check, if the timer was already in the past */
        if (hrtimer_active(&ts->sched_timer))
            break;
        now = ktime_get();
    }

#ifdef CONFIG_NO_HZ
    if (tick_nohz_enabled)
        ts->nohz_mode = NOHZ_MODE_HIGHRES;
#endif
}

每个时钟周期仿真最终调用函数为：

static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)
{
    。。。。。
    /* Check, if the jiffies need an update */
    if (tick_do_timer_cpu == cpu)
        tick_do_update_jiffies64(now);//更新jiffy

    /*
     * Do not call, when we are not in irq context and have
     * no valid regs pointer
     */
    if (regs) {
        。。。。。。
        update_process_times(user_mode(regs));//更新进程相关信息
        profile_tick(CPU_PROFILING);
    }

    hrtimer_forward(timer, now, tick_period);//重新定时

    return HRTIMER_RESTART;
}

三、低分辨定时器切换到高分辨率定时器

主要是通过下面的内容来实现切换的：

int tick_init_highres(void)
{
    return tick_switch_to_oneshot(hrtimer_interrupt);
}

int tick_switch_to_oneshot(void (*handler)(struct clock_event_device *))
{
    struct tick_device *td = &__get_cpu_var(tick_cpu_device);//每cpu的时钟设备
    struct clock_event_device *dev = td->evtdev;

。。。。。。

    td->mode = TICKDEV_MODE_ONESHOT;
    dev->event_handler = handler;//切换处理函数，此时就切换为hrtimer_interrupt
    clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);//设置为一次性模式
    tick_broadcast_switch_to_oneshot();
    return 0;
}

每个软中断中会检查是否有高精度定时器可以切换，若是有，直接切换高精度定时器。其调用路径如下：
软中断发生 --》 run_timer_softirq--》hrtimer_run_pending --》hrtimer_switch_to_hres--》tick_init_highres（切换高精端定时器） + tick_setup_sched_timer（启动周期仿真层）