linux中断控制之tasklet

定义tasklet

定义于#include<linux/interrupt.h>  内核3.1.4

先看看tasklet的结构体

struct tasklet_struct

{

struct tasklet_struct *next;    //指向链表的下一个结构

unsigned long state;    //任务状态

atomic_t count;    //计数

void (*func)(unsigned long);    //处理函数

unsigned long data;    //传递参数

};

state的取值：

enum

{

TASKLET_STATE_SCHED, /* Tasklet is scheduled for execution */

TASKLET_STATE_RUN /* Tasklet is running ( SMP only) */

};

既可以静态创建，也可以动态创建。

如果静态创建一个tasklet，使用以下两个宏：

#define DECLARE_TASKLET(name, func, data) \

struct tasklet_struct name = { NULL, 0, ATOMIC_INIT( 0), func, data }    //激活状态

#define DECLARE_TASKLET_DISABLED(name, func, data) \

struct tasklet_struct name = { NULL, 0, ATOMIC_INIT( 1), func, data }    //禁止状态

动态创建：

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_head

{

struct tasklet_struct *head;

struct tasklet_struct **tail;

};

static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec);

static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec);

编写处理函数tasklet_handler

void tasklet_handler(unsigned long data)

因为是靠软中断实现，所以tasklet 不能睡眠。这意味着不能在tasklet中使用信号量或者其他阻塞函数。

tasklet运行时运行可以响应中断。

但如果tasklet和中断处理程序之间共享了某些数据的话，要做好预防工作。

调度tasklet

static inline void   tasklet_schedule(struct tasklet_struct *t)

{

if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))

__tasklet_schedule(t);

}

__tasklet_schedule()源码在kernel/softirq.c

void   __tasklet_schedule(struct tasklet_struct *t)

{

unsigned long flags;

local_irq_save(flags);

t->next = NULL;

*__this_cpu_read(tasklet_vec.tail) = t;

__this_cpu_write(tasklet_vec.tail, &(t->next));

raise_softirq_irqoff(TASKLET_SOFTIRQ);

local_irq_restore(flags);

}

EXPORT_SYMBOL(__tasklet_schedule);    //把内核函数的符号导出，符号的意思就是函数的入口地址，让其他地方可以调用

__tasklet_schedule(stuct tasklet_struct *t)的实现是通过 获取当前CPU的tasklet_vec链表，将需要调度的tasklet插入当前CPU的tasklet_vec链表头部，并执行TASKLET_SOFTIRQ软中断。

禁止/使能 删除tasklet

static inline void tasklet_disable_nosync(struct tasklet_struct *t)

{

atomic_inc(&t->count);

smp_mb__after_atomic_inc();

}

用来禁止指定的tasklet，不用等待tasklet执行完毕就返回，不过不安全

static inline void tasklet_disable(struct tasklet_struct *t)

{

tasklet_disable_nosync(t);

tasklet_unlock_wait(t);

smp_mb();

}

禁止某个指定的tasklet，如果该tasklet正在执行，会等待它执行完毕再返回

static inline void tasklet_enable(struct tasklet_struct *t)

{

smp_mb__before_atomic_dec();

atomic_dec(&t->count);

}

激活一个tasklet。

void tasklet_kill(struct tasklet_struct *t)

{

if (in_interrupt())

printk("Attempt to kill tasklet from interrupt\n");

while (test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) {

do {

yield();

} while (test_bit(TASKLET_STATE_SCHED, &t->state));

}

tasklet_unlock_wait(t);        //等待tasklet执行完毕，再去移除它，能引起休眠，禁止在中断上下文中使用

clear_bit(TASKLET_STATE_SCHED, &t->state);

}

从挂起的队列中去掉一个tasklet。

tasklet核心处理函数

static void tasklet_action(struct softirq_action *a)

{

struct tasklet_struct *list;

local_irq_disable();

list = __this_cpu_read(tasklet_vec.head);    //得到tasklet链表

__this_cpu_write(tasklet_vec.head, NULL);    //清空链表

__this_cpu_write(tasklet_vec.tail, &__get_cpu_var(tasklet_vec).head);

local_irq_enable();

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);

tasklet_unlock(t);

continue;

}

tasklet_unlock(t);    //以上保证了同一时间，相同类型的tasklet只能有一个执行

}

local_irq_disable();

t->next = NULL;

*__this_cpu_read(tasklet_vec.tail) = t;

__this_cpu_write(tasklet_vec.tail, &(t->next));

__raise_softirq_irqoff(TASKLET_SOFTIRQ);

local_irq_enable();

}

}

tasklet流程

驱动程序在初始化时，通过函数tasklet_init建立一个tasklet，然后调用函数tasklet_schedule将这个tasklet 放在 tasklet_vec链表的头部，并唤醒后台线程ksoftirqd。当后台线程ksoftirqd运行调用__do_softirq时，会执行在中断 向量表softirq_vec里中断号TASKLET_SOFTIRQ对应的tasklet_action函数，然后tasklet_action遍历 tasklet_vec链表，调用每个tasklet的函数完成软中断操作。

其中：ksoftirqd 是一个后台运行的内核线程，它会周期的遍历软中断的向量列表。

注意：

1.Tasklet 可被hi-schedule和一般schedule（调度），hi-schedule一定比一般shedule早运行

2.同一个Tasklet可同时被hi-schedule和一般schedule

3.同一个Tasklet若被同时hi-schedule多次，等同于只hi-shedule一次，因为，在tasklet未 运行时，hi-shedule同一tasklet无意义，会冲掉前一个tasklet

4.不同的tasklet不按先后shedule顺序运行，而是并行运行

5.Taskelet的hi-schedule 使用softirq 0, 一般schedule用softirq 30

tasklet是作为中断下半部的一个很好的选择，它在性能和易用性之间有着很好的平衡。较之于softirq，tasklet不需要考虑SMP下的并行问题，而又比workqueues有着更好的性能。

tasklet通常作为硬中断的下半部来使用，在硬中断中调用tasklet_schedule(t)。每次硬中断都会触发一次tasklet_schedule(t)，但是每次中断它只会向其中的一个CPU注册，而不是所有的CPU。

完成注册后的tasklet由tasklet_action()来执行，在SMP环境下，它保证同一时刻，同一个tasklet只有一个副本在运行，这样就避免了使用softirq所要考虑的互斥的问题。

再者，tasklet在执行tasklet->func()前，再一次允许tasklet可调度（注册），但是在该tasklet已有一个副本在其他CPU上运行的情况下，它只能退后执行。

总之，同一个硬中断引起的一个tasklet_schedule()动作只会使一个tasklet被注册，而不同中断引起的tasklet则可能在不同的时刻被注册而多次被执行。

用例

定义tasklet和底半部函数，并关联

void xxx_do_tasklet(unsigned long);

DECLARE_TASKLET(xxx_tasklet,xxx_do_tasklet,0);

中断处理底半部

void xxx_do_tasklet(unsigned long)

{

    ……

}

中断处理顶半部

irqreturn_t xxx_interrupt(int irq,void *dev_id)

{

      ……

      tasklet_schedule(&xxx_tasklet);    //调度tasklet

      ……

}

设备驱动加载模块

int __init xxx_init(void)

{

      ……

      result=request_irq(xxx_irq,xxx_interrupt,IRQF_DISABLED,”xxx”,NULL)

      ……

    return IRQ_HANDLED;

}

void __exit xxx_exit(void)

{

      ……

      free_irq(xxx_irq,xxx_irq_interrupt);

      ……

}