linux进程timer,Linux系统进程间隔定时器Itimer

所谓“间隔定时器(Interval

Timer，简称itimer)就是指定时器采用“间隔”值(interval)来作为计时方式，当定时器启动后，间隔值interval将不断减小。当

interval值减到0时，我们就说该间隔定时器到期。与上一节所说的内核动态定时器相比，二者最大的区别在于定时器的计时方式不同。内核定时器是通过

它的到期时刻expires值来计时的，当全局变量jiffies值大于或等于内核动态定时器的expires值时，我们说内核内核定时器到期。而间隔定

时器则实际上是通过一个不断减小的计数器来计时的。虽然这两种定时器并不相同，但却也是相互联系的。假如我们每个时钟节拍都使间隔定时器的间隔计数器减

1，那么在这种情形下间隔定时器实际上就是内核动态定时器(下面我们会看到进程的真实间隔定时器就是这样通过内核定时器来实现的)。

间隔定时器主要被应用在用户进程上。每个Linux进程都有三个相互关联的间隔定时器。其各自的间隔计数器都定义在进程的task_struct结构中，如下所示(include/linux/sched.h)：struct task_struct｛

……

unsigned long it_real_value, it_prof_value, it_virt_value;

unsigned long it_real_incr, it_prof_incr, it_virt_incr;

struct timer_list real_timer;

……

}(1)真实间隔定时器(ITIMER_REAL)：这种间隔定时器在启动后，不管进程是否运行，每个时钟滴答都将其间隔计数器减1。当减到0值时，内核向

进程发送SIGALRM信号。结构类型task_struct中的成员it_real_incr则表示真实间隔定时器的间隔计数器的初始值，而成员

it_real_value则表示真实间隔定时器的间隔计数器的当前值。由于这种间隔定时器本质上与上一节的内核定时器时一样的，因此Linux实际上是

通过real_timer这个内嵌在task_struct结构中的内核动态定时器来实现真实间隔定时器ITIMER_REAL的。

2)虚拟间隔定时器ITIMER_VIRT：也称为进程的用户态间隔定时器。结构类型task_struct中成员it_virt_incr和

it_virt_value分别表示虚拟间隔定时器的间隔计数器的初始值和当前值，二者均以时钟滴答次数位计数单位。当虚拟间隔定时器启动后，只有当进程

在用户态下运行时，一次时钟滴答才能使间隔计数器当前值it_virt_value减1。当减到0值时，内核向进程发送SIGVTALRM信号(虚拟闹钟

信号)，并将it_virt_value重置为初值it_virt_incr。具体请见7.4.3节中的do_it_virt()函数的实现。

(3)PROF间隔定时器ITIMER_PROF：进程的task_struct结构中的it_prof_value和it_prof_incr成员分

别表示PROF间隔定时器的间隔计数器的当前值和初始值(均以时钟滴答为单位)。当一个进程的PROF间隔定时器启动后，则只要该进程处于运行中，而不管

是在用户态或核心态下执行，每个时钟滴答都使间隔计数器it_prof_value值减1。当减到0值时，内核向进程发送SIGPROF信号，并将

it_prof_value重置为初值it_prof_incr。具体请见7.4.3节的do_it_prof()函数。

Linux在include/linux/time.h头文件中为上述三种进程间隔定时器定义了索引标识，如下所示：#define ITIMER_REAL 0

#define ITIMER_VIRTUAL 1

#define ITIMER_PROF 2　7．7．1 数据结构itimerval

虽然，在内核中间隔定时器的间隔计数器是以时钟滴答次数为单位，但是让用户以时钟滴答

为单位来指定间隔定时器的间隔计数器的初值显然是不太方便的，因为用户习惯的时间单位是秒、毫秒或微秒等。所以Linux定义了数据结构

itimerval来让用户以秒或微秒为单位指定间隔定时器的时间间隔值。其定义如下(include/linux/time.h)：struct itimerval {

struct timeval it_interval; /* timer interval */

struct timeval it_value; /* current value */

};其中，it_interval成员表示间隔计数器的初始值，而it_value成员表示间隔计数器的当前值。这两个成员都是timeval结构类型的变量，因此其精度可以达到微秒级。

timeval与jiffies之间的相互转换

由于间隔定时器的间隔计数器的内部表示方式与外部表现方式互不相同，因此有必要实现以微秒为单位的timeval结构和为时钟滴答次数单位的

jiffies之间的相互转换。为此，Linux在kernel/itimer.c中实现了两个函数实现二者的互相转换——tvtojiffies()函

数和jiffiestotv()函数。它们的源码如下：static unsigned long tvtojiffies(struct timeval *value)

