pillarbuaa
pillarbuaa

Linux时间子系统

http://blog.csdn.net/droidphone/article/details/7975694

Linux时间子系统之一：clock source（时钟源）

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函数通知内核它的工作时钟的频率，调用的过程如下：
Linux时间子系统_第1张图片

由上图可见，最终大部分工作会转由__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时间子系统之二：表示时间的单位和结构

人们习惯用于表示时间的方法是：年、月、日、时、分、秒、毫秒、星期等等，但是在内核中，为了软件逻辑和代码的方便性，它使用了一些不同的时间表示方法，并为这些表示方法定义了相应的变量和数据结构，本节的内容就是阐述这些表示方法的意义和区别。


/*****************************************************************************************************/

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

/*****************************************************************************************************/

1.  jiffies

内核用jiffies变量记录系统启动以来经过的时钟滴答数，它的声明如下：

@kernel/include/linux/jiffies.h
  1. extern u64 __jiffy_data jiffies_64;  
  2. extern unsigned long volatile __jiffy_data jiffies;  
可见， 在32位的系统上，jiffies是一个32位的无符号数，系统每过1/HZ秒，jiffies的值就会加1，最终该变量可能会溢出，所以内核同时又定义了一个64位的变量jiffies_64，链接的脚本保证jiffies变量和jiffies_64变量的内存地址是相同的，通常，我们可以直接访问jiffies变量，但是要获得jiffies_64变量，必须通过辅助函数get_jiffies_64来实现。jiffies是内核的低精度定时器的计时单位，所以内核配置的HZ数决定了低精度定时器的精度，如果HZ数被设定为1000，那么，低精度定时器（timer_list）的精度就是1ms=1/1000秒。因为jiffies变量可能存在溢出的问题，所以在用基于jiffies进行比较时，应该使用以下辅助宏来实现：
[cpp] view plain copy
  1. time_after(a,b)  
  2. time_before(a,b)  
  3. time_after_eq(a,b)  
  4. time_before_eq(a,b)  
  5. time_in_range(a,b,c)  

同时，内核还提供了一些辅助函数用于jiffies和毫秒以及纳秒之间的转换：

[cpp] view plain copy
  1. unsigned int jiffies_to_msecs(const unsigned long j);  
  2. unsigned int jiffies_to_usecs(const unsigned long j);  
  3. unsigned long msecs_to_jiffies(const unsigned int m);  
  4. unsigned long usecs_to_jiffies(const unsigned int u);  

2.  struct timeval

timeval由秒和微秒组成，它的定义如下：
[cpp] view plain copy
  1. struct timeval {  
  2.     __kernel_time_t     tv_sec;     /* seconds */  
  3.     __kernel_suseconds_t    tv_usec;    /* microseconds */  
  4. };  
__kernel_time_t 和 __kernel_suseconds_t 实际上都是long型的整数。gettimeofday和settimeofday使用timeval作为时间单位。

3.  struct timespec

timespec由秒和纳秒组成，它的定义如下：
[cpp] view plain copy
  1. struct timespec {  
  2.     __kernel_time_t tv_sec;         /* seconds */  
  3.     long        tv_nsec;        /* nanoseconds */  
  4. };  
同样地，内核也提供了一些辅助函数用于jiffies、timeval、timespec之间的转换：
[cpp] view plain copy
  1. static inline int timespec_equal(const struct timespec *a, const struct timespec *b);  
  2. static inline int timespec_compare(const struct timespec *lhs, const struct timespec *rhs);  
  3. static inline int timeval_compare(const struct timeval *lhs, const struct timeval *rhs);  
  4. extern unsigned long mktime(const unsigned int year, const unsigned int mon,  
  5.                 const unsigned int day, const unsigned int hour,  
  6.                 const unsigned int min, const unsigned int sec);  
  7. extern void set_normalized_timespec(struct timespec *ts, time_t sec, s64 nsec);  
  8. static inline struct timespec timespec_add(struct timespec lhs, struct timespec rhs);  
  9. static inline struct timespec timespec_sub(struct timespec lhs, struct timespec rhs);  
  10.   
  11. static inline s64 timespec_to_ns(const struct timespec *ts);  
  12. static inline s64 timeval_to_ns(const struct timeval *tv);  
  13. extern struct timespec ns_to_timespec(const s64 nsec);  
  14. extern struct timeval ns_to_timeval(const s64 nsec);  
  15. static __always_inline void timespec_add_ns(struct timespec *a, u64 ns);  
[cpp] view plain copy
  1. unsigned long timespec_to_jiffies(const struct timespec *value);  
  2. void jiffies_to_timespec(const unsigned long jiffies, struct timespec *value);  
  3. unsigned long timeval_to_jiffies(const struct timeval *value);  
  4. void jiffies_to_timeval(const unsigned long jiffies, struct timeval *value);  

timekeeper中的xtime字段用timespec作为时间单位。

4.  struct ktime

l inux的通用时间架构用ktime来表示时间，为了兼容32位和64位以及big-little endian系统，ktime结构被定义如下：
[cpp] view plain copy
  1. union ktime {  
  2.     s64 tv64;  
  3. #if BITS_PER_LONG != 64 && !defined(CONFIG_KTIME_SCALAR)  
  4.     struct {  
  5. # ifdef __BIG_ENDIAN  
  6.     s32 sec, nsec;  
  7. # else  
  8.     s32 nsec, sec;  
  9. # endif  
  10.     } tv;  
  11. #endif  
  12. };  
64位的系统可以直接访问tv64字段，单位是纳秒，32位的系统则被拆分为两个字段：sec和nsec，并且照顾了大小端的不同。高精度定时器通常用ktime作为计时单位。下面是一些辅助函数用于计算和转换：
[cpp] view plain copy
  1. ktime_t ktime_set(const long secs, const unsigned long nsecs);   
  2. ktime_t ktime_sub(const ktime_t lhs, const ktime_t rhs);   
  3. ktime_t ktime_add(const ktime_t add1, const ktime_t add2);   
  4. ktime_t ktime_add_ns(const ktime_t kt, u64 nsec);   
  5. ktime_t ktime_sub_ns(const ktime_t kt, u64 nsec);   
  6. ktime_t timespec_to_ktime(const struct timespec ts);   
  7. ktime_t timeval_to_ktime(const struct timeval tv);   
  8. struct timespec ktime_to_timespec(const ktime_t kt);   
  9. struct timeval ktime_to_timeval(const ktime_t kt);   
  10. s64 ktime_to_ns(const ktime_t kt);   
  11. int ktime_equal(const ktime_t cmp1, const ktime_t cmp2);   
  12. s64 ktime_to_us(const ktime_t kt);   
  13. s64 ktime_to_ms(const ktime_t kt);   
  14. ktime_t ns_to_ktime(u64 ns); 

Linux时间子系统之三：时间的维护者：timekeeper

本系列文章的前两节讨论了用于计时的时钟源：clocksource，以及内核内部时间的一些表示方法，但是对于真实的用户来说，我们感知的是真实世界的真实时间，也就是所谓的墙上时间，clocksource只能提供一个按给定频率不停递增的周期计数，如何把它和真实的墙上时间相关联？本节的内容正是要讨论这一点。

1.  时间的种类

内核管理着多种时间，它们分别是：

  • RTC时间
  • wall time：墙上时间
  • monotonic time
  • raw monotonic time
  • boot time：总启动时间

RTC时间  在PC中，RTC时间又叫CMOS时间，它通常由一个专门的计时硬件来实现，软件可以读取该硬件来获得年月日、时分秒等时间信息，而在嵌入式系统中，有使用专门的RTC芯片，也有直接把RTC集成到Soc芯片中，读取Soc中的某个寄存器即可获取当前时间信息。一般来说，RTC是一种可持续计时的，也就是说，不管系统是否上电，RTC中的时间信息都不会丢失，计时会一直持续进行，硬件上通常使用一个后备电池对RTC硬件进行单独的供电。因为RTC硬件的多样性，开发者需要为每种RTC时钟硬件提供相应的驱动程序，内核和用户空间通过驱动程序访问RTC硬件来获取或设置时间信息。

xtime  xtime和RTC时间一样，都是人们日常所使用的墙上时间，只是RTC时间的精度通常比较低，大多数情况下只能达到毫秒级别的精度，如果是使用外部的RTC芯片，访问速度也比较慢，为此，内核维护了另外一个wall time时间：xtime，取决于用于对xtime计时的clocksource，它的精度甚至可以达到纳秒级别，因为xtime实际上是一个内存中的变量，它的访问速度非常快，内核大部分时间都是使用xtime来获得当前时间信息。xtime记录的是自1970年1月1日24时到当前时刻所经历的纳秒数。

monotonic time  该时间自系统开机后就一直单调地增加，它不像xtime可以因用户的调整时间而产生跳变，不过该时间不计算系统休眠的时间，也就是说，系统休眠时，monotoic时间不会递增。

raw monotonic time  该时间与monotonic时间类似，也是单调递增的时间，唯一的不同是：raw monotonic time“更纯净”，他不会受到NTP时间调整的影响，它代表着系统独立时钟硬件对时间的统计。

boot time  与monotonic时间相同，不过会累加上系统休眠的时间，它代表着系统上电后的总时间。

时间种类 精度（统计单位） 访问速度 累计休眠时间 受NTP调整的影响
RTC 低 慢 Yes Yes
xtime 高 快 Yes Yes
monotonic 高 快 No Yes
raw monotonic 高 快 No No
boot time 高 快 Yes Yes

2.  struct timekeeper

内核用timekeeper结构来组织与时间相关的数据，它的定义如下：

[cpp] view plain copy
  1. struct timekeeper {  
  2.     struct clocksource *clock;    /* Current clocksource used for timekeeping. */  
  3.     u32 mult;    /* NTP adjusted clock multiplier */  
  4.     int shift;  /* The shift value of the current clocksource. */  
  5.     cycle_t cycle_interval; /* Number of clock cycles in one NTP interval. */  
  6.     u64 xtime_interval; /* Number of clock shifted nano seconds in one NTP interval. */  
  7.     s64 xtime_remainder;    /* shifted nano seconds left over when rounding cycle_interval */  
  8.     u32 raw_interval;   /* Raw nano seconds accumulated per NTP interval. */  
  9.   
  10.     u64 xtime_nsec; /* Clock shifted nano seconds remainder not stored in xtime.tv_nsec. */  
  11.     /* Difference between accumulated time and NTP time in ntp 
  12.      * shifted nano seconds. */  
  13.     s64 ntp_error;  
  14.     /* Shift conversion between clock shifted nano seconds and 
  15.      * ntp shifted nano seconds. */  
  16.     int ntp_error_shift;  
  17.   
  18.     struct timespec xtime;  /* The current time */  
  19.   
  20.     struct timespec wall_to_monotonic;  
  21.     struct timespec total_sleep_time;   /* time spent in suspend */  
  22.     struct timespec raw_time;   /* The raw monotonic time for the CLOCK_MONOTONIC_RAW posix clock. */  
  23.   
  24.     ktime_t offs_real;  /* Offset clock monotonic -> clock realtime */  
  25.   
  26.     ktime_t offs_boot;  /* Offset clock monotonic -> clock boottime */  
  27.   
  28.     seqlock_t lock; /* Seqlock for all timekeeper values */  
  29. };  
其中的xtime字段就是上面所说的墙上时间，它是一个timespec结构的变量，它记录了自1970年1月1日以来所经过的时间，因为是timespec结构，所以它的精度可以达到纳秒级，当然那要取决于系统的硬件是否支持这一精度。

内核除了用xtime表示墙上的真实时间外，还维护了另外一个时间：monotonic time，可以把它理解为自系统启动以来所经过的时间，该时间只能单调递增，可以理解为xtime虽然正常情况下也是递增的，但是毕竟用户可以主动向前或向后调整墙上时间，从而修改xtime值。但是monotonic时间不可以往后退，系统启动后只能不断递增。奇怪的是，内核并没有直接定义一个这样的变量来记录monotonic时间，而是定义了一个变量wall_to_monotonic，记录了墙上时间和monotonic时间之间的偏移量，当需要获得monotonic时间时，把xtime和wall_to_monotonic相加即可，因为默认启动时monotonic时间为0，所以实际上wall_to_monotonic的值是一个负数，它和xtime同一时间被初始化，请参考timekeeping_init函数。

计算monotonic时间要去除系统休眠期间花费的时间，内核用total_sleep_time记录休眠的时间，每次休眠醒来后重新累加该时间，并调整wall_to_monotonic的值，使其在系统休眠醒来后，monotonic时间不会发生跳变。因为wall_to_monotonic值被调整。所以如果想获取boot time，需要加入该变量的值：

[cpp] view plain copy
  1. void get_monotonic_boottime(struct timespec *ts)  
  2. {  
  3.         ......  
  4.     do {  
  5.         seq = read_seqbegin(&timekeeper.lock);  
  6.         *ts = timekeeper.xtime;  
  7.         tomono = timekeeper.wall_to_monotonic;  
  8.         <span style="color:#ff0000;">sleep = timekeeper.total_sleep_time;</span>  
  9.         nsecs = timekeeping_get_ns();  
  10.   
  11.     } while (read_seqretry(&timekeeper.lock, seq));  
  12.   
  13.     set_normalized_timespec(ts, ts->tv_sec + tomono.tv_sec + sleep.tv_sec,  
  14.             ts->tv_nsec + tomono.tv_nsec + sleep.tv_nsec + nsecs);  
  15. }  
raw_time字段用来表示真正的硬件时间，也就是上面所说的raw monotonic time，它不受时间调整的影响，monotonic时间虽然也不受settimeofday的影响，但会受到ntp调整的影响，但是raw_time不受ntp的影响，他真的就是开完机后就单调地递增。xtime、monotonic-time和raw_time可以通过用户空间的clock_gettime函数获得，对应的ID参数分别是 CLOCK_REALTIME、CLOCK_MONOTONIC、CLOCK_MONOTONIC_RAW。

clock字段则指向了目前timekeeper所使用的时钟源，xtime，monotonic time和raw time都是基于该时钟源进行计时操作，当有新的精度更高的时钟源被注册时，通过timekeeping_notify函数，change_clocksource函数将会被调用，timekeeper.clock字段将会被更新，指向新的clocksource。

早期的内核版本中，xtime、wall_to_monotonic、raw_time其实是定义为全局静态变量，到我目前的版本（V3.4.10），这几个变量被移入到了timekeeper结构中，现在只需维护一个timekeeper全局静态变量即可：

[cpp] view plain copy
  1. static struct timekeeper timekeeper;  

3.  timekeeper的初始化

timekeeper的初始化由timekeeping_init完成，该函数在start_kernel的初始化序列中被调用，timekeeping_init首先从RTC中获取当前时间：

[cpp] view plain copy
  1. void __init timekeeping_init(void)  
  2. {  
  3.     struct clocksource *clock;  
  4.     unsigned long flags;  
  5.     struct timespec now, boot;  
  6.   
  7.     read_persistent_clock(&now);  
  8.     read_boot_clock(&boot);  
然后对锁和ntp进行必要的初始化：
[cpp] view plain copy
  1. seqlock_init(&timekeeper.lock);  
  2.   
  3. ntp_init();  
接着获取默认的clocksource，如果平台没有重新实现clocksource_default_clock函数，默认的clocksource就是基于jiffies的clocksource_jiffies，然后通过timekeeper_setup_inernals内部函数把timekeeper和clocksource进行关联：
[cpp] view plain copy
  1. write_seqlock_irqsave(&timekeeper.lock, flags);  
  2. clock = clocksource_default_clock();  
  3. if (clock->enable)  
  4.     clock->enable(clock);  
  5. timekeeper_setup_internals(clock);  
利用RTC的当前时间，初始化xtime，raw_time，wall_to_monotonic等字段：
[cpp] view plain copy
  1. timekeeper.xtime.tv_sec = now.tv_sec;  
  2. timekeeper.xtime.tv_nsec = now.tv_nsec;  
  3. timekeeper.raw_time.tv_sec = 0;  
  4. timekeeper.raw_time.tv_nsec = 0;  
  5. if (boot.tv_sec == 0 && boot.tv_nsec == 0) {  
  6.     boot.tv_sec = timekeeper.xtime.tv_sec;  
  7.     boot.tv_nsec = timekeeper.xtime.tv_nsec;  
  8. }  
  9. set_normalized_timespec(&timekeeper.wall_to_monotonic,  
  10.             -boot.tv_sec, -boot.tv_nsec);  
最后，初始化代表实时时间和monotonic时间之间偏移量的offs_real字段，total_sleep_time字段初始化为0：
[cpp] view plain copy
  1. update_rt_offset();  
  2. timekeeper.total_sleep_time.tv_sec = 0;  
  3. timekeeper.total_sleep_time.tv_nsec = 0;  
  4. write_sequnlock_irqrestore(&timekeeper.lock, flags);  
[cpp] view plain copy
  1. }  
xtime字段因为是保存在内存中，系统掉电后无法保存时间信息，所以每次启动时都要通过timekeeping_init从RTC中同步正确的时间信息。其中，read_persistent_clock和read_boot_clock是平台级的函数，分别用于获取RTC硬件时间和启动时的时间，不过值得注意到是，到目前为止（我的代码树基于3.4版本），ARM体系中，只有tegra和omap平台实现了read_persistent_clock函数。如果平台没有实现该函数，内核提供了一个默认的实现：
[cpp] view plain copy
  1. void __attribute__((weak)) read_persistent_clock(struct timespec *ts)  
  2. {  
  3.     ts->tv_sec = 0;  
  4.     ts->tv_nsec = 0;  
  5. }  
[cpp] view plain copy
  1. void __attribute__((weak)) read_boot_clock(struct timespec *ts)  
  2. {  
  3.     ts->tv_sec = 0;  
  4.     ts->tv_nsec = 0;  
  5. }  
那么，其他ARM平台是如何初始化xtime的？答案就是CONFIG_RTC_HCTOSYS这个内核配置项，打开该配置后，driver/rtc/hctosys.c将会编译到系统中，由rtc_hctosys函数通过do_settimeofday在系统初始化时完成xtime变量的初始化：
[cpp] view plain copy
  1. static int __init rtc_hctosys(void)   
  2. {   
  3.         ......   
  4.         err = rtc_read_time(rtc, &tm);   
  5.         ......  
  6.         rtc_tm_to_time(&tm, &tv.tv_sec);   
  7.         do_settimeofday(&tv);   
  8.         ......   
  9.         return err;   
  10. }   
  11. late_initcall(rtc_hctosys);  

4.  时间的更新

