linux kernel中timer的使用

68 阅读 0 评论 45 点赞

我是靠谱客的博主醉熏身影，最近开发中收集的这篇文章主要介绍linux kernel中timer的使用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

在kernel中如果想周期性的干些什么事情，或者某个特定时间干些什么事情，可以使用timer。
例如像周期性地dump某段buffer的数据等等。

先来看看使用方法。
先定义一个struct timer_list的对象。eg: struct timer_list dump_t;
这个对象相当于一个闹钟，其中包含了时间点，也就是什么时候激活闹钟；一个函数指针，闹钟激活后干活的地方；
还有一个void 指针，在闹钟干活的时候可能需要传给它一些当前的数据。

先看使用方法，之后再稍微深入了解一下。
前面定义好了struct timer_list对象，接下来就需要初始化该对象。
调用函数init_timer进行初步初始化。
然后对结构体中的一些成员进行赋值：
  init_timer(&dump_t);
  dump_t.function = dump_function;
  dump_t.data = (unsigned long) my_dev;
  dump_t.expires = jiffies + HZ;    // 1秒钟之后timer被激活，如果是n秒，将HZ改为n*HZ。注意单位是tick
这样就OK了么？
当然没有，需要把timer加到timer list中，也就是要告诉系统，你申请了这么一个timer。
  add_timer(&dump_t);

现在不明白的地方就是timer到了，干活的地方，即dump_function函数。
函数声明：
static void dump_function(unsigned long channel);
其中的实现么，就随意了，看你想让这个timer干些什么活。
注意一点，这个timer只会响应一次，因为jiffies + HZ时间点只有一个。
如果想让此timer周期性地干活，就需要在dump_function函数中重新启动该timer。
启动方法：
del_timer(&dump_t);
dump_t.function = dump_function;
dump_t.data = (unsigned long) mydev;
dump_t.expires = jiffies + HZ;
add_timer(&dump_t);

使用方法至此基本上介绍完了。
下面看看timer的具体实现。

先看看struct timer_list的定义：
struct timer_list {
/*
* All fields that change during normal runtime grouped to the
* same cacheline
*/
struct list_head entry;
unsigned long expires;
struct tvec_base *base;

void (*function)(unsigned long);
unsigned long data;

int slack;

#ifdef CONFIG_TIMER_STATS
int start_pid;
void *start_site;
char start_comm[16];
#endif
#ifdef CONFIG_LOCKDEP
struct lockdep_map lockdep_map;
#endif
};

init_timer的定义：
#define init_timer(timer)
do {
  static struct lock_class_key __key;
  init_timer_key((timer), #timer, &__key);
} while (0)

/**
* init_timer_key - initialize a timer
* @timer: the timer to be initialized
* @name: name of the timer
* @key: lockdep class key of the fake lock used for tracking timer
*       sync lock dependencies
*
* init_timer_key() must be done to a timer prior calling *any* of the
* other timer functions.
*/
void init_timer_key(struct timer_list *timer,
      const char *name,
      struct lock_class_key *key)
{
debug_init(timer);
__init_timer(timer, name, key);
}

static inline void debug_init(struct timer_list *timer)
{
debug_timer_init(timer);
trace_timer_init(timer);
}

static inline void debug_timer_init(struct timer_list *timer)
{
debug_object_init(timer, &timer_debug_descr);
}

/**
* debug_object_init - debug checks when an object is initialized
* @addr: address of the object
* @descr: pointer to an object specific debug description structure
*/
void debug_object_init(void *addr, struct debug_obj_descr *descr)
{
if (!debug_objects_enabled)
return;

__debug_object_init(addr, descr, 0);
}

static void
__debug_object_init(void *addr, struct debug_obj_descr *descr, int onstack)
{
enum debug_obj_state state;
struct debug_bucket *db;
struct debug_obj *obj;
unsigned long flags;

fill_pool();

db = get_bucket((unsigned long) addr);

raw_spin_lock_irqsave(&db->lock, flags);

obj = lookup_object(addr, db);
if (!obj) {
  obj = alloc_object(addr, db, descr);
  if (!obj) {
   debug_objects_enabled = 0;
   raw_spin_unlock_irqrestore(&db->lock, flags);
   debug_objects_oom();
   return;
  }
  debug_object_is_on_stack(addr, onstack);
}

switch (obj->state) {
case ODEBUG_STATE_NONE:
case ODEBUG_STATE_INIT:
case ODEBUG_STATE_INACTIVE:
obj->state = ODEBUG_STATE_INIT;
break;

case ODEBUG_STATE_ACTIVE:
  debug_print_object(obj, "init");
  state = obj->state;
  raw_spin_unlock_irqrestore(&db->lock, flags);
  debug_object_fixup(descr->fixup_init, addr, state);
  return;

case ODEBUG_STATE_DESTROYED:
  debug_print_object(obj, "init");
  break;
default:
  break;
}

raw_spin_unlock_irqrestore(&db->lock, flags);
}

static void __init_timer(struct timer_list *timer,
const char *name,
struct lock_class_key *key)
{
timer->entry.next = NULL;
timer->base = __raw_get_cpu_var(tvec_bases);
timer->slack = -1;
#ifdef CONFIG_TIMER_STATS
timer->start_site = NULL;
timer->start_pid = -1;
memset(timer->start_comm, 0, TASK_COMM_LEN);
#endif
lockdep_init_map(&timer->lockdep_map, name, key, 0);
}

对下面这个东东比较感兴趣：
timer->base = __raw_get_cpu_var(tvec_bases);

看看__raw_get_cpu_var的实现，其中SMP和非SMP有差别。
SMP的情况：
#define __raw_get_cpu_var(var) (*__this_cpu_ptr(&(var)))
非SMP的情况：
#define __raw_get_cpu_var(var) (*VERIFY_PERCPU_PTR(&(var)))

先看简单的：
#define VERIFY_PERCPU_PTR(__p) ({
__verify_pcpu_ptr((__p));
(typeof(*(__p)) __kernel __force *)(__p);
})