{

unsigned long sec = (unsigned) value->tv_sec;

unsigned long usec = (unsigned) value->tv_usec;

if (sec > (ULONG_MAX / HZ))

return ULONG_MAX;

usec += 1000000 / HZ - 1;

usec /= 1000000 / HZ;

return HZ*sec+usec;

}

static void jiffiestotv(unsigned long jiffies, struct timeval *value)

{

value->tv_usec = (jiffies % HZ) * (1000000 / HZ);

value->tv_sec = jiffies / HZ;

}7．7．2 真实间隔定时器ITIMER_REAL的底层运行机制

间隔定时器ITIMER_VIRT和ITIMER_PROF的底层运行机制是分别通过函数do_it_virt()函数和do_it_prof()函数来实现的，这里就不再重述(可以参见7.4.3节)。

由于间隔定时器ITIMER_REAL本质上与内核动态定时器并无区别。因此内核实际上是通过内核动态定时器来实现进程的ITIMER_REAL间隔定

时器的。为此，task_struct结构中专门设立一个timer_list结构类型的成员变量real_timer。动态定时器real_timer

的函数指针function总是被task_struct结构的初始化宏INIT_TASK设置为指向函数it_real_fn()。如下所示

(include/linux/sched.h)：#define INIT_TASK(tsk)

……

real_timer： {

function： it_real_fn

}

……

}而real_timer链表元素list和data成员总是被进程创建时分别初始化为空和进程task_struct结构的地址，如下所示(kernel/fork.c)：int do_fork(……)

{

……

p->it_real_value = p->it_virt_value = p->it_prof_value = 0;

p->it_real_incr = p->it_virt_incr = p->it_prof_incr = 0;

init_timer(&p->real_timer);

p->real_timer.data = (unsigned long)p;

……

}当用户通过setitimer()系统调用来设置进程的ITIMER_REAL间隔定时器时，it_real_incr被设置成非零值，于是该系统调用相

应地设置好real_timer.expires值，然后进程的real_timer定时器就被加入到内核动态定时器链表中，这样该进程的

ITIMER_REAL间隔定时器就被启动了。当real_timer定时器到期时，它的关联函数it_real_fn()将被执行。注意！所有进程的

real_timer定时器的function函数指针都指向it_real_fn()这同一个函数，因此it_real_fn()函数必须通过其参数来

识别是哪一个进程，为此它将unsigned long类型的参数p解释为进程task_struct结构的地址。该函数的源码如下(kernel/itimer.c)：

void it_real_fn(unsigned long __data)

{

struct task_struct * p = (struct task_struct *) __data;

unsigned long interval;

send_sig(SIGALRM, p, 1);

interval = p->it_real_incr;

if (interval) {

if (interval > (unsigned long) LONG_MAX)

interval = LONG_MAX;

p->real_timer.expires = jiffies + interval;

add_timer(&p->real_timer);

}

}　函数it_real_fn()的执行过程大致如下：

(1)首先将参数p通过强制类型转换解释为进程的task_struct结构类型的指针。

(2)向进程发送SIGALRM信号。

(3)在进程的it_real_incr非0的情况下继续启动real_timer定时器。首先，计算real_timer定时器的expires值为

(jiffies＋it_real_incr)。然后，调用add_timer()函数将real_timer加入到内核动态定时器链表中。

7．7．3 itimer定时器的系统调用

与itimer定时器相关的syscall有两个：getitimer()和setitimer()。其中，getitimer()用于查询调用进程的

三个间隔定时器的信息，而setitimer()则用来设置调用进程的三个间隔定时器。这两个syscall都是现在kernel/itimer.c文件

中。

7．7．3．1 getitimer()系统调用的实现

函数sys_getitimer()有两个参数：

(1)which，指定查询调用进程的哪一个间隔定时器，其取值可以是ITIMER_REAL、ITIMER_VIRT和ITIMER_PROF三者之

一。(2)value指针，指向用户空间中的一个itimerval结构，用于接收查询结果。该函数的源码如下：/* SMP: Only we modify our itimer values. */

asmlinkage long sys_getitimer(int which, struct itimerval *value)

{

int error = -EFAULT;

struct itimerval get_buffer;

if (value) {

error = do_getitimer(which, &get_buffer);

if (!error &&

copy_to_user(value, &get_buffer, sizeof(get_buffer)))

error = -EFAULT;

}

return error;

}　显然，sys_getitimer()函数主要通过do_getitimer()函数来查询当前进程的间隔定时器信息，并将查询结果保存在内核空间的结

构变量get_buffer中。然后，调用copy_to_usr()宏将get_buffer中结果拷贝到用户空间缓冲区中。