xtime一旦初始化完成后，timekeeper就开始独立于RTC，利用自身关联的clocksource进行时间的更新操作，根据内核的配置项的不同，更新时间的操作发生的频度也不尽相同，如果没有配置NO_HZ选项，通常每个tick的定时中断周期，do_timer会被调用一次，相反，如果配置了NO_HZ选项，可能会在好几个tick后，do_timer才会被调用一次，当然传入的参数是本次更新离上一次更新时相隔了多少个tick周期，系统会保证在clocksource的max_idle_ns时间内调用do_timer，以防止clocksource的溢出：

@kernel/arch/arm/kernel/time.c

#ifndef CONFIG_GENERIC_CLOCKEVENTS
/*
 * Kernel system timer support.
 */
void timer_tick(void)
{
    profile_tick(CPU_PROFILING);
    do_leds();
    xtime_update(1);
#ifndef CONFIG_SMP
    update_process_times(user_mode(get_irq_regs()));
#endif
}
#endif


@kernel/time/timekeeping.c
void xtime_update(unsigned long ticks)
{
    write_seqlock(&xtime_lock);
    do_timer(ticks);
    write_sequnlock(&xtime_lock);
}

void do_timer(unsigned long ticks) 
{ 
    jiffies_64 += ticks; 
    update_wall_time(); 
    calc_global_load(ticks); 
}  
在do_timer中，jiffies_64变量被相应地累加，然后在update_wall_time中完成xtime等时间的更新操作，更新时间的核心操作就是读取关联clocksource的计数值，累加到xtime等字段中，其中还设计ntp时间的调整等代码，详细的代码就不贴了。

5.  获取时间

timekeeper提供了一系列的接口用于获取各种时间信息。

  • void getboottime(struct timespec *ts);    获取系统启动时刻的实时时间
  • void get_monotonic_boottime(struct timespec *ts);     获取系统启动以来所经过的时间，包含休眠时间
  • ktime_t ktime_get_boottime(void);   获取系统启动以来所经过的c时间，包含休眠时间，返回ktime类型
  • ktime_t ktime_get(void);    获取系统启动以来所经过的c时间，不包含休眠时间，返回ktime类型
  • void ktime_get_ts(struct timespec *ts) ;   获取系统启动以来所经过的c时间，不包含休眠时间，返回timespec结构
  • unsigned long get_seconds(void);    返回xtime中的秒计数值
  • struct timespec current_kernel_time(void);    返回内核最后一次更新的xtime时间，不累计最后一次更新至今clocksource的计数值
  • void getnstimeofday(struct timespec *ts);    获取当前时间，返回timespec结构
  • void do_gettimeofday(struct timeval *tv);    获取当前时间，返回timeval结构

Linux时间子系统之四：定时器的引擎：clock_event_device

早期的内核版本中，进程的调度基于一个称之为tick的时钟滴答，通常使用时钟中断来定时地产生tick信号，每次tick定时中断都会进行进程的统计和调度，并对tick进行计数，记录在一个jiffies变量中，定时器的设计也是基于jiffies。这时候的内核代码中，几乎所有关于时钟的操作都是在machine级的代码中实现，很多公共的代码要在每个平台上重复实现。随后，随着通用时钟框架的引入，内核需要支持高精度的定时器，为此，通用时间框架为定时器硬件定义了一个标准的接口：clock_event_device，machine级的代码只要按这个标准接口实现相应的硬件控制功能，剩下的与平台无关的特性则统一由通用时间框架层来实现。

/*****************************************************************************************************/

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

/*****************************************************************************************************/

1.  时钟事件软件架构

本系列文章的第一节中，我们曾经讨论了时钟源设备：clocksource，现在又来一个时钟事件设备：clock_event_device，它们有何区别？看名字，好像都是给系统提供时钟的设备，实际上， clocksource不能被编程，没有产生事件的能力，它主要被用于timekeeper来实现对真实时间进行精确的统计，而clock_event_device则是可编程的，它可以工作在周期触发或单次触发模式，系统可以对它进行编程，以确定下一次事件触发的时间， clock_event_device主要用于实现普通定时器和高精度定时器，同时也用于产生tick事件，供给进程调度子系统使用。时钟事件设备与通用时间框架中的其他模块的关系如下图所示：

Linux时间子系统_第2张图片

                                                                  图1.1   clock_event_device软件架构

  • 与clocksource一样，系统中可以存在多个clock_event_device，系统会根据它们的精度和能力，选择合适的clock_event_device对系统提供时钟事件服务。在smp系统中，为了减少处理器间的通信开销，基本上每个cpu都会具备一个属于自己的本地clock_event_device，独立地为该cpu提供时钟事件服务，smp中的每个cpu基于本地的clock_event_device，建立自己的tick_device，普通定时器和高精度定时器。
  • 在软件架构上看，clock_event_device被分为了两层，与硬件相关的被放在了machine层，而与硬件无关的通用代码则被集中到了通用时间框架层，这符合内核对软件的设计需求，平台的开发者只需实现平台相关的接口即可，无需关注复杂的上层时间框架。
  • tick_device是基于clock_event_device的进一步封装，用于代替原有的时钟滴答中断，给内核提供tick事件，以完成进程的调度和进程信息统计，负载平衡和时间更新等操作。

2.  时钟事件设备相关数据结构

2.1  struct clock_event_device

时钟事件设备的核心数据结构是clock_event_device结构，它代表着一个时钟硬件设备，该设备就好像是一个具有事件触发能力（通常就是指中断）的clocksource，它不停地计数，当计数值达到预先编程设定的数值那一刻，会引发一个时钟事件中断，继而触发该设备的事件处理回调函数，以完成对时钟事件的处理。clock_event_device结构的定义如下：

[cpp] view plain copy
  1. struct clock_event_device {  
  2.     void            (*event_handler)(struct clock_event_device *);  
  3.     int         (*set_next_event)(unsigned long evt,  
  4.                           struct clock_event_device *);  
  5.     int         (*set_next_ktime)(ktime_t expires,  
  6.                           struct clock_event_device *);  
  7.     ktime_t         next_event;  
  8.     u64         max_delta_ns;  
  9.     u64         min_delta_ns;  
  10.     u32         mult;  
  11.     u32         shift;  
  12.     enum clock_event_mode   mode;  
  13.     unsigned int        features;  
  14.     unsigned long       retries;  
  15.   
  16.     void            (*broadcast)(const struct cpumask *mask);  
  17.     void            (*set_mode)(enum clock_event_mode mode,  
  18.                         struct clock_event_device *);  
  19.     unsigned long       min_delta_ticks;  
  20.     unsigned long       max_delta_ticks;  
  21.   
  22.     const char      *name;  
  23.     int         rating;  
  24.     int         irq;  
  25.     const struct cpumask    *cpumask;  
  26.     struct list_head    list;  
  27. } ____cacheline_aligned;  

event_handler  该字段是一个回调函数指针，通常由通用框架层设置，在时间中断到来时，machine底层的的中断服务程序会调用该回调，框架层利用该回调实现对时钟事件的处理。

set_next_event  设置下一次时间触发的时间，使用类似于clocksource的cycle计数值（离现在的cycle差值）作为参数。

set_next_ktime  设置下一次时间触发的时间，直接使用ktime时间作为参数。

max_delta_ns  可设置的最大时间差，单位是纳秒。

min_delta_ns  可设置的最小时间差，单位是纳秒。

mult shift  与clocksource中的类似，只不过是用于把纳秒转换为cycle。

mode  该时钟事件设备的工作模式，两种主要的工作模式分别是：

  • CLOCK_EVT_MODE_PERIODIC  周期触发模式，设置后按给定的周期不停地触发事件；
  • CLOCK_EVT_MODE_ONESHOT  单次触发模式，只在设置好的触发时刻触发一次；

set_mode  函数指针，用于设置时钟事件设备的工作模式。

rating  表示该设备的精度等级。

list  系统中注册的时钟事件设备用该字段挂在全局链表变量clockevent_devices上。

2.2  全局变量clockevent_devices

系统中所有注册的clock_event_device都会挂在该链表下面，它在kernel/time/clockevents.c中定义：
[cpp] view plain copy
  1. static LIST_HEAD(clockevent_devices);  

2.3  全局变量clockevents_chain

通用时间框架初始化时会注册一个通知链（NOTIFIER），当系统中的时钟时间设备的状态发生变化时，利用该通知链通知系统的其它模块。
[cpp] view plain copy
  1. /* Notification for clock events */  
  2. static RAW_NOTIFIER_HEAD(clockevents_chain);  

3.  clock_event_device的初始化和注册

每一个machine，都要定义一个自己的machine_desc结构，该结构定义了该machine的一些最基本的特性，其中需要设定一个sys_timer结构指针，machine级的代码负责定义sys_timer结构，sys_timer的声明很简单：
[cpp] view plain copy
  1. struct sys_timer {  
  2.     void            (*init)(void);  
  3.     void            (*suspend)(void);  
  4.     void            (*resume)(void);  
  5. #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET  
  6.     unsigned long       (*offset)(void);  
  7. #endif  
  8. };  
通常，我们至少要定义它的init字段，系统初始化阶段，该init回调会被调用，该init回调函数的主要作用就是完成系统中的clocksource和clock_event_device的硬件初始化工作，以samsung的exynos4为例，在V3.4内核的代码树中，machine_desc的定义如下：
[cpp] view plain copy
  1. MACHINE_START(SMDK4412, "SMDK4412")  
  2.     /* Maintainer: Kukjin Kim <[email protected]> */  
  3.     /* Maintainer: Changhwan Youn <[email protected]> */  
  4.     .atag_offset    = 0x100,  
  5.     .init_irq   = exynos4_init_irq,  
  6.     .map_io     = smdk4x12_map_io,  
  7.     .handle_irq = gic_handle_irq,  
  8.     .init_machine   = smdk4x12_machine_init,  
  9.     .timer      = &exynos4_timer,  
  10.     .restart    = exynos4_restart,  
  11. MACHINE_END  
定义的sys_timer是exynos4_timer，它的定义和init回调定义如下：
[cpp] view plain copy
  1. static void __init exynos4_timer_init(void)  
  2. {  
  3.     if (soc_is_exynos4210())  
  4.         mct_int_type = MCT_INT_SPI;  
  5.     else  
  6.         mct_int_type = MCT_INT_PPI;  
  7.   
  8.     exynos4_timer_resources();  
  9.     exynos4_clocksource_init();  
  10.     exynos4_clockevent_init();  
  11. }  
  12.   
  13. struct sys_timer exynos4_timer = {  
  14.     .init       = exynos4_timer_init,  
  15. };  
exynos4_clockevent_init函数显然是初始化和注册clock_event_device的合适时机，在这里，它注册了一个rating为250的clock_event_device，并把它指定给cpu0：
[cpp] view plain copy
  1. static struct clock_event_device mct_comp_device = {  
  2.     .name       = "mct-comp",  
  3.     .features       = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT,  
  4.     .rating     = 250,  
  5.     .set_next_event = exynos4_comp_set_next_event,  
  6.     .set_mode   = exynos4_comp_set_mode,  
  7. };  
  8. ......  
  9. static void exynos4_clockevent_init(void)  
  10. {  
  11.     clockevents_calc_mult_shift(&mct_comp_device, clk_rate, 5);  
  12.         ......  
  13.     mct_comp_device.cpumask = cpumask_of(0);  
  14.     clockevents_register_device(&mct_comp_device);  
  15.   
  16.     setup_irq(EXYNOS4_IRQ_MCT_G0, &mct_comp_event_irq);  
  17. }  
因为这个阶段其它cpu核尚未开始工作，所以该clock_event_device也只是在启动阶段给系统提供服务，实际上，因为exynos4是一个smp系统，具备2-4个cpu核心，前面说过，smp系统中，通常会使用各个cpu的本地定时器来为每个cpu单独提供时钟事件服务，继续翻阅代码，在系统初始化的后段，kernel_init会被调用，它会调用smp_prepare_cpus，其中会调用percpu_timer_setup函数，在arch/arm/kernel/smp.c中，为每个cpu定义了一个clock_event_device：
[cpp] view plain copy
  1. /* 
  2.  * Timer (local or broadcast) support 
  3.  */  
  4. static DEFINE_PER_CPU(struct clock_event_device, percpu_clockevent);  
percpu_timer_setup最终会调用exynos4_local_timer_setup函数完成对本地clock_event_device的初始化工作：
[cpp] view plain copy
  1. static int __cpuinit exynos4_local_timer_setup(struct clock_event_device *evt)  
  2. {  
  3.     ......  
  4.     evt->name = mevt->name;  
  5.     evt->cpumask = cpumask_of(cpu);  
  6.     evt->set_next_event = exynos4_tick_set_next_event;  
  7.     evt->set_mode = exynos4_tick_set_mode;  
  8.     evt->features = CLOCK_EVT_FEAT_PERIODIC | CLOCK_EVT_FEAT_ONESHOT;  
  9.     evt->rating = 450;  
  10.   
  11.     clockevents_calc_mult_shift(evt, clk_rate / (TICK_BASE_CNT + 1), 5);  
  12.     ......  
  13.     clockevents_register_device(evt);  
  14.     ......  
  15.     enable_percpu_irq(EXYNOS_IRQ_MCT_LOCALTIMER, 0);  
  16.     ......  
  17.     return 0;  
  18. }  
由此可见，每个cpu的本地clock_event_device的rating是450，比启动阶段的250要高，显然，之前注册给cpu0的精度要高，系统会用本地clock_event_device替换掉原来分配给cpu0的clock_event_device，至于怎么替换？我们先停一停，到这里我们一直在讨论machine级别的初始化和注册，让我们回过头来，看看框架层的初始化。在继续之前，让我们看看整个clock_event_device的初始化的调用序列图：

Linux时间子系统_第3张图片

                                                                                           图3.1  clock_event_device的系统初始化

由上面的图示可以看出，框架层的初始化步骤很简单，又start_kernel开始，调用tick_init，它位于kernel/time/tick-common.c中，也只是简单地调用clockevents_register_notifier，同时把类型为notifier_block的tick_notifier作为参数传入，回看2.3节，clockevents_register_notifier注册了一个通知链，这样，当系统中的clock_event_device状态发生变化时（新增，删除，挂起，唤醒等等），tick_notifier中的notifier_call字段中设定的回调函数tick_notify就会被调用。接下来start_kernel调用了time_init函数，该函数通常定义在体系相关的代码中，正如前面所讨论的一样，它主要完成machine级别对时钟系统的初始化工作，最终通过clockevents_register_device注册系统中的时钟事件设备，把每个时钟时间设备挂在clockevent_device全局链表上，最后通过clockevent_do_notify触发框架层事先注册好的通知链，其实就是调用了tick_notify函数，我们主要关注CLOCK_EVT_NOTIFY_ADD通知，其它通知请自行参考代码，下面是tick_notify的简化版本：

[cpp] view plain copy
  1. static int tick_notify(struct notifier_block *nb, unsigned long reason,  
  2.                    void *dev)  
  3. {  
  4.     switch (reason) {  
  5.   
  6.     case CLOCK_EVT_NOTIFY_ADD:  
  7.         return tick_check_new_device(dev);  
  8.   
  9.     case CLOCK_EVT_NOTIFY_BROADCAST_ON:  
  10.     case CLOCK_EVT_NOTIFY_BROADCAST_OFF:  
  11.     case CLOCK_EVT_NOTIFY_BROADCAST_FORCE:  
  12.             ......  
  13.     case CLOCK_EVT_NOTIFY_BROADCAST_ENTER:  
  14.     case CLOCK_EVT_NOTIFY_BROADCAST_EXIT:  
  15.             ......  
  16.     case CLOCK_EVT_NOTIFY_CPU_DYING:  
  17.             ......  
  18.     case CLOCK_EVT_NOTIFY_CPU_DEAD:  
  19.             ......  
  20.     case CLOCK_EVT_NOTIFY_SUSPEND:  
  21.             ......  
  22.     case CLOCK_EVT_NOTIFY_RESUME:  
  23.             ......  
  24.     }  
  25.   
  26.     return NOTIFY_OK;  
  27. }  
可见，对于新注册的clock_event_device，会发出CLOCK_EVT_NOTIFY_ADD通知，最终会进入函数：tick_check_new_device，这个函数比对当前cpu所使用的与新注册的clock_event_device之间的特性，如果认为新的clock_event_device更好，则会进行切换工作。下一节将会详细的讨论该函数。到这里，每个cpu已经有了自己的clock_event_device，在这以后，框架层的代码会根据内核的配置项（CONFIG_NO_HZ、CONFIG_HIGH_RES_TIMERS），对注册的clock_event_device进行不同的设置，从而为系统的tick和高精度定时器提供服务，这些内容我们留在本系列的后续文章进行讨论。

4.  tick_device

当内核没有配置成支持高精度定时器时，系统的tick由tick_device产生，tick_device其实是clock_event_device的简单封装，它内嵌了一个clock_event_device指针和它的工作模式：
[cpp] view plain copy
  1. struct tick_device {  
  2.     struct clock_event_device *evtdev;  
  3.     enum tick_device_mode mode;  
  4. };  
在kernel/time/tick-common.c中，定义了一个per-cpu的tick_device全局变量，tick_cpu_device：
[cpp] view plain copy
  1. /* 
  2.  * Tick devices 
  3.  */  
  4. DEFINE_PER_CPU(struct tick_device, tick_cpu_device);  
