精华内容
下载资源
问答
  • Linux子系统系列-时钟子系统

    千次阅读 2011-02-24 16:35:00
    年前处理了一个涉及linux时钟子系统比较麻烦的问题,问题虽然解决了,但在过程中遇到很多不太清晰地的地方,今天一起整理一下 由于本人涉猎不广,不思进取,所总结东西大部分来源于网络,希望能早日迈过这个层次,多...

    年前处理了一个涉及linux时钟子系统比较麻烦的问题,问题虽然解决了,但在过程中遇到很多不太清晰地的地方,今天一起整理一下

    由于本人涉猎不广,不思进取,所总结东西大部分来源于网络,希望能早日迈过这个层次,多有些自己的东西,一些自己在技术方面的积极思考。

    +++++++++++++++++++++++++++++++++++++++++++++++++++++

    目录:

    1,时间在Linux的地位

    2,Linux如何管理时间

    3,时钟子系统的实现

    4,在Linux中如何计时

    5,Linux出了一个NO~HZ......

     

    一,时间在Linux的地位

    在一般操作系统中,很多活动都和时间有关,例如:进程调度,定时器任务,网络处理等等,内核中有大量的函数都是基于时间驱动的。记得在linux基础系列里面也提到了时钟相当于一个操作系统的“心跳”,操作系统没有了时钟也就想到于一个生物没有了心跳。所以说,了解Linux中的时钟处理机制有助于更好地了解Linux的运作方式。

     

    二,Linux如何管理时间

    一般说来,Linux内核主要需要两种类型的时间:
    1. 在内核运行期间持续记录当前的时间与日期,以便内核对某些对象和事件作时间标记(timestamp,也称为“时间戳”,“墙上时间”,“实际时间”)。
    2. 维持一个固定周期的定时器,以提醒内核或用户一段时间已经过去了。

    无论我们说软件时钟还是硬件时钟,他们都是建立在时钟硬件基础上的。内核必须在硬件的帮助下才能计算和管理时间。硬件为内核提供了一个系统定时器用以计算流逝的时间,系统定时器以某种频率自行触发时钟中断,该频率可以通过编程设定。

    在计算机系统中存在着许多硬件计时器(such as RTC, TSC, PIT. HPET etc...),而且根据架构的不同而支持的不同的硬件计时器(such as TSC on Intel, TBH/TBL on PPC, and COUNT on MIPS)。

    注:ARM架构目前没有专门的时间戳寄存器,所以也造成了在arm架构上没有标准的高精度接口export出来,能够使用的最大精度就是1/HZ秒。

     

    通常来说,硬件时钟就是指直接使用硬件计时器作为驱动的时钟,软件时钟即指timer,他是在硬件时钟之上构建的一套定时器方法。

     

    系统起来以后,系统被动的接受时钟中断,然后运行时钟中断处理程序,该ISR主要完成以下工作:

    1,更新系统运行时间

    2,更新墙上时间

    3,如在SMP系统上,均衡调度程序中个处理器上的运行队列,使其负载均衡

    4,检查当前进程是否用尽了自己的时间片。如果用尽,就重新调度

    5,运行超时的动态定时器

    6,更新资源消耗和处理器时间的统计值

    注:以上内容很多来自于Love的LD3,就象生活不能没有爱,搞linux就不能缺少“Love”。

     

     

    如果实在没有任务需要切换,执行完该ISR后,那么就执行idle,时钟中断会周期性的打破idle,然后查询有没有需要做的事情,如果没有继续idle,这基本上是linux中时钟管理的基本模式。 

     

    三,时钟子系统的实现

     

    我们知道,linux中各个子系统的实现都是一层层抽象的结果,时钟子系统也不例外。

     

    1,原理

    clocksource和clock_event_device两个结构被用来抽象linux的时钟管理:

     

    • struct clocksource :对硬件设备的抽象,描述时钟源信息
    • struct clock_event_device :时钟的事件信息,包括当硬件时钟中断发生时要执行那些操作,也可将该结构称作为“时钟事件设备”。

    需要特别注意的是结构 clock_event_device 的成员 event_handler ,它指定了当硬件时钟中断发生时,内核应该执行那些操作,也就是真正的时钟中断处理函数。

     

    Linux 内核维护了两个链表,分别存储了系统中所有时钟源的信息和时钟事件设备的信息。这两个链表的表头在内核中分别是 clocksource_list 和 clockevent_devices。

     

     

    2,初始化

     

    内核初始化部分( start_kernel 函数)和时钟相关的过程主要有以下几个(内核版本2.6.34):

     

    tick_init();

    init_timers();
    hrtimers_init();

    timekeeping_init();
    time_init();

     

     

    2.1 tick_init 函数

    函数 tick_init() 很简单,调用 clockevents_register_notifier 函数向 clockevents_chain 通知链注册元素: tick_notifier。这个元素的回调函数指明了当时钟事件设备信息发生变化(例如新加入一个时钟事件设备等等)时,应该执行的操作,该回调函数为 tick_notify。并不是我们从字面意思理解的这个就是直接注册tick中断服务函数。

     

    2.2 init_timers 函数

    初始化本 CPU 上的软件时钟相关的数据结构,向 cpu_chain 通知链注册元素 timers_nb ,该元素的回调函数用于初始化指定 CPU 上的软件时钟相关的数据结构,最后初始化时钟的软中断处理函数。

     

    2.3 hrtimers_init函数

    高精度时钟定时器相关处理

     

    2.4 timekeeping_init函数

    涉及到另外内核子系统timekeeping subsystem,这里略过

     

    2.5 time_init函数

    初始化硬件时钟源和时钟事件信息,这个函数和硬件体系相关,各个架构都有不同的实现,这里就体现了linux分层抽象的魅力,一个子系统的设计会抽象成好几层,会尽力将和体系相关的部分放到一层,这样在不同架构上,该子系统就能做到尽量少的改动。

     

    3,处理流程

    主要关注time_init函数中的处理流程,该部分是和架构有关系的,不同架构的实现都各不相同,要具体分析。

    以ARM架构为例,CPU为OMAP L138

    3.1 在arch/arm/mach-davinci/time.c中,将架构相关的代码在此实现,并将davinci_timer_init挂载到davinci_timer中,我们在davinci_timer_init中将完成:

    • timer硬件初始化
    • setup clocksource 和clock event

    3.2 在arch/arm/mach-davinci/board-da850-evm.c中设置MACHINE DES时,将davinci_timer挂到系统的timer上。

     

    3.3 在arch/arm/kernel/setup.c中的setup_arch()函数,将会取出MACHINE DES中挂载的内容,对于timer,将会赋值到一个全局变量system_timer:

    struct machine_desc *mdesc;

    mdesc = setup_machine(machine_arch_type);

    system_timer = mdesc->timer;

     

    3.4 这样初始化完成后,arch/arm/kernel的time_init会最终调用system->init()完成time的设置。

     

    四,linux中如何计时


    1,用户侧

    在用户空间中可以使用C语言函数gettimeofday 得到时间。


    2,shell

     

    在Linux的Shell下,我们经常也使用Shell内置的time命令和GNU版的time命令来测试程序运行的时间。

    内置的time提供的参数选项比较少,而GNU的time则提供了丰富的参数选项,包括指定输出文件等功能。

    [grandiose@Bygone grandiose]$ /usr/bin/time --output=foo.txt foo
    

    上句只有时间信息输出到了foo.txt文件中,如果想要包括foo执行的结果,就需要按下句这样使用:

     
    [grandiose@Bygone grandiose]$ /usr/bin/time --output=foo.txt --append foo >foo.txt
    

    如果想要控制输出时间的格式,可以使用-f开关进行格式化:

    [grandiose@Bygone grandiose]$ /usr/bin/time 
       --output=foo.txt -f "//t%E real,//t%U user,//t%S sys" foo
    

    如果仍需要使用Shell内置的time命令,可以用下面一句将结果输出至文件:

    [grandiose@Bygone grandiose]$ (time foo) 2>foo.txt
    

    这样写是因为内置命令time的输出是到标准错误的,文件描述符2表示标准错误stderr。如果还想要包括foo执行的结果,就要这样:

    [grandiose@Bygone grandiose]$ (time foo) >foo.txt 2>&1
    

    其中2>&1的含义是2与1 相同,一起送入foo.txt中。

    nohup命令可以保证进程在退出系统之后仍能运行,这是它的常规用法。我们也可以这样使用nohup:

    [grandiose@Bygone grandiose]$ nohup time foo
    

    结果全部输出至nohup.out,也包括程序运行的时间信息。可以使用下面的语句将时间信息输出至文件foo.txt中。

     

    [grandiose@Bygone grandiose]$ tail -2 nohup.out > foo.txt

    3,内核侧
    如果要定制自己的设备驱动程序,可能就会用到内核里的计时功能。Linux内核空间中的计时与用户空间
    的计时不太相同。在内核空间里,有一个全局变量Jiffies维护着当前的时间。与系统时钟有关的调用有
    #include <asm/param.h> 
    #include <linux/timer.h> 
    void add_timer(struct timer_list * timer); 
    int del_timer(struct timer_list * timer); 
    inline void init_timer(struct timer_list * timer); 
    五,linux来了一个NO~HZ

    NOHZ对于linux意味着什么呢,dog250兄表述的很到位(以下完全来自dog250兄的博文:

    http://blog.csdn.net/dog250/archive/2010/02/09/5303566.aspx):

     如果说nohz之前的linux内核是骨架的话,那么从 nohz之后,linux开始了精彩,之后几乎瞬时,cfs出现了,然后是cgroup, cgroup正式开始了虚拟容器,从此linux再也不用被 unix老大们看作是小孩子了,nohz标着linux开始成熟起来。

    nohz为何这么重要呢?因为它直接关系到了性能,直接联系着系统的心跳,在之前,系统总是被动的接受时钟中断,然后运行中断处理程序最终可能导致调度的发生,如果实在没有任务可以运行,那么就执行idle,这也许也算一种创意,可是时钟中断还是会周期性的打破idle,然后查询有没有需要做的事情,如果没有继续idle,这种方式没有什么问题,可是我们总是希望系统可以主动的做些事情,比如不是被动的接受中断而是主动的设置什么时候中断,因此必须将系统时钟发生中断这件事进行向上抽象,于是相应的clocksource和clock_event_device,这两个结构体就是时钟以及时钟行为的抽象,clocksource代表了一个时钟源,一般都会有一个计数器,其中的read回调函数就是负责读出其计数器的值,可是我们为何找不到write或者set之类的回调函数呢?这些回调函数其实不应该在 closksource中,而应该在clock_event_device中。实际上,clocksource只是一个钟,你可以类比我们用的钟表,clocksource就是一个钟表,我们需要一个钟表就是需要读出它的指针的值从而知道现在几点,就是这些,因此钟表都会有显示盘用于读数,至于钟表怎么运作,那就是钟表内部的机械原理了,记住,钟表就是用来读数的。另外我们为了害怕误事而需要闹铃,需要闹铃在一个时间段之后把我们唤醒,这就是个event,而这个event不一定非要有钟表,当然钟表的读数会为我们提供有用的参考值,这样的话钟表和闹铃就解耦合了,再重申一遍:

    不要因为有闹钟的存在就说钟表都会响铃或者说闹铃都有钟表,它们其实是两个东西,钟表为你展示某些事情,而闹铃需要你的设置,设想一个场景,你手边有一个没有闹铃的钟表,还有一个没有 钟表的闹铃,这个闹铃只能设置绝对时间,然后到期振铃,你现在不知道几点,可是你要睡觉并且得到通知必须在四个小时后去参加一个聚会,那么你现在要做什么?你肯定要看看你的钟表,然后设置你的闹钟。


    以上的例子中,钟表就是clocksource,而闹钟就是clock_event_device,前者提供了一个指示盘,后者封装
    了闹铃到期以后的行为以及设置闹铃的handler,就好像你的闹铃都有旋钮一样。既然操作系统的行为是时钟中断驱动的,那么它很符合我刚才例子中的那个逻辑,即使不用在内核中抽象出 clocksource和clock_event_device这些概念,只要能做到定时“振铃”,然后去执行时钟中断就可以了,2.6.18之前的内核中在没有抽象出“钟表”和“闹铃”的情况下实现了上述的逻辑,就是我们上面所说的硬件时钟中断模式。可是这种方式有一个默认的前提就是内核一直有事可做,软件是硬件的奴隶,不得不在硬件的默认前提下每隔一个时间段就被中断一次,而硬件只管定时中断而不管到底是否真正有事可做,理想的实现应该是将定时的任务交给内核自己,就好比我希望定一个闹铃到一定时间后叫醒我,我希望我自己定这个闹铃而不是希望到时间我正在熟睡而被不知情的叫醒。

     2.6.18以前的内核中,根本就没有简单的“定闹铃”的handler,因此不得不忍受硬件的有事无事的定时中断。clocksource和clock_event_device被抽象出来以 后,clock_event_device中有了定闹铃的handler,一切就醒目多了,实际上clocksource和clock_event_device被抽象出来并不是为了nohz,而是为了将时钟相关的代码从平台相关的代码中分离出来,以便于独立修改统一管理,否则需要维护很多平台的不同的时钟处理代码,而这些代码的逻辑大致相同,随后的2.6.22以后,nohz才出现,nohz其实就是托了抽象出来的clocksource和 clock_event_device的福,因为nohz直接需要设置下一次的中断时间而不是使用系统无条件的默认的HZ中断。 clock_event_device中的set_next_event就是定闹铃的把手,而event_handler则是可以让你自己定义闹铃到期后的事件,就好比手机定闹铃时可以选到期后播放的音乐一样可以自定义事件处理回调函数。

         cfs调度和HZ分离了clocksource和clock_event_device封装的时钟以及其操作,以往的进程在特定的固定时间片内运行,时钟的定时中断提供了时间片的监督工作,一切显得十分和谐,可是系统内核本身就是没有主权,一切都在硬件的安排下进行,clocksource和 clock_event_device被抽象出来以后,内核有了一定的主权,它可以在运行时设置硬件了,内核的运行和硬件的特性进一步解除耦合,内核不再是奴隶了,它终于可以作为主人设置硬件本身了,cfs调度器之后,关于进程以及整个系统的运行特性彻底从底层硬件的时钟中分离了,完全采用linux的逻辑进行,再也不用受制于底层的时钟以及时间片分配特性,linux可以按照自己的方式来进行调度,或者用自己的方式设置下一个中断的到来时间,这难道还是中断吗?中断的含义就是异步到来的事件,clock_event_device的set_next_event致使系统明确的知道下一个中断什么时候到来,这其实没有什么不对,就是因为它是时钟相关的,而时钟中断在老的版本的内核里面的中断间隔也是确定的。新的内核越来越多的将硬件把手抽象给内核,或者将内核把手抽象给用户,这样的内核显得越来越成熟了,内核可以通过硬件把手操控硬件从而影响运行时的策略,而用户可以通过内核把手操控内核从而影响内核的运行时策略。内核对下面的硬件可以控制了,对上面的用户空间也提供了很多不错的操作接口,三层的联系越来越紧密但是却没有增加耦合性,实在是妙!


         clocksource是一个钟表,clock_event_device是一个闹铃,它们可以合并为一个闹钟,也可以单独
    行动,既然clock_event_device是一个闹钟而且必然拥有定闹铃的把手(set_next_event),那么时钟中断就是由这个clock_event_device来设置的了,设置的中断到来以后,还是这个clock_event_device负责用event_handler 来唱一支歌,毕竟它是闹铃,闹铃要负责在到期后响铃的,而且除了响铃也可以做别的,而clocksource只是一个可以从中得到一个读数的一个源头罢 了,如果说谁要是有疑问,觉得如果一个clocksource没有中断功能却成功的成了一个全局的主要clocksource,那么怎么办?没有问题,设置中断和clocksource有没有中断功能没有关系,只要clock_event_device的set_next_event中有设置中断硬件的逻辑就可以了。比如tsc时钟源没有中断功能,它是一个高精度计数器,那么在系统的clock_event_device中的set_next_event中必须实现设置当前中断源的代码。用clocksource和clock_event_device实现的新的时钟逻辑更像是一个软件定时器。


    既然硬件时钟可以由运行中的内核软件驱动了,那么很多机制都随之变得灵活起来,比如hrtimer的实现,比如时钟中断的实现等等,在nohz模式中,在cpu进入idle之前要进入ick_nohz_stop_sched_tick,这个函数中可能就会停掉时钟中断,如果停掉的话,那么在每次其他硬件中断执行完之后会再次进入这个函数以检测timer队列是否被更新,或者定时器到期后,系统会重新开启间隔为tick_period的时钟中断,这个可以用 hrtimer实现,也可以用别的机制实现。为了维持系统内cpu的负载均衡,所有开启nohz停掉cpu的idle进程不能全部都停掉cpu进入halt,而是要有一个进行idle load balance,为何不能让别的cpu代劳呢?因为别的cpu忙着呢?只要处于idle状态的cpu比较闲,因此就由它来负责所有的停掉的cpu的负载均 衡工作,一旦有进程被拉到了这些cpu上,那么马上唤醒它们,这在load_balance函数代码中有描述:

    if (ld_moved && this_cpu != smp_processor_id()) 
        resched_cpu(this_cpu); 
    以上的片段就是说一旦有进程拉到了this_cpu上并且这个cpu不是当前的执行load_balance的cpu,那么就
    发送ipi唤醒处于nohz停止状态的cpu,因为由于系统不平衡,它已经不能再继续睡下去了。


    之前说过,由于2.6.23之前的内核的进程调度只要是基于时间片的,而时间片的计算又没有办法找到一种比较统一的方式,这个原因就是内核对硬件的控制力弱加上操作系统内核的抽象机制严重依赖底层的硬件配置,你可以将HZ设置到1000甚至更高(HZ不能随意高,必须依照cpu硬件来设置,HZ能设置多高不在于你的代码多高效,而是在于你的cpu有多快),可是你却要面对新的问题,比如时间片跨度太大的响应慢问题,时间片跨度太小导致的高优先级进程不怎么优先问题或者低优先级时间片和HZ相关并且有时过小导致的cache频繁失效问题,虽然双斜率机制解决了部分问题,可是又引入了新的问题,比如 nice 0两端不对称问题。在新的cfs中,调度行为不再依赖HZ的值,并且在时钟相关的操作抽象成clocksource和clock_event_device之后,底层的时钟硬件不再被在start_kernel中一次性的设置,而且被封装了,可以随时设置,新的设置方式 显得更加直观。

    展开全文
  • clock source用于为linux内核提供一个时间基线,如果你用linux的date命令获取当前...时钟源是内核计时的基础,系统启动时,内核通过硬件RTC获得当前时间,在这以后,在大多数情况下,内核通过选定的时钟源更新实时时

    clock source用于为linux内核提供一个时间基线,如果你用linux的date命令获取当前时间,内核会读取当前的clock source,转换并返回合适的时间单位给用户空间。在硬件层,它通常实现为一个由固定时钟频率驱动的计数器,计数器只能单调地增加,直到溢出为止。时钟源是内核计时的基础,系统启动时,内核通过硬件RTC获得当前时间,在这以后,在大多数情况下,内核通过选定的时钟源更新实时时间信息(墙上时间),而不再读取RTC的时间。本节的内核代码树基于V3.4.10。

    /*****************************************************************************************************/
    声明:本博内容均由http://blog.csdn.net/droidphone原创,转载请注明出处,谢谢!
    /*****************************************************************************************************/

    1.  struct clocksource结构

    内核用一个clocksource结构对真实的时钟源进行软件抽象,现在我们从clock source的数据结构开始,它的定义如下:

    [cpp] view plain copy
    1. struct clocksource {  
    2.     /* 
    3.      * Hotpath data, fits in a single cache line when the 
    4.      * clocksource itself is cacheline aligned. 
    5.      */  
    6.     cycle_t (*read)(struct clocksource *cs);  
    7.     cycle_t cycle_last;  
    8.     cycle_t mask;  
    9.     u32 mult;  
    10.     u32 shift;  
    11.     u64 max_idle_ns;  
    12.     u32 maxadj;  
    13. #ifdef CONFIG_ARCH_CLOCKSOURCE_DATA  
    14.     struct arch_clocksource_data archdata;  
    15. #endif  
    16.   
    17.     const char *name;  
    18.     struct list_head list;  
    19.     int rating;  
    20.     int (*enable)(struct clocksource *cs);  
    21.     void (*disable)(struct clocksource *cs);  
    22.     unsigned long flags;  
    23.     void (*suspend)(struct clocksource *cs);  
    24.     void (*resume)(struct clocksource *cs);  
    25.   
    26.     /* private: */  
    27. #ifdef CONFIG_CLOCKSOURCE_WATCHDOG  
    28.     /* Watchdog related data, used by the framework */  
    29.     struct list_head wd_list;  
    30.     cycle_t cs_last;  
    31.     cycle_t wd_last;  
    32. #endif  
    33. } ____cacheline_aligned;  
    我们只关注clocksource中的几个重要的字段。

    1.1  rating:时钟源的精度

    同一个设备下,可以有多个时钟源,每个时钟源的精度由驱动它的时钟频率决定,比如一个由10MHz时钟驱动的时钟源,他的精度就是100nS。clocksource结构中有一个rating字段,代表着该时钟源的精度范围,它的取值范围如下:
    • 1--99: 不适合于用作实际的时钟源,只用于启动过程或用于测试;
    • 100--199:基本可用,可用作真实的时钟源,但不推荐;
    • 200--299:精度较好,可用作真实的时钟源;
    • 300--399:很好,精确的时钟源;
    • 400--499:理想的时钟源,如有可能就必须选择它作为时钟源;

    1.2  read回调函数

    时钟源本身不会产生中断,要获得时钟源的当前计数,只能通过主动调用它的read回调函数来获得当前的计数值,注意这里只能获得计数值,也就是所谓的cycle,要获得相应的时间,必须要借助clocksource的mult和shift字段进行转换计算。

    1.3  mult和shift字段

    因为从clocksource中读到的值是一个cycle计数值,要转换为时间,我们必须要知道驱动clocksource的时钟频率F,一个简单的计算就可以完成:

    t = cycle/F;

    可是clocksource并没有保存时钟的频率F,因为使用上面的公式进行计算,需要使用浮点运算,这在内核中是不允许的,因此,内核使用了另外一个变通的办法,根据时钟的频率和期望的精度,事先计算出两个辅助常数mult和shift,然后使用以下公式进行cycle和t的转换:

    t = (cycle * mult) >> shift;

    只要我们保证:

    F = (1 << shift) / mult;

    内核内部使用64位进行该转换计算:
    [cpp] view plain copy
    1. static inline s64 clocksource_cyc2ns(cycle_t cycles, u32 mult, u32 shift)  
    2. {  
    3.         return ((u64) cycles * mult) >> shift;  
    4. }  
    从转换精度考虑,mult的值是越大越好,但是为了计算过程不发生溢出,mult的值又不能取得过大。为此内核假设cycle计数值被转换后的最大时间值:10分钟(600秒),主要的考虑是CPU进入IDLE状态后,时间信息不会被更新,只要在10分钟内退出IDLE,clocksource的cycle计数值就可以被正确地转换为相应的时间,然后系统的时间信息可以被正确地更新。当然最后的结果不一定是10分钟,它由clocksource_max_deferment进行计算,并保存max_idle_ns字段中,tickless的代码要考虑这个值,以防止在NO_HZ配置环境下,系统保持IDLE状态的时间过长。在这样,由10分钟这个假设的时间值,我们可以推算出合适的mult和shift值。

    2.  clocksource的注册和初始化

    通常,clocksource要在初始化阶段通过clocksource_register_hz函数通知内核它的工作时钟的频率,调用的过程如下:


    由上图可见,最终大部分工作会转由__clocksource_register_scale完成,该函数首先完成对mult和shift值的计算,然后根据mult和shift值,最终通过clocksource_max_deferment获得该clocksource可接受的最大IDLE时间,并记录在clocksource的max_idle_ns字段中。clocksource_enqueue函数负责按clocksource的rating的大小,把该clocksource按顺序挂在全局链表clocksource_list上,rating值越大,在链表上的位置越靠前。
    每次新的clocksource注册进来,都会触发clocksource_select函数被调用,它按照rating值选择最好的clocksource,并记录在全局变量curr_clocksource中,然后通过timekeeping_notify函数通知timekeeping,当前clocksource已经变更,关于timekeeping,我将会在后续的博文中阐述。

    3.  clocksource watchdog

    系统中可能同时会注册对个clocksource,各个clocksource的精度和稳定性各不相同,为了筛选这些注册的clocksource,内核启用了一个定时器用于监控这些clocksource的性能,定时器的周期设为0.5秒:

    [cpp] view plain copy
    1. #define WATCHDOG_INTERVAL (HZ >> 1)  
    2. #define WATCHDOG_THRESHOLD (NSEC_PER_SEC >> 4)  

    当有新的clocksource被注册时,除了会挂在全局链表clocksource_list外,还会同时挂在一个watchdog链表上:watchdog_list。定时器周期性地(0.5秒)检查watchdog_list上的clocksource,WATCHDOG_THRESHOLD的值定义为0.0625秒,如果在0.5秒内,clocksource的偏差大于这个值就表示这个clocksource是不稳定的,定时器的回调函数通过clocksource_watchdog_kthread线程标记该clocksource,并把它的rate修改为0,表示精度极差。

    4.  建立clocksource的简要过程

    在系统的启动阶段,内核注册了一个基于jiffies的clocksource,代码位于kernel/time/jiffies.c:

    [cpp] view plain copy
    1. struct clocksource clocksource_jiffies = {  
    2.     .name       = "jiffies",  
    3.     .rating     = 1, /* lowest valid rating*/  
    4.     .read       = jiffies_read,  
    5.     .mask       = 0xffffffff, /*32bits*/  
    6.     .mult       = NSEC_PER_JIFFY << JIFFIES_SHIFT, /* details above */  
    7.     .shift      = JIFFIES_SHIFT,  
    8. };  
    9. ......  
    10.   
    11. static int __init init_jiffies_clocksource(void)  
    12. {  
    13.     return clocksource_register(&clocksource_jiffies);  
    14. }  
    15.   
    16. core_initcall(init_jiffies_clocksource);  
    它的精度只有1/HZ秒,rating值为1,如果平台的代码没有提供定制的clocksource_default_clock函数,它将返回该clocksource:

    [cpp] view plain copy
    1. struct clocksource * __init __weak clocksource_default_clock(void)  
    2. {  
    3.     return &clocksource_jiffies;  
    4. }  
    然后,在初始化的后段,clocksource的代码会把全局变量curr_clocksource设置为上述的clocksource:

    [cpp] view plain copy
    1. static int __init clocksource_done_booting(void)  
    2. {  
    3.         ......  
    4.     curr_clocksource = clocksource_default_clock();  
    5.         ......  
    6.     finished_booting = 1;  
    7.         ......  
    8.     clocksource_select();  
    9.         ......  
    10.     return 0;  
    11. }  
    12. fs_initcall(clocksource_done_booting);  
    当然,如果平台级的代码在初始化时也会注册真正的硬件clocksource,所以经过clocksource_select()函数后,curr_clocksource将会被设为最合适的clocksource。如果clocksource_select函数认为需要切换更好的时钟源,它会通过timekeeping_notify通知timekeeping系统,使用新的clocksource进行时间计数和更新操作。
    展开全文
  • Linux时间子系统

    2013-04-26 09:37:55
  • Linux时间子系统之Tick层

    千次阅读 2020-04-23 20:08:58
    Tick设备在Linux时间子系统中用tick_device结构体表示(代码位于kernel/time/tick-sched.h中): struct tick_device { struct clock_event_device *evtdev; enum tick_device_mode mode; }; 可以看出来,它...
  • Linux时间子系统之八:动态时钟框架(CONFIG_NO_HZ、tickless) 分类: Linux时间管理系统 Linux内核架构2012-10-27 16:01 1827人阅读 评论(7) 收藏 举报 目录(?)[+] 在前面章节的讨论...
  • linux时间子系统 - clocksource/timekeeper

    千次阅读 2016-12-11 20:13:15
    linux时间子系统中有一个很重要的记录时间的模块就是timekeeper,而timekeeper需要底层clock硬件设备的支持,每一个设备用结构体clocksource来表示,注册进系统的每一个clocksource会凭借优先级最终被选择成为...
  • Linux SCSI子系统

    千次阅读 2012-10-04 19:09:20
    M. Tim Jones, 顾问工程师, Emulex Corp. 2007 年 12 月 06 日 ...Small Computer Systems ... Linux® 提供了一种 SCSI 子系统,用于与这些设备通信。Linux 是分层架构的一个很好的例子,它将高层的驱动器
  • linux驱动基础系列--linux rtc子系统

    千次阅读 2016-04-19 09:38:23
     linux驱动子系统太多了,连时钟也搞了个子系统,这导致一般的时钟芯片的驱动也会涉及到至少2个子系统,一个是时钟芯片接口子系统(比如I2c接口的时钟芯片),一个是内核给所有时钟芯片提供的rtc子系统。...
  • clock source用于为linux内核提供一个时间基线,如果你用linux的date命令获取当前时间,内核会读取当前的clock source,转换并返回合适的时间单位给用户空间。在硬件层,它通常实现为一个由固定时钟频率驱动的计数器...
  • Linux内核时间管理子系统——时钟

    千次阅读 2014-08-27 22:17:13
    Linux内核中有两种不同的clock设备,一种是clock source设备,另一种是clock event设备。
  • ...移动开发之Android(11)Linux内核架构(15)Linux设备驱动(20)Linux电源管理(3)Linux音频子系统(15)Linux中断子系统(5)Linux时间管理系统(8)Linux输入子系统(4) Linux时间子系统之一:clock so
  • 初探linux子系统集之timer子系统(一)

    千次阅读 2016-02-01 21:27:01
    一般来说要让整个linux系统跑起来,那么一个必须的就是linux时钟,也就是时间子系统了,这里正好工作需要,那么就研究下linux下的时间子系统了。  linux内核必须完成两种主要的定时测量。一个是计时,保存当前的...
  • linux时间子系统 - 周期性任务

    千次阅读 2016-12-25 17:33:07
    内核中有大量的需求需要时间的帮助,比如:定时、进程调度、获得时间等等,在内核中时间子系统就是来实现这部分功能的,根据不同的工作模式(periodic和oneshot)会有不同的工作函数来实现周期性任务,具体分为低精度...
  • 一般在系统初始化的时候,Linux内核会默认注册一个精度最低的缺省时钟源设备,叫做jiffies(代码位于kernel/time/jiffies.c中): static struct clocksource clocksource_jiffies = { .name = "jiffies", ....
  • linux IIO子系统使用说明

    千次阅读 2018-06-24 13:09:23
    新的内核将ADC/DAC/G_sensor这样的设备统一成IIO子系统,用户层通过访问IIO的接口来实现如ADC的触发、采样等操作。 下面给出IIO接口用户层的接口使用实例(以ADC的采样为例) 1. 方法一:直接读取/sys下的接口 以下...
  • Linux SPI 子系统驱动开发之Linux spi设备驱动与SPI控制器驱动的匹配问题。1.SPI协议层驱动是怎么与SPI控制器(spi_master)匹配的。2.spi控制器是怎么区分多个spi设备的。在SPI协议层中,spi_device是通过spi_...
  • Linux 时钟处理机制

    2012-10-16 20:05:03
    Linux 时钟处理机制 ...简介: 在 Linux 操作系统中,很多...本文分析了 Linux 2.6.25 内核的时钟处理机制,首先介绍了在计算机系统中的一些硬件计时器,然后重点介绍了 Linux 操作系统中的硬件时钟和软件时钟
  • linux spi子系统

    万次阅读 2011-04-12 15:34:00
     spi_device是驱动的下界,它的上界包含了sysfs、输入子系统、ALSA、网络层、MTD、字符设备框架或者其他Linux子系统。 非静态声明 ====== 静态声明是在内核编译时便已经能确定spi设备了。但是有时无法在编译...
  • linux 时钟详解

    千次阅读 2013-07-24 15:38:23
    本文分析了 Linux 2.6.25 内核的时钟处理机制,首先介绍了在计算机系统中的一些硬件计时器,然后重点介绍了 Linux 操作系统中的硬件时钟和软件时钟的处理过程以及软件时钟的应用。最后对全文进行了总结。 ◆1、
  • 几乎所有的计算机系统中都会...系统中的每一种实际的定时事件设备都由一个叫做clock_event_device的结构体变量表示(代码位于include/linux/clockchips.h): struct clock_event_device { void (*event_han...
  • Linux 时钟管理

    2011-10-17 21:17:49
    原文: http://www.ibm.com/developerworks/cn/linux/l-cn-timerm/ Linux 时钟管理 陈 功, 软件工程师, Intel 陈功,在 Intel 北京开源技术中心工作。负责 Intel 服务器平台的相关开
  • Linux时间子系统(一) -- 原理

    千次阅读 2017-08-19 16:34:18
    转载请标明出处floater的csdn blog,http://blog.csdn.net/flaoter1 内核概述内核2.6之前的时间子系统主要是围绕低分辨定时器和基于它实现的tick时钟周期展开的,随着嵌入式应用的发展,时间子系统引入了两个主要...
  • linux内核之时间子系统

    千次阅读 2018-01-30 17:17:09
    linux内核时间子系统

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,968
精华内容 12,387
关键字:

linux时钟子系统

linux 订阅