函数do_getitimer()的源码如下(kernel/itimer.c)：

int do_getitimer(int which, struct itimerval *value)

{

register unsigned long val, interval;

switch (which) {

case ITIMER_REAL:

interval = current->it_real_incr;

val = 0;

/*

* FIXME! This needs to be atomic, in case the kernel timer happens!

*/

if (timer_pending(¤t->real_timer)) {

val = current->real_timer.expires - jiffies;

/* look out for negative/zero itimer.. */

if ((long) val <= 0)

val = 1;

}

break;

case ITIMER_VIRTUAL:

val = current->it_virt_value;

interval = current->it_virt_incr;

break;

case ITIMER_PROF:

val = current->it_prof_value;

interval = current->it_prof_incr;

break;

default:

return(-EINVAL);

}

jiffiestotv(val, &value->it_value);

jiffiestotv(interval, &value->it_interval);

return 0;

}查询的过程如下：

(1)首先，用局部变量val和interval分别表示待查询间隔定时器的间隔计数器的当前值和初始值。

(2)如果which＝ITIMER_REAL，则查询当前进程的ITIMER_REAL间隔定时器。于是从

current->it_real_incr中得到ITIMER_REAL间隔定时器的间隔计数器的初始值，并将其保存到interval局部变量

中。而对于间隔计数器的当前值，由于ITITMER_REAL间隔定时器是通过real_timer这个内核动态定时器来实现的，因此不能通过

current->it_real_value来获得ITIMER_REAL间隔定时器的间隔计数器的当前值，而必须通过real_timer来得

到这个值。为此先用timer_pending()函数来判断current->real_timer是否已被起动。如果未启动，则说明

ITIMER_REAL间隔定时器也未启动，因此其间隔计数器的当前值肯定是0。因此将val变量简单地置0就可以了。如果已经启动，则间隔计数器的当前

值应该等于(timer_real.expires－jiffies)。

(3)如果which＝ITIMER_VIRT，则查询当前进程的ITIMER_VIRT间隔定时器。于是简单地将计数器初值it_virt_incr和当前值it_virt_value分别保存到局部变量interval和val中。

(4)如果which＝ITIMER_PROF，则查询当前进程的ITIMER_PROF间隔定时器。于是简单地将计数器初值it_prof_incr和当前值it_prof_value分别保存到局部变量interval和val中。

(5)最后，通过转换函数jiffiestotv()将val和interval转换成timeval格式的时间值，并保存到value->it_value和value->it_interval中，作为查询结果返回。

7．7．3．2 setitimer()系统调用的实现

函数sys_setitimer()不仅设置调用进程的指定间隔定时器，而且还返回该间隔定时器的原有信息。它有三个参数：(1)which，含义与

sys_getitimer()中的参数相同。(2)输入参数value，指向用户空间中的一个itimerval结构，含有待设置的新值。(3)输出参

数ovalue，指向用户空间中的一个itimerval结构，用于接收间隔定时器的原有信息。

该函数的源码如下(kernel/itimer.c)：/* SMP: Again, only we play with our itimers, and signals are SMP safe

* now so that is not an issue at all anymore.

*/

asmlinkage long sys_setitimer(int which, struct itimerval *value,

struct itimerval *ovalue)

{

struct itimerval set_buffer, get_buffer;

int error;

if (value) {

if(copy_from_user(&set_buffer, value, sizeof(set_buffer)))

return -EFAULT;

} else

memset((char *) &set_buffer, 0, sizeof(set_buffer));

error = do_setitimer(which, &set_buffer, ovalue ? &get_buffer : 0);

if (error || !ovalue)

return error;

if (copy_to_user(ovalue, &get_buffer, sizeof(get_buffer)))

return -EFAULT;

return 0;

}对该函数的注释如下：

(1)在输入参数指针value非空的情况下，调用copy_from_user()宏将用户空间中的待设置信息拷贝到内核空间中的set_buffer结构变量中。如果value指针为空，则简单地将set_buffer结构变量全部置0。

(2)调用do_setitimer()函数完成实际的设置操作。如果输出参数ovalue指针有效，则以内核变量get_buffer的地址作为

do_setitimer()函数的第三那个调用参数，这样当do_setitimer()函数返回时，get_buffer结构变量中就将含有当前进程

的指定间隔定时器的原来信息。Do_setitimer()函数返回0值表示成功，非0值表示失败。

(3)在do_setitimer()函数返回非0值的情况下，或者ovalue指针为空的情况下(不需要输出间隔定时器的原有信息)，函数就可以直接返回了。

