Linux时间子系统(三) -- clockevent, tick device

转载请标明出处floater的csdn blog，http://blog.csdn.net/flaoter

1 clockevent

clockevent是具有编程和事件产生能力的定时器，在我使用的ARM SOC平台上底层依赖的硬件是ARM Generic Timer中的Timers。当然，在SOC系统中应该还会有其它的timer可以使用，但是本文的介绍只限于arm的timer。

1.1 数据结构

struct clock_event_device {    void            (*event_handler)(struct clock_event_device *); //事件处理函数指针    int         (*set_next_event)(unsigned long evt,                          struct clock_event_device *);  //设置下次触发事件，cycles    int         (*set_next_ktime)(ktime_t expires,                          struct clock_event_device *);  //设置下次触发事件，ktime    ktime_t         next_event;    u64         max_delta_ns;  //最大时间差ns    u64         min_delta_ns;  //最小时间差ns    u32         mult;    u32         shift;   //ns和cylces的转换关系    enum clock_event_mode   mode;    unsigned int        features;    unsigned long       retries;    void            (*broadcast)(const struct cpumask *mask);    void            (*set_mode)(enum clock_event_mode mode,                        struct clock_event_device *);    void            (*suspend)(struct clock_event_device *);    void            (*resume)(struct clock_event_device *);    unsigned long       min_delta_ticks;    unsigned long       max_delta_ticks;    const char      *name;    int         rating;    int         irq;    int         bound_on;    const struct cpumask    *cpumask;    struct list_head    list;    struct module       *owner;} ____cacheline_aligned;

• mode
这个成员是说明clockevent的工作模式，具体的mode设定是由set_mode这个callback函数来完成的。