前面曾经说过，当machine的代码为每个cpu注册clock_event_device时，通知回调函数tick_notify会被调用，进而进入tick_check_new_device函数，下面让我们看看该函数如何工作，首先，该函数先判断注册的clock_event_device是否可用于本cpu，然后从per-cpu变量中取出本cpu的tick_device：
[cpp] view plain copy
  1. static int tick_check_new_device(struct clock_event_device *newdev)  
  2. {  
  3.         ......  
  4.     cpu = smp_processor_id();  
  5.     if (!cpumask_test_cpu(cpu, newdev->cpumask))  
  6.         goto out_bc;  
  7.   
  8.     td = &per_cpu(tick_cpu_device, cpu);  
  9.     curdev = td->evtdev;  
如果不是本地clock_event_device，会做进一步的判断：如果不能把irq绑定到本cpu，则放弃处理，如果本cpu已经有了一个本地clock_event_device，也放弃处理：
[cpp] view plain copy
  1. if (!cpumask_equal(newdev->cpumask, cpumask_of(cpu))) {  
  2.                ......  
  3.     if (!irq_can_set_affinity(newdev->irq))  
  4.         goto out_bc;  
  5.                ......  
  6.     if (curdev && cpumask_equal(curdev->cpumask, cpumask_of(cpu)))  
  7.         goto out_bc;  
  8. }  
反之，如果本cpu已经有了一个clock_event_device，则根据是否支持单触发模式和它的rating值，决定是否替换原来旧的clock_event_device：
[cpp] view plain copy
  1. if (curdev) {  
  2.     if ((curdev->features & CLOCK_EVT_FEAT_ONESHOT) &&  
  3.         !(newdev->features & CLOCK_EVT_FEAT_ONESHOT))  
  4.         goto out_bc;  // 新的不支持单触发，但旧的支持，所以不能替换  
  5.     if (curdev->rating >= newdev->rating)  
  6.         goto out_bc;  // 旧的比新的精度高，不能替换  
  7. }  
在这些判断都通过之后，说明或者来cpu还没有绑定tick_device，或者是新的更好，需要替换：
[cpp] view plain copy
  1. if (tick_is_broadcast_device(curdev)) {  
  2.     clockevents_shutdown(curdev);  
  3.     curdev = NULL;  
  4. }  
  5. clockevents_exchange_device(curdev, newdev);  
  6. tick_setup_device(td, newdev, cpu, cpumask_of(cpu));  
上面的tick_setup_device函数负责重新绑定当前cpu的tick_device和新注册的clock_event_device，如果发现是当前cpu第一次注册tick_device，就把它设置为TICKDEV_MODE_PERIODIC模式，如果是替换旧的tick_device，则根据新的tick_device的特性，设置为TICKDEV_MODE_PERIODIC或TICKDEV_MODE_ONESHOT模式。可见，在系统的启动阶段，tick_device是工作在周期触发模式的，直到框架层在合适的时机，才会开启单触发模式，以便支持NO_HZ和HRTIMER。

5.  tick事件的处理--最简单的情况

clock_event_device最基本的应用就是实现tick_device，然后给系统定期地产生tick事件，通用时间框架对clock_event_device和tick_device的处理相当复杂，因为涉及配置项：CONFIG_NO_HZ和CONFIG_HIGH_RES_TIMERS的组合，两个配置项就有4种组合，这四种组合的处理都有所不同，所以这里我先只讨论最简单的情况：
  • CONFIG_NO_HZ == 0;
  • CONFIG_HIGH_RES_TIMERS == 0;
在这种配置模式下，我们回到上一节的tick_setup_device函数的最后：
[cpp] view plain copy
  1. if (td->mode == TICKDEV_MODE_PERIODIC)  
  2.     tick_setup_periodic(newdev, 0);  
  3. else  
  4.     tick_setup_oneshot(newdev, handler, next_event);  
因为启动期间，第一个注册的tick_device必然工作在TICKDEV_MODE_PERIODIC模式，所以tick_setup_periodic会设置clock_event_device的事件回调字段event_handler为tick_handle_periodic，工作一段时间后，就算有新的支持TICKDEV_MODE_ONESHOT模式的clock_event_device需要替换，再次进入tick_setup_device函数，tick_setup_oneshot的handler参数也是之前设置的tick_handle_periodic函数，所以我们考察tick_handle_periodic即可：
[cpp] view plain copy
  1. void tick_handle_periodic(struct clock_event_device *dev)  
  2. {  
  3.     int cpu = smp_processor_id();  
  4.     ktime_t next;  
  5.   
  6.     tick_periodic(cpu);  
  7.   
  8.     if (dev->mode != CLOCK_EVT_MODE_ONESHOT)  
  9.         return;  
  10.   
  11.     next = ktime_add(dev->next_event, tick_period);  
  12.     for (;;) {  
  13.         if (!clockevents_program_event(dev, next, false))  
  14.             return;  
  15.         if (timekeeping_valid_for_hres())  
  16.             tick_periodic(cpu);  
  17.         next = ktime_add(next, tick_period);  
  18.     }  
  19. }  
该函数首先调用tick_periodic函数，完成tick事件的所有处理，如果是周期触发模式，处理结束，如果工作在单触发模式，则计算并设置下一次的触发时刻，这里用了一个循环，是为了防止当该函数被调用时，clock_event_device中的计时实际上已经经过了不止一个tick周期，这时候，tick_periodic可能被多次调用，使得jiffies和时间可以被正确地更新。tick_periodic的代码如下：
[cpp] view plain copy
  1. static void tick_periodic(int cpu)  
  2. {  
  3.     if (tick_do_timer_cpu == cpu) {  
  4.         write_seqlock(&xtime_lock);  
  5.   
  6.         /* Keep track of the next tick event */  
  7.         tick_next_period = ktime_add(tick_next_period, tick_period);  
  8.   
  9.         do_timer(1);  
  10.         write_sequnlock(&xtime_lock);  
  11.     }  
  12.   
  13.     update_process_times(user_mode(get_irq_regs()));  
  14.     profile_tick(CPU_PROFILING);  
  15. }  
如果当前cpu负责更新时间，则通过do_timer进行以下操作：
  • 更新jiffies_64变量；
  • 更新墙上时钟；
  • 每10个tick，更新一次cpu的负载信息；
调用update_peocess_times，完成以下事情：
  • 更新进程的时间统计信息；
  • 触发TIMER_SOFTIRQ软件中断，以便系统处理传统的低分辨率定时器；
  • 检查rcu的callback；
  • 通过scheduler_tick触发调度系统进行进程统计和调度工作；

Linux时间子系统之五：低分辨率定时器的原理和实现

利用定时器，我们可以设定在未来的某一时刻，触发一个特定的事件。 所谓低分辨率定时器，是指这种定时器的计时单位基于jiffies值的计数，也就是说，它的精度只有1/HZ，假如你的内核配置的HZ是1000，那意味着系统中的低分辨率定时器的精度就是1ms。早期的内核版本中，内核并不支持高精度定时器，理所当然只能使用这种低分辨率定时器，我们有时候把这种基于HZ的定时器机制成为时间轮：time wheel。虽然后来出现了高分辨率定时器，但它只是内核的一个可选配置项，所以直到目前最新的内核版本，这种低分辨率定时器依然被大量地使用着。
/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

1.  定时器的使用方法

在讨论定时器的实现原理之前，我们先看看如何使用定时器。要在内核编程中使用定时器，首先我们要定义一个time_list结构，该结构在include/linux/timer.h中定义：

[cpp] view plain copy
  1. struct timer_list {  
  2.     /* 
  3.      * All fields that change during normal runtime grouped to the 
  4.      * same cacheline 
  5.      */  
  6.     struct list_head entry;  
  7.     unsigned long expires;  
  8.     struct tvec_base *base;  
  9.   
  10.     void (*function)(unsigned long);  
  11.     unsigned long data;  
  12.   
  13.     int slack;  
  14.         ......  
  15. };  
entry  字段用于把一组定时器组成一个链表，至于内核如何对定时器进行分组，我们会在后面进行解释。

expires  字段指出了该定时器的到期时刻，也就是期望定时器到期时刻的jiffies计数值。

base  每个cpu拥有一个自己的用于管理定时器的tvec_base结构，该字段指向该定时器所属的cpu所对应tvec_base结构。

function  字段是一个函数指针，定时器到期时，系统将会调用该回调函数，用于响应该定时器的到期事件。

data  该字段用于上述回调函数的参数。

slack  对有些对到期时间精度不太敏感的定时器，到期时刻允许适当地延迟一小段时间，该字段用于计算每次延迟的HZ数。

要定义一个timer_list，我们可以使用静态和动态两种办法，静态方法使用DEFINE_TIMER宏：

#define DEFINE_TIMER(_name, _function, _expires, _data)

该宏将得到一个名字为_name，并分别用_function,_expires,_data参数填充timer_list的相关字段。

如果要使用动态的方法，则可以自己声明一个timer_list结构，然后手动初始化它的各个字段：

[cpp] view plain copy
  1. struct timer_list timer;  
  2. ......  
  3. init_timer(&timer);  
  4. timer.function = _function;  
  5. timer.expires = _expires;  
  6. timer.data = _data;  
要激活一个定时器，我们只要调用add_timer即可：
[cpp] view plain copy
  1. add_timer(&timer);  

要修改定时器的到期时间，我们只要调用mod_timer即可：
[cpp] view plain copy
  1. mod_timer(&timer, jiffies+50);  
要移除一个定时器，我们只要调用del_timer即可：
[cpp] view plain copy
  1. del_timer(&timer);  
定时器系统还提供了以下这些API供我们使用：
  • void add_timer_on(struct timer_list *timer, int cpu);  // 在指定的cpu上添加定时器
  • int mod_timer_pending(struct timer_list *timer, unsigned long expires);  //  只有当timer已经处在激活状态时，才修改timer的到期时刻
  • int mod_timer_pinned(struct timer_list *timer, unsigned long expires);  //  当
  • void set_timer_slack(struct timer_list *time, int slack_hz);  //  设定timer允许的到期时刻的最大延迟，用于对精度不敏感的定时器
  • int del_timer_sync(struct timer_list *timer);  //  如果该timer正在被处理中，则等待timer处理完成才移除该timer

2.  定时器的软件架构

低分辨率定时器是基于HZ来实现的，也就是说，每个tick周期，都有可能有定时器到期，关于tick如何产生，请参考：Linux时间子系统之四：定时器的引擎：clock_event_device。系统中有可能有成百上千个定时器，难道在每个tick中断中遍历一下所有的定时器，检查它们是否到期？内核当然不会使用这么笨的办法，它使用了一个更聪明的办法：按定时器的到期时间对定时器进行分组。因为目前的多核处理器使用越来越广泛，连智能手机的处理器动不动就是4核心，内核对多核处理器有较好的支持，低分辨率定时器在实现时也充分地考虑了多核处理器的支持和优化。为了较好地利用cache line，也为了避免cpu之间的互锁，内核为多核处理器中的每个cpu单独分配了管理定时器的相关数据结构和资源，每个cpu独立地管理属于自己的定时器。

2.1  定时器的分组

首先，内核为每个cpu定义了一个tvec_base结构指针：

[cpp] view plain copy
  1. static DEFINE_PER_CPU(struct tvec_base *, tvec_bases) = &boot_tvec_bases;  
tvec_base结构的定义如下：
[cpp] view plain copy
  1. struct tvec_base {  
  2.     spinlock_t lock;  
  3.     struct timer_list *running_timer;  
  4.     unsigned long timer_jiffies;  
  5.     unsigned long next_timer;  
  6.     struct tvec_root tv1;  
  7.     struct tvec tv2;  
  8.     struct tvec tv3;  
  9.     struct tvec tv4;  
  10.     struct tvec tv5;  
  11. } ____cacheline_aligned;  
running_timer  该字段指向当前cpu正在处理的定时器所对应的timer_list结构。

timer_jiffies  该字段表示当前cpu定时器所经历过的jiffies数，大多数情况下，该值和jiffies计数值相等，当cpu的idle状态连续持续了多个jiffies时间时，当退出idle状态时，jiffies计数值就会大于该字段，在接下来的tick中断后，定时器系统会让该字段的值追赶上jiffies值。

next_timer  该字段指向该cpu下一个即将到期的定时器。

tv1--tv5  这5个字段用于对定时器进行分组，实际上，tv1--tv5都是一个链表数组，其中tv1的数组大小为TVR_SIZE， tv2 tv3 tv4 tv5的数组大小为TVN_SIZE，根据CONFIG_BASE_SMALL配置项的不同，它们有不同的大小：

[cpp] view plain copy
  1. #define TVN_BITS (CONFIG_BASE_SMALL ? 4 : 6)  
  2. #define TVR_BITS (CONFIG_BASE_SMALL ? 6 : 8)  
  3. #define TVN_SIZE (1 << TVN_BITS)  
  4. #define TVR_SIZE (1 << TVR_BITS)  
  5. #define TVN_MASK (TVN_SIZE - 1)  
  6. #define TVR_MASK (TVR_SIZE - 1)  
  7.   
  8. struct tvec {  
  9.     struct list_head vec[TVN_SIZE];  
  10. };  
  11.   
  12. struct tvec_root {  
  13.     struct list_head vec[TVR_SIZE];  
  14. };  
默认情况下，没有使能CONFIG_BASE_SMALL，TVR_SIZE的大小是256，TVN_SIZE的大小则是64，当需要节省内存空间时，也可以使能CONFIG_BASE_SMALL，这时TVR_SIZE的大小是64，TVN_SIZE的大小则是16，以下的讨论我都是基于没有使能CONFIG_BASE_SMALL的情况。 当有一个新的定时器要加入时，系统根据定时器到期的jiffies值和timer_jiffies字段的差值来决定该定时器被放入tv1至tv5中的哪一个数组中，最终，系统中所有的定时器的组织结构如下图所示：
Linux时间子系统_第4张图片
                                                        图 2.1.1  定时器在系统中的组织结构
2.2  定时器的添加

要加入一个新的定时器，我们可以通过api函数add_timer或mod_timer来完成，最终的工作会交由internal_add_timer函数来处理。该函数按以下步骤进行处理：

  • 计算定时器到期时间和所属cpu的tvec_base结构中的timer_jiffies字段的差值，记为idx；
  • 根据idx的值，选择该定时器应该被放到tv1--tv5中的哪一个链表数组中，可以认为tv1-tv5分别占据一个32位数的不同比特位，tv1占据最低的8位，tv2占据紧接着的6位，然后tv3再占位，以此类推，最高的6位分配给tv5。最终的选择规则如下表所示：
链表数组 idx范围
tv1 0-255(2^8)
tv2 256--16383(2^14)
tv3 16384--1048575(2^20)
tv4 1048576--67108863(2^26)
tv5 67108864--4294967295(2^32)

确定链表数组后，接着要确定把该定时器放入数组中的哪一个链表中，如果时间差idx小于256，按规则要放入tv1中，因为tv1包含了256个链表，所以可以简单地使用timer_list.expires的低8位作为数组的索引下标，把定时器链接到tv1中相应的链表中即可。如果时间差idx的值在256--18383之间，则需要把定时器放入tv2中，同样的，使用timer_list.expires的8--14位作为数组的索引下标，把定时器链接到tv2中相应的链表中,。定时器要加入tv3 tv4 tv5使用同样的原理。经过这样分组后的定时器，在后续的tick事件中，系统可以很方便地定位并取出相应的到期定时器进行处理。以上的讨论都体现在internal_add_timer的代码中：

[cpp] view plain copy
  1. static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)  
  2. {  
  3.     unsigned long expires = timer->expires;  
  4.     unsigned long idx = expires - base->timer_jiffies;  
  5.     struct list_head *vec;  
  6.   
  7.     if (idx < TVR_SIZE) {  
  8.         int i = expires & TVR_MASK;  
  9.         vec = base->tv1.vec + i;  
  10.     } else if (idx < 1 << (TVR_BITS + TVN_BITS)) {  
  11.         int i = (expires >> TVR_BITS) & TVN_MASK;  
  12.         vec = base->tv2.vec + i;  
  13.     } else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {  
  14.         int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;  
  15.         vec = base->tv3.vec + i;  
  16.     } else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {  
  17.         int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;  
  18.         vec = base->tv4.vec + i;  
  19.     } else if ((signed long) idx < 0) {  
  20.                 ......  
  21.     } else {  
  22.                 ......  
  23.         i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;  
  24.         vec = base->tv5.vec + i;  
  25.     }  
  26.     list_add_tail(&timer->entry, vec);  
  27. }  
2.2  定时器的到期处理

经过2.1节的处理后，系统中的定时器按到期时间有规律地放置在tv1--tv5各个链表数组中，其中tv1中放置着在接下来的256个jiffies即将到期的定时器列表，需要注意的是，并不是tv1.vec[0]中放置着马上到期的定时器列表，tv1.vec[1]中放置着将在jiffies+1到期的定时器列表。因为base.timer_jiffies的值一直在随着系统的运行而动态地增加，原则上是每个tick事件会加1，base.timer_jiffies代表者该cpu定时器系统当前时刻，定时器也是动态地加入头256个链表tv1中，按2.1节的讨论，定时器加入tv1中使用的下标索引是定时器到期时间expires的低8位，所以假设当前的base.timer_jiffies值是0x34567826，则马上到期的定时器是在tv1.vec[0x26]中，如果这时候系统加入一个在jiffies值0x34567828到期的定时器，他将会加入到tv1.vec[0x28]中，运行两个tick后，base.timer_jiffies的值会变为0x34567828，很显然，在每次tick事件中，定时器系统只要以base.timer_jiffies的低8位作为索引，取出tv1中相应的链表，里面正好包含了所有在该jiffies值到期的定时器列表。

那什么时候处理tv2--tv5中的定时器？每当base.timer_jiffies的低8位为0值时，这表明base.timer_jiffies的第8-13位有进位发生，这6位正好代表着tv2，这时只要按base.timer_jiffies的第8-13位的值作为下标，移出tv2中对应的定时器链表，然后用internal_add_timer把它们从新加入到定时器系统中来，因为这些定时器一定会在接下来的256个tick期间到期，所以它们肯定会被加入到tv1数组中，这样就完成了tv2往tv1迁移的过程。同样地，当base.timer_jiffies的第8-13位为0时，这表明base.timer_jiffies的第14-19位有进位发生，这6位正好代表着tv3，按base.timer_jiffies的第14-19位的值作为下标，移出tv3中对应的定时器链表，然后用internal_add_timer把它们从新加入到定时器系统中来，显然它们会被加入到tv2中，从而完成tv3到tv2的迁移，tv4，tv5的处理可以以此作类推。具体迁移的代码如下，参数index为事先计算好的高一级tv的需要迁移的数组索引：

[cpp] view plain copy
  1. static int cascade(struct tvec_base *base, struct tvec *tv, int index)  
  2. {  
  3.     /* cascade all the timers from tv up one level */  
  4.     struct timer_list *timer, *tmp;  
  5.     struct list_head tv_list;  
  6.   
  7.     list_replace_init(tv->vec + index, &tv_list);  //  移除需要迁移的链表  
  8.   
  9.     /* 
  10.      * We are removing _all_ timers from the list, so we 
  11.      * don't have to detach them individually. 
  12.      */  
  13.     list_for_each_entry_safe(timer, tmp, &tv_list, entry) {  
  14.         BUG_ON(tbase_get_base(timer->base) != base);  
  15.                 //  重新加入到定时器系统中，实际上将会迁移到下一级的tv数组中  
  16.         internal_add_timer(base, timer);    
  17.     }  
  18.   
  19.     return index;  
  20. }  
