时钟中断处理程序

   时钟中断处理程序可以划分为两个部分：体系结构相关部分和体系结构无关部分。

 

 与体系结构相关的例程作为系统定时器的中断处理程序而注册到内核中，以便在产生时钟中断时，它都能够相应地运行。这部分处理程序主要完成：

获得xtime_lock锁，以便对访问jiffies_64和墙上时间xtime进行保护

需要时应答或重新设置系统时钟

周期性地使用墙上时间更新实时时钟

调用体系结构无关的时钟例程：do_timer()

2. 在<Time.h(incluce/linux)>中
4. extern struct timespec xtime;
6. #ifndef _STRUCT_TIMESPEC
7. #define _STRUCT_TIMESPEC
8. struct timespec {
9.     time_t  tv_sec;     /* seconds */
10.     long    tv_nsec;    /* nanoseconds 十亿分之一秒*/
11. };
12. #endif

  中断服务程序主要通过调用与体系结构无关的例程do_timer()执行下面的工作：

给jiffies_64变量增加1

更新资源消耗的统计值，比如当前进程所消耗的系统时间和用户时间

执行已经到期的动态定时器

执行scheduler_tick()函数

更新墙上时间，该时间存放在xtime变量中

计算平均负载

 

1. 在<Time.c(kernel)>中
2. /*
3.  * Called by the timer interrupt. xtime_lock must already be taken
4.  * by the timer IRQ!
5.  */
6. static inline void update_times(unsigned long ticks)
7. {
8.     update_wall_time(); /* 更新墙上时间 */
9.     calc_load(ticks); /* 计算平均负载值*/
10. }
11.   
12. /*
13.  * The 64-bit jiffies value is not atomic - you MUST NOT read it
14.  * without sampling the sequence number in xtime_lock.
15.  * jiffies is defined in the linker script...
16.  */
18. void do_timer(unsigned long ticks)
19. {
20.     jiffies_64 += ticks;/* 给jiffies_64变量加1: */
21.     update_times(ticks);
22. }
23. /**
24.  * update_wall_time - Uses the current clocksource to increment the wall time
25.  *
26.  * Called from the timer interrupt, must hold a write on xtime_lock.
27.  */
28. static void update_wall_time(void)
29. {
30.     cycle_t offset;
32.     /* Make sure we're fully resumed: */
33.     if (unlikely(timekeeping_suspended))
34.         return;
36. #ifdef CONFIG_GENERIC_TIME
37.     offset = (clocksource_read(clock) - clock->cycle_last) & clock->mask;
38. #else
39.     offset = clock->cycle_interval;
40. #endif
41.     clock->xtime_nsec += (s64)xtime.tv_nsec << clock->shift;
43.     /* normally this loop will run just once, however in the
44.      * case of lost or late ticks, it will accumulate correctly.
45.      */
46.     while (offset >= clock->cycle_interval) {
47.         /* accumulate one interval */
48.         clock->xtime_nsec += clock->xtime_interval;
49.         clock->cycle_last += clock->cycle_interval;
50.         offset -= clock->cycle_interval;
52.         if (clock->xtime_nsec >= (u64)NSEC_PER_SEC << clock->shift) {
53.             clock->xtime_nsec -= (u64)NSEC_PER_SEC << clock->shift;
54.             xtime.tv_sec++;
55.             second_overflow();
56.         }
58.         /* interpolator bits */
59.         time_interpolator_update(clock->xtime_interval
60.                         >> clock->shift);
62.         /* accumulate error between NTP and clock interval */
63.         clock->error += current_tick_length();
64.         clock->error -= clock->xtime_interval << (TICK_LENGTH_SHIFT - clock->shift);
65.     }
67.     /* correct the clock when NTP error is too big */
68.     clocksource_adjust(clock, offset);
70.     /* store full nanoseconds into xtime */
71.     xtime.tv_nsec = (s64)clock->xtime_nsec >> clock->shift;
72.     clock->xtime_nsec -= (s64)xtime.tv_nsec << clock->shift;
74.     /* check to see if there is a new clocksource to use */
75.     change_clocksource();
76.     update_vsyscall(&xtime, clock);
77. }
78. /*
79.  * calc_load - given tick count, update the avenrun load estimates.
80.  * This is called while holding a write_lock on xtime_lock.
81.  */
82. static inline void calc_load(unsigned long ticks)
83. {
84.     unsigned long active_tasks; /* fixed-point */
85.     static int count = LOAD_FREQ;
87.     count -= ticks;
88.     if (unlikely(count < 0)) {
89.         active_tasks = count_active_tasks();
90.         do {
91.             CALC_LOAD(avenrun[0], EXP_1, active_tasks);
92.             CALC_LOAD(avenrun[1], EXP_5, active_tasks);
93.             CALC_LOAD(avenrun[2], EXP_15, active_tasks);
94.             count += LOAD_FREQ;
95.         } while (count < 0);
96.     }
97. }

  do_timer()执行完毕后返回与体系结构相关的中断处理程序，继续执行后面的工作，释放xtime_lock锁，然后退出。

  以上全部工作每1/Hz秒都要发生一次。

  相关数据类型如下：

 

1. 在<Clocksource.h(include/linux)>中
2. /* clocksource cycle base type */
3. typedef u64 cycle_t;
4. struct clocksource;
6. /**
7.  * struct clocksource - hardware abstraction for a free running counter
8.  *  Provides mostly state-free accessors to the underlying hardware.
9.  *
10.  * @name:       ptr to clocksource name
11.  * @list:       list head for registration
12.  * @rating:     rating value for selection (higher is better)
13.  *          To avoid rating inflation the following
14.  *          list should give you a guide as to how
15.  *          to assign your clocksource a rating
16.  *          1-99: Unfit for real use
17.  *              Only available for bootup and testing purposes.
18.  *          100-199: Base level usability.
19.  *              Functional for real use, but not desired.
20.  *          200-299: Good.
21.  *              A correct and usable clocksource.
22.  *          300-399: Desired.
23.  *              A reasonably fast and accurate clocksource.
24.  *          400-499: Perfect
25.  *              The ideal clocksource. A must-use where
26.  *              available.
27.  * @read:       returns a cycle value
28.  * @mask:       bitmask for two's complement
29.  *          subtraction of non 64 bit counters
30.  * @mult:       cycle to nanosecond multiplier
31.  * @shift:      cycle to nanosecond divisor (power of two)
32.  * @flags:      flags describing special properties
33.  * @vread:      vsyscall based read
34.  * @cycle_interval: Used internally by timekeeping core, please ignore.
35.  * @xtime_interval: Used internally by timekeeping core, please ignore.
36.  */
37. struct clocksource {
38.     char *name;
39.     struct list_head list;
40.     int rating;
41.     cycle_t (*read)(void);
42.     cycle_t mask;
43.     u32 mult;
44.     u32 shift;
45.     unsigned long flags;
46.     cycle_t (*vread)(void);
48.     /* timekeeping specific data, ignore */
49.     cycle_t cycle_last, cycle_interval;
50.     u64 xtime_nsec, xtime_interval;
51.     s64 error;
53. #ifdef CONFIG_CLOCKSOURCE_WATCHDOG
54.     /* Watchdog related data, used by the framework */
55.     struct list_head wd_list;
56.     cycle_t wd_last;
57. #endif

呵呵