* Macro which verifies @ptr is a percpu pointer without evaluating
* @ptr. This is to be used in percpu accessors to verify that the
* input parameter is a percpu pointer.
*/
#define __verify_pcpu_ptr(ptr) do {
const void __percpu *__vpp_verify = (typeof(ptr))NULL;
(void)__vpp_verify;
} while (0)

再看看__this_cpu_ptr：
#define __this_cpu_ptr(ptr) SHIFT_PERCPU_PTR(ptr, __my_cpu_offset)

/*
* Add a offset to a pointer but keep the pointer as is.
*
* Only S390 provides its own means of moving the pointer.
*/
#ifndef SHIFT_PERCPU_PTR
/* Weird cast keeps both GCC and sparse happy. */
#define SHIFT_PERCPU_PTR(__p, __offset) ({
__verify_pcpu_ptr((__p));
RELOC_HIDE((typeof(*(__p)) __kernel __force *)(__p), (__offset));
})
#endif

又合二为一了。

init先看到这，还是一头雾水，先把代码整理出来，以后学习用。

下面看看add_timer的实现。
/**
* add_timer - start a timer
* @timer: the timer to be added
*
* The kernel will do a ->function(->data) callback from the
* timer interrupt at the ->expires point in the future. The
* current time is 'jiffies'.
*
* The timer's ->expires, ->function (and if the handler uses it, ->data)
* fields must be set prior calling this function.
*
* Timers with an ->expires field in the past will be executed in the next
* timer tick.
*/
void add_timer(struct timer_list *timer)
{
BUG_ON(timer_pending(timer));
mod_timer(timer, timer->expires);
}

/**
* timer_pending - is a timer pending?
* @timer: the timer in question
*
* timer_pending will tell whether a given timer is currently pending,
* or not. Callers must ensure serialization wrt. other operations done
* to this timer, eg. interrupt contexts, or other CPUs on SMP.
*
* return value: 1 if the timer is pending, 0 if not.
*/
static inline int timer_pending(const struct timer_list * timer)
{
return timer->entry.next != NULL;
}

/**
* mod_timer - modify a timer's timeout
* @timer: the timer to be modified
* @expires: new timeout in jiffies
*
* mod_timer() is a more efficient way to update the expire field of an
* active timer (if the timer is inactive it will be activated)
*
* mod_timer(timer, expires) is equivalent to:
*
* del_timer(timer); timer->expires = expires; add_timer(timer);
*
* Note that if there are multiple unserialized concurrent users of the
* same timer, then mod_timer() is the only safe way to modify the timeout,
* since add_timer() cannot modify an already running timer.
*
* The function returns whether it has modified a pending timer or not.
* (ie. mod_timer() of an inactive timer returns 0, mod_timer() of an
* active timer returns 1.)
*/
int mod_timer(struct timer_list *timer, unsigned long expires)
{
expires = apply_slack(timer, expires);

/*
* This is a common optimization triggered by the
* networking code - if the timer is re-modified
* to be the same thing then just return:
*/
if (timer_pending(timer) && timer->expires == expires)
return 1;

return __mod_timer(timer, expires, false, TIMER_NOT_PINNED);
}