每个tick事件到来时，内核会在tick定时中断处理期间激活定时器软中断：TIMER_SOFTIRQ，关于软件中断，请参考另一篇博文： Linux中断（interrupt）子系统之五：软件中断（softIRQ。TIMER_SOFTIRQ的执行函数是__run_timers，它实现了本节讨论的逻辑，取出tv1中到期的定时器，执行定时器的回调函数，由此可见， 低分辨率定时器的回调函数是执行在软件中断上下文中的，这点在写定时器的回调函数时需要注意。__run_timers的代码如下：
[cpp] view plain copy
  1. static inline void __run_timers(struct tvec_base *base)  
  2. {  
  3.     struct timer_list *timer;  
  4.   
  5.     spin_lock_irq(&base->lock);  
  6.         /* 同步jiffies，在NO_HZ情况下，base->timer_jiffies可能落后不止一个tick  */  
  7.     while (time_after_eq(jiffies, base->timer_jiffies)) {    
  8.         struct list_head work_list;  
  9.         struct list_head *head = &work_list;  
  10.                 /*  计算到期定时器链表在tv1中的索引  */  
  11.         int index = base->timer_jiffies & TVR_MASK;    
  12.   
  13.         /* 
  14.          * /*  tv2--tv5定时器列表迁移处理  */  
  15.          */  
  16.         if (!index &&  
  17.             (!cascade(base, &base->tv2, INDEX(0))) &&                
  18.                 (!cascade(base, &base->tv3, INDEX(1))) &&        
  19.                     !cascade(base, &base->tv4, INDEX(2)))    
  20.             cascade(base, &base->tv5, INDEX(3));    
  21.                 /*  该cpu定时器系统运行时间递增一个tick  */                   
  22.         ++base->timer_jiffies;    
  23.                 /*  取出到期的定时器链表  */                                         
  24.         list_replace_init(base->tv1.vec + index, &work_list);  
  25.                 /*  遍历所有的到期定时器  */            
  26.         while (!list_empty(head)) {                                      
  27.             void (*fn)(unsigned long);  
  28.             unsigned long data;  
  29.   
  30.             timer = list_first_entry(head, struct timer_list,entry);  
  31.             fn = timer->function;  
  32.             data = timer->data;  
  33.   
  34.             timer_stats_account_timer(timer);  
  35.   
  36.             base->running_timer = timer;    /*  标记正在处理的定时器  */  
  37.             detach_timer(timer, 1);  
  38.   
  39.             spin_unlock_irq(&base->lock);  
  40.             call_timer_fn(timer, fn, data);  /*  调用定时器的回调函数  */  
  41.             spin_lock_irq(&base->lock);  
  42.         }  
  43.     }  
  44.     base->running_timer = NULL;  
  45.     spin_unlock_irq(&base->lock);  
  46. }  
通过上面的讨论，我们可以发现，内核的低分辨率定时器的实现非常精妙，既实现了大量定时器的管理，又实现了快速的O(1)查找到期定时器的能力，利用巧妙的数组结构，使得只需在间隔256个tick时间才处理一次迁移操作，5个数组就好比是5个齿轮，它们随着base->timer_jifffies的增长而不停地转动，每次只需处理第一个齿轮的某一个齿节，低一级的齿轮转动一圈，高一级的齿轮转动一个齿，同时自动把即将到期的定时器迁移到上一个齿轮中， 所以低分辨率定时器通常又被叫做时间轮：time wheel。事实上，它的实现是一个很好的空间换时间软件算法。

3.  定时器软件中断

系统初始化时，start_kernel会调用定时器系统的初始化函数init_timers：

[cpp] view plain copy
  1. void __init init_timers(void)  
  2. {        
  3.     int err = timer_cpu_notify(&timers_nb, (unsigned long)CPU_UP_PREPARE,   
  4.                 (void *)(long)smp_processor_id());  
  5.   
  6.     init_timer_stats();  
  7.   
  8.     BUG_ON(err != NOTIFY_OK);  
  9.     register_cpu_notifier(&timers_nb);  /* 注册cpu notify，以便在hotplug时在cpu之间进行定时器的迁移 */  
  10.     open_softirq(TIMER_SOFTIRQ, run_timer_softirq);  
  11. }  
可见，open_softirq把run_timer_softirq注册为TIMER_SOFTIRQ的处理函数，另外，当cpu的每个tick事件到来时，在事件处理中断中，update_process_times会被调用，该函数会进一步调用run_local_timers，run_local_timers会触发TIMER_SOFTIRQ软中断：
[cpp] view plain copy
  1. void run_local_timers(void)  
  2. {  
  3.     hrtimer_run_queues();  
  4.     raise_softirq(TIMER_SOFTIRQ);  
  5. }  
TIMER_SOFTIRQ的处理函数是run_timer_softirq：
[cpp] view plain copy
  1. static void run_timer_softirq(struct softirq_action *h)  
  2. {  
  3.     struct tvec_base *base = __this_cpu_read(tvec_bases);  
  4.   
  5.     hrtimer_run_pending();  
  6.   
  7.     if (time_after_eq(jiffies, base->timer_jiffies))  
  8.         __run_timers(base);  
  9. }  
好啦，终于看到__run_timers函数了，2.2节已经介绍过，正是这个函数完成了对到期定时器的处理工作，也完成了时间轮的不停转动。

Linux时间子系统之六：高精度定时器（HRTIMER）的原理和实现

上一篇文章，我介绍了传统的 低分辨率定时器的实现原理。而随着内核的不断演进，大牛们已经对这种低分辨率定时器的精度不再满足，而且， 硬件也在不断地发展，系统中的定时器硬件的精度也越来越高，这也给高分辨率定时器的出现创造了条件。内核从2.6.16开始加入了高精度定时器架构。在实现方式上，内核的高分辨率定时器的实现代码几乎没有借用低分辨率定时器的数据结构和代码，内核文档给出的解释主要有以下几点：

  • 低分辨率定时器的代码和jiffies的关系太过紧密，并且默认按32位进行设计，并且它的代码已经经过长时间的优化，目前的使用也是没有任何错误，如果硬要基于它来实现高分辨率定时器，势必会打破原有的时间轮概念，并且会引入一大堆#if--#else判断；
  • 虽然大部分时间里，时间轮可以实现O(1)时间复杂度，但是当有进位发生时，不可预测的O(N)定时器级联迁移时间，这对于低分辨率定时器来说问题不大，可是它大大地影响了定时器的精度；
  • 低分辨率定时器几乎是为“超时”而设计的，并为此对它进行了大量的优化，对于这些以“超时”未目的而使用定时器，它们大多数期望在超时到来之前获得正确的结果，然后删除定时器，精确时间并不是它们主要的目的，例如网络通信、设备IO等等。

为此，内核为高精度定时器重新设计了一套软件架构，它可以为我们提供纳秒级的定时精度，以满足对精确时间有迫切需求的应用程序或内核驱动，例如多媒体应用，音频设备的驱动程序等等。以下的讨论用hrtimer(high resolution timer)表示高精度定时器。
/*****************************************************************************************************/
声明：本博内容均由http://blog.csdn.net/droidphone原创，转载请注明出处，谢谢！
/*****************************************************************************************************/

1.  如何组织hrtimer？

我们知道，低分辨率定时器使用5个链表数组来组织timer_list结构，形成了著名的时间轮概念，对于高分辨率定时器，我们期望组织它们的数据结构至少具备以下条件：

  • 稳定而且快速的查找能力；
  • 快速地插入和删除定时器的能力；
  • 排序功能；

内核的开发者考察了多种数据结构，例如基数树、哈希表等等，最终他们选择了红黑树（rbtree）来组织hrtimer，红黑树已经以库的形式存在于内核中，并被成功地使用在内存管理子系统和文件系统中，随着系统的运行，hrtimer不停地被创建和销毁，新的hrtimer按顺序被插入到红黑树中，树的最左边的节点就是最快到期的定时器，内核用一个hrtimer结构来表示一个高精度定时器：

[cpp] view plain copy
  1. struct hrtimer {  
  2.     struct timerqueue_node      node;  
  3.     ktime_t             _softexpires;  
  4.     enum hrtimer_restart        (*function)(struct hrtimer *);  
  5.     struct hrtimer_clock_base   *base;  
  6.     unsigned long           state;  
  7.         ......  
  8. };  
定时器的到期时间用ktime_t来表示，_softexpires字段记录了时间，定时器一旦到期，function字段指定的回调函数会被调用，该函数的返回值为一个枚举值，它决定了该hrtimer是否需要被重新激活：
[cpp] view plain copy
  1. enum hrtimer_restart {  
  2.     HRTIMER_NORESTART,  /* Timer is not restarted */  
  3.     HRTIMER_RESTART,    /* Timer must be restarted */  
  4. };  
state字段用于表示hrtimer当前的状态，有几下几种位组合：
[cpp] view plain copy
  1. #define HRTIMER_STATE_INACTIVE  0x00  // 定时器未激活  
  2. #define HRTIMER_STATE_ENQUEUED  0x01  // 定时器已经被排入红黑树中  
  3. #define HRTIMER_STATE_CALLBACK  0x02  // 定时器的回调函数正在被调用  
  4. #define HRTIMER_STATE_MIGRATE   0x04  // 定时器正在CPU之间做迁移  
hrtimer的到期时间可以基于以下几种时间基准系统：
[cpp] view plain copy
  1. enum  hrtimer_base_type {  
  2.     HRTIMER_BASE_MONOTONIC,  // 单调递增的monotonic时间，不包含休眠时间  
  3.     HRTIMER_BASE_REALTIME,   // 平常使用的墙上真实时间  
  4.     HRTIMER_BASE_BOOTTIME,   // 单调递增的boottime，包含休眠时间  
  5.     HRTIMER_MAX_CLOCK_BASES, // 用于后续数组的定义  
  6. };  
和低分辨率定时器一样，处于效率和上锁的考虑，每个cpu单独管理属于自己的hrtimer，为此，专门定义了一个结构hrtimer_cpu_base：
[cpp] view plain copy
  1. struct hrtimer_cpu_base {  
  2.         ......  
  3.     struct hrtimer_clock_base   clock_base[HRTIMER_MAX_CLOCK_BASES];  
  4. };  
其中，clock_base数组为每种时间基准系统都定义了一个hrtimer_clock_base结构，它的定义如下：
[cpp] view plain copy
  1. struct hrtimer_clock_base {  
  2.     struct hrtimer_cpu_base *cpu_base;  // 指向所属cpu的hrtimer_cpu_base结构  
  3.         ......  
  4.     struct timerqueue_head  active;     // 红黑树，包含了所有使用该时间基准系统的hrtimer  
  5.     ktime_t         resolution; // 时间基准系统的分辨率  
  6.     ktime_t         (*get_time)(void); // 获取该基准系统的时间函数  
  7.     ktime_t         softirq_time;// 当用jiffies  
  8.     ktime_t         offset;      //   
  9. };  
active字段是一个timerqueue_head结构，它实际上是对rbtree的进一步封装：
[cpp] view plain copy
  1. struct timerqueue_node {  
  2.     struct rb_node node;  // 红黑树的节点  
  3.     ktime_t expires;      // 该节点代表队hrtimer的到期时间，与hrtimer结构中的_softexpires稍有不同  
  4. };  
  5.   
  6. struct timerqueue_head {  
  7.     struct rb_root head;          // 红黑树的根节点  
  8.     struct timerqueue_node *next; // 该红黑树中最早到期的节点，也就是最左下的节点  
  9. };  
timerqueue_head结构在红黑树的基础上，增加了一个next字段，用于保存树中最先到期的定时器节点，实际上就是树的最左下方的节点，有了next字段，当到期事件到来时，系统不必遍历整个红黑树，只要取出next字段对应的节点进行处理即可。timerqueue_node用于表示一个hrtimer节点，它在标准红黑树节点rb_node的基础上增加了expires字段，该字段和hrtimer中的_softexpires字段一起，设定了hrtimer的到期时间的一个范围，hrtimer可以在hrtimer._softexpires至timerqueue_node.expires之间的任何时刻到期，我们也称timerqueue_node.expires为硬过期时间(hard)，意思很明显：到了此时刻，定时器一定会到期，有了这个范围可以选择，定时器系统可以让范围接近的多个定时器在同一时刻同时到期，这种设计可以降低进程频繁地被hrtimer进行唤醒。经过以上的讨论，我们可以得出以下的图示，它表明了每个cpu上的hrtimer是如何被组织在一起的：

Linux时间子系统_第5张图片

                                                       图 1.1  每个cpu的hrtimer组织结构

总结一下：

  • 每个cpu有一个hrtimer_cpu_base结构；
  • hrtimer_cpu_base结构管理着3种不同的时间基准系统的hrtimer，分别是：实时时间，启动时间和单调时间；
  • 每种时间基准系统通过它的active字段（timerqueue_head结构指针），指向它们各自的红黑树；
  • 红黑树上，按到期时间进行排序，最先到期的hrtimer位于最左下的节点，并被记录在active.next字段中；
  • 3中时间基准的最先到期时间可能不同，所以，它们之中最先到期的时间被记录在hrtimer_cpu_base的expires_next字段中。

2.  hrtimer如何运转

hrtimer的实现需要一定的硬件基础，它的实现依赖于我们前几章介绍的timekeeper和clock_event_device，如果你对timekeeper和clock_event_device不了解请参考以下文章：Linux时间子系统之三：时间的维护者：timekeeper，Linux时间子系统之四：定时器的引擎：clock_event_device。hrtimer系统需要通过timekeeper获取当前的时间，计算与到期时间的差值，并根据该差值，设定该cpu的tick_device（clock_event_device）的下一次的到期时间，时间一到，在clock_event_device的事件回调函数中处理到期的hrtimer。现在你或许有疑问：前面在介绍clock_event_device时，我们知道，每个cpu有自己的tick_device，通常用于周期性地产生进程调度和时间统计的tick事件，这里又说要用tick_device调度hrtimer系统，通常cpu只有一个tick_device，那他们如何协调工作？这个问题也一度困扰着我，如果再加上NO_HZ配置带来tickless特性，你可能会更晕。这里我们先把这个疑问放下，我将在后面的章节中来讨论这个问题，现在我们只要先知道，一旦开启了hrtimer，tick_device所关联的clock_event_device的事件回调函数会被修改为：hrtimer_interrupt，并且会被设置成工作于CLOCK_EVT_MODE_ONESHOT单触发模式。

2.1  添加一个hrtimer

要添加一个hrtimer，系统提供了一些api供我们使用，首先我们需要定义一个hrtimer结构的实例，然后用hrtimer_init函数对它进行初始化，它的原型如下：

[cpp] view plain copy
  1. void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,  
  2.              enum hrtimer_mode mode);  
which_clock可以是CLOCK_REALTIME、CLOCK_MONOTONIC、CLOCK_BOOTTIME中的一种，mode则可以是相对时间HRTIMER_MODE_REL，也可以是绝对时间HRTIMER_MODE_ABS。设定回调函数：
[cpp] view plain copy
  1. timer.function = hr_callback;  

如果定时器无需指定一个到期范围，可以在设定回调函数后直接使用hrtimer_start激活该定时器：

[cpp] view plain copy
  1. int hrtimer_start(struct hrtimer *timer, ktime_t tim,  
  2.              const enum hrtimer_mode mode);  
如果需要指定到期范围，则可以使用hrtimer_start_range_ns激活定时器：
[cpp] view plain copy
  1. hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,  
  2.             unsigned long range_ns, const enum hrtimer_mode mode);  
要取消一个hrtimer，使用hrtimer_cancel：
[cpp] view plain copy
  1. int hrtimer_cancel(struct hrtimer *timer);  
以下两个函数用于推后定时器的到期时间：
[cpp] view plain copy
  1. extern u64  
  2. hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);  
  3.   
  4. /* Forward a hrtimer so it expires after the hrtimer's current now */  
  5. static inline u64 hrtimer_forward_now(struct hrtimer *timer,  
  6.                       ktime_t interval)  
  7. {  
  8.     return hrtimer_forward(timer, timer->base->get_time(), interval);  
  9. }  
以下几个函数用于获取定时器的当前状态：
[cpp] view plain copy
  1. static inline int hrtimer_active(const struct hrtimer *timer)  
  2. {  
  3.     return timer->state != HRTIMER_STATE_INACTIVE;  
  4. }  
  5.   
  6. static inline int hrtimer_is_queued(struct hrtimer *timer)  
  7. {  
  8.     return timer->state & HRTIMER_STATE_ENQUEUED;  
  9. }  
  10.   
  11. static inline int hrtimer_callback_running(struct hrtimer *timer)  
  12. {  
  13.     return timer->state & HRTIMER_STATE_CALLBACK;  
  14. }  
hrtimer_init最终会进入__hrtimer_init函数，该函数的主要目的是初始化hrtimer的base字段，同时初始化作为红黑树的节点的node字段：
[cpp] view plain copy
  1. static void __hrtimer_init(struct hrtimer *timer, clockid_t clock_id,  
  2.                enum hrtimer_mode mode)  
  3. {  
  4.     struct hrtimer_cpu_base *cpu_base;  
  5.     int base;  
  6.   
  7.     memset(timer, 0, sizeof(struct hrtimer));  
  8.   
  9.     cpu_base = &__raw_get_cpu_var(hrtimer_bases);  
  10.   
  11.     if (clock_id == CLOCK_REALTIME && mode != HRTIMER_MODE_ABS)  
  12.         clock_id = CLOCK_MONOTONIC;  
  13.   
  14.     base = hrtimer_clockid_to_base(clock_id);  
  15.     timer->base = &cpu_base->clock_base[base];  
  16.     timerqueue_init(&timer->node);  
  17.         ......  
  18. }  

hrtimer_start和hrtimer_start_range_ns最终会把实际的工作交由__hrtimer_start_range_ns来完成：

[cpp] view plain copy
  1. int __hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,  
  2.         unsigned long delta_ns, const enum hrtimer_mode mode,  
  3.         int wakeup)  
  4. {  
  5.         ......          
  6.         /* 取得hrtimer_clock_base指针 */  
  7.         base = lock_hrtimer_base(timer, &flags);   
  8.         /* 如果已经在红黑树中，先移除它: */  
  9.         ret = remove_hrtimer(timer, base); ......  
  10.         /* 如果是相对时间，则需要加上当前时间，因为内部是使用绝对时间 */  
  11.         if (mode & HRTIMER_MODE_REL) {  
  12.                 tim = ktime_add_safe(tim, new_base->get_time());  
  13.                 ......  
  14.         }   
  15.         /* 设置到期的时间范围 */  
  16.         hrtimer_set_expires_range_ns(timer, tim, delta_ns);  
  17.         ......   
  18.         /* 把hrtime按到期时间排序，加入到对应时间基准系统的红黑树中 */  
  19.         /* 如果该定时器的是最早到期的，将会返回true */  
  20.         leftmost = enqueue_hrtimer(timer, new_base);  
  21.         /*  
  22.         * Only allow reprogramming if the new base is on this CPU.  
  23.         * (it might still be on another CPU if the timer was pending)  
  24.         *  
  25.         * XXX send_remote_softirq() ? 
  26.         * 定时器比之前的到期时间要早，所以需要重新对tick_device进行编程，重新设定的的到期时间 
  27.         */  
  28.         if (leftmost && new_base->cpu_base == &__get_cpu_var(hrtimer_bases))  
  29.                 hrtimer_enqueue_reprogram(timer, new_base, wakeup);  
  30.         unlock_hrtimer_base(timer, &flags);  
  31.         return ret;  
  32. }  
  33. <p>  
  34. </p>  
