[原创]中断下半部分析(tasklet)

lullaby2005

v\:* {behavior:url(#default#VML);}
o\:* {behavior:url(#default#VML);}
w\:* {behavior:url(#default#VML);}
.shape {behavior:url(#default#VML);}

  Normal
  0
  
  7.8 磅
  0
  2
  
  false
  false
  false
  
   
   
   
   
   
   
   
   
   
   
   
   
  
  MicrosoftInternetExplorer4



/* Style Definitions */
table.MsoNormalTable
        {mso-style-name:普通表格;
        mso-tstyle-rowband-size:0;
        mso-tstyle-colband-size:0;
        mso-style-noshow:yes;
        mso-style-parent:"";
        mso-padding-alt:0cm 5.4pt 0cm 5.4pt;
        mso-para-margin:0cm;
        mso-para-margin-bottom:.0001pt;
        mso-pagination:widow-orphan;
        font-size:10.0pt;
        font-family:"Times New Roman";
        mso-ansi-language:#0400;
        mso-fareast-language:#0400;
        mso-bidi-language:#0400;}
中断下半部分析(tasklet)
/*本文系lullaby2005.cublog.cn原创，如果建议或问题请发到lullaby2005@gmail.com指正交流，谢谢！*/

一、为什么要进入tasklet
我们在softirq的文章中分析过，在SMP系统中，任何一个处理器在响应外设中断请求，完成中断上半部处理后，都可以调用函数do_softirq()来处理构建在softirq机制上的下半部。也就是说，softirq处理函数在SMP系统中是可以并行执行的，这要求使用softirq机制的下半部必须是多处理器可重入的。这对于一般的驱动程序开发者而言，
事情会变得复杂化、难度增大。为了降低驱动开发难度必须提供一套有效的机制，tasklet就是为了解决这一问题而出现的。

二、tasklet实现分析
1.      
一个实例
#include
#include
#include
#include
#include
#include
#include

static struct tasklet_struct
my_tasklet;  /*定义自己的tasklet_struct变量*/

static void tasklet_handler (unsigned long
data)
{
      
printk(KERN_ALERT “tasklet_handler is running.\n”);
}

static int __init test_init(void)
{
      
tasklet_init(&my_tasklet, tasklet_handler, 0); /*挂入钩子函数tasklet_handler*/
      
tasklet_schedule(&my_tasklet); /* 触发softirq的TASKLET_SOFTIRQ,在下一次运行softirq时运行这个tasklet*/  
      
return 0;
}

static void __exit test_exit(void)
{
      
tasklet_kill(&my_tasklet); /*禁止该tasklet的运行*/
      
printk(KERN_ALERT “test_exit running.\n”);
}
MODULE_LICENSE(“GPL”);

module_init(test_init);
module_exit(test_exit);

运行结果如图：



2.      
实现分析
我们就从上面这个实例入手来分析tasklet的实现，
在init中，通过函数tasklet_init()来初始化自己需要注册到系统中的tasklet结构：
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_struct的各个字段，挂上钩子函数。

然后，通过函数tasklet_schedule()来触发该tasklet
static inline void tasklet_schedule(struct
tasklet_struct *t)
{
        /*如果需要调度的tasklet的state不为TASKLET_STATE_SCHED，则触发之。这样，就保证了多个cpu不可能同时运行同一个tasklet，因为如果一个tasklet被调度过一次，那么它的state字段就会被设置TASKLET_STATE_SCHED标记，然后插入per-cpu变量的链表中。如果这时另外一个cpu也去调度该tasklet，那么就会在下面的if语句中被挡掉，不会运行到__tasklet_schedule()，从而不会插入到另外这个cpu的per-cpu变量的链表中，就不会被运行到。所以这里是保证了tasklet编写的函数不用是可重入的，这样就方便了编程人员。(注意，softirq机制需要编写可重入的函数)*/
       if
(!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
              __tasklet_schedule(t);
}

我们来看__tasklet_schedule()的实现：
void fastcall __tasklet_schedule(struct
tasklet_struct *t)
{
       unsigned
long flags;

       local_irq_save(flags);
        /*把需要添加进系统的自己编写的struct tasklet_struc加入
        到per-cpu变量tasklet_vec的本地副本的链表的表头中*/
       t->next
= __get_cpu_var(tasklet_vec).list;
       __get_cpu_var(tasklet_vec).list
= t;
       raise_softirq_irqoff(TASKLET_SOFTIRQ);
/*触发softirq的TASKLET_SOFTIRQ*/  
       local_irq_restore(flags);
}
这段代码也非常简单，只是把自己要注册到系统中的tasklet_struct挂入到per-cpu变量tasklet_vec的list中而已，这里是挂到链表首部。因为需要修改per-cpu变量tasklet_vec的list的值，为了防止中断处理程序也去修改这个值，所以要加自旋锁，为了保持数据的一致性。
然后通过raise_softirq_irqoff()设置低优先级的tasklet对应的softirq标记，以便cpu在运行softirq的时候运行到tasklet，因为tasklet是凌驾在softirq机制之上的。

OK，这里就完成了我们自己的my_tasklet的注册和触发对应的softirq，那我们现在就应该分析tasklet的运行了。
我们前面提到，tasklet是凌驾在softirq机制之上的。还记得前面说到了Linux中有六种softirq，优先级最高的是HI_SOFTIRQ，优先级最低的是TASKLET_SOFTIRQ,一般情况下我们是利用TASKLET_SOFTIRQ来实现tasklet的功能。
       open_softirq(TASKLET_SOFTIRQ,
tasklet_action, NULL);中定义了处理tasklet的处理函数tasklet_action.所以我们要分析这个函数的实现：

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

       /*把per-cpu变量tasklet_vec的本地副本上的list设置为NULL,
       由于这里要修改per-cpu变量，为了防止中断处理程序
       或者内核抢占造成该数据的不一致性，所以这里禁止中断再修改数据
       ，然后再开启中断.(注意，关闭本地中断的副作用就是禁止内核抢占，
       因为内核抢占只有两个时间点: 1.中断返回到内核态;2.手动使能内核抢占。
       明显程序员不会在临界区内手动使能内核抢占，所以关闭本地中断的
       副作用就是禁止内核抢占)*/
       local_irq_disable();
       list
= __get_cpu_var(tasklet_vec).list;
       __get_cpu_var(tasklet_vec).list
= NULL;
       local_irq_enable();

       /*遍历tasklet链表，让链表上挂入的函数全部执行完成*/
       while
(list) {
              struct
tasklet_struct *t = list;

              list
= list->next;

              if
(tasklet_trylock(t)) {
                     if
(!atomic_read(&t->count)) {
                            if
(!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))
                                   BUG();
                            t->func(t->data);
/*真正运行user注册的tasklet函数的地方*/
                            tasklet_unlock(t);
                            continue;
                     }
                     tasklet_unlock(t);
              }

              /*这里相当于把tasklet的list指针从链表中后移了(可以自行画图分析),
              所以刚才运行过的tasklet回调函数以后不会再次运行，除非用于再次
              通过tasklet_schedule()注册之*/
              local_irq_disable();
              t->next
= __get_cpu_var(tasklet_vec).list;
              __get_cpu_var(tasklet_vec).list
= t;
              __raise_softirq_irqoff(TASKLET_SOFTIRQ);  /*再一次触发tasklet对应的softirq，使下次系统运行softirq时能运行到tasklet*/
              local_irq_enable();
       }
}
运行流程是不是很简单呢？呵呵。只要注意到加锁的时机就OK了！


三、总结
Tasklet与一般的softirq的比较重要的一个区别在于: softirq处理函数需要被编写成可重入的，因为多个cpu可能同时执行同一个softirq处理函数，为了防止数据出现不一致性，所以softirq的处理函数必须被编写成可重入。最典型的就是要在softirq处理函数中用spinlock保护一些共享资源。而tasklet机制本身就保证了tasklet处理函数不会同时被多个cpu调度到。因为在tasklet_schedule()中，就保证了多个cpu不可能同时调度到同一个tasklet处理函数，这样tasklet就不用编写成可重入的处理函数，这样就大大减轻了kernel编程人员的负担。


本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u1/38534/showart_1904316.html