中断处理的 tasklet 机制

中断处理的 tasklet 机制
中断服务程序一般都是在中断请求关闭的条件下执行的,以避免嵌套而使中断控制复杂化。但是，中断是一个随机事件，它随时会到来，如果关中断的时间太长，CPU就不能及时响应其他的中断请求，从而造成中断的丢失。因此，Linux内核的目标就是尽可能快的处理完中断请求，尽其所能把更多的处理向后推迟。
例如，假设一个数据块已经达到了网线，当中断控制器接受到这个中断请求信号时，Linux内核只是简单地标志数据到来了，然后让处理器恢复到它以前运行的状态，其余的处理稍后再进行（如把数据移入一个缓冲区，接受数据的进程就可以在缓冲区找到数据）。
因此，内核把中断处理分为两部分：上半部（tophalf）和下半部（bottomhalf），上半部（就是中断服务程序）内核立即执行，而下半部（就是一些内核函数）留着稍后处理。

首先，一个快速的“上半部”来处理硬件发出的请求，它必须在一个新的中断产生之前终止。通常，除了在设备和一些内存缓冲区（如果你的设备用到了DMA，就不止这些）之间移动或传送数据，确定硬件是否处于健全的状态之外，这一部分做的工作很少。

下半部运行时是允许中断请求的，而上半部运行时是关中断的，这是二者之间的主要区别。

但是，内核到底什时候执行下半部，以何种方式组织下半部？这就是我们要讨论的下半部实现机制，这种机制在内核的演变过程中不断得到改进，在以前的内核中，这个机制叫做bottomhalf(简称bh)，在2.4以后的版本中有了新的发展和改进，改进的目标使下半部可以在多处理器上并行执行，并有助于驱动程序的开发者进行驱动程序的开发。下面主要介绍常用的小任务(Tasklet)机制及2.6内核中的工作队列机制。

小任务机制   

这里的小任务是指对要推迟执行的函数进行组织的一种机制。其数据结构为tasklet_struct，每个结构代表一个独立的小任务，其定义如下：
struct tasklet_struct {
    struct tasklet_struct *next;    //链表中的下一个tasklet
    unsigned long state;            //tasklet的状态        
    atomic_t count;                 // 引用计数器
    void(*func) (unsigned long data);    //tasklet处理函数             
    unsigned long data;             //给tasklet处理函数的参数     
}；
结构中的func域就是下半部中要推迟执行的函数，data是它唯一的参数。
state参数：TASKLET_STATE_SCHED、 TASKLET_STATE_RUN之间一个
在src/linux/interrupt.h 定义了上述
 enum
 {
    /* Tasklet is scheduled for execution tasklet，正准备投入运行*/
   TASKLET_STATE_SCHED, 

   /* Tasklet is running (SMP only) tasklet正在运行*/
   TASKLET_STATE_RUN 
 };
域的取值为 TASKLET_STATE_SCHED 或 TASKLET_STATE_RUN。
TASKLET_STATE_SCHED 表示小任务已被调度，正准备投入运行;
TASKLET_STATE_RUN 表示小任务正在运行。
TASKLET_STATE_RUN 只有在多处理器系统上才使用，单处理器系统什么时候都清楚一个小任务是不是正在运行（它要么就是当前正在执行的代码，要么不是）。


count域是小任务的引用计数器。如果它不为 0 ，则小任务被禁止，不允许执行；只有当它为零，小任务才被激活，并且在被设置为挂起时，小任务才能够执行。


1. 声明和使用小任务大多数情况下，为了控制一个寻常的硬件设备，小任务机制是实现下半部的最佳选择。小任务可以动态创建，使用方便，执行起来也比较快。

我们既可以静态地创建小任务，也可以动态地创建它。选择那种方式取决于到底是想要对小任务进行直接引用还是一个间接引用。如果准备静态地创建一个小任务（也就是对它直接引用），使用下面两个宏中的一个：
DECLARE_TASKLET(name,func, data)         //引用计数器count=0,激活状态

#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

DECLARE_TASKLET_DISABLED(name,func, data)//引用计数器count=1，禁止状态这里的data是unsigned long类型，传入 void func(unsigned long p)函数中
#define DECLARE_TASKLET_DISABLED(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(1), func, data }