2.2  hrtimer的到期处理

高精度定时器系统有3个入口可以对到期定时器进行处理，它们分别是：

  • 没有切换到高精度模式时，在每个jiffie的tick事件中断中进行查询和处理；
  • 在HRTIMER_SOFTIRQ软中断中进行查询和处理；
  • 切换到高精度模式后，在每个clock_event_device的到期事件中断中进行查询和处理；

低精度模式  因为系统并不是一开始就会支持高精度模式，而是在系统启动后的某个阶段，等待所有的条件都满足后，才会切换到高精度模式，当系统还没有切换到高精度模式时，所有的高精度定时器运行在低精度模式下，在每个jiffie的tick事件中断中进行到期定时器的查询和处理，显然这时候的精度和低分辨率定时器是一样的（HZ级别）。低精度模式下，每个tick事件中断中，hrtimer_run_queues函数会被调用，由它完成定时器的到期处理。hrtimer_run_queues首先判断目前高精度模式是否已经启用，如果已经切换到了高精度模式，什么也不做，直接返回：

[cpp] view plain copy
  1. void hrtimer_run_queues(void)  
  2. {  
  3.   
  4.     if (hrtimer_hres_active())  
  5.         return;  
如果hrtimer_hres_active返回false，说明目前处于低精度模式下，则继续处理，它用一个for循环遍历各个时间基准系统，查询每个hrtimer_clock_base对应红黑树的左下节点，判断它的时间是否到期，如果到期，通过__run_hrtimer函数，对到期定时器进行处理，包括：调用定时器的回调函数、从红黑树中移除该定时器、根据回调函数的返回值决定是否重新启动该定时器等等：
[cpp] view plain copy
  1. for (index = 0; index < HRTIMER_MAX_CLOCK_BASES; index++) {  
  2.     base = &cpu_base->clock_base[index];  
  3.     if (!timerqueue_getnext(&base->active))  
  4.         continue;  
  5.   
  6.     if (gettime) {  
  7.         hrtimer_get_softirq_time(cpu_base);  
  8.         gettime = 0;  
  9.     }  
  10.   
  11.     raw_spin_lock(&cpu_base->lock);  
  12.   
  13.     while ((node = timerqueue_getnext(&base->active))) {  
  14.         struct hrtimer *timer;  
  15.   
  16.         timer = container_of(node, struct hrtimer, node);  
  17.         if (base->softirq_time.tv64 <=  
  18.                 hrtimer_get_expires_tv64(timer))  
  19.             break;  
  20.   
  21.         __run_hrtimer(timer, &base->softirq_time);  
  22.     }  
  23.     raw_spin_unlock(&cpu_base->lock);  
  24. }  
上面的timerqueue_getnext函数返回红黑树中的左下节点，之所以可以在while循环中使用该函数，是因为__run_hrtimer会在移除旧的左下节点时，新的左下节点会被更新到base->active->next字段中，使得循环可以继续执行，直到没有新的到期定时器为止。

高精度模式  切换到高精度模式后，原来给cpu提供tick事件的tick_device（clock_event_device）会被高精度定时器系统接管，它的中断事件回调函数被设置为hrtimer_interrupt，红黑树中最左下的节点的定时器的到期时间被编程到该clock_event_device中，这样每次clock_event_device的中断意味着至少有一个高精度定时器到期。另外，当timekeeper系统中的时间需要修正，或者clock_event_device的到期事件时间被重新编程时，系统会发出HRTIMER_SOFTIRQ软中断，软中断的处理函数run_hrtimer_softirq最终也会调用hrtimer_interrupt函数对到期定时器进行处理，所以在这里我们只要讨论hrtimer_interrupt函数的实现即可。

hrtimer_interrupt函数的前半部分和低精度模式下的hrtimer_run_queues函数完成相同的事情：它用一个for循环遍历各个时间基准系统，查询每个hrtimer_clock_base对应红黑树的左下节点，判断它的时间是否到期，如果到期，通过__run_hrtimer函数，对到期定时器进行处理，所以我们只讨论后半部分，在处理完所有到期定时器后，下一个到期定时器的到期时间保存在变量expires_next中，接下来的工作就是把这个到期时间编程到tick_device中：

[cpp] view plain copy
  1. void hrtimer_interrupt(struct clock_event_device *dev)  
  2. {  
  3.         ......  
  4.     for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++) {  
  5.                 ......  
  6.         while ((node = timerqueue_getnext(&base->active))) {  
  7.                         ......  
  8.             if (basenow.tv64 < hrtimer_get_softexpires_tv64(timer)) {  
  9.                 ktime_t expires;  
  10.   
  11.                 expires = ktime_sub(hrtimer_get_expires(timer),  
  12.                             base->offset);  
  13.                 if (expires.tv64 < expires_next.tv64)  
  14.                     expires_next = expires;  
  15.                 break;  
  16.             }  
  17.   
  18.             __run_hrtimer(timer, &basenow);  
  19.         }  
  20.     }  
  21.   
  22.     /* 
  23.      * Store the new expiry value so the migration code can verify 
  24.      * against it. 
  25.      */  
  26.     cpu_base->expires_next = expires_next;  
  27.     raw_spin_unlock(&cpu_base->lock);  
  28.   
  29.     /* Reprogramming necessary ? */  
  30.     if (expires_next.tv64 == KTIME_MAX ||  
  31.         !tick_program_event(expires_next, 0)) {  
  32.         cpu_base->hang_detected = 0;  
  33.         return;  
  34.     }  
如果这时的tick_program_event返回了非0值，表示过期时间已经在当前时间的前面，这通常由以下原因造成：
  • 系统正在被调试跟踪，导致时间在走，程序不走；
  • 定时器的回调函数花了太长的时间；
  • 系统运行在虚拟机中，而虚拟机被调度导致停止运行；
为了避免这些情况的发生，接下来系统提供3次机会，重新执行前面的循环，处理到期的定时器：
[cpp] view plain copy
  1. raw_spin_lock(&cpu_base->lock);  
  2. now = hrtimer_update_base(cpu_base);  
  3. cpu_base->nr_retries++;  
  4. if (++retries < 3)  
  5.     goto retry;  
如果3次循环后还无法完成到期处理，系统不再循环，转为计算本次总循环的时间，然后把tick_device的到期时间强制设置为当前时间加上本次的总循环时间，不过推后的时间被限制在100ms以内：
[cpp] view plain copy
  1.     delta = ktime_sub(now, entry_time);  
  2.     if (delta.tv64 > cpu_base->max_hang_time.tv64)  
  3.         cpu_base->max_hang_time = delta;  
  4.     /* 
  5.      * Limit it to a sensible value as we enforce a longer 
  6.      * delay. Give the CPU at least 100ms to catch up. 
  7.      */  
  8.     if (delta.tv64 > 100 * NSEC_PER_MSEC)  
  9.         expires_next = ktime_add_ns(now, 100 * NSEC_PER_MSEC);  
  10.     else  
  11.         expires_next = ktime_add(now, delta);  
  12.     tick_program_event(expires_next, 1);  
  13.     printk_once(KERN_WARNING "hrtimer: interrupt took %llu ns\n",  
  14.             ktime_to_ns(delta));  
  15. }  

3.  切换到高精度模式

上面提到，尽管内核配置成支持高精度定时器，但并不是一开始就工作于高精度模式，系统在启动的开始阶段，还是按照传统的模式在运行：tick_device按HZ频率定期地产生tick事件，这时的hrtimer工作在低分辨率模式，到期事件在每个tick事件中断中由hrtimer_run_queues函数处理，同时，在低分辨率定时器（时间轮）的软件中断TIMER_SOFTIRQ中，hrtimer_run_pending会被调用，系统在这个函数中判断系统的条件是否满足切换到高精度模式，如果条件满足，则会切换至高分辨率模式，另外提一下，NO_HZ模式也是在该函数中判断并切换。

[cpp] view plain copy
  1. void hrtimer_run_pending(void)  
  2. {  
  3.     if (hrtimer_hres_active())  
  4.         return;  
  5.         ......  
  6.     if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))  
  7.         hrtimer_switch_to_hres();  
  8. }  
因为不管系统是否工作于高精度模式，每个TIMER_SOFTIRQ期间，该函数都会被调用，所以函数一开始先用hrtimer_hres_active判断目前高精度模式是否已经激活，如果已经激活，则说明之前的调用中已经切换了工作模式，不必再次切换，直接返回。hrtimer_hres_active很简单：
[cpp] view plain copy
  1. DEFINE_PER_CPU(struct hrtimer_cpu_base, hrtimer_bases) = {  
  2.         ......  
  3. }  
  4.   
  5. static inline int hrtimer_hres_active(void)  
  6. {  
  7.     return __this_cpu_read(hrtimer_bases.hres_active);  
  8. }  
hrtimer_run_pending函数接着通过tick_check_oneshot_change判断系统是否可以切换到高精度模式，
[cpp] view plain copy
  1. int tick_check_oneshot_change(int allow_nohz)  
  2. {  
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  4.   
  5.     if (!test_and_clear_bit(0, &ts->check_clocks))  
  6.         return 0;  
  7.   
  8.     if (ts->nohz_mode != NOHZ_MODE_INACTIVE)  
  9.         return 0;  
  10.   
  11.     if (!timekeeping_valid_for_hres() || !tick_is_oneshot_available())  
  12.         return 0;  
  13.   
  14.     if (!allow_nohz)  
  15.         return 1;  
  16.   
  17.     tick_nohz_switch_to_nohz();  
  18.     return 0;  
  19. }  
函数的一开始先判断check_clock标志的第0位是否被置位，如果没有置位，说明系统中没有注册符合要求的时钟事件设备，函数直接返回，check_clock标志由clocksource和clock_event_device系统的notify系统置位，当系统中有更高精度的clocksource被注册和选择后，或者有更精确的支持CLOCK_EVT_MODE_ONESHOT模式的clock_event_device被注册时，通过它们的notify函数，check_clock标志的第0为会置位。

如果tick_sched结构中的nohz_mode字段不是NOHZ_MODE_INACTIVE，表明系统已经切换到其它模式，直接返回。nohz_mode的取值有3种：

  • NOHZ_MODE_INACTIVE    // 未启用NO_HZ模式
  • NOHZ_MODE_LOWRES    // 启用NO_HZ模式，hrtimer工作于低精度模式下
  • NOHZ_MODE_HIGHRES   // 启用NO_HZ模式，hrtimer工作于高精度模式下
接下来的timerkeeping_valid_for_hres判断timekeeper系统是否支持高精度模式，tick_is_oneshot_available判断tick_device是否支持CLOCK_EVT_MODE_ONESHOT模式。如果都满足要求，则继续往下判断。allow_nohz是函数的参数，为true表明可以切换到NOHZ_MODE_LOWRES 模式，函数将进入tick_nohz_switch_to_nohz，切换至NOHZ_MODE_LOWRES 模式，这里我们传入的allow_nohz是表达式：

(!hrtimer_is_hres_enabled())

所以当系统不允许高精度模式时，将会在tick_check_oneshot_change函数内，通过tick_nohz_switch_to_nohz切换至NOHZ_MODE_LOWRES 模式，如果系统允许高精度模式，传入的allow_nohz参数为false，tick_check_oneshot_change函数返回1，回到上面的hrtimer_run_pending函数，hrtimer_switch_to_hres函数将会被调用，已完成切换到NOHZ_MODE_HIGHRES高精度模式。好啦，真正的切换函数找到了，我们看一看它如何切换：

首先，它通过hrtimer_cpu_base中的hres_active字段判断该cpu是否已经切换至高精度模式，如果是则直接返回：

[cpp] view plain copy
  1. static int hrtimer_switch_to_hres(void)  
  2. {  
  3.     int i, cpu = smp_processor_id();  
  4.     struct hrtimer_cpu_base *base = &per_cpu(hrtimer_bases, cpu);  
  5.     unsigned long flags;  
  6.   
  7.     if (base->hres_active)  
  8.         return 1;  
接着，通过tick_init_highres函数接管tick_device关联的clock_event_device：
[cpp] view plain copy
  1. local_irq_save(flags);  
  2.   
  3. if (tick_init_highres()) {  
  4.     local_irq_restore(flags);  
  5.     printk(KERN_WARNING "Could not switch to high resolution "  
  6.                 "mode on CPU %d\n", cpu);  
  7.     return 0;  
  8. }  
tick_init_highres函数把tick_device切换到CLOCK_EVT_FEAT_ONESHOT模式，同时把clock_event_device的回调handler设置为hrtimer_interrupt，这样设置以后，tick_device的中断回调将由hrtimer_interrupt接管，hrtimer_interrupt在上面已经讨论过，它将完成高精度定时器的调度和到期处理。

接着，设置hres_active标志，以表明高精度模式已经切换，然后把3个时间基准系统的resolution字段设为KTIME_HIGH_RES：

[cpp] view plain copy
  1. base->hres_active = 1;  
  2. for (i = 0; i < HRTIMER_MAX_CLOCK_BASES; i++)  
  3.     base->clock_base[i].resolution = KTIME_HIGH_RES;  
最后，因为tick_device被高精度定时器接管，它将不会再提供原有的tick事件机制，所以需要由高精度定时器系统模拟一个tick事件设备，继续为系统提供tick事件能力，这个工作由tick_setup_sched_timer函数完成。因为刚刚完成切换，tick_device的到期时间并没有被正确地设置为下一个到期定时器的时间，这里使用retrigger_next_event函数，传入参数NULL，使得tick_device立刻产生到期中断，hrtimer_interrupt被调用一次，然后下一个到期的定时器的时间会编程到tick_device中，从而完成了到高精度模式的切换：
[cpp] view plain copy
  1. tick_setup_sched_timer();  
  2. /* "Retrigger" the interrupt to get things going */  
  3. retrigger_next_event(NULL);  
  4. local_irq_restore(flags);  
  5. return 1;  

整个切换过程可以用下图表示：

Linux时间子系统_第6张图片

                                                                             图3.1  低精度模式切换至高精度模式

4.  模拟tick事件

根据上一节的讨论，当系统切换到高精度模式后，tick_device被高精度定时器系统接管，不再定期地产生tick事件，我们知道，到目前的版本为止（V3.4），内核还没有彻底废除jiffies机制，系统还是依赖定期到来的tick事件，供进程调度系统和时间更新等操作，大量存在的低精度定时器也仍然依赖于jiffies的计数，所以，尽管tick_device被接管，高精度定时器系统还是要想办法继续提供定期的tick事件。为了达到这一目的，内核使用了一个取巧的办法：既然高精度模式已经启用，可以定义一个hrtimer，把它的到期时间设定为一个jiffy的时间，当这个hrtimer到期时，在这个hrtimer的到期回调函数中，进行和原来的tick_device同样的操作，然后把该hrtimer的到期时间顺延一个jiffy周期，如此反复循环，完美地模拟了原有tick_device的功能。下面我们看看具体点代码是如何实现的。

在kernel/time/tick-sched.c中，内核定义了一个per_cpu全局变量：tick_cpu_sched，从而为每个cpu提供了一个tick_sched结构， 该结构主要用于管理NO_HZ配置下的tickless处理，因为模拟tick事件与tickless有很强的相关性，所以高精度定时器系统也利用了该结构的以下字段，用于完成模拟tick事件的操作：

[cpp] view plain copy
  1. struct tick_sched {  
  2.     struct hrtimer          sched_timer;  
  3.     unsigned long           check_clocks;  
  4.     enum tick_nohz_mode     nohz_mode;  
  5.         ......  
  6. };  
sched_timer就是要用于模拟tick事件的hrtimer，check_clock上面几节已经讨论过，用于notify系统通知hrtimer系统需要检查是否切换到高精度模式，nohz_mode则用于表示当前的工作模式。

上一节提到，用于切换至高精度模式的函数是hrtimer_switch_to_hres，在它的最后，调用了函数tick_setup_sched_timer，该函数的作用就是设置一个用于模拟tick事件的hrtimer：

[cpp] view plain copy
  1. void tick_setup_sched_timer(void)  
  2. {  
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  4.     ktime_t now = ktime_get();  
  5.   
  6.     /* 
  7.      * Emulate tick processing via per-CPU hrtimers: 
  8.      */  
  9.     hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);  
  10.     ts->sched_timer.function = tick_sched_timer;  
  11.   
  12.     /* Get the next period (per cpu) */  
  13.     hrtimer_set_expires(&ts->sched_timer, tick_init_jiffy_update());  
  14.   
  15.     for (;;) {  
  16.         hrtimer_forward(&ts->sched_timer, now, tick_period);  
  17.         hrtimer_start_expires(&ts->sched_timer,  
  18.                       HRTIMER_MODE_ABS_PINNED);  
  19.         /* Check, if the timer was already in the past */  
  20.         if (hrtimer_active(&ts->sched_timer))  
  21.             break;  
  22.         now = ktime_get();  
  23.     }  
  24.   
  25. #ifdef CONFIG_NO_HZ  
  26.     if (tick_nohz_enabled)  
  27.         ts->nohz_mode = NOHZ_MODE_HIGHRES;  
  28. #endif  
  29. }  
该函数首先初始化该cpu所属的tick_sched结构中sched_timer字段，把该hrtimer的回调函数设置为tick_sched_timer，然后把它的到期时间设定为下一个jiffy时刻，返回前把工作模式设置为NOHZ_MODE_HIGHRES，表明是利用高精度模式实现NO_HZ。

接着我们关注一下hrtimer的回调函数tick_sched_timer，我们知道，系统中的jiffies计数，时间更新等是全局操作，在smp系统中，只有一个cpu负责该工作，所以在tick_sched_timer的一开始，先判断当前cpu是否负责更新jiffies和时间，如果是，则执行更新操作：

[cpp] view plain copy
  1. static enum hrtimer_restart tick_sched_timer(struct hrtimer *timer)  
  2. {  
  3.         ......  
  4.   
  5. #ifdef CONFIG_NO_HZ  
  6.     if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))  
  7.         tick_do_timer_cpu = cpu;  
  8. #endif  
  9.   
  10.     /* Check, if the jiffies need an update */  
  11.     if (tick_do_timer_cpu == cpu)  
  12.         tick_do_update_jiffies64(now);  
然后，利用regs指针确保当前是在中断上下文中，然后调用update_process_timer：
[cpp] view plain copy
  1. if (regs) {  
  2.                ......  
  3.     update_process_times(user_mode(regs));  
  4.     ......  
  5. }  
最后，把hrtimer的到期时间推进一个tick周期，返回HRTIMER_RESTART表明该hrtimer需要再次启动，以便产生下一个tick事件。
[cpp] view plain copy
  1.     hrtimer_forward(timer, now, tick_period);  
  2.   
  3.     return HRTIMER_RESTART;  
  4. }  
