linux中断延迟之tasklet

转自:http://blog.csdn.net/bullbat/article/details/7101140

 

tasklet是I/O驱动程序中实现可延迟函数的首选方法。从下面的内核代码的分析中我们会看到，tasklet建立在两个叫做HI_SOFTIRQ和TASKLET_SOFTIRQ的软中断之上。几个tasklet可以与同一个软中断相关联，每个tasklet执行自己的函数。tasklet和高优先级的tasklet分别存放在tasklet_vec和tasklet_hi_vec数组中。下面我们结合具体的代码来了解他的实现和运用。

tasklet的内核实现

在start_kernel函数做内核初始化工作的时候会调用函数softirq_init

[cpp] view plain copy print ?

1. void __init softirq_init(void) 
2. { 
3.     int cpu; 
4.  
5.     for_each_possible_cpu(cpu) { 
6.         int i; 
7.         /*对tasklet相关pcp变量的初始化*/ 
8.         per_cpu(tasklet_vec, cpu).tail = 
9.             &per_cpu(tasklet_vec, cpu).head; 
10.         per_cpu(tasklet_hi_vec, cpu).tail = 
11.             &per_cpu(tasklet_hi_vec, cpu).head; 
12.         for (i = 0; i < NR_SOFTIRQS; i++) 
13.             INIT_LIST_HEAD(&per_cpu(softirq_work_list[i], cpu)); 
14.     } 
15.  
16.     register_hotcpu_notifier(&remote_softirq_cpu_notifier); 
17.     /*将tasklet 执行函数加入软中断向量中,
18.     这个执行函数会执行tasklet对应一个链表
19.     中的所有函数*/ 
20.     open_softirq(TASKLET_SOFTIRQ, tasklet_action); 
21.     open_softirq(HI_SOFTIRQ, tasklet_hi_action); 
22. } 

void __init softirq_init(void)
{
	int cpu;

	for_each_possible_cpu(cpu) {
		int i;
		/*对tasklet相关pcp变量的初始化*/
		per_cpu(tasklet_vec, cpu).tail =
			&per_cpu(tasklet_vec, cpu).head;
		per_cpu(tasklet_hi_vec, cpu).tail =
			&per_cpu(tasklet_hi_vec, cpu).head;
		for (i = 0; i < NR_SOFTIRQS; i++)
			INIT_LIST_HEAD(&per_cpu(softirq_work_list[i], cpu));
	}

	register_hotcpu_notifier(&remote_softirq_cpu_notifier);
	/*将tasklet 执行函数加入软中断向量中,
	这个执行函数会执行tasklet对应一个链表
	中的所有函数*/
	open_softirq(TASKLET_SOFTIRQ, tasklet_action);
	open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

open_softirq函数在前面我们已经分析过了，在这里可以看出，两类tasklet以一个软中断的方式加入软中断向量中，而这两种tasklet实际上位两个链表，就是上面的tasklet_hi_vec和tasklet_vec，我们看一个就行了，实现大同小异。

[cpp] view plain copy print ?

1. static void tasklet_action(struct softirq_action *a) 
2. { 
3.     struct tasklet_struct *list; 
4.  
5.     local_irq_disable();/*禁用本地中断*/ 
6.     list = __get_cpu_var(tasklet_vec).head;/*将链表的地址保存*/ 
7.     __get_cpu_var(tasklet_vec).head = NULL;/*已调度的tasklet描述符的链表被清空*/ 
8.     __get_cpu_var(tasklet_vec).tail = &__get_cpu_var(tasklet_vec).head; 
9.     local_irq_enable();/*打开本地中断*/ 
10.  
11.     while (list) {/*对于list链表的每个tasklet描述符*/ 
12.         struct tasklet_struct *t = list; 
13.  
14.         list = list->next; 
15.  
16.         if (tasklet_trylock(t)) { 
17.             /*通过查看tasklet描述符的count字段，
18.             检查tasklet是否被禁止*/ 
19.             if (!atomic_read(&t->count)) {/*如果没有禁止*/ 
20.                 /*清楚调度标志*/ 
21.                 if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state)) 
22.                     BUG(); 
23.                 t->func(t->data);/*执行对应函数*/ 
24.                 tasklet_unlock(t); 
25.                 continue;/*继续下一个*/ 
26.             } 
27.             tasklet_unlock(t); 
28.         } 
29.         /*运行到这里，表示tasklet被禁止*/ 
30.         local_irq_disable(); 
31.         t->next = NULL; 
32.         /*重新插入到链表中，然后再次激活软中断*/ 
33.         *__get_cpu_var(tasklet_vec).tail = t; 
34.         __get_cpu_var(tasklet_vec).tail = &(t->next); 
35.         /*这里的激活实际上设置位掩码pending
36.         的对应位，使其在软中断时能够被执行*/ 
37.         __raise_softirq_irqoff(TASKLET_SOFTIRQ); 
38.         local_irq_enable(); 
39.     } 
40. } 

