linux内核定时器详解,Linux系统内核定时器机制详解（下）

╰半橙微兮° 2023-01-19 15:49 252阅读 0赞

7．6．3．4 把一个定时器插入到链表中

函数add\_timer()用来把参数timer指针所指向的定时器插入到一个合适的定时器链表中。它首先调用timer\_pending()函数判断所指定的定时器是否已经位于在某个定时器向量中等待执行。如果是，则不进行任何操作，只是打印一条内核告警信息就返回了；如果不是，则调用internal\_add\_timer()函数完成实际的插入操作。其源码如下(kernel/timer.c)：

void add\_timer(struct timer\_list \*timer)

unsigned long flags;

spin\_lock\_irqsave(&timerlist\_lock, flags);

if (timer\_pending(timer))

goto bug;

internal\_add\_timer(timer);

spin\_unlock\_irqrestore(&timerlist\_lock, flags);

return;

bug:

spin\_unlock\_irqrestore(&timerlist\_lock, flags);

printk("bug: kernel timer added twice at %p.\\n",

\_\_builtin\_return\_address(0));

函数internal\_add\_timer()用于把一个不处于任何定时器向量中的定时器插入到它应该所处的定时器向量中去(根据定时器的expires值来决定)。如下所示(kernel/timer.c)：

static inline void internal\_add\_timer(struct timer\_list \*timer)

/\*

\* must be cli-ed when calling this

\*/

unsigned long expires = timer->expires;

unsigned long idx = expires - timer\_jiffies;

struct list\_head \* vec;