关于update_process_times，如果你你感兴趣，回看一下本系列关于clock_event_device的那一章： Linux时间子系统之四：定时器的引擎：clock_event_device中的第5小节，对比一下模拟tick事件的hrtimer的回调函数tick_sched_timer和切换前tick_device的回调函数 tick_handle_periodic，它们是如此地相像，实际上，它们几乎完成了一样的工作。

Linux时间子系统之七：定时器的应用--msleep()，hrtimer_nanosleep()

我们已经在前面几章介绍了低分辨率定时器和高精度定时器的实现原理，内核为了方便其它子系统，在时间子系统中提供了一些用于延时或调度的API，例如msleep，hrtimer_nanosleep等等，这些API基于低分辨率定时器或高精度定时器来实现，本章的内容就是讨论这些方便、好用的API是如何利用定时器系统来完成所需的功能的。

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

1.  msleep

msleep相信大家都用过，它可能是内核用使用最广泛的延时函数之一，它会使当前进程被调度并让出cpu一段时间，因为这一特性，它不能用于中断上下文，只能用于进程上下文中。要想在中断上下文中使用延时函数，请使用会阻塞cpu的无调度版本mdelay。msleep的函数原型如下：

[cpp] view plain copy
  1. void msleep(unsigned int msecs)  
延时的时间由参数msecs指定，单位是毫秒，事实上， msleep的实现基于低分辨率定时器，所以msleep的实际精度只能也是1/HZ级别。内核还提供了另一个比较类似的延时函数msleep_interruptible：
[cpp] view plain copy
  1. unsigned long msleep_interruptible(unsigned int msecs)  
延时的单位同样毫秒数，它们的区别如下：

函数 延时单位 返回值 是否可被信号中断
msleep 毫秒 无 否
msleep_interruptible 毫秒 未完成的毫秒数 是
最主要的区别就是msleep会保证所需的延时一定会被执行完，而msleep_interruptible则可以在延时进行到一半时被信号打断而退出延时，剩余的延时数则通过返回值返回。两个函数最终的代码都会到达schedule_timeout函数，它们的调用序列如下图所示：
                                              Linux时间子系统_第7张图片

                                                                            图1.1  两个延时函数的调用序列

下面我们看看schedule_timeout函数的实现，函数首先处理两种特殊情况，一种是传入的延时jiffies数是个负数，则打印一句警告信息，然后马上返回，另一种是延时jiffies数是MAX_SCHEDULE_TIMEOUT，表明需要一直延时，直接执行调度即可：

[cpp] view plain copy
  1. signed long __sched schedule_timeout(signed long timeout)  
  2. {  
  3.     struct timer_list timer;  
  4.     unsigned long expire;  
  5.   
  6.     switch (timeout)  
  7.     {  
  8.     case MAX_SCHEDULE_TIMEOUT:  
  9.         schedule();  
  10.         goto out;  
  11.     default:  
  12.         if (timeout < 0) {  
  13.             printk(KERN_ERR "schedule_timeout: wrong timeout "  
  14.                 "value %lx\n", timeout);  
  15.             dump_stack();  
  16.             current->state = TASK_RUNNING;  
  17.             goto out;  
  18.         }  
  19.     }  
然后计算到期的jiffies数，并在堆栈上建立一个低分辨率定时器，把到期时间设置到该定时器中，启动定时器后，通过schedule把当前进程调度出cpu的运行队列：
[cpp] view plain copy
  1. expire = timeout + jiffies;  
  2.   
  3. setup_timer_on_stack(&timer, process_timeout, (unsigned long)current);  
  4. __mod_timer(&timer, expire, false, TIMER_NOT_PINNED);  
  5. schedule();  
到这个时候，进程已经被调度走，那它如何返回继续执行？我们看到定时器的到期回调函数是process_timeout，参数是当前进程的task_struct指针，看看它的实现：
[cpp] view plain copy
  1. static void process_timeout(unsigned long __data)  
  2. {  
  3.     wake_up_process((struct task_struct *)__data);  
  4. }  
噢，没错，定时器一旦到期，进程会被唤醒并继续执行：
[cpp] view plain copy
  1.     del_singleshot_timer_sync(&timer);  
  2.   
  3.     /* Remove the timer from the object tracker */  
  4.     destroy_timer_on_stack(&timer);  
  5.   
  6.     timeout = expire - jiffies;  
  7.   
  8.  out:  
  9.     return timeout < 0 ? 0 : timeout;  
  10. }  
schedule返回后，说明要不就是定时器到期，要不就是因为其它时间导致进程被唤醒，函数要做的就是删除在堆栈上建立的定时器，返回剩余未完成的jiffies数。

说完了关键的schedule_timeout函数，我们看看msleep如何实现：

[cpp] view plain copy
  1. signed long __sched schedule_timeout_uninterruptible(signed long timeout)  
  2. {  
  3.     __set_current_state(TASK_UNINTERRUPTIBLE);  
  4.     return schedule_timeout(timeout);  
  5. }  
  6.   
  7. void msleep(unsigned int msecs)  
  8. {  
  9.     unsigned long timeout = msecs_to_jiffies(msecs) + 1;  
  10.   
  11.     while (timeout)  
  12.         timeout = schedule_timeout_uninterruptible(timeout);  
  13. }  
msleep先是把毫秒转换为jiffies数，通过一个while循环保证所有的延时被执行完毕，延时操作通过schedule_timeout_uninterruptible函数完成，它仅仅是在把进程的状态修改为TASK_UNINTERRUPTIBLE后，调用上述的schedule_timeout来完成具体的延时操作，TASK_UNINTERRUPTIBLE状态保证了msleep不会被信号唤醒，也就意味着在msleep期间，进程不能被kill掉。

看看msleep_interruptible的实现：

[cpp] view plain copy
  1. signed long __sched schedule_timeout_interruptible(signed long timeout)  
  2. {  
  3.     __set_current_state(TASK_INTERRUPTIBLE);  
  4.     return schedule_timeout(timeout);  
  5. }  
  6.   
  7. unsigned long msleep_interruptible(unsigned int msecs)  
  8. {  
  9.     unsigned long timeout = msecs_to_jiffies(msecs) + 1;  
  10.   
  11.     while (timeout && !signal_pending(current))  
  12.         timeout = schedule_timeout_interruptible(timeout);  
  13.     return jiffies_to_msecs(timeout);  
  14. }  
msleep_interruptible通过schedule_timeout_interruptible中转，schedule_timeout_interruptible的唯一区别就是把进程的状态设置为了TASK_INTERRUPTIBLE，说明在延时期间有信号通知，while循环会马上终止，剩余的jiffies数被转换成毫秒返回。实际上，你也可以利用schedule_timeout_interruptible或schedule_timeout_uninterruptible构造自己的延时函数，同时，内核还提供了另外一个类似的函数，不用我解释，看代码就知道它的用意了：
[cpp] view plain copy
  1. signed long __sched schedule_timeout_killable(signed long timeout)  
  2. {  
  3.     __set_current_state(TASK_KILLABLE);  
  4.     return schedule_timeout(timeout);  
  5. }  

2.  hrtimer_nanosleep

第一节讨论的 msleep函数基于时间轮定时系统，只能提供毫秒级的精度，实际上，它的精度取决于HZ的配置值，如果HZ小于1000，它甚至无法达到毫秒级的精度，要想得到更为精确的延时，我们自然想到的是要利用高精度定时器来实现。没错，linux为用户空间提供了一个api：nanosleep，它能提供纳秒级的延时精度，该用户空间函数对应的内核实现是sys_nanosleep，它的工作交由高精度定时器系统的hrtimer_nanosleep函数实现，最终的大部分工作则由do_nanosleep完成。调用过程如下图所示：

Linux时间子系统_第8张图片
                 图  2.1  nanosleep的调用过程
与msleep的实现相类似，hrtimer_nanosleep函数首先在堆栈中创建一个高精度定时器，设置它的到期时间，然后通过do_nanosleep完成最终的延时工作，当前进程在挂起相应的延时时间后，退出do_nanosleep函数，销毁堆栈中的定时器并返回0值表示执行成功。不过do_nanosleep可能在没有达到所需延时数量时由于其它原因退出，如果出现这种情况，hrtimer_nanosleep的最后部分把剩余的延时时间记入进程的restart_block中，并返回ERESTART_RESTARTBLOCK错误代码，系统或者用户空间可以根据此返回值决定是否重新调用nanosleep以便把剩余的延时继续执行完成。下面是hrtimer_nanosleep的代码：
[cpp] view plain copy
  1. long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,  
  2.                const enum hrtimer_mode mode, const clockid_t clockid)  
  3. {  
  4.     struct restart_block *restart;  
  5.     struct hrtimer_sleeper t;  
  6.     int ret = 0;  
  7.     unsigned long slack;  
  8.   
  9.     slack = current->timer_slack_ns;  
  10.     if (rt_task(current))  
  11.         slack = 0;  
  12.   
  13.     hrtimer_init_on_stack(&t.timer, clockid, mode);  
  14.     hrtimer_set_expires_range_ns(&t.timer, timespec_to_ktime(*rqtp), slack);  
  15.     if (do_nanosleep(&t, mode))  
  16.         goto out;  
  17.   
  18.     /* Absolute timers do not update the rmtp value and restart: */  
  19.     if (mode == HRTIMER_MODE_ABS) {  
  20.         ret = -ERESTARTNOHAND;  
  21.         goto out;  
  22.     }  
  23.   
  24.     if (rmtp) {  
  25.         ret = update_rmtp(&t.timer, rmtp);  
  26.         if (ret <= 0)  
  27.             goto out;  
  28.     }  
  29.   
  30.     restart = ¤t_thread_info()->restart_block;  
  31.     restart->fn = hrtimer_nanosleep_restart;  
  32.     restart->nanosleep.clockid = t.timer.base->clockid;  
  33.     restart->nanosleep.rmtp = rmtp;  
  34.     restart->nanosleep.expires = hrtimer_get_expires_tv64(&t.timer);  
  35.   
  36.     ret = -ERESTART_RESTARTBLOCK;  
  37. out:  
  38.     destroy_hrtimer_on_stack(&t.timer);  
  39.     return ret;  
  40. }  
接着我们看看do_nanosleep的实现代码，它首先通过hrtimer_init_sleeper函数，把定时器的回调函数设置为hrtimer_wakeup，把当前进程的task_struct结构指针保存在hrtimer_sleeper结构的task字段中：
[cpp] view plain copy
  1. void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, struct task_struct *task)  
  2. {  
  3.     sl->timer.function = hrtimer_wakeup;  
  4.     sl->task = task;  
  5. }  
  6. EXPORT_SYMBOL_GPL(hrtimer_init_sleeper);  
  7.   
  8. static int __sched do_nanosleep(struct hrtimer_sleeper *t, enum hrtimer_mode mode)  
  9. {  
  10.     hrtimer_init_sleeper(t, current);  
然后，通过一个do/while循环内：启动定时器，挂起当前进程，等待定时器或其它事件唤醒进程。这里的循环体实现比较怪异，它使用hrtimer_active函数间接地判断定时器是否到期，如果hrtimer_active返回false，说明定时器已经过期，然后把hrtimer_sleeper结构的task字段设置为NULL，从而导致循环体的结束，另一个结束条件是当前进程收到了信号事件，所以，当因为是定时器到期而退出时，do_nanosleep返回true，否则返回false，上述的hrtimer_nanosleep正是利用了这一特性来决定它的返回值。以下是do_nanosleep循环体的代码：
[cpp] view plain copy
  1.     do {  
  2.         set_current_state(TASK_INTERRUPTIBLE);  
  3.         hrtimer_start_expires(&t->timer, mode);  
  4.         if (!hrtimer_active(&t->timer))  
  5.             t->task = NULL;  
  6.   
  7.         if (likely(t->task))  
  8.             schedule();  
  9.   
  10.         hrtimer_cancel(&t->timer);  
  11.         mode = HRTIMER_MODE_ABS;  
  12.   
  13.     } while (t->task && !signal_pending(current));  
  14.   
  15.     __set_current_state(TASK_RUNNING);  
  16.   
  17.     return t->task == NULL;  
  18. }  
除了hrtimer_nanosleep，高精度定时器系统还提供了几种用于延时/挂起进程的api：
  • schedule_hrtimeout    使得当前进程休眠指定的时间，使用CLOCK_MONOTONIC计时系统；
  • schedule_hrtimeout_range    使得当前进程休眠指定的时间范围，使用CLOCK_MONOTONIC计时系统；
  • schedule_hrtimeout_range_clock    使得当前进程休眠指定的时间范围，可以自行指定计时系统；
  • usleep_range 使得当前进程休眠指定的微妙数，使用CLOCK_MONOTONIC计时系统；
它们之间的调用关系如下：
Linux时间子系统_第9张图片
                                                          图 2.2  schedule_hrtimeout_xxxx系列函数
最终，所有的实现都会进入到schedule_hrtimeout_range_clock函数。需要注意的是schedule_hrtimeout_xxxx系列函数在调用前，最好利用set_current_state函数先设置进程的状态，在这些函数返回前，进城的状态会再次被设置为TASK_RUNNING。如果事先把状态设置为TASK_UNINTERRUPTIBLE，它们会保证函数返回前一定已经经过了所需的延时时间，如果事先把状态设置为TASK_INTERRUPTIBLE，则有可能在尚未到期时由其它信号唤醒进程从而导致函数返回。主要实现该功能的函数schedule_hrtimeout_range_clock和前面的do_nanosleep函数实现原理基本一致。大家可以自行参考内核的代码，它们位于：kernel/hrtimer.c。

Linux时间子系统之八：动态时钟框架（CONFIG_NO_HZ、tickless）

在前面章节的讨论中，我们一直基于一个假设：Linux中的时钟事件都是由一个周期时钟提供，不管系统中的clock_event_device是工作于周期触发模式，还是工作于单触发模式，也不管定时器系统是工作于低分辨率模式，还是高精度模式，内核都竭尽所能，用不同的方式提供周期时钟，以产生定期的tick事件，tick事件或者用于全局的时间管理（jiffies和时间的更新），或者用于本地cpu的进程统计、时间轮定时器框架等等。周期性时钟虽然简单有效，但是也带来了一些缺点，尤其在系统的功耗上，因为就算系统目前无事可做，也必须定期地发出时钟事件，激活系统。为此，内核的开发者提出了动态时钟这一概念，我们可以通过内核的配置项CONFIG_NO_HZ来激活特性。有时候这一特性也被叫做tickless，不过还是把它称呼为动态时钟比较合适，因为并不是真的没有tick事件了，只是在系统无事所做的idle阶段，我们可以通过停止周期时钟来达到降低系统功耗的目的，只要有进程处于活动状态，时钟事件依然会被周期性地发出。

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

在动态时钟正确工作之前，系统需要切换至动态时钟模式，而要切换至动态时钟模式，需要一些前提条件，最主要的一条就是cpu的时钟事件设备必须要支持单触发模式，当条件满足时，系统切换至动态时钟模式，接着，由idle进程决定是否可以停止周期时钟，退出idle进程时则需要恢复周期时钟。

1.  数据结构

在上一章的内容里，我们曾经提到，切换到高精度模式后，高精度定时器系统需要使用一个高精度定时器来模拟传统的周期时钟，其中利用了tick_sched结构中的一些字段，事实上，tick_sched结构也是实现动态时钟的一个重要的数据结构，在smp系统中，内核会为每个cpu都定义一个tick_sched结构，这通过一个percpu全局变量tick_cpu_sched来实现，它在kernel/time/tick-sched.c中定义：

[cpp] view plain copy
  1. /* 
  2.  * Per cpu nohz control structure 
  3.  */  
  4. static DEFINE_PER_CPU(struct tick_sched, tick_cpu_sched);  
tick_sched结构在include/linux/tick.h中定义，我们看看tick_sched结构的详细定义：
[cpp] view plain copy
  1. struct tick_sched {  
  2.     struct hrtimer          sched_timer;  
  3.     unsigned long           check_clocks;  
  4.     enum tick_nohz_mode     nohz_mode;  
  5.     ktime_t             idle_tick;  
  6.     int             inidle;  
  7.     int             tick_stopped;  
  8.     unsigned long           idle_jiffies;  
  9.     unsigned long           idle_calls;  
  10.     unsigned long           idle_sleeps;  
  11.     int             idle_active;  
  12.     ktime_t             idle_entrytime;  
  13.     ktime_t             idle_waketime;  
  14.     ktime_t             idle_exittime;  
  15.     ktime_t             idle_sleeptime;  
  16.     ktime_t             iowait_sleeptime;  
  17.     ktime_t             sleep_length;  
  18.     unsigned long           last_jiffies;  
  19.     unsigned long           next_jiffies;  
  20.     ktime_t             idle_expires;  
  21.     int             do_timer_last;  
  22. };  
sched_timer  该字段用于在高精度模式下，模拟周期时钟的一个hrtimer，请参看 Linux时间子系统之六：高精度定时器（HRTIMER）的原理和实现。

check_clocks  该字段用于实现clock_event_device和clocksource的异步通知机制，帮助系统切换至高精度模式或者是动态时钟模式。

nohz_mode  保存动态时钟的工作模式，基于低分辨率和高精度模式下，动态时钟的实现稍有不同，根据模式它可以是以下的值：

  • NOHZ_MODE_INACTIVE  系统动态时钟尚未激活
  • NOHZ_MODE_LOWRES  系统工作于低分辨率模式下的动态时钟
  • NOHZ_MODE_HIGHRES  系统工作于高精度模式下的动态时钟

idle_tick  该字段用于保存停止周期时钟是的内核时间，当退出idle时要恢复周期时钟，需要使用该时间，以保持系统中时间线（jiffies）的正确性。

tick_stopped  该字段用于表明idle状态的周期时钟已经停止。

idle_jiffies  系统进入idle时的jiffies值，用于信息统计。

idle_calls 系统进入idle的统计次数。

idle_sleeps  系统进入idle且成功停掉周期时钟的次数。

idle_active  表明目前系统是否处于idle状态中。

idle_entrytime  系统进入idle的时刻。

idle_waketime  idle状态被打断的时刻。

idle_exittime  系统退出idle的时刻。

idle_sleeptime  累计各次idle中停止周期时钟的总时间。

sleep_length  本次idle中停止周期时钟的时间。

last_jiffies  系统中最后一次周期时钟的jiffies值。

next_jiffies  预计下一次周期时钟的jiffies。

idle_expires  进入idle后，下一个最先到期的定时器时刻。

我们知道，根据系统目前的工作模式，系统提供周期时钟（tick）的方式会有所不同，当处于低分辨率模式时，由cpu的tick_device提供周期时钟，而当处于高精度模式时，是由一个高精度定时器来提供周期时钟，下面我们分别讨论一下在两种模式下的动态时钟实现方式。