(4)如果ovalue指针非空，调用copy_to_user()宏将get_buffer()结构变量中值拷贝到ovalue所指向的用户空间中去，以便让用户得到指定间隔定时器的原有信息值。

函数do_setitimer()的源码如下(kernel/itimer.c)：int do_setitimer(int which, struct itimerval *value, struct itimerval *ovalue)

{

register unsigned long i, j;

int k;

i = tvtojiffies(&value->it_interval);

j = tvtojiffies(&value->it_value);

if (ovalue && (k = do_getitimer(which, ovalue)) < 0)

return k;

switch (which) {

case ITIMER_REAL:

del_timer_sync(¤t->real_timer);

current->it_real_value = j;

current->it_real_incr = i;

if (!j)

break;

if (j > (unsigned long) LONG_MAX)

j = LONG_MAX;

i = j + jiffies;

current->real_timer.expires = i;

add_timer(¤t->real_timer);

break;

case ITIMER_VIRTUAL:

if (j)

j++;

current->it_virt_value = j;

current->it_virt_incr = i;

break;

case ITIMER_PROF:

if (j)

j++;

current->it_prof_value = j;

current->it_prof_incr = i;

break;

default:

return -EINVAL;

}

return 0;

}　对该函数的注释如下：

(1)首先调用tvtojiffies()函数将timeval格式的初始值和当前值转换成以时钟滴答为单位的时间值。并分别保存在局部变量i和j中。

(2)如果ovalue指针非空，则调用do_getitimer()函数查询指定间隔定时器的原来信息。如果do_getitimer()函数返回负值，说明出错。因此就要直接返回错误值。否则继续向下执行开始真正地设置指定的间隔定时器。

(3)如果which=ITITMER_REAL，表示设置ITIMER_REAL间隔定时器。(a)调用del_timer_sync()函数(该函

数在单CPU系统中就是del_timer()函数)将当前进程的real_timer定时器从内核动态定时器链表中删除。(b)将

it_real_incr和it_real_value分别设置为局部变量i和j。(c)如果j=0，说明不必启动real_timer定时器，因此执行

break语句退出switch…case控制结构，而直接返回。(d)将real_timer的expires成员设置成(jiffies＋当前值

j)，然后调用add_timer()函数将当前进程的real_timer定时器加入到内核动态定时器链表中，从而启动该定时器。

(4)如果which=ITIMER_VIRT，则简单地用局部变量i和j的值分别更新it_virt_incr和it_virt_value就可以了。

(5)如果which=ITIMER_PROF，则简单地用局部变量i和j的值分别更新it_prof_incr和it_prof_value就可以了。

(6)最后，返回0值表示成功。

7．7．3．3 alarm系统调用

系统调用alarm可以让调用进程在指定的秒数间隔后收到一个SIGALRM信号。它只有一个参数seconds，指定以秒数计的定时间隔。函数sys_alarm()的源码如下(kernel/timer.c)：/*

* For backwards compatibility? This can be done in libc so Alpha

* and all newer ports shouldn't need it.

*/

asmlinkage unsigned long sys_alarm(unsigned int seconds)

{

struct itimerval it_new, it_old;

unsigned int oldalarm;

it_new.it_interval.tv_sec = it_new.it_interval.tv_usec = 0;

it_new.it_value.tv_sec = seconds;

it_new.it_value.tv_usec = 0;

do_setitimer(ITIMER_REAL, &it_new, &it_old);

oldalarm = it_old.it_value.tv_sec;

/* ehhh.. We can't return 0 if we have an alarm pending.. */

/* And we'd better return too much than too little anyway */

if (it_old.it_value.tv_usec)

oldalarm++;

return oldalarm;

}　这个系统调用实际上就是启动进程的ITIMER_REAL间隔定时器。因此它完全可放到用户空间的C函数库(比如libc和glibc)中来实

现。但是为了保此内核的向后兼容性，2.4.0版的内核仍然将这个syscall放在内核空间中来实现。函数sys_alarm()的实现过程如下：

(1)根据参数seconds的值构造一个itimerval结构变量it_new。注意！由于alarm启动的ITIMER_REAL间隔定时器是一次性而不是循环重复的，因此it_new变量中的it_interval成员一定要设置为0。

(2)调用函数do_setitimer()函数以新构造的定时器it_new来启动当前进程的ITIMER_REAL定时器，同时将该间隔定时器的原定时间隔保存到局部变量it_old中。

(3)返回值oldalarm表示以秒数计的ITIMER_REAL间隔定时器的原定时间隔值。因此先把it_old.it_value.tv_sec

赋给oldalarm，并且在it_old.it_value.tv_usec非0的情况下，将oldalarm的值加1(也即不足1秒补足1秒)。