码迷,mamicode.com
首页 > 系统相关 > 详细

Linux时间子系统(十六) clockevent

时间:2018-02-14 15:07:34      阅读:43      评论:0      收藏:0      [点我收藏+]

标签:new   长度   end   cas   linux时间   用两个   方便   release   amp   

一、clock event控制的通用逻辑

1、产生clock event的设备

各种系统的timer硬件形形色色,不过在general clock event device layer,struct clock_event_device被来抽象一个可以产生clock event的timer硬件设备,如下:

struct clock_event_device {
    void          (*event_handler)(struct clock_event_device *);
    int            (*set_next_event)(unsigned long evt,   struct clock_event_device *);
    int            (*set_next_ktime)(ktime_t expires,     struct clock_event_device *);
    ktime_t       next_event;
    u64            max_delta_ns;
    u64            min_delta_ns;
    u32            mult;
    u32            shift;
    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; -------------使用的IRQ number
    const struct cpumask    *cpumask; ----该clock event device附着在哪一个CPU core上
    struct list_head    list;
    struct module        *owner;
} ____cacheline_aligned;

在把目光投向每一个成员之前,我们先聊一聊____cacheline_aligned,其实最开始定义这个数据结构的时候没有这个属性,而且struct clock_event_device的各个成员也不是这样排列的。为了提高cacheline hit radio,内核工程师对这个数据结构进行的改造,一方面对齐了cache line,另外一方面重排了那些有密切关系的成员(所谓密切关系就是指在代码执行上下文中,如果访问了A成员,有非常大的概率访问B成员)。

event_handler顾名思义就是产生了clock event的时候调用的handler。一般而言,底层的clock event chip driver会注册中断处理函数,在硬件timer中断到来的时候调用该timer中断handler,而在这个中断handler中再调用event_handler。

既然是产生clock event的device,那么总是要控制下一次event产生的时间点,我们有两个成员函数完成这个功能:set_next_event和set_next_ktime。set_next_ktime函数可以直接接收ktime作为参数,而set_next_event设定的counter的cycle数值。一般的timer硬件都是用cycle值设定会比较方便,当然,不排除有些奇葩可以直接使用ktime(秒、纳秒),这时候clock event device的features成员要打上CLOCK_EVT_FEAT_KTIME的标记。

features成员是描述底层硬件的功能feature的,包括:

#define CLOCK_EVT_FEAT_PERIODIC        0x000001------具备产生周期性event的能力
#define CLOCK_EVT_FEAT_ONESHOT        0x000002-----具备产生oneshot类型event的能力
#define CLOCK_EVT_FEAT_KTIME        0x000004-------上面已经描述了

#define CLOCK_EVT_FEAT_C3STOP        0x000008
#define CLOCK_EVT_FEAT_DUMMY        0x000010

CLOCK_EVT_FEAT_C3STOP是一个很有意思的feature:内核中有一个模块叫做cpuidle framework,当没有任务做的时候,cpu会进入idle状态。这种CPU的sleep state叫做C-states,有C1/C2…Cn种states(具体多少种和CPU设计相关),当然不同的状态是在功耗和唤醒时间上进行平衡,CPU睡的越浅,功耗越大,但是能够很快的唤醒。一般而言,在sleep state的CPU可以被local timer唤醒,但是,当CPU进入某个深度睡眠状态的时候,停止了local timer的运作,这时候,local timer将无法唤醒CPU了。

kernel的注释说这是一个x86(64)的功能设计失误(misfeature),不过,在嵌入式平台上,这也可以认为是对功耗的极致追求(ARM 的generic timer也有这个misfeature,呵呵~~)。为了让系统可以继续运作,传说中tick broadcast framework粉墨登场了。struct clock_event_device中的broadcast这个callback函数是和clock event广播有关。在per CPU 的local timer硬件无法正常运作的时候,需要一个独立于各个CPU的timer硬件来作为broadcast clock event device。在这种情况下,它可以将clock event广播到所有的CPU core,以此推动各个CPU core上的tick device的运作。当然它不是本文的主要内容,如果有兴趣可以参考本站其他文档。

clock event mode的定义如下:

enum clock_event_mode {
    CLOCK_EVT_MODE_UNUSED = 0, ------未使用
    CLOCK_EVT_MODE_SHUTDOWN, ------被软件shutdown
    CLOCK_EVT_MODE_PERIODIC, -------工作状态,处于periodic模式,周期性产生event
    CLOCK_EVT_MODE_ONESHOT, -------工作状态,处于one shot模式,event是一次性的
    CLOCK_EVT_MODE_RESUME, -------处于系统resume中
};

具体的mode设定是由set_mode这个callback函数来完成的,毫无疑问,这是需要底层的clock event chip driver需要设定的。虽然定义了这么多mode,实际上底层的硬件未必支持,有些HW timer硬件支持oneshot和periodic的设定,不过有些就不支持(例如:ARM general timer)。具体clock event device如何在各个mode中切换会在tick device的文档中描述。

rating、mult和shift的概念和clocksource中的类似,这里就不描述了。此外很多成员这里也不细述了,在后面的逻辑分析中自然就清晰了。

2、如何组织系统中的clock event device?

相关的全局变量定义如下:

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

clock event device core模块使用两个链表来管理系统中的clock event device,一个是clockevent_devices链表,该链表中的clock event device都是当前active的device。active的clock device有两种情况,一种是cpu core的current  clockevent device,这些device是各个cpu上产生tick的那个clock event device,还有一些active的device由于优先级比较低,当前没有使用,不过可以作为backup的device。另外一个是clockevents_released链表,这个链表中clock event device都是由于种种原因,无法进入active list,从而挂入了该队列。

 

二、向上层的其它driver提供操作clock event的通用API

1、设定clock event device的触发event的时间参数

int clockevents_program_event(struct clock_event_device *dev, ktime_t expires, bool force)
{
    unsigned long long clc;
    int64_t delta;
    int rc;

    dev->next_event = expires; -------设定下一次触发clock event的时间
    if (dev->features & CLOCK_EVT_FEAT_KTIME)----- -------------(1)
        return dev->set_next_ktime(expires, dev);

    delta = ktime_to_ns(ktime_sub(expires, ktime_get()));----- ----------(2)
    if (delta <= 0)
        return force ? clockevents_program_min_delta(dev) : -ETIME; -----------(3)

    delta = min(delta, (int64_t) dev->max_delta_ns);
    delta = max(delta, (int64_t) dev->min_delta_ns); ------------------(4)

    clc = ((unsigned long long) delta * dev->mult) >> dev->shift; ---------转换成cycle值

    rc = dev->set_next_event((unsigned long) clc, dev); ---调用底层driver callback函数进行设定

    return (rc && force) ? clockevents_program_min_delta(dev) : rc; -----------(5)
}

我们先看看该接口函数的参数值:dev指向具体的clock event device,expires参数是设定下一次产生event的时间点,force参数控制在expires设定异常的时候(例如设定在一个过去的时间点上产生event)该函数 的行为,一种是出错返回,另外一种还是进行event的产生,只是设定一个最小的delta。

(1)如果chip driver支持使用ktime的设定(这需要硬件支持,设定了CLOCK_EVT_FEAT_KTIME flag的那些clock event device才支持哦),事情会比较简单,直接调用set_next_ktime就搞定了。

(2)对于一个“正常”的clock event device,需要转换成cycle这样的单位。不过在转换成cycle之前,需要先将ktime格式的时间(传入的expires参数就是这样的格式)转换成纳秒这样的时间单位。

(3)delta小于0意味着用户设定的时间点已经是过去的一个时间点,如果强制产生event的话,那么事不宜迟,要立刻产生event,这需要调用clockevents_program_min_delta函数,代码如下:

static int clockevents_program_min_delta(struct clock_event_device *dev)
{
    unsigned long long clc;
    int64_t delta;

    delta = dev->min_delta_ns; ---------------------------(a)
    dev->next_event = ktime_add_ns(ktime_get(), delta); ----------------(b)

    if (dev->mode == CLOCK_EVT_MODE_SHUTDOWN)
        return 0;

    dev->retries++; -------记录retry的次数
    clc = ((unsigned long long) delta * dev->mult) >> dev->shift; ------转换成cycle值
    return dev->set_next_event((unsigned long) clc, dev); ----调用底层driver callback函数进行设定
}