2.  低分辨率下的动态时钟

回看之前一篇文章： Linux时间子系统之四：定时器的引擎：clock_event_device中的关于tick_device一节，不管tick_device的工作模式（周期触发或者是单次触发），tick_device所关联的clock_event_device的事件回调处理函数都是：tick_handle_periodic，不管当前是否处于idle状态，他都会精确地按HZ数来提供周期性的tick事件，这不符合动态时钟的要求，所以，要使动态时钟发挥作用，系统首先要切换至支持动态时钟的工作模式：NOHZ_MODE_LOWRES  。
2.1  切换至动态时钟模式

动态时钟模式的切换过程的前半部分和切换至高精度定时器模式所经过的路径是一样的，请参考：Linux时间子系统之六：高精度定时器（HRTIMER）的原理和实现。这里再简单描述一下过程：系统工作于周期时钟模式，定期地发出tick事件中断，tick事件中断触发定时器软中断：TIMER_SOFTIRQ，执行软中断处理函数run_timer_softirq，run_timer_softirq调用hrtimer_run_pending函数：

[cpp] view plain copy
  1. void hrtimer_run_pending(void)  
  2. {  
  3.     if (hrtimer_hres_active())  
  4.         return;  
  5.         ......  
  6.     if (tick_check_oneshot_change(!hrtimer_is_hres_enabled()))  
  7.         hrtimer_switch_to_hres();  
  8. }  
tick_check_oneshot_change函数的参数决定了现在是要切换至低分辨率动态时钟模式，还是高精度定时器模式，我们现在假设系统不支持高精度定时器模式，hrtimer_is_hres_enabled会直接返回false，对应的tick_check_oneshot_change函数的参数则是true，表明需要切换至动态时钟模式。tick_check_oneshot_change在检查过timekeeper和clock_event_device都具备动态时钟的条件后，通过tick_nohz_switch_to_nohz函数切换至动态时钟模式：

首先，该函数通过tick_switch_to_oneshot函数把tick_device的工作模式设置为单触发模式，并把它的中断事件回调函数置换为tick_nohz_handler，接着把tick_sched结构中的模式字段设置为NOHZ_MODE_LOWRES：

[cpp] view plain copy
  1. static void tick_nohz_switch_to_nohz(void)  
  2. {  
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  4.     ktime_t next;  
  5.   
  6.     if (!tick_nohz_enabled)  
  7.         return;  
  8.   
  9.     local_irq_disable();  
  10.     if (tick_switch_to_oneshot(tick_nohz_handler)) {  
  11.         local_irq_enable();  
  12.         return;  
  13.     }  
  14.   
  15.     ts->nohz_mode = NOHZ_MODE_LOWRES;  
然后，初始化tick_sched结构中的sched_timer定时器，通过tick_init_jiffy_update获取下一次tick事件的时间并初始化全局变量last_jiffies_update，以便后续可以正确地更新jiffies计数值，最后，把下一次tick事件的时间编程到tick_device中，到此，系统完成了到低分辨率动态时钟的切换过程。
[cpp] view plain copy
  1.     hrtimer_init(&ts->sched_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);  
  2.     /* Get the next period */  
  3.     next = tick_init_jiffy_update();  
  4.   
  5.     for (;;) {  
  6.         hrtimer_set_expires(&ts->sched_timer, next);  
  7.         if (!tick_program_event(next, 0))  
  8.             break;  
  9.         next = ktime_add(next, tick_period);  
  10.     }  
  11.     local_irq_enable();  
  12. }  
上面的代码中，明明现在没有切换至高精度模式，为什么要初始化tick_sched结构中的高精度定时器？原因并不是要使用它的定时功能，而是想重用hrtimer代码中的hrtimer_forward函数，利用这个函数来计算下一次tick事件的时间。
2.2  低分辨率动态时钟下的事件中断处理函数

上一节提到，当切换至低分辨率动态时钟模式后，tick_device的事件中断处理函数会被设置为tick_nohz_handler，总体来说，它和周期时钟模式的事件处理函数tick_handle_periodic所完成的工作大致类似：更新时间、更新jiffies计数值、调用update_process_time更新进程信息和触发定时器软中断等等，最后重新编程tick_device，使得它在下一个正确的tick时刻再次触发本函数：

[cpp] view plain copy
  1. static void tick_nohz_handler(struct clock_event_device *dev)  
  2. {  
  3.         ......  
  4.     dev->next_event.tv64 = KTIME_MAX;  
  5.   
  6.     if (unlikely(tick_do_timer_cpu == TICK_DO_TIMER_NONE))  
  7.         tick_do_timer_cpu = cpu;  
  8.   
  9.     /* Check, if the jiffies need an update */  
  10.     if (tick_do_timer_cpu == cpu)  
  11.         tick_do_update_jiffies64(now);  
  12.         ......    
  13.     if (ts->tick_stopped) {  
  14.         touch_softlockup_watchdog();  
  15.         ts->idle_jiffies++;  
  16.     }  
  17.   
  18.     update_process_times(user_mode(regs));  
  19.     profile_tick(CPU_PROFILING);  
  20.   
  21.     while (tick_nohz_reprogram(ts, now)) {  
  22.         now = ktime_get();  
  23.         tick_do_update_jiffies64(now);  
  24.     }  
  25. }  
因为现在工作于动态时钟模式，所以，tick时钟可能在idle进程中被停掉不止一个tick周期，所以当该函数被再次触发时，离上一次触发的时间可能已经不止一个tick周期，tick_nohz_reprogram对tick_device进行编程时必须正确地处理这一情况，它利用了前面所说的hrtimer_forward函数来实现这一特性：
[cpp] view plain copy
  1. static int tick_nohz_reprogram(struct tick_sched *ts, ktime_t now)  
  2. {  
  3.     hrtimer_forward(&ts->sched_timer, now, tick_period);  
  4.     return tick_program_event(hrtimer_get_expires(&ts->sched_timer), 0);  
  5. }  

2.3  动态时钟：停止周期tick时钟事件

开启动态时钟模式后，周期时钟的开启和关闭由idle进程控制，idle进程内最终是一个循环，循环的一开始通过tick_nohz_idle_enter检测是否允许关闭周期时钟若干时间，然后进入低功耗的idle模式，当有中断事件使得cpu退出低功耗idle模式后，判断是否有新的进程被激活从而需要重新调度，如果需要则通过tick_nohz_idle_exit重新启用周期时钟，然后重新进行进程调度，等待下一次idle的发生，我们可以用下图来表示：

Linux时间子系统_第10张图片

                                    图2.3.1  idle进程中的动态时钟处理

停止周期时钟的时机在tick_nohz_idle_enter函数中，它把主要的工作交由tick_nohz_stop_sched_tick函数来完成。内核也不是每次进入tick_nohz_stop_sched_tick都会停止周期时钟，那么什么时候才会停止？我们想一想，这时候既然idle进程在运行，说明系统中的其他进程都在等待某种事件，系统处于无事所做的状态，唯一要处理的就是中断，除了定时器中断，其它的中断我们无法预测它会何时发生，但是我们可以知道最先一个到期的定时器的到期时间，也就是说，在该时间到期前，产生周期时钟是没有必要的，我们可以据此推算出周期时钟可以停止的tick数，然后重新对tick_device进行编程，使得在最早一个定时器到期前都不会产生周期时钟，实际上，tick_nohz_stop_sched_tick还做了一些限制：当下一个定时器的到期时间与当前jiffies值只相差1时，不会停止周期时钟，当定时器的到期时间与当前的jiffies值相差的时间大于timekeeper允许的最大idle时间时，则下一个tick时刻被设置timekeeper允许的最大idle时间，这主要是为了防止太长时间不去更新timekeeper中的系统时间，有可能导致clocksource的溢出问题。tick_nohz_stop_sched_tick函数体看起来很长，实现的也就是上述的逻辑，所以这里就不贴它的代码了，有兴趣的读者可以自行阅读内核的代码：kernel/time/tick-sched.c。

看了动态时钟的停止过程和tick_nohz_handler的实现方式，其实还有一个情况没有处理：当系统进入idle进程后，周期时钟被停止若干个tick周期，当这若干个tick周期到期后，tick事件必然会产生，tick_nohz_handler被触发调用，然后最先到期的定时器被处理。但是在tick_nohz_handler的最后，tick_device一定会被编程为紧跟着的下一个tick周期的时刻被触发，如果刚才的定时器处理后，并没有激活新的进程，我们的期望是周期时钟可以用下一个新的定时器重新计算可以停止的时间，而不是下一个tick时刻，但是tick_nohz_handler却仅仅简单地把tick_device的到期时间设为下一个周期的tick时刻，这导致了周期时钟被恢复，显然这不是我们想要的。为了处理这种情况，内核使用了一点小伎俩，我们知道定时器是在软中断中执行的，所以内核在irq_exit中的软件中断处理完后，加入了一小段代码，kernel/softirq.c ：

[cpp] view plain copy
  1. void irq_exit(void)  
  2. {  
  3.         ......  
  4.     if (!in_interrupt() && local_softirq_pending())  
  5.         invoke_softirq();  
  6.   
  7. #ifdef CONFIG_NO_HZ  
  8.     /* Make sure that timer wheel updates are propagated */  
  9.     if (idle_cpu(smp_processor_id()) && !in_interrupt() && !need_resched())  
  10.         tick_nohz_irq_exit();  
  11. #endif  
  12.         ......  
  13. }  
关键的调用是tick_nohz_irq_exit：
[cpp] view plain copy
  1. void tick_nohz_irq_exit(void)  
  2. {  
  3.     struct tick_sched *ts = &__get_cpu_var(tick_cpu_sched);  
  4.   
  5.     if (!ts->inidle)  
  6.         return;  
  7.   
  8.     tick_nohz_stop_sched_tick(ts);  
  9. }  
tick_nohz_irq_exit再次调用了tick_nohz_stop_sched_tick函数，使得系统有机会再次停止周期时钟若干个tick周期。
2.3  动态时钟：重新开启周期tick时钟事件

回到图2.3.1，当在idle进程中停止周期时钟后，在某一时刻，有新的进程被激活，在重新调度前，tick_nohz_idle_exit会被调用，该函数负责恢复被停止的周期时钟。tick_nohz_idle_exit最终会调用tick_nohz_restart函数，由tick_nohz_restart函数最后完成恢复周期时钟的工作。函数并不复杂：先是把上一次停止周期时钟的时刻设置到tick_sched结构的sched_timer定时器中，然后在通过hrtimer_forward函数把该定时器的到期时刻设置为当前时间的下一个tick时刻，对于高精度模式，启动该定时器即可，对于低分辨率模式，使用该时间对tick_device重新编程，最后通过tick_do_update_jiffies64更新jiffies数值，为了防止此时正在一个tick时刻的边界，可能当前时刻正好刚刚越过了该到期时间，函数使用了一个while循环：

[cpp] view plain copy
  1. static void tick_nohz_restart(struct tick_sched *ts, ktime_t now)  
  2. {  
  3.     hrtimer_cancel(&ts->sched_timer);  
  4.     hrtimer_set_expires(&ts->sched_timer, ts->idle_tick);  
  5.   
  6.     while (1) {  
  7.         /* Forward the time to expire in the future */  
  8.         hrtimer_forward(&ts->sched_timer, now, tick_period);  
  9.   
  10.         if (ts->nohz_mode == NOHZ_MODE_HIGHRES) {  
  11.             hrtimer_start_expires(&ts->sched_timer,  
  12.                           HRTIMER_MODE_ABS_PINNED);  
  13.             /* Check, if the timer was already in the past */  
  14.             if (hrtimer_active(&ts->sched_timer))  
  15.                 break;  
  16.         } else {  
  17.             if (!tick_program_event(  
  18.                 hrtimer_get_expires(&ts->sched_timer), 0))  
  19.                 break;  
  20.         }  
  21.         /* Reread time and update jiffies */  
  22.         now = ktime_get();  
  23.         tick_do_update_jiffies64(now);  
  24.     }  
  25. }  

3.  高精度模式下的动态时钟

高精度模式和低分辨率模式的主要区别是在切换过程中，怎样切换到高精度模式，我已经在上一篇文章中做了说明，切换到高精度模式后，动态时钟的开启和关闭和低分辨率模式下没有太大的区别，也是通过tick_nohz_stop_sched_tick和tick_nohz_restart来控制，在这两个函数中，分别判断了当前的两种模式：
  • NOHZ_MODE_HIGHRES
  • NOHZ_MODE_LOWRES
如果是NOHZ_MODE_HIGHRES则对tick_sched结构的sched_timer定时器进行设置，如果是NOHZ_MODE_LOWRES，则直接对tick_device进行操作。

4.  动态时钟对中断的影响

在进入和退出中断时，因为动态时钟的关系，中断系统需要作出一些配合。先说中断发生于周期时钟停止期间，如果不做任何处理，中断服务程序中如果要访问jiffies计数值，可能得到一个滞后的jiffies值，因为正常状态下，jiffies值会在恢复周期时钟时正确地更新，所以，为了防止这种情况发生，在进入中断的irq_enter期间，tick_check_idle会被调用：
[cpp] view plain copy
  1. void tick_check_idle(int cpu)  
  2. {  
  3.     tick_check_oneshot_broadcast(cpu);  
  4.     tick_check_nohz(cpu);  
  5. }  
tick_check_nohz函数的最重要的作用就是更新jiffies计数值：
[cpp] view plain copy
  1. static inline void tick_check_nohz(int cpu)  
  2. {  
  3.     struct tick_sched *ts = &per_cpu(tick_cpu_sched, cpu);  
  4.     ktime_t now;  
  5.   
  6.     if (!ts->idle_active && !ts->tick_stopped)  
  7.         return;  
  8.     now = ktime_get();  
  9.     if (ts->idle_active)  
  10.         tick_nohz_stop_idle(cpu, now);  
  11.     if (ts->tick_stopped) {  
  12.         tick_nohz_update_jiffies(now);  
  13.         tick_nohz_kick_tick(cpu, now);  
  14.     }  
  15. }  
另外一种情况是在退出定时器中断时，需要重新评估周期时钟的运行状况，这一点已经在2.3节中做了说明，这里就不在赘述了。