/*
* Decide where to put the timer while taking the slack into account
*
* Algorithm:
*   1) calculate the maximum (absolute) time
*   2) calculate the highest bit where the expires and new max are different
*   3) use this bit to make a mask
*   4) use the bitmask to round down the maximum time, so that all last
*      bits are zeros
*/
static inline
unsigned long apply_slack(struct timer_list *timer, unsigned long expires)
{
unsigned long expires_limit, mask;
int bit;

if (timer->slack >= 0) {
expires_limit = expires + timer->slack;
} else {
long delta = expires - jiffies;

if (delta < 256)
return expires;

expires_limit = expires + delta / 256;
}
mask = expires ^ expires_limit;
if (mask == 0)
return expires;

bit = find_last_bit(&mask, BITS_PER_LONG);

mask = (1 << bit) - 1;

expires_limit = expires_limit & ~(mask);

return expires_limit;
}

static inline int
__mod_timer(struct timer_list *timer, unsigned long expires,
bool pending_only, int pinned)
{
struct tvec_base *base, *new_base;
unsigned long flags;
int ret = 0 , cpu;

timer_stats_timer_set_start_info(timer);
BUG_ON(!timer->function);

base = lock_timer_base(timer, &flags);

if (timer_pending(timer)) {
  detach_timer(timer, 0);
  if (timer->expires == base->next_timer &&
      !tbase_get_deferrable(timer->base))
   base->next_timer = base->timer_jiffies;
  ret = 1;
} else {
  if (pending_only)
   goto out_unlock;
}

debug_activate(timer, expires);

cpu = smp_processor_id();

#if defined(CONFIG_NO_HZ) && defined(CONFIG_SMP)
if (!pinned && get_sysctl_timer_migration() && idle_cpu(cpu))
cpu = get_nohz_timer_target();
#endif
new_base = per_cpu(tvec_bases, cpu);

if (base != new_base) {
  /*
   * We are trying to schedule the timer on the local CPU.
   * However we can't change timer's base while it is running,
   * otherwise del_timer_sync() can't detect that the timer's
   * handler yet has not finished. This also guarantees that
   * the timer is serialized wrt itself.
   */
  if (likely(base->running_timer != timer)) {
   /* See the comment in lock_timer_base() */
   timer_set_base(timer, NULL);
   spin_unlock(&base->lock);
   base = new_base;
   spin_lock(&base->lock);
   timer_set_base(timer, base);
  }
}

timer->expires = expires;
if (time_before(timer->expires, base->next_timer) &&
!tbase_get_deferrable(timer->base))
base->next_timer = timer->expires;
internal_add_timer(base, timer);

out_unlock:
spin_unlock_irqrestore(&base->lock, flags);

return ret;
}

太多了，不一一看了，只看internal_add_timer。

static void internal_add_timer(struct tvec_base *base, struct timer_list *timer)
{
unsigned long expires = timer->expires;
unsigned long idx = expires - base->timer_jiffies;
struct list_head *vec;

if (idx < TVR_SIZE) {
  int i = expires & TVR_MASK;
  vec = base->tv1.vec + i;
} else if (idx < 1 << (TVR_BITS + TVN_BITS)) {
  int i = (expires >> TVR_BITS) & TVN_MASK;
  vec = base->tv2.vec + i;
} else if (idx < 1 << (TVR_BITS + 2 * TVN_BITS)) {
  int i = (expires >> (TVR_BITS + TVN_BITS)) & TVN_MASK;
  vec = base->tv3.vec + i;
} else if (idx < 1 << (TVR_BITS + 3 * TVN_BITS)) {
  int i = (expires >> (TVR_BITS + 2 * TVN_BITS)) & TVN_MASK;
  vec = base->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 = base->tv1.vec + (base->timer_jiffies & TVR_MASK);
} else {
  int i;
  /* If the timeout is larger than 0xffffffff on 64-bit
   * architectures then we use the maximum timeout:
   */
  if (idx > 0xffffffffUL) {
   idx = 0xffffffffUL;
   expires = idx + base->timer_jiffies;
  }
  i = (expires >> (TVR_BITS + 3 * TVN_BITS)) & TVN_MASK;
  vec = base->tv5.vec + i;
}
/*
* Timers are FIFO:
*/
list_add_tail(&timer->entry, vec);
}

/**
* list_add_tail - add a new entry
* @new: new entry to be added
* @head: list head to add it before
*
* Insert a new entry before the specified head.
* This is useful for implementing queues.
*/
static inline void list_add_tail(struct list_head *new, struct list_head *head)
{
__list_add(new, head->prev, head);
}

__list_add的实现就比较简单了，基本链表操作。