static void tasklet_action(struct softirq_action *a)
{
	struct tasklet_struct *list;

	local_irq_disable();/*禁用本地中断*/
	list = __get_cpu_var(tasklet_vec).head;/*将链表的地址保存*/
	__get_cpu_var(tasklet_vec).head = NULL;/*已调度的tasklet描述符的链表被清空*/
	__get_cpu_var(tasklet_vec).tail = &__get_cpu_var(tasklet_vec).head;
	local_irq_enable();/*打开本地中断*/

	while (list) {/*对于list链表的每个tasklet描述符*/
		struct tasklet_struct *t = list;

		list = list->next;

		if (tasklet_trylock(t)) {
			/*通过查看tasklet描述符的count字段，
			检查tasklet是否被禁止*/
			if (!atomic_read(&t->count)) {/*如果没有禁止*/
				/*清楚调度标志*/
				if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
					BUG();
				t->func(t->data);/*执行对应函数*/
				tasklet_unlock(t);
				continue;/*继续下一个*/
			}
			tasklet_unlock(t);
		}
		/*运行到这里，表示tasklet被禁止*/
		local_irq_disable();
		t->next = NULL;
		/*重新插入到链表中，然后再次激活软中断*/
		*__get_cpu_var(tasklet_vec).tail = t;
		__get_cpu_var(tasklet_vec).tail = &(t->next);
		/*这里的激活实际上设置位掩码pending
		的对应位，使其在软中断时能够被执行*/
		__raise_softirq_irqoff(TASKLET_SOFTIRQ);
		local_irq_enable();
	}
}

可以看到，tasklet其实是软中断中两项，每一项对应的不是一个软中断函数，而是一个链表上的所有函数，在对应的软中断到来时，对应链表中的所有函数都将得到执行。而对于tasklet的唤醒其实就是设置pending位掩码的相应位，使软中断到来时会执行他。

tasklet的内核编程与应用

了解了tasklet的内核实现，对于他的应用就很简单了，首先，你应该分配一个新的tasklet_struct数据结构，并调用tasklet_init函数初始化它。

[cpp] view plain copy print ?

1. void tasklet_init(struct tasklet_struct *t, 
2.           void (*func)(unsigned long), unsigned long data) 
3. { 
4.     t->next = NULL; 
5.     t->state = 0; 
6.     atomic_set(&t->count, 0); 
7.     t->func = func; 
8.     t->data = data; 
9. } 

void tasklet_init(struct tasklet_struct *t,
		  void (*func)(unsigned long), unsigned long data)
{
	t->next = NULL;
	t->state = 0;
	atomic_set(&t->count, 0);
	t->func = func;
	t->data = data;
}

为了重新激活你的tasklet，调用tasklet_enable函数；

为了激活tasklet，根据自己tasklet需要的优先级，调用tasklet_schedule函数或tasklet_hi_schedule函数。我们也只看一个

[cpp] view plain copy print ?

1. static inline void tasklet_hi_schedule(struct tasklet_struct *t) 
2. { 
3.     /*标志位的检查*/ 
4.     if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) 
5.         __tasklet_hi_schedule(t); 
6. } 

static inline void tasklet_hi_schedule(struct tasklet_struct *t)
{
	/*标志位的检查*/
	if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
		__tasklet_hi_schedule(t);
}

[cpp] view plain copy print ?

1. void __tasklet_hi_schedule(struct tasklet_struct *t) 
2. { 
3.     unsigned long flags; 
4.  
5.     local_irq_save(flags); 
6.     t->next = NULL; 
7.     *__get_cpu_var(tasklet_hi_vec).tail = t; 
8.     __get_cpu_var(tasklet_hi_vec).tail = &(t->next); 
9.     /*激活对应softirq_vec[]数组中HI_SOFTIRQ下标
10.     的软中断，就是tasklet_hi_vec链表*/ 
11.     raise_softirq_irqoff(HI_SOFTIRQ); 
12.     local_irq_restore(flags); 
13. } 

void __tasklet_hi_schedule(struct tasklet_struct *t)
{
	unsigned long flags;

	local_irq_save(flags);
	t->next = NULL;
	*__get_cpu_var(tasklet_hi_vec).tail = t;
	__get_cpu_var(tasklet_hi_vec).tail = &(t->next);
	/*激活对应softirq_vec[]数组中HI_SOFTIRQ下标
	的软中断，就是tasklet_hi_vec链表*/
	raise_softirq_irqoff(HI_SOFTIRQ);
	local_irq_restore(flags);
}

实现了上面的几个操作流程，当软中断函数一旦被唤醒就由do_softirq函数来执行。