if (idx < TVR\_SIZE) \{

int i = expires & TVR\_MASK;

vec = tv1.vec + i;

\} else if (idx < 1 << (TVR\_BITS + TVN\_BITS)) \{

int i = (expires >> TVR\_BITS) & TVN\_MASK;

vec = tv2.vec + i;

\} else if (idx < 1 << (TVR\_BITS + 2 \* TVN\_BITS)) \{

int i = (expires >> (TVR\_BITS + TVN\_BITS)) & TVN\_MASK;

vec = tv3.vec + i;

\} else if (idx < 1 << (TVR\_BITS + 3 \* TVN\_BITS)) \{

int i = (expires >> (TVR\_BITS + 2 \* TVN\_BITS)) & TVN\_MASK;

vec = tv4.vec + i;

\} else if ((signed long) idx < 0) \{

/\* can happen if you add a timer with expires == jiffies,

\* or you set a timer to go off in the past

\*/

vec = tv1.vec + tv1.index;

\} else if (idx <= 0xffffffffUL) \{

int i = (expires >> (TVR\_BITS + 3 \* TVN\_BITS)) & TVN\_MASK;

vec = tv5.vec + i;

\} else \{

/\* Can only get here on architectures with 64-bit jiffies \*/

INIT\_LIST\_HEAD(&timer->list);

return;

/\*

\* Timers are FIFO!

\*/

list\_add(&timer->list, vec->prev);

对该函数的注释如下：

(1)首先，计算定时器的expires值与timer\_jiffies的插值(注意！这里应该使用动态定时器自己的时间基准)，这个差值就表示这个定时器相对于上一次运行定时器机制的那个时刻还需要多长时间间隔才到期。局部变量idx保存这个差值。

(2)根据idx的值确定这个定时器应被插入到哪一个定时器向量中。其具体的确定方法我们在7.6.2节已经说过了，这里不再详述。最后，定时器向量的头部指针vec表示这个定时器应该所处的定时器向量链表头部。

(3)最后，调用list\_add()函数把定时器插入到vec指针所指向的定时器队列的尾部。

7．6．3．5 修改一个定时器的expires值

当一个定时器已经被插入到内核动态定时器链表中后，我们还可以修改该定时器的expires值。函数mod\_timer()实现这一点。如下所示(kernel/timer.c)：

int mod\_timer(struct timer\_list \*timer, unsigned long expires)

int ret;

unsigned long flags;

spin\_lock\_irqsave(&timerlist\_lock, flags);

timer->expires = expires;

ret = detach\_timer(timer);

internal\_add\_timer(timer);

spin\_unlock\_irqrestore(&timerlist\_lock, flags);

return ret;

该函数首先根据参数expires值更新定时器的expires成员。然后调用detach\_timer()函数把该定时器从它原来所属的链表中删除。最后调用internal\_add\_timer()函数把该定时器根据它新的expires值重新插入到相应的链表中。

函数detach\_timer()首先调用timer\_pending()来判断指定的定时器是否已经处于某个链表中，如果定时器原来就不处于任何链表中，则detach\_timer()函数什么也不做，直接返回0值，表示失败。否则，就调用list\_del()函数把定时器从它原来所处的链表中摘除。如下所示(kernel/timer.c)：

static inline int detach\_timer (struct timer\_list \*timer)

if (!timer\_pending(timer))

return 0;

list\_del(&timer->list);

return 1;

7．6．3．6 删除一个定时器

函数del\_timer()用来把一个定时器从相应的内核定时器队列中删除。该函数实际上是对detach\_timer()函数的高层封装。如下所示(kernel/timer.c)：

int del\_timer(struct timer\_list \* timer)

int ret;

unsigned long flags;

spin\_lock\_irqsave(&timerlist\_lock, flags);

ret = detach\_timer(timer);

timer->list.next = timer->list.prev = NULL;

spin\_unlock\_irqrestore(&timerlist\_lock, flags);

return ret;

7．6．3．7 定时器迁移操作

由于一个定时器的interval值会随着时间的不断流逝(即jiffies值的不断增大)而不断变小，因此那些原本到期紧迫程度较低的定时器会随着jiffies值的不断增大而成为既把马上到期的定时器。比如定时器向量tv2.vec\[0\]中的定时器在经过256个时钟滴答后会成为未来256个时钟滴答内会到期的定时器。因此，定时器在内核动态定时器链表中的位置也应相应地随着改变。改变的规则是：当tv1.index重新变为0时(意味着tv1中的256个定时器向量都已被内核扫描一遍了，从而使tv1中的256个定时器向量变为空)，则用tv2.vec［index］定时器向量中的定时器去填充tv1，同时使tv2.index加1(它以64为模)。当tv2.index重新变为0(意味着tv2中的64个定时器向量都已经被全部填充到tv1中去了，从而使得tv2变为空)，则用tv3.vec［index］定时器向量中的定时器去填充tv2。如此一直类推下去，直到tv5。

函数cascade\_timers()完成这种定时器迁移操作，该函数只有一个timer\_vec结构类型指针的参数tv。这个函数把把定时器向量tv->vec［tv->index］中的所有定时器重新填充到上一层定时器向量中去。如下所示(kernel/timer.c)：

static inline void cascade\_timers(struct timer\_vec \*tv)

/\* cascade all the timers from tv up one level \*/

struct list\_head \*head, \*curr, \*next;

head = tv->vec + tv->index;

curr = head->next;

/\*

\* We are removing \_all\_ timers from the list, so we don't have to

\* detach them individually, just clear the list afterwards.

\*/

while (curr != head) \{

struct timer\_list \*tmp;

tmp = list\_entry(curr, struct timer\_list, list);

next = curr->next;

list\_del(curr); // not needed

internal\_add\_timer(tmp);

curr = next;

INIT\_LIST\_HEAD(head);

tv->index = (tv->index + 1) & TVN\_MASK;

对该函数的注释如下：

(1)首先，用指针head指向定时器头部向量头部的list\_head结构。指针curr指向定时器向量中的第一个定时器。

(2)然后，用一个while\{\}循环来遍历定时器向量tv->vec［tv->index］。由于定时器向量是一个双向循环队列，因此循环的终止条件是curr=head。对于每一个被扫描的定时器，循环体都先调用list\_del()函数把当前定时器从链表中摘除，然后调用internal\_add\_timer()函数重新确定该定时器应该被放到哪个定时器向量中去。

(3)当从while\{\}循环退出后，定时器向量tv->vec［tv->index］中所有的定时器都已被迁移到其它地方(到它们该呆的地方：－)，因此它本身就成为一个空队列。这里我们显示地调用INIT\_LIST\_HEAD()宏来把定时器向量的表头结构初始化为空。

(4)最后，把tv->index值加1，当然它是以64为模。

7．6．4．8 扫描并执行当前已经到期的定时器

函数run\_timer\_list()完成这个功能。如前所述，该函数是被timer\_bh()函数所调用的，因此内核定时器是在时钟中断的Bottom Half中被执行的。记住这一点非常重要。全局变量timer\_jiffies表示了内核上一次执行run\_timer\_list()函数的时间，因此jiffies与timer\_jiffies的差值就表示了自从上一次处理定时器以来，期间一共发生了多少次时钟中断，显然run\_timer\_list()函数必须为期间所发生的每一次时钟中断补上定时器服务。该函数的源码如下(kernel/timer.c)：

static inline void run\_timer\_list(void)

spin\_lock\_irq(&timerlist\_lock);

while ((long)(jiffies - timer\_jiffies) >= 0) \{

struct list\_head \*head, \*curr;

if (!tv1.index) \{

int n = 1;

do \{

cascade\_timers(tvecs\[n\]);

\} while (tvecs\[n\]->index == 1 && ++n < NOOF\_TVECS);

repeat:

head = tv1.vec + tv1.index;

curr = head->next;

if (curr != head) \{

struct timer\_list \*timer;

void (\*fn)(unsigned long);

unsigned long data;

timer = list\_entry(curr, struct timer\_list, list);

fn = timer->function;

data= timer->data;

detach\_timer(timer);

timer->list.next = timer->list.prev = NULL;

timer\_enter(timer);

spin\_unlock\_irq(&timerlist\_lock);

fn(data);

spin\_lock\_irq(&timerlist\_lock);

timer\_exit();

goto repeat;

\++timer\_jiffies;

tv1.index = (tv1.index + 1) & TVR\_MASK;

spin\_unlock\_irq(&timerlist\_lock);

函数run\_timer\_list()的执行过程主要就是用一个大while\{\}循环来为时钟中断执行定时器服务，每一次循环服务一次时钟中断。因此一共要执行(jiffies－timer\_jiffies＋1)次循环。循环体所执行的服务步骤如下：

(1)首先，判断tv1.index是否为0，如果为0则需要从tv2中补充定时器到tv1中来。但tv2也可能为空而需要从tv3中补充定时器，因此用一个do\{\}while循环来调用cascade\_timer()函数来依次视需要从tv2中补充tv1，从tv3中补充tv2、…、从tv5中补充tv4。显然如果tvi.index=0(2≤i≤5)，则对于tvi执行cascade\_timers()函数后，tvi.index肯定为1。反过来讲，如果对tvi执行过cascade\_timers()函数后tvi.index不等于1，那么可以肯定在未对tvi执行cascade\_timers()函数之前，tvi.index值肯定不为0，因此这时tvi不需要从tv(i+1)中补充定时器，这时就可以终止do\{\}while循环。

(2)接下来，就要执行定时器向量tv1.vec［tv1.index］中的所有到期定时器。因此这里用一个goto repeat循环从头到尾依次扫描整个定时器对列。由于在执行定时器的关联函数时并不需要关CPU中断，所以在用detach\_timer()函数把当前定时器从对列中摘除后，就可以调用spin\_unlock\_irq()函数进行解锁和开中断，然后在执行完当前定时器的关联函数后重新用spin\_lock\_irq()函数加锁和关中断。

(3)当执行完定时器向量tv1.vec\[tv1.index\]中的所有到期定时器后，tv1.vec［tv1.index］应该是个空队列。至此这一次定时器服务也就宣告结束。

(4)最后，把timer\_jiffies值加1，把tv1.index值加1，当然它的模是256。然后，回到while循环开始下一次定时器服务。