 enum clock_event_mode {    CLOCK_EVT_MODE_UNUSED = 0,    CLOCK_EVT_MODE_SHUTDOWN,    CLOCK_EVT_MODE_PERIODIC,    CLOCK_EVT_MODE_ONESHOT,    CLOCK_EVT_MODE_RESUME,};

• feature
说明clockevetn设备的特征。CLOCK_EVT_FEAT_PERIODIC说明该硬件timer可以产生周期性的clock event，CLOCK_EVT_FEAT_ONESHOT说明该硬件timer可以产生单触发的clock event。不要将feature和mode的使用场景混淆。

#define CLOCK_EVT_FEAT_PERIODIC     0x000001  //产生周期触发事件的特征#define CLOCK_EVT_FEAT_ONESHOT      0x000002  //产生单触发事件的特征#define CLOCK_EVT_FEAT_KTIME        0x000004  //产生事件的时间基准是ktime，不是cycles

• list
内核使用如下两个链表来管理系统中的clock_event_device。clockevent_devices list中是当前active的device。

static LIST_HEAD(clockevent_devices);static LIST_HEAD(clockevents_released);

1.2 clockevent的建立过程

这里我先对clockevent的注册函数进行介绍，再对在ARM SOC平台调用它的流程进行说明。

1.2.1 clock_event_device的注册

注册函数如下，

void clockevents_register_device(struct clock_event_device *dev){    unsigned long flags;    BUG_ON(dev->mode != CLOCK_EVT_MODE_UNUSED);    if (!dev->cpumask) {        WARN_ON(num_possible_cpus() > 1);        dev->cpumask = cpumask_of(smp_processor_id());    }    raw_spin_lock_irqsave(&clockevents_lock, flags);    list_add(&dev->list, &clockevent_devices);  //将当前clock_event_device设备加入到clockevent_devices list中    tick_check_new_device(dev);  //通知tick device层进行处理，clockevent的替换也在该函数进行    clockevents_notify_released(); //遍历clockevents_released list，添加到clockevent_devices list中    raw_spin_unlock_irqrestore(&clockevents_lock, flags);}

tick_check_new_device是tick device层的函数，在此只列出它调用的clockevents_exchange_device，clockevents_exchange_device函数不再展开了，它实现将curdev从clockevent_devices list中删除，添加到clockevents_released list中。

void tick_check_new_device(struct clock_event_device *newdev){...//前面有很多情况的判断，在后续章节中会有介绍    clockevents_exchange_device(curdev, newdev); //将curdev从clockevent_devices list中删除，添加到clockevents_released list中    tick_setup_device(td, newdev, cpu, cpumask_of(cpu));...}

1.2.2 ARM SOC平台上clockevent的注册

在上一节介绍clocksource的注册时提到过在内核启动阶段的time_init函数的clocksource_of_init中，会对段__clksrc_of_table进行解析，armv8_arch_timer的注册函数arch_timer_init会被调用，在本小节会对此函数进行详解。
在解析此函数之前，先看看dts中关于此timer的定义，

timer {        compatible = "arm,armv8-timer";        interrupts = <GIC_PPI 13 (GIC_CPU_MASK_SIMPLE(8)                     | IRQ_TYPE_LEVEL_LOW)>,                 <GIC_PPI 14 (GIC_CPU_MASK_SIMPLE(8)                     | IRQ_TYPE_LEVEL_LOW)>,                 <GIC_PPI 11 (GIC_CPU_MASK_SIMPLE(8)                     | IRQ_TYPE_LEVEL_LOW)>,                 <GIC_PPI 10 (GIC_CPU_MASK_SIMPLE(8)                     | IRQ_TYPE_LEVEL_LOW)>;        clock-frequency = <26000000>;    };

在时间子系统（一）中曾经对ARM Generic Timer进行过说明，每个processor都有如下四个timer， 并且由于它们都是cpu私有的，所以产生的中断都是PPI类型的。
• A Non-secure EL1 physical timer.
• A Secure EL1 physical timer.
• A Non-secure EL2 physical timer.
• A virtual timer.
关于这几个中断，在内核中有如下枚举描述。

enum ppi_nr {    PHYS_SECURE_PPI,    PHYS_NONSECURE_PPI,    VIRT_PPI,    HYP_PPI,    MAX_TIMER_PPI};

回顾了这些知识后，在对arch_timer_init进行解析。

static void __init arch_timer_init(struct device_node *np){    int i;    if (arch_timers_present & ARCH_CP15_TIMER) {        pr_warn("arch_timer: multiple nodes in dt, skipping\n");        return;    }    arch_timers_present |= ARCH_CP15_TIMER;  //CP15方式访问    for (i = PHYS_SECURE_PPI; i < MAX_TIMER_PPI; i++)        arch_timer_ppi[i] = irq_of_parse_and_map(np, i);  //分析dt，申请irq num    arch_timer_detect_rate(NULL, np);  //timer时钟频率    /*     * If HYP mode is available, we know that the physical timer     * has been configured to be accessible from PL1. Use it, so     * that a guest can use the virtual timer instead.     *     * If no interrupt provided for virtual timer, we'll have to     * stick to the physical timer. It'd better be accessible...     *///如果hyper模式可用或者没给virtual timer分配中断号，需要使用physical timer//hyper模式下，guest OS需要访问virtual timer，我们还是使用physical timer    if (is_hyp_mode_available() || !arch_timer_ppi[VIRT_PPI]) {          arch_timer_use_virtual = false;                             if (!arch_timer_ppi[PHYS_SECURE_PPI] ||            !arch_timer_ppi[PHYS_NONSECURE_PPI]) {            pr_warn("arch_timer: No interrupt available, giving up\n");            return;        }    }    arch_timer_c3stop = !of_property_read_bool(np, "always-on");    arch_timer_register(); //arch timer的注册    arch_timer_common_init(); //之前介绍clocksource的章节有过介绍}

请注意下面arch_timer_register中使用的是percpu类型的变量，clock_event_device是percpu的资源。

static int __init arch_timer_register(void){    int err;    int ppi;    arch_timer_evt = alloc_percpu(struct clock_event_device);  //为clock_event_device类型的percpu变量申请内存    if (!arch_timer_evt) {        err = -ENOMEM;        goto out;    }    if (arch_timer_use_virtual) {        ppi = arch_timer_ppi[VIRT_PPI];        err = request_percpu_irq(ppi, arch_timer_handler_virt,                     "arch_timer", arch_timer_evt);    } else {  //为physcal timer申请中断，需要分别注册secure和non-secure physical timer PPI        ppi = arch_timer_ppi[PHYS_SECURE_PPI];        err = request_percpu_irq(ppi, arch_timer_handler_phys,                     "arch_timer", arch_timer_evt);        if (!err && arch_timer_ppi[PHYS_NONSECURE_PPI]) {            ppi = arch_timer_ppi[PHYS_NONSECURE_PPI];            err = request_percpu_irq(ppi, arch_timer_handler_phys,                         "arch_timer", arch_timer_evt);            if (err)                free_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI],                        arch_timer_evt);        }    }    if (err) {        pr_err("arch_timer: can't register interrupt %d (%d)\n",               ppi, err);        goto out_free;    }    err = register_cpu_notifier(&arch_timer_cpu_nb);    if (err)        goto out_free_irq;    err = arch_timer_cpu_pm_init();    if (err)        goto out_unreg_notify;    /* Immediately configure the timer on the boot CPU */    arch_timer_setup(this_cpu_ptr(arch_timer_evt));   //注册clock event device    return 0;}

平台的percpu timer硬件寄存器都是通过CP15方式来访问。

static int arch_timer_setup(struct clock_event_device *clk){    __arch_timer_setup(ARCH_CP15_TIMER, clk);  //通过协处理器CP15访问timer的寄存器    if (arch_timer_use_virtual)        enable_percpu_irq(arch_timer_ppi[VIRT_PPI], 0);    else {        enable_percpu_irq(arch_timer_ppi[PHYS_SECURE_PPI], 0);  //使能中断        if (arch_timer_ppi[PHYS_NONSECURE_PPI])            enable_percpu_irq(arch_timer_ppi[PHYS_NONSECURE_PPI], 0);    }    arch_counter_set_user_access();    if (IS_ENABLED(CONFIG_ARM_ARCH_TIMER_EVTSTREAM))        arch_timer_configure_evtstream();    return 0;}static void __arch_timer_setup(unsigned type,                   struct clock_event_device *clk){//clock_event_device变量赋值    clk->features = CLOCK_EVT_FEAT_ONESHOT;    if (type == ARCH_CP15_TIMER) {           if (arch_timer_c3stop)            clk->features |= CLOCK_EVT_FEAT_C3STOP;        clk->name = "arch_sys_timer";        clk->rating = 450;        clk->cpumask = cpumask_of(smp_processor_id());        if (arch_timer_use_virtual) {            clk->irq = arch_timer_ppi[VIRT_PPI];            clk->set_mode = arch_timer_set_mode_virt;            clk->set_next_event = arch_timer_set_next_event_virt;        } else {            clk->irq = arch_timer_ppi[PHYS_SECURE_PPI];            clk->set_mode = arch_timer_set_mode_phys;            clk->set_next_event = arch_timer_set_next_event_phys;        }    } else {        clk->features |= CLOCK_EVT_FEAT_DYNIRQ;        clk->name = "arch_mem_timer";        clk->rating = 400;        clk->cpumask = cpu_all_mask;        if (arch_timer_mem_use_virtual) {            clk->set_mode = arch_timer_set_mode_virt_mem;            clk->set_next_event =                arch_timer_set_next_event_virt_mem;        } else {            clk->set_mode = arch_timer_set_mode_phys_mem;            clk->set_next_event =                arch_timer_set_next_event_phys_mem;        }    }    clk->set_mode(CLOCK_EVT_MODE_SHUTDOWN, clk);    clockevents_config_and_register(clk, arch_timer_rate, 0xf, 0x7fffffff);  //注册clock_event_device}

通过__arch_timer_setup函数可见arch-timer的feature并不支持CLOCK_EVT_FEAT_PERIODIC。

void clockevents_config_and_register(struct clock_event_device *dev,                     u32 freq, unsigned long min_delta,                     unsigned long max_delta){    dev->min_delta_ticks = min_delta;    dev->max_delta_ticks = max_delta;    clockevents_config(dev, freq);    clockevents_register_device(dev);}

clockevents_register_device已经在1.2.1节中进行了解析。至此，clockevent的注册过程就完成了。
内核中还有为应用层提供了sysfs的接口，实现过程不再描述了，可以通过如下接口查看。

cat /sys/devices/system/clockevents/clockevent0/current_device arch_sys_timercat /sys/devices/system/clockevents/clockevent1/current_device arch_sys_timer

此外，除了cpu core上的clockevent设备外，kernel中还有broadcast的clockevent注册，在此处也不说明了。

2 tick device

2.1 数据结构

struct tick_device只是对struct clock_event_device的一个封装，加入了运行模式变量，支持PERIODIC和ONESHOT两种模式。

struct tick_device {      struct clock_event_device *evtdev;      enum tick_device_mode mode;  }; enum tick_device_mode {    TICKDEV_MODE_PERIODIC,    TICKDEV_MODE_ONESHOT,};

请注意此处的TICKDEV_MODE_PERIODIC与clock_event_device的成员feature CLOCK_EVT_FEAT_PERIODIC不要一起理解，即使是CLOCK_EVT_FEAT_ONESHOT的clockevent也可以支持TICKDEV_MODE_PERIODIC模式的tick device。

2.2 tickdevice的建立过程

在clock_event_device的注册过程中会调用tick_check_new_device通知tick device层进行处理，上文中只介绍了更新clockevent，此处对检查处理和tick device设备的创建进行说明。
此函数中的条件判断很多，一些场景在我使用的平台并没有出现，所以我只能按照代码进行理解了。

void tick_check_new_device(struct clock_event_device *newdev){    struct clock_event_device *curdev;    struct tick_device *td;    int cpu;    cpu = smp_processor_id();  //获得本地cpu id    if (!cpumask_test_cpu(cpu, newdev->cpumask))  //是否为本cpu服务        goto out_bc;    td = &per_cpu(tick_cpu_device, cpu);  //获取当前cpu的tick device    curdev = td->evtdev;      /* cpu local device ? *///此处判断比较复杂，如果newdev只为此cpu服务，继续注册。否则clockevent可以服务多个cpu，这种情况我使用的平台没有出现，不太理解它的处理。    if (!tick_check_percpu(curdev, newdev, cpu))        goto out_bc;    /* Preference decision *///根据是否支持单触发模式和它的rating值，决定是否替换原来旧的clock_event_device，代码不再进行展开了    if (!tick_check_preferred(curdev, newdev))           goto out_bc;    if (!try_module_get(newdev->owner))        return;    /*     * Replace the eventually existing device by the new     * device. If the current device is the broadcast device, do     * not give it back to the clockevents layer !     */    if (tick_is_broadcast_device(curdev)) {        clockevents_shutdown(curdev);        curdev = NULL;    }    clockevents_exchange_device(curdev, newdev);   //更新clockevent    tick_setup_device(td, newdev, cpu, cpumask_of(cpu));      if (newdev->features & CLOCK_EVT_FEAT_ONESHOT)        tick_oneshot_notify();    return;}

根据tick_device_mode会建立周期性的或单触发的tick_device。如果是第一次setup，只能建立周期模式的tick device。

static void tick_setup_device(struct tick_device *td,                  struct clock_event_device *newdev, int cpu,                  const struct cpumask *cpumask){    ktime_t next_event;    void (*handler)(struct clock_event_device *) = NULL;    /*     * First device setup ?     */    if (!td->evtdev) {   //当前cpu第一次注册tick_device        /*         * If no cpu took the do_timer update, assign it to         * this cpu:         */        if (tick_do_timer_cpu == TICK_DO_TIMER_BOOT) {  //需要有一个global的tick device管理全局的jiffies等时间信息            if (!tick_nohz_full_cpu(cpu))                tick_do_timer_cpu = cpu;            else                tick_do_timer_cpu = TICK_DO_TIMER_NONE;            tick_next_period = ktime_get();            tick_period = ktime_set(0, NSEC_PER_SEC / HZ);        }        /*         * Startup in periodic mode first.         */        td->mode = TICKDEV_MODE_PERIODIC;  //当前cpu第一次设定tick device的时候，缺省设定为周期性的tick    } else {        handler = td->evtdev->event_handler;        next_event = td->evtdev->next_event;        td->evtdev->event_handler = clockevents_handle_noop;    }    td->evtdev = newdev;  //将新的clock_event_device赋值给tick_device    /*     * When the device is not per cpu, pin the interrupt to the     * current cpu:     */    if (!cpumask_equal(newdev->cpumask, cpumask))        irq_set_affinity(newdev->irq, cpumask);    /*     * When global broadcasting is active, check if the current     * device is registered as a placeholder for broadcast mode.     * This allows us to handle this x86 misfeature in a generic     * way. This function also returns !=0 when we keep the     * current active broadcast state for this CPU.     */    if (tick_device_uses_broadcast(newdev, cpu))        return;    if (td->mode == TICKDEV_MODE_PERIODIC)        tick_setup_periodic(newdev, 0);    else        tick_setup_oneshot(newdev, handler, next_event);}

配置周期性的tick_device，需要调用tick_setup_periodic。前面说过cpu第一次设置tick_device时默认配置成周期触发，所以启动阶段每个cpu都会调用tick_setup_period。

void tick_setup_periodic(struct clock_event_device *dev, int broadcast){    tick_set_periodic_handler(dev, broadcast);   //(1)    /* Broadcast setup ? */    if (!tick_device_is_functional(dev))        return;    if ((dev->features & CLOCK_EVT_FEAT_PERIODIC) &&           !tick_broadcast_oneshot_active()) {     //(2)        clockevents_set_mode(dev, CLOCK_EVT_MODE_PERIODIC);    } else {    //(3)        unsigned long seq;        ktime_t next;        do {            seq = read_seqbegin(&jiffies_lock);            next = tick_next_period;        } while (read_seqretry(&jiffies_lock, seq));        clockevents_set_mode(dev, CLOCK_EVT_MODE_ONESHOT);        for (;;) {            if (!clockevents_program_event(dev, next, false))                return;            next = ktime_add(next, tick_period);        }    }}

(1)设置event_handler=tick_handle_periodic
(2)clock_event_device支持周期触发，只需要设置clock_event_device的模式为周期触发
(3)clock_event_device不支持周期触发，将clock_event_device设置为单触发模式，并使用clockevents_program_event编程设置下一事件。
在下一次clockevent事件发生时都会调用tick_handle_periodic。
周期性tick的clock event handler的处理函数tick_handle_periodic分析如下，

void tick_handle_periodic(struct clock_event_device *dev){    int cpu = smp_processor_id();    ktime_t next = dev->next_event;    tick_periodic(cpu);  //(1)    if (dev->mode != CLOCK_EVT_MODE_ONESHOT)  //模式为周期模式的clockevent直接返回        return;    for (;;) {  //模式为单触发的clockevent还需要按照前面的配置，再使用clockevents_program_event编程设置下一事件        /*         * Setup the next period for devices, which do not have         * periodic mode:         */        next = ktime_add(next, tick_period);        if (!clockevents_program_event(dev, next, false))            return;        /*         * Have to be careful here. If we're in oneshot mode,         * before we call tick_periodic() in a loop, we need         * to be sure we're using a real hardware clocksource.         * Otherwise we could get trapped in an infinite         * loop, as the tick_periodic() increments jiffies,         * which then will increment time, possibly causing         * the loop to trigger again and again.         */        if (timekeeping_valid_for_hres())            tick_periodic(cpu);    }}

tick_period会处理全局的时间信息更新任务和本地cpu上的进程时间信息。处理全局时间jiffies时，它需要选用一个全局的tick device来执行。

static void tick_periodic(int cpu){    if (tick_do_timer_cpu == cpu) {   //如果当前tick_device是全局的tick_device        write_seqlock(&jiffies_lock);        /* Keep track of the next tick event */        tick_next_period = ktime_add(tick_next_period, tick_period);        do_timer(1);  //更新jiffies        write_sequnlock(&jiffies_lock);        update_wall_time(); //更新墙上时间    }    update_process_times(user_mode(get_irq_regs()));  //更新进程的时间信息，并调用周期调度器schedulet_tick    profile_tick(CPU_PROFILING);}

到此介绍了每个cpu的tick_device的注册，启动阶段tick_device工作在周期触发模式，并且它对应的event_handler为tick_handle_periodic。在高分辨时钟(CONFIG_HIGH_RES_TIMERS)和动态时钟(CONFIG_TICKLESS)特性开启后还会有变化。