这两个宏都能根据给定的名字静态地创建一个tasklet_struct结构。当该小任务被调度以后，给定的函数func会被执行，它的参数由data给出。这两个宏之间的区别在于引用计数器的初始值设置不同。第一个宏把创建的小任务的引用计数器设置为0，因此，该小任务处于激活状态。另一个把引用计数器设置为1，所以该小任务处于禁止状态。例如：
DECLARE_TASKLET(my_tasklet,my_tasklet_handler, dev);

这行代码其实等价于
struct tasklet_struct my_tasklet = { NULL, 0, ATOMIC_INIT(0),tasklet_handler,dev};

这样就创建了一个名为 my_tasklet 的小任务，其处理程序为 tasklet_handler，并且已被激活。当处理程序被调用的时候， dev 就会被传递给它。


动态创建
src/kernel/softirq.c
void tasklet_init( struct tasklet_struct *t,
                   void (*func)(unsigned long),
                   unsigned long data);
初始化 tasklet_struct 结构体，将引用计数器count=0，和状态state=0。

struct tasklet_struct my_tasklet;
tasklet_init(&my_tasklet,myfunc,data);//动态创建


2.  编写自己的小任务处理程序小任务处理程序必须符合如下的函数类型：
void tasklet_handler(unsigned long data)
由于小任务不能睡眠，因此不能在小任务中使用信号量或者其它产生阻塞的函数。但是小任务运行时可以响应中断。

3. 调度自己的小任务通过调用tasklet_schedule()函数并传递给它相应的tasklt_struct指针，该小任务就会被调度以便适当的时候执行：
tasklet_schedule(&my_tasklet); msleep(1)     
tasklet_schedule(&my_tasklet); msleep(1)    
tasklet_schedule(&my_tasklet); msleep(1)    
在小任务被调度以后，只要有机会它就会尽可能早的运行。
在它还没有得到运行机会之前，如果一个相同的小任务又被调度了，那么它仍然只会运行一次。

可以调用tasklet_disable()函数来禁止某个指定的小任务。如果该小任务当前正在执行，这个函数会等到它执行完毕再返回。调用tasklet_enable()函数可以激活一个小任务，如果希望把以DECLARE_TASKLET_DISABLED（）创建的小任务激活，也得调用这个函数，如：
tasklet_disable(&my_tasklet);        
tasklet_enable(&my_tasklet);   

也可以调用tasklet_kill()函数从挂起的队列中去掉一个小任务。该函数的参数是一个指向某个小任务的tasklet_struct的长指针。在小任务重新调度它自身的时候，从挂起的队列中移去已调度的小任务会很有用。这个函数首先等待该小任务执行完毕，然后再将它移去。

4.tasklet的简单用法     

下面是tasklet的一个简单应用,以模块的形成加载。


#include <linux/module.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/kdev_t.h>
#include <linux/cdev.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>

static struct  tasklet_struct my_tasklet;

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_schedule(&my_tasklet);

        return0;
}

static  void __exit test_exit(void)
{
        tasklet_kill(&tasklet);
        printk(KERN_ALERT,"test_exit is running.\n");
}
MODULE_LICENSE("GPL");

module_init(test_init);
module_exit(test_exit);

从这个例子可以看出，所谓的小任务机制是为下半部函数的执行提供了一种执行机制，也就是说，推迟处理的事情是由tasklet_handler实现，何时执行，经由小任务机制封装后交给内核去处理。

使用tasklet处理中断事例

#include <linux/module.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/sched.h>
#include <linux/irq.h>
#include <asm/io.h>

#define INTRNO 7

static void tasklet_callback(unsigned long data)
{
        printk(KERN_ALERT "received a interrupt.\n");
}

DECLARE_TASKLET(tasklet, tasklet_callback, 0);

static irqreturn_t irq_handler(int irq, void *arg)
{
        tasklet_schedule(&tasklet);

        return IRQ_HANDLED;
}

static int __init test_init(void)
{
        int ret;

        ret = request_irq(INTRNO, irq_handler, 0, "hello", NULL);
        if (ret < 0)
                goto err;

        outb(0x10, 0x37a);
err:
        return ret;
}

static void __exit test_exit(void)
{
        free_irq(INTRNO, NULL);
}

MODULE_LICENSE("GPL");