(a)在逻辑思维的世界里,你可以想像任意小的时间片段,但是在实现面,这个要收到timer硬件能力的限制。一个输入频率是1Hz的timer硬件,其最小时间粒度就是1秒,如何产生0.1秒的clock event呢?因此,所谓立刻产出也就是在硬件允许的最小的时间点上产生event。在注册clock event device的时候已经设定这个参数了,就是struct clock_event_device的min_delta_ns这个成员。

(b)ktime_get函数获取当前的时间点,加上min_delta_ns就是下一次要触发event的时间点,struct clock_event_device的next_event 这个成员就是用来记录下一次要触发event的时间点信息的。

(4)有最小值就有最大值,struct clock_event_device的max_delta_ns这个成员就是设定next event触发的最大时间值。这个最大值是和硬件counter的bit数目有关:如果一个硬件timer最大能表示60秒的时间长度,那么设定65秒后触发clock event是没有意义的,因为这时候counter会溢出,如果强行设定那么硬件实际会在5秒后触发event。同样的,max_delta_ns也是在注册clock event device的时候设定了这个参数。

(5)如果调用底层driver callback函数进行实际的cycle设定的时候出错(例如:由于种种原因,在实际设定的时候发现时间点是过去值,如果仍然设定,那么上层软件实际上要等到硬件counter 溢出后在下一个round中才会触发event,实际这时候黄花菜都凉了),并且是强制产生event的话,那么也需要调用clockevents_program_min_delta函数在最小时间点上产生clock event。

2、更换clock event设备

上层的tick device驱动层会根据情况(clock event的精度,是否local cpu的)调用clockevents_exchange_device 进行clock event设备的更换,具体代码如下:

void clockevents_exchange_device(struct clock_event_device *old,  struct clock_event_device *new)
{
    unsigned long flags;

    local_irq_save(flags);

    if (old) { -------------------------------(1)
        module_put(old->owner);
        clockevents_set_mode(old, CLOCK_EVT_MODE_UNUSED);
        list_del(&old->list);
        list_add(&old->list, &clockevents_released);
    }

    if (new) { ------------------------------(2)
        BUG_ON(new->mode != CLOCK_EVT_MODE_UNUSED);
        clockevents_shutdown(new);
    }
    local_irq_restore(flags);
}

(1)旧的clock event device要被替换掉,因此将其模式设定为CLOCK_EVT_MODE_UNUSED,并且从全局clock event device链表中摘下来,挂入clockevents_released链表

(2)我们要确保新的clock event设备没有被使用,如果新的clock event设备不是CLOCK_EVT_MODE_UNUSED状态,说明其目前被其他的上层软件使用,因此要kernel panic,并且shutdown该clock event device。这是该设备状态是CLOCK_EVT_MODE_SHUTDOWN状态。这里没有插入clockevent_devices全局链表的动作,主要是因为在调用该函数之前,新的clock event device已经挂入队列了。

 

三、向底层clockevent chip driver提供的接口

1、配置clock event device

底层的clock event chip driver可以调用clockevents_config对该设备进行配置。这里的操作类似clocksource中的内容,也就是说调用者输入频率参数,在clockevents_config中计算struct clock_event_device中一些类似mult、shift等成员的配置值:

void clockevents_config(struct clock_event_device *dev, u32 freq)
{
    u64 sec;

    if (!(dev->features & CLOCK_EVT_FEAT_ONESHOT))--------------(1)
        return;

    sec = dev->max_delta_ticks;-------------------------(2)
    do_div(sec, freq);
    if (!sec)
        sec = 1;-----限制最小值
    else if (sec > 600 && dev->max_delta_ticks > UINT_MAX)
        sec = 600; -------------------------------(3)

    clockevents_calc_mult_shift(dev, freq, sec);------------------(4)
    dev->min_delta_ns = cev_delta2ns(dev->min_delta_ticks, dev, false);-------(5)
    dev->max_delta_ns = cev_delta2ns(dev->max_delta_ticks, dev, true);
}