你可能感兴趣的:(Linux时间子系统)

  • 什么是接口测试？做接口测试的意义是什么？ 白码会说 软件测试接口测试软件测试
    Timewilltell.1、什么是接口测试？为什么要做接口测试？接口测试是测试系统组件间接口的一种测试。接口测试主要用于检测外部系统与系统之间以及内部各个子系统之间的交互点。测试的重点是要检查数据的交换，传递和控制管理过程，以及系统间的相互逻辑依赖关系等。由于如今的系统复杂度不断上升，传统的测试方法成本急剧增加且测试效率大幅下降，所以就要做接口测试。同时，接口测试相对容易实现自动化持续集成，且相
  • 【网上商城项目结构】 启山智软 商城 源码 小程序java
    文章目录前言一、网站前台二、运营商后台三、商家管理后台四、系统架构五、数据库设计六、关键技术总结前言网上商城项目结构通常包括网站前台、运营商后台和商家管理后台三个子系统，以及多个功能模块，如门户、搜索、购物车、订单、秒杀、个人中心等。在设计网上商城项目结构时，需要从用户需求和企业运营两个维度考虑，确保系统既能为用户提供良好的购物体验，又能满足企业高效管理的需求。以下是对网上商城项目结构的详细介绍：
  • Android面试从新手到架构师，一篇解析就够(1)，跳槽字节跳动 m0_60607609 程序员androidjava面试后端
    5.抽象工厂模式：结构型（7）：描述如何将类或对象按某种规则组成更大的结构1.桥接模式：对于两个或以上纬度独立变化的场景，将抽象与具体实现分离，实例：用不同颜色画不同形状2.外观模式：对外有一个统一接口，外部不用关心内部子系统的具体实现，这是"迪米特原则"的典型应用3.适配器模式：改变类的接口，使原本由于接口不匹配而无法一起工作的两个类能够在一工作，实例：RecycleView的Adapter不管
  • 论文分享系列（三）——论软件架构风格 马斯洛金字塔下的小灵猴儿 #软考高项架构师论软件架构风格论文
    论软件架构风格摘要2023年5月，我司启动了精彩购电商系统的开发工作，该项目组中我担任系统架构师岗位，主要负责整体架构设计与中间件选型。本文以该电商平台为例，主要讨论了软件架构风格在该项目中的具体应用。整个系统采用具有三层的层次式软件架构的设计思想，分别是应用层，服务层，数据层。在应用层中的业务逻辑层的设计中，将整个业务系统划分为十余个子系统。服务层以springcloud服务框架为核心，数据采用
  • [AI资讯·0605] GLM-4系列开源模型，OpenAI安全疑云，ARM推出终端计算子系统，猿辅导大模型备案…… 老牛同学 AI人工智能ai大模型AI资讯
    AI资讯1毛钱1百万token，写2遍红楼梦！国产大模型下一步还想卷什么？AI「末日」突然来临，公司同事集体变蠢！只因四大聊天机器人同时宕机OpenAI员工们开始反抗了！AI手机PC大爆发，Arm从软硬件到生态发力，打造行业AI百宝箱GLM-4开源版本：超越Llama3，多模态比肩GPT4V，MaaS平台也大升级猿辅导竟然是一家AI公司？大模型全家桶曝光｜甲子光年FineChatBI，帆软在AI方
  • JVM---内存管理 Wangwq. 八股文JVM
    JVM是一种用于计算设备的规范，他是一个虚构的计算机。是通过在实际的计算机上的仿真模拟各种计算机的功能来实现的。引入java虚拟机后，java语言在不同的平台上运行时不需要重新编译，运行字节码即可。五大内存区域1、方法区（1）所有线程共享的内存区域（2）用于存储已被虚拟机加载的类信息、常量、静态常量等。如：被static修饰的常量（3）方法区中的信息来源于类装载子系统，其加载class信息（4）这
  • Linux字符设备驱动 -- regmap子系统 lagransun linux运维服务器
    文章目录环境一、关于regmap子系统二、regmap-i2c初始化2.1regmap_get_i2c_bus()2.2__devm_regmap_init()三、regmap与irq3.1申请中断描述符irq_alloc_descs()3.2为设备申请irq_domian，建立hwirq与virq联系3.3request_threaded_irq()函数注册中断处理函数环境linux4.9arm
  • 软考架构-架构风格 zyhJhon 架构
    一、概念：风格就是架构的模式，比如C/S、B/S架构，比如现实生活中的中式风格、欧式风格描述某一特定应用领域中系统组织的方式软件架构风格反映了领域中众多系统所共有的结构和语义特性，并指导如何将各个模块和子系统有效地组织成一个完整的系统。架构设计的核心问题是能否达到架构级的软件复用架构风格定义了用于描述系统的术语表和一组指导构架系统的规则二、风格分类架构风格考点说明数据流-批处理传统编译器，每个阶段
  • android10 CarService @OuYang android
    图CarService架构AndroidAutomotiveOS定义了标准的硬件抽象层(HAL)来规范各个子系统与Framework的调用接口，并且通过CarService及其相关的CarAPI对上层应用提供标准编程接口。通过这张图可以看出CarService运行在独立的进程中，其作为原有Android服务的补充。CarService的启动流程CarService时序图xref:/framewor
  • RK3568平台开发系列讲解（PWM篇）使用 sysfs 接口操作 pwm 内核笔记 RK3568
    返回专栏总目录文章目录一、查看pwm设备信息二、使用sysfs操作PWM沉淀、分享、成长，让自己和他人都能有所收获！PWM子系统被划分为了三个层次，分别为用户空间、内核空间和硬件层，内核空间包括PWM设备驱动层、PWM核心层和PWM适配器驱动层一、查看pwm设备信息cat/sys/kernel/debug/pwm根据rk3568的数据手册或者设备树可以得到pwm12的设备地址为fe700000，与
  • 手把手教你从零开始开发上线一个生产级别的 Java 小说系统 大牛撸码 java开发语言
    项目简介novel是一套基于时下最新Java技术栈SpringBoot3+Vue3开发的前后端分离的学习型小说项目，配备详细的项目开发文档手把手教你从零开始开发上线一个生产级别的Java系统，由小说门户系统、作家后台管理系统、平台后台管理系统等多个子系统构成。包括小说推荐、作品检索、小说排行榜、小说阅读、小说评论、会员中心、作家专区、充值订阅、新闻发布等功能。#开发环境MySQL8.0Redis7
  • 轨道交通系统详解，以及地铁如何精准停靠站台 炸膛坦客 自动驾驶人工智能自动驾驶
    ATC系统全称“自动列车控制系统”，AutomaticTrainControl，ATCATC是地铁运行的核心系统，它包括列车自动防护（ATP）、列车自动运行（ATO）和列车自动监控（ATS）三个子系统。ATS系统全称“自动列车监控系统”，AutomaticTrainSupervision，ATS主要负责列车运行状态的监控和管理。ATS系统通常由控制中心、车站设备和车辆设备组成，它们通过通信网络相互
  • 快穿小世界：绝色美人她好孕连连（青宁新书）全文在线阅读完整版 云轩书阁
    快穿小世界：绝色美人她好孕连连（青宁新书）全文在线阅读完整版主角：青宁简介：“搜索到宿主正在绑定生子系统……”省吃俭用辛苦攒钱，本来想旅行。我却在下一秒出了车祸，身体已经被车撞的稀巴烂。如果不绑定生子系统不去完成生子任务，我已经死翘翘了。关注微信公众号【旺精灵】去回个书號【9494】，即可阅读【快穿小世界：绝色美人她好孕连连】小说全文！第20章：想当初，她进宫时也不得圣宠。皇上并不重色，刚登上帝位
  • 双十一亿级电商系统JVM性能调优实战 YonchanLew
    （1）JDK体系结构这个是JDK的体系结构，JDK包含JRE，JRE包含JVM，所以JDK无非就是一些工具集和支持java运行的类库以及java虚拟机java跨平台就是靠JVM进行的（2）JVM组成部分那么JVM由什么部分组成？由类装载子系统、运行时数据区、字节码执行引擎组成。先由类装载子系统加载class字节码文件到数据区（内存区）中，再由字节码执行引擎执行内存区中的代码附上官方文档，这里教一下
  • 硬件工程师笔试面试——继电器 逼子歌 硬件工程师笔试面试题目汇总硬件工程师面试电子器件继电器笔试题目
    目录6、继电器6.1基础继电器原理图继电器实物图6.1.1概念6.1.2结构组成及工作6.1.3应用场景6.1.4优点与缺点6.1.5继电器工作原理6.2相关问题6.2.1如何选择合适的继电器满足特定的应用需求6.2.2继电器在汽车电子系统中通常承担那些角色6.2.3如何提高继电器的耐用性和可靠性?6.2.4继电器的电磁原理是如何影响其性能的?6.2.5继电器的寿命通常受哪些因素影响，如何延长其使
  • 零基础搭建一套完整的微服务框架【window版】 superswang dockerjava微服务
    技术栈：springboot+dubbo+docker零基础搭即可建微服务，完整运行本文你想学到什么?本文将以实战方式，首先对“微服务”相关的概念进行概要介绍，然后开始手把手教你搭建这一整套完整的微服务系统。项目完整代码下载地址https://github.com/gggcgba/mall微服务架构解决了什么问题此系统建立完以后，你的整个系统将被拆分成一个个独立的子系统，独立运行，系统与系统之间通
  • facade java_Java设计模式之Facade模式 weixin_39866966 facadejava
    Java设计模式之Facade模式GOF《设计模式》一书对Facade模式是这样描述的:为子系统中的一组接口提供一个统一接口。Facade模式定义了一个更高层的接口，使子系统更加容易使用。大致意思是说：使用一种比原有方式更简单的办法与系统交互。例如，我们把一个很重要的文件，放在了第二抽屉里，而第二个抽屉的钥匙放在了第一个抽屉里，我们要想取出这个文件，第一步肯定要拿到第一个抽屉的钥匙，然后打开它再拿
  • java设计模式之一 Facade模式 cuihuang1302 设计模式java
    GOF《设计模式》一书对Facade模式是这样描述的：为子系统中的一组接口提供一个统一接口。Facade模式定义了一个更高层的接口，使子系统更加容易使用。大致意思是说：使用一种比原有方式更简单的办法与系统交互。例如，我们把一个很重要的文件，放在了第二抽屉里，而第二个抽屉的钥匙放在了第一个抽屉里，我们要想取出这个文件，第一步肯定要拿到第一个抽屉的钥匙，然后打开它再拿出第二个抽屉的钥匙，最后打开第二个
  • Java 入门指南：初识 JVM Java虚拟机（Java Virtual Machine） ZachOn1y Javajavajvm开发语言后端个人开发java-ee
    文章目录引言JVM架构类加载器子系统（ClassLoaderSubsystem）运行时数据区（RuntimeDataArea）执行引擎（ExecutionEngine）垃圾回收器（GarbageCollector）内存管理堆内存方法区垃圾回收机制性能调优总结引言Java虚拟机（JVM）是一种抽象计算模型，它在软件层面模拟了一个计算机，允许开发者编写平台无关的程序。Java程序被编译成一种中间表示—
  • MT6769处理器规格参数_MTK联发科平台方案定制 新移科技 安卓核心板安卓开发板MTK平台安卓手机主板MTK联发科安卓主板定制MT67694G核心板
    MT6769安卓核心板具有集成的蓝牙、FM、WLAN和GPS模块，是一个高度集成的基带平台，结合了调制解调器和应用处理子系统，以支持LTE/LTE-A和C2K智能手机应用。该芯片集成了两个工作频率高达2.0GHz的ARM®Cortex-A75内核、六个工作频率高达1.70GHz的ARM®Cortex-A55内核和强大的多标准视频编解码器。此外，还包括一组广泛的接口和连接外围设备，用于连接相机、触摸
  • MTK6983/MT6983天玑9000芯片详细性能参数_MTK联发科5G方案定制 新移科技 MTK平台MTK方案安卓手机主板MTK联发科安卓主板定制手机芯片天玑9000
    联发科MT6983旗舰5G移动平台处理器集成了蓝牙、FM、WLAN和GPS模块，是一个高度集成的基带平台，集成了调制解调器和应用处理子系统，可支持LTE/LTE-A/NR和C2K智能手机应用。该芯片集成了四个Arm®Matterhorn(ELP)内核、四个Arm®Klein内核和强大的多标准视频编解码器。此外，还包括一组广泛的接口和连接外围设备，用于连接相机、触摸屏显示器和UFS/MMC/SD卡。
  • Postman接口测试，从入门到实战（一） 追忆袍泽 学习笔记自动化测试自动化测试postman测试工具
    一、什么是接口测试？接口测试分为两种：测试外部接口：系统和外部系统之间的接口。如：电商网站：支付宝支付。测试内部接口：系统内部的模块之间的联调，或者子系统之间的数据交互。测试重点：测试接口参数传递的正确性，接口功能的正确性，输出结果的正确性，以及对各种异常情况的容错性和权限控制。接口测试过程？比如我们出去吃饭，餐饮服务接口请求过程：饭馆地址（接口地址）选择菜系：东北菜、四川菜、湖南菜（接口请求方式
  • Android Camera HAL1&HAL3的区别 嵌入式_笔记 Androidandroid
    1.HAL1概述由于相机HAL1已弃用，建议在搭载Android9或更高版本的设备上使用相机HAL3.相机子系统的第1个版本被设计为具有高级控件和以下三种运行模式的黑盒子：预览视频录制静态拍摄三种模式具有略有不同又相互重叠的功能。这样就难以实现介于其中两种运行模式之间的新功能，例如连拍模式由于很多设备仍然依赖相机HAL1，因此Android7.0继续支持该模块。此外，Android相机服务还支持同
  • shiro 采用redis共享session，出现反序列化错误的排查过程 nightseventhunit redisjava数据库
    这是一个老系统改造的过程，该老系统采用的框架是#jfinal#shiroredis,采用outh2协议的方式，对多个子系统之间进行单点登录，以实现系统之间的session，由于速度方面的影响，现在要改造成多个系统之间共享session，并采用redis集群的方式。说明一下当前项目的整体运行环境，此项目的多个子系统都在同一个域名下，通过上下文不同来区分子系统。以下将记录整个改造过程，采用jfinal
  • 车载测试| 汽车的五域架构 （含线控技术知识） squirrel快乐敲码 汽车架构
    汽车的五域架构是一种将汽车电子控制系统按照功能进行划分的架构模式，主要包括动力域、底盘域、座舱域、自动驾驶域和车身域。（汽车三域架构通常是指将汽车电子系统划分为三个主要领域：动力域、底盘域和智能座舱域（或车身舒适域））以下是对这五个域的详细介绍：1、**动力域**：**功能**：动力域控制器是智能化的动力总成管理单元，主要功能包括对多种动力系统单元（如内燃机、电动机/发电机、电池、变速箱等）进行计
  • 软件架构概念分类 finemoon [随笔分类][20]Architecture数据结构框架
    软件架构对于每一个人的理解都是不同的，通过分类可以在包容细节差异的小基础上明确共性，达到“概念总体上的清晰”。将软件架构概念分派别：1.组成派软件系统的架构将系统描述为计算组件及组件之间的交互。计算组件是泛指的，可以进一步细分为处理组件，数据组件，连接组件可以是子系统，框架，模块，类等不同粒度的软件单元特征：(1.关注架构实践中的客体--软件，以软件本身为描述对象；(2.分析了软件的组成，即软件由
  • Android系统冻屏、黑屏问题的分析思路 sino lee 图形显示系统黑屏冻屏图层SurfaceFlinger
    在Android系统开发过程中，偶尔会遇到显示异常的问题，如画面不再刷新，也就是冻屏，或者屏幕变黑，如果对图形显示系统不熟悉，遇到此类问题还是比较棘手的。如果在工作中遇到类似的问题，或者对图形显示系统感兴趣，可参考清华大学出版社出版的《Android图形显示系统》。图形显示系统是Android系统中最为核心、复杂的子系统，掌握它对于理解Android系统会有一个很大的提升，是一门进阶课题。下面主要
  • Android图形显示架构概览 sino lee SurfaceFlingerWMSBinderHIDLOpenGL
    图形显示系统作为Android系统核心的子系统，掌握它对于理解Android系统很有帮助，下面从整体上简单介绍图形显示系统的架构，如下图所示。这个框架只包含了用户空间的图形组件，不涉及底层的显示驱动。框架主要包括以下4个图形组件。1、图形流生产者图形流生产者一般指的是各个应用，应用通过不同的方式生产出要显示的图形流。可以通过Skia、OpenGLES等图形库绘制得到，也可以通过Camera拍摄得到
  • Java Virtual Machine One LongProgrammer jvm
    jvm结构类加载子系统：类加载器验证准备解析数据运行时数据区：1.方法区类信息方法信息常量池2.堆体系:线程共享区域堆存放new的对象3.栈线程私有的存放线程执行过程的方法信息（存储单位为栈帧）4.程序计时器执行线程的行号计时器5.本地方法栈native方法栈执行引擎：将二进制的指令解释给操作系统栈虚拟栈:存储每个线程的栈结构，线程私有，栈中存储的元素是栈帧每个栈帧存储一个线程的方法信息，方法内部
  • windows与服务器之间的数据传递rsync同步文件，跳过服务器上已有的文件 Fu_Xingwen 小工具windows服务器运维
    有时候我们必须将数据上传到服务器当有很多文件时上传过程中由于网络原因可能会导致部分文件丢失那么这个时候就需要进行文件同步这时rsync就派上用场了但是rsync在Ubuntu上比较友好所以我们需要在windows上安装ubuntu子系统然后安装rsync，最后进行文件同步。首先在windows上安装ubuntu子系统windows自带的ubuntu子系统挺好用的推荐教程https://blog.c
  • java线程的无限循环和退出 3213213333332132 java
    最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。 突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。 希望帮助刚学java线程的童鞋 package thread; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date
  • tomcat 容器 BlueSkator tomcatWebservlet
    Tomcat的组成部分 1、server A Server element represents the entire Catalina servlet container. (Singleton) 2、service service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。   3、connector 一个connector
  • php递归,静态变量,匿名函数使用 dcj3sjt126com PHP递归函数匿名函数静态变量引用传参
      <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body>
  • 属性颜色字体变化 周华华 JavaScript
    function changSize(className){ var diva=byId("fot") diva.className=className; } </script> <style type="text/css"> .max{ background: #900; color:#039;
  • 将properties内容放置到map中 g21121 properties
    代码比较简单： private static Map<Object, Object> map; private static Properties p; static { //读取properties文件 InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
  • [简单]拼接字符串 53873039oycg 字符串
             工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下：           import java.util.HashMap; import java.uti
  • Struts2学习 云端月影
    最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。 配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。 使用Convention插件，你需要将其JAR文件放
  • Java新手入门的30个基本概念二 aijuans java新手java 入门
    基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
  • jedis 简单使用 antlove javarediscachecommandjedis
    jedis.RedisOperationCollection.java package jedis; import org.apache.log4j.Logger; import redis.clients.jedis.Jedis; import java.util.List; import java.util.Map; import java.util.Set; pub
  • PL/SQL的函数和包体的基础 百合不是茶 PL/SQL编程函数包体显示包的具体数据包
    由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,,   函数; 函数:PL/SQL中的函数相当于java中的方法;函数有返回值 定义函数的 --输入姓名找到该姓名的年薪 create or re
  • Mockito(二)--实例篇 bijian1013 持续集成mockito单元测试
            学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。         比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
  • 精通Oracle10编程SQL(7)编写控制结构 bijian1013 oracle数据库plsql
    /* *编写控制结构 */ --条件分支语句 --简单条件判断 DECLARE v_sal NUMBER(6,2); BEGIN select sal into v_sal from emp where lower(ename)=lower('&name'); if v_sal<2000 then update emp set
  • 【Log4j二】Log4j属性文件配置详解 bit1129 log4j
    如下是一个log4j.properties的配置   log4j.rootCategory=INFO, stdout , R log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appe
  • java集合排序笔记 白糖_ java
    public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{ private static final long serialVersionUID = -2958090810811192128L; private int id; private String nam
  • java导致linux负载过高的定位方法 ronin47
    定位java进程ID 可以使用top或ps -ef |grep java ![图片描述][1] 根据进程ID找到最消耗资源的java pid 比如第一步找到的进程ID为5431 执行 top -p 5431 -H ![图片描述][2] 打印java栈信息 $ jstack -l 5431 > 5431.log 在栈信息中定位具体问题 将消耗资源的Java PID转
  • 给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数 bylijinnan 函数
    import java.util.ArrayList; import java.util.List; import java.util.Random; public class RandNFromRand5 { /** 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。 解法1： f(k) = (x0-1)*5^0+(x1-
  • PL/SQL Developer保存布局 Kai_Ge
          近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段：   &n
  • [未来战士计划]超能查派[剧透,慎入] comsci 计划
           非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........        虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活....    &nbs
  • Google Map API V2 dai_lm google map
    以后如果要开发包含google map的程序就更麻烦咯 http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 找到篇不错的文章，大家可以参考一下 http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 1. 创建Android工程 由于v2的key需要G
  • java数据计算层的几种解决方法2 datamachine javasql集算器
    2、SQL     SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。     成熟度：5星。最成熟的。   
  • Linux下Telnet的安装与运行 dcj3sjt126com linuxtelnet
    Linux下Telnet的安装与运行   linux默认是使用SSH服务的 而不安装telnet服务  如果要使用telnet 就必须先安装相应的软件包  即使安装了软件包 默认的设置telnet 服务也是不运行的 需要手工进行设置 如果是redhat9，则在第三张光盘中找到 telnet-server-0.17-25.i386.rpm
  • PHP中钩子函数的实现与认识 dcj3sjt126com PHP
    假如有这么一段程序： function fun(){ fun1(); fun2(); }   首先程序执行完fun1()之后执行fun2()然后fun()结束。   但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。   我们可以在fu
  • EOS中的WorkSpace密码修改 蕃薯耀 修改WorkSpace密码
    EOS中BPS的WorkSpace密码修改 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】 hanqunfeng SpringSecurity
     SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下：   applicationContex
  • ie 9 kendo ui中ajax跨域的问题 jackyrong AJAX跨域
    这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序， 浏览起来是没问题的，但把应用放到公网上的一台服务器， 却发现如下情况： 1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题
  • 不要让别人笑你不能成为程序员 lampcy 编程程序员
    在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。 说实话，我感觉我的脑细胞像被轰炸过一样。 手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？ 难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？ 我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
  • 马皇后的贤德 nannan408
       马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。 　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
  • 选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以） Rainbow702 sqlgroup by最大值max最大的那条记录
    好久好久不写SQL了，技能退化严重啊！！！   直入主题： 比如我有一张表，file_info， 它有两个属性（但实际不只，我这里只是作说明用）： file_code, file_version 同一个code可能对应多个version 现在，我想针对每一个code，取得它相关的记录中，version 值 最大的那条记录， SQL如下： select *
  • VBScript脚本语言 tntxia VBScript
      VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。   VB家族语言简介   Visual Basic 6.0           源于BASIC语言。           由微软公司开发的包含协助开发环境的事
  • java中枚举类型的使用 xiao1zhao2 javaenum枚举1.5新特性
    枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量.   1.定义一个简单的枚举类型 public enum Sex { MAN, WOMAN }   枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型.   2.常用方法 静态的values()方
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他