module_init(test_init);
module_exit(test_exit);


为了最大程度的避免中断处理时间过长而导致中断丢失，有时候我们需要把一些在中断处理中不是非常紧急的任务放在后面执行，而让中断处理程序尽快返回。在老版本的 linux 中通常将中断处理分为 top half handler 、 bottom half handler 。利用 top half handler 处理中断必须处理的任务，而 bottom half handler 处理不是太紧急的任务。
但是 linux2.6 以后的 linux 采取了另外一种机制，就是软中断来代替 bottom half handler 的处理。而 tasklet 机制正是利用软中断来完成对驱动 bottom half 的处理。 Linux2.6 中软中断通常只有固定的几种： HI_SOFTIRQ( 高优先级的 tasklet ，一种特殊的 tasklet) 、 TIMER_SOFTIRQ （定时器）、 NET_TX_SOFTIRQ （网口发送）、 NET_RX_SOFTIRQ （网口接收） 、 BLOCK_SOFTIRQ （块设备）、 TASKLET_SOFTIRQ （普通 tasklet ）。当然也可以通过直接修改内核自己加入自己的软中断，但是一般来说这是不合理的，软中断的优先级比较高，如果不是在内核处理频繁的任务不建议使用。通常驱动用户使用 tasklet 足够了。

　软中断和 tasklet 的关系如下图：

                     软中断列表                                                   
   ----------        -------------------                                          
  |内核线程  |历遍   |sint0 |  scation0|                                          
  |          |------>|------------------                                          
  |ksoftirqd |       |sint1 |  scation1|                                          
  |----------        |------------------                                          
                     |sint2 |  scation2|                                          
                     |------------------                                          
                     |sint3 |  scation3|                                          
                     |------------------              Tasklet_vec链表             
                     |sint4 |  scation4|           ----------      ----------     
                     |------------------           |         |     |         |    
                     |tasklet | tasklet|  ----->   |tasklet0 | --->| tasklet1|--->
                     |        |  hander|           |         |     |         |      
                     |------------------            ---------       ---------     
                                                       |               |          
                                                   -----------     -----------       
                                                   |         |     |         |       
                                                   | hander0 |     | hander1 |--->
                                                   |         |     |         |    
                                                    ---------      -----------   

上图可以看出， ksoftirqd 是一个后台运行的内核线程，它会周期的遍历软中断的向量列表，如果发现哪个软中断向量被挂起了（ pend ），就执行对应的处理函数，对于 tasklet 来说，此处理函数就是 tasklet_action ，这个处理函数在系统启动时初始化软中断的就挂接了。

　　Tasklet_action 函数，遍历一个全局的 tasklet_vec 链表（此链表对于 SMP 系统是每个 CPU 都有一个），此链表中的元素为 tasklet_struct 。此结构如下 :

　　struct tasklet_struct

　　{

　　struct tasklet_struct *next;

　　unsigned long state;

　　atomic_t count;

　　void (*func)(unsigned long);

　　unsigned long data;

　　};

　　每个结构一个函数指针，指向你自己定义的函数。当我们要使用 tasklet ，首先新定义一个 tasklet_struct 结构，并初始化好要执行函数指针，然后将它挂接到 task_vec 链表中，并发一个软中断就可以等着被执行了。

　　原理大概如此，对于 linux 驱动的作者其实不需要关心这些，关键是我们如何去使用 tasklet 这种机制。

　　Linux 中提供了如下接口：

　　DECLARE_TASKLET(name,function,data) ：此接口初始化一个 tasklet ；其中 name 是 tasklet 的名字， function 是执行 tasklet 的函数； data 是 unsigned long 类型的 function 参数。

　　static inline void tasklet_schedule(struct tasklet_struct *t) ：此接口将定义后的 tasklet 挂接到 cpu 的 tasklet_vec 链表，具体是哪个 cpu 的 tasklet_vec 链表，是根据当前线程是运行在哪个 cpu 来决定的。此函数不仅会挂接 tasklet ，而且会起一个软 tasklet 的软中断 , 既把 tasklet 对应的中断向量挂起 (pend) 。

　　两个工作完成后，基本上可以了， tasklet 机制并不复杂，很容易的使程序尽快的响应中断，避免造成中断丢失。