(1)底层的硬件驱动知道自己的能力,可以通过struct clock_event_device中的features成员宣称自己的功能:CLOCK_EVT_FEAT_PERIODIC说明该硬件timer可以产生周期性的clock event,CLOCK_EVT_FEAT_ONESHOT说明自己只能产生one shot类型的clock event。如果能产生one shot类型的event,那么即便是硬件不支持周期性的clock event,其实上层的软件可以通过不断设定next event的方法来模拟周期性的clock event。但是如果只是支持周期性的clock event就有些麻烦了,这时候是无法模拟one shot类型的event。也就是说,在这种情况下,整个系统必须有周期性tick,同时,系统无法支持高精度timer和dynamic tick的情况。在这样的硬件条件下,后续的配置是没有意义的,因此直接return。

(2)底层的硬件驱动需要设定max_delta_ticks和min_delta_ticks。需要注意的是这里的tick不是system tick,而是输入硬件timer的clock tick,其实就是可以设定最大和最小cycle数目。这个cycle数目除以freq就是时间值,单位是秒。

(3)又是600秒,是否似曾相识。我们在clock source那篇文档中已经介绍过了,这里就不再赘述

(4)根据输入频率和最大的秒数可以计算出clock event的mult和shift这两个成员的数值,具体计算过程在clock source那篇文档中已经介绍过了,这里就不再赘述。

(5)计算min_delta_ticks和max_delta_ticks对应的ns值。

2、注册clock event device

底层的timer硬件驱动会调用clockevents_register_device函数向系统注册clock event device,代码如下:

void clockevents_register_device(struct clock_event_device *dev)
{
    unsigned long flags;

    if (!dev->cpumask) {---------------------------(1)
        WARN_ON(num_possible_cpus() > 1);
        dev->cpumask = cpumask_of(smp_processor_id());
    }

    raw_spin_lock_irqsave(&clockevents_lock, flags); --------------(2)

    list_add(&dev->list, &clockevent_devices); ----加入clock event设备全局列表
    tick_check_new_device(dev); -----------------------(3)
    clockevents_notify_released(); ----------------------(4)

    raw_spin_unlock_irqrestore(&clockevents_lock, flags);
}

(1)clock event device的cpumask指明该设备为哪一个CPU工作,如果没有设定并且cpu的个数大于1的时候要给出warning信息并进行设定(设定为当前运行该代码的那个CPU core)。在multi core的环境下,底层driver在调用该接口函数注册clock event设备之前就需要设定cpumask成员,毕竟一个timer硬件附着在哪一个cpu上底层硬件最清楚,这里仅仅是亡羊补牢(毕竟我们还是希望代码不要随随便便就kernel panic了,尽量让代码执行下去)。

(2)考虑到来自多个CPU上的并发,这里使用spin lock进行保护。关闭本地中断,可以防止来自本cpu上的并发操作。

(3)调用tick_check_new_device函数,让上层软件知道底层又注册一个新的clock device,当然,是否上层软件要使用这个新的clock event device是上层软件的事情,clock event device driver这个层次完成描述自己能力这部分代码就OK了。tick device相关内容请参考本站其他文档。

(4)如果上层软件想要使用新的clock event device的话(tick_check_new_device函数中有可能会进行此操作),它会调用clockevents_exchange_device函数(可以参考上面的描述)。这时候,旧的clock event会被从clockevent_devices链表中摘下,挂到clockevents_released队列中。在clockevents_notify_released函数中,会将old clock event device重新挂入clockevent_devices,并调用tick_check_new_device函数。

3、配置并注册clock event device

是上面两个接口函数的综合体,这里不再详细描述。

 

四、用户空间接口

1、sysfs接口初始化

在系统初始化的时候会调用clockevents_init_sysfs函数(呵呵~~~对于clock source,这个函数名字是init_clocksource_sysfs,很显然不是一个人的风格,我喜欢clockevents_sysfs_init和clocksource_sysfs_init这种函数定义风格)来初始化clock event device layer的sys file system接口,如下:

static int __init clockevents_init_sysfs(void)
{
    int err = subsys_system_register(&clockevents_subsys, NULL); --注册clock event这种bus type

    if (!err)
        err = tick_init_sysfs();
    return err;
}

该说的在clocksource那份文档中都描述了,这里直接不再赘述,重点关注tick_init_sysfs函数:

static int __init tick_init_sysfs(void)
{
    int cpu;

    for_each_possible_cpu(cpu) {----------遍历各个CPU的clock event device
        struct device *dev = &per_cpu(tick_percpu_dev, cpu);--------------(1)
        int err;

        dev->id = cpu;
        dev->bus = &clockevents_subsys;
        err = device_register(dev);--------------------------(2)
        if (!err)
            err = device_create_file(dev, &dev_attr_current_device);------------(3)
        if (!err)
            err = device_create_file(dev, &dev_attr_unbind_device);
        if (err)
            return err;
    }
    return tick_broadcast_init_sysfs(); -----------------------(4)
}

(1)我们始终还是要回归统一模型的三件套,bus type,device和driver。现在有了clock event bus type,还缺少device。在clock source中,由于它是全局的,属于所有CPU core的,因此我们定义了一个device就OK了。对于clock event,我们需要为每一个CPU定义一个device,如下:

static DEFINE_PER_CPU(struct device, tick_percpu_dev);

是否需要定义clock event device对应的driver呢?本来定义device和driver的目的是让它们在适当的时机(bus type的match函数)相遇,相知(调用driver的probe函数)。对于clock event device而言,是不需要定义driver的,因为设备树提供了其他的方法来进行具体底层chip级别的初始化(具体可以参考ARM generic timer驱动中的描述)。

还有一点需要注意,实际上,每一个硬件设备都是设备模型中的一个device,不过,在clock event device这个场景下,实际上系统并不是为每一个timer硬件定义一个device,而仅仅是为每一个当前active(作为tick device那个clock event device)的clockevent设备定义了一个device数据结构,有空的时候大家可以思考一下这个问题。

(2)调用device_register就可以把所有的clock event device注册到系统中,统一设备模型会帮我们做一切事情。

(3)device_register之后,每个clock event device体现为一个sysfs中的目录,我们还需要为这个目录增加一些属性文件。定义如下:

static DEVICE_ATTR(current_device, 0444, sysfs_show_current_tick_dev, NULL);

static DEVICE_ATTR(unbind_device, 0200, NULL, sysfs_unbind_tick_dev);

(4)除了per cpu的device,还有一个broadcast device,定义如下:

static struct device tick_bc_dev = {
    .init_name    = "broadcast",
    .id        = 0,
    .bus        = &clockevents_subsys,
};

这个device在tick_broadcast_init_sysfs函数中调用device_register注册到系统,并创建了dev_attr_current_device的属性。和per cpu device不同的是:没有提供用户空间的unbind操作,也就是说,userspace无法unbind当前的broadcast clock event device。

2、属性文件操作:显示current tick device

读clock event device的current_device属性文件

static ssize_t sysfs_show_current_tick_dev(struct device *dev, struct device_attribute *attr, char *buf)
{
    struct tick_device *td;
    ssize_t count = 0;

    raw_spin_lock_irq(&clockevents_lock);
    td = tick_get_tick_dev(dev); ----获取tick device
    if (td && td->evtdev)
        count = snprintf(buf, PAGE_SIZE, "%s\n", td->evtdev->name);
    raw_spin_unlock_irq(&clockevents_lock);
    return count;
}

一个active的clock event device对应的tick device有两种情况,一种是per cpu的tick device,驱动系统运作。另外一种是broadcast tick device,这些内容留在在tick device部分描述吧。

3、属性文件操作:unbind tick device

一个tick device总是绑定一个属于该cpu core并且精度最高的那个clock event device。通过sysfs的接口可以解除这个绑定。如果解除绑定的那个clock event device是unused,可以直接从clockevent_devices全局链表中删除。如果该设备当前使用中,那么需要找到一个替代的clock event device。如果找不到一个替代的clock event device,那么不能unbind当前的device,返回EBUSY。具体的代码逻辑就不分析,大家可以自己阅读代码理解。

Linux时间子系统(十六) clockevent

标签:new   长度   end   cas   linux时间   用两个   方便   release   amp   

原文地址:https://www.cnblogs.com/alantu2018/p/8448314.html

(0)
(0)
   
举报
评论 一句话评论(0
0条  
登录后才能评论!
© 2014 mamicode.com 版权所有 京ICP备13008772号-2
迷上了代码!