Linux中断分层--软中断和tasklet
1. Linux中断分层
（1）上半部：当中断发生时，它进行相应的硬件读写，并“登记”该中断。通常由中断处理程序充当上半部。（一般情况下，上半部不可被打断）
（2）下半部：在系统空闲的时候，对上半部“登记”的中断进行后续处理（“延迟处理”）
2. 对于中断下半部的实现方式一共有三种
（1）软中断
（2）tasklet微线程
（3）工作队列
3. Linux内核软中断分析
（1）当中断发生时，Linux内核会跳转到中断总入口函数asm_do_IRQ()，根据传入的中断号，执行相应handle_irq()函数。做完这些工作之后，会调用函数irq_exit()（位于文件：kernal/softirq.c），该函数负责调用和处理待决的软中断。
void irq_exit(void) { account_system_vtime(current); trace_hardirq_exit(); sub_preempt_count(IRQ_EXIT_OFFSET); if (!in_interrupt() && local_softirq_pending()) invoke_softirq(); #ifdef CONFIG_NO_HZ /* Make sure that timer wheel updates are propagated */ rcu_irq_exit(); if (idle_cpu(smp_processor_id()) && !in_interrupt() && !need_resched()) tick_nohz_stop_sched_tick(0); #endif preempt_enable_no_resched(); }
（2）invoke_softirq()是一个宏，等价于do_softirq()。调用do_softirq函数，就说明程序已经进入软中断环境了。与asm_do_IRQ所处的中断的上半部不同，处于软中断环境中，是可以被其他中断程序打断的，甚至是处于同一中断线的中断。也因为此，所以软中断可以执行一些稍微时间长一点的任务，也不会迟滞系统对中断的反应时间。
（3）软中断由一个softirq_action结构体表示，在该结构体中只定义了一个函数指针
struct softirq_action { void (*action)(struct softirq_action *); };
（4）Linux内核中用一个数据项为softirq_action类型的数组softirq_vec来存储所支持的所有软中断
static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;
（5）在驱动程序中，注册软中断使用函数open_softirq
void open_softirq(int nr, void (*action)(struct softirq_action *)) { softirq_vec[nr].action = action; }
（6）softirq_vec数组的下表代表不同类型的软中断，值越小，优先级越高，他们定义为一个枚举常量
enum { HI_SOFTIRQ=0, TIMER_SOFTIRQ, NET_TX_SOFTIRQ, NET_RX_SOFTIRQ, BLOCK_SOFTIRQ, TASKLET_SOFTIRQ, SCHED_SOFTIRQ, HRTIMER_SOFTIRQ, RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */ NR_SOFTIRQS };
（7）驱动程序所要做的工作是把软中断注册进去，而执行是do_softirq调用一个名为Ksoftirq的内核线程来完成。我们如果想要执行我们注册的软中断，还需要调用raise_softirq函数将我们想要执行的软中断处理程序挂起
void raise_softirq(unsigned int nr) { unsigned long flags; local_irq_save(flags); raise_softirq_irqoff(nr); local_irq_restore(flags); }
（8）相应类型的软中断被挂起之后，将会通过do_softirq得到执行
asmlinkage void do_softirq(void) { __u32 pending; unsigned long flags; if (in_interrupt()) return; local_irq_save(flags); pending = local_softirq_pending(); if (pending) __do_softirq(); local_irq_restore(flags); }
（9）do_softirq调用函数__do_softirq来真正执行软中断
asmlinkage void __do_softirq(void) { struct softirq_action *h; __u32 pending; int max_restart = MAX_SOFTIRQ_RESTART; int cpu; pending = local_softirq_pending(); account_system_vtime(current); __local_bh_disable((unsigned long)__builtin_return_address(0)); trace_softirq_enter(); cpu = smp_processor_id(); restart: /* Reset the pending bitmask before enabling irqs */ set_softirq_pending(0); local_irq_enable(); h = softirq_vec; do { if (pending & 1) { int prev_count = preempt_count(); h->action(h); if (unlikely(prev_count != preempt_count())) { printk(KERN_ERR "huh, entered softirq %td %p" "with preempt_count %08x," " exited with %08x?\n", h - softirq_vec, h->action, prev_count, preempt_count()); preempt_count() = prev_count; } rcu_bh_qsctr_inc(cpu); } h++; pending >>= 1; } while (pending); local_irq_disable(); pending = local_softirq_pending(); if (pending && --max_restart) goto restart; if (pending) wakeup_softirqd(); trace_softirq_exit(); account_system_vtime(current); _local_bh_enable(); }
4. Linux内核tasklet分析
（1）软中断是将操作推迟到将来某一个时刻执行的最有效的方法。由于该延迟机制处理复杂，多个处理器可以同时并且独立得处理（即do_softirq函数可以被多个CPU同时执行），并且一个软中断的处理程序可以在多个CPU上同时执行，因此处理程序必须要被设计为完全可重入和线程安全的。此外临界区必须用自旋锁保护。软中断因为这些原因显得太过于麻烦，因此引入tasklet机制。
（2）tasklet是基于软中断实现的，确切的说应该是软中断的一个类型。所以根据软中断的性质，一个软中断类型对应一个软中断处理程序action。同理，也可以推出tasklet也会对应于一个唯一的action。
（3）每一个CPU都会有自己独立的tasklet队列，虽然一个tasklet类型的软中断只对应一个action处理程序，但是我们可以在该处理程序中轮询执行一个tasklet队列，队列里面的每一个tasklet_struct都会对应一个tasklet处理函数，这样当我们的驱动程序中需要使用到tasklet的时候，只要往这个tasklet队列加入我们自定义的tasklet_struct对象就可以了。同时，由于每一个CPU都会有一个tasklet队列，并且每一个CPU只会执行自己tasklet队列里面的tasklet_struct对象，因此tasklet并不需要自旋锁的保护（当然这只能是对同一个tasklet而言，如果多个不同的tasklet需要使用同一资源的话，仍需要自旋锁的保护）。
（4）Linux内核通过一个tasklet_struct结构体来描述一个tasklet对象，该结构体定义在include\linux\interrupt.h文件中
struct tasklet_struct { struct tasklet_struct *next; unsigned long state; atomic_t count; void (*func)(unsigned long); unsigned long data; };
（5）tasklet的队列示意图
（5）Linux内核时通过名为tasklet_vec的tasklet_head结构体来组织tasklet对象的
struct tasklet_head { struct tasklet_struct *head; struct tasklet_struct **tail; };
head：指向第一个tasklet_struct结构体的指针
tail：指向tasklet队列最后一个tasklet_struct的next指针的地址
（6）如果tasklet队列没有元素，两个指针的指向是这样的
（7）向tasklet队列添加tasklet_struct对象，就是将最后一个tasklet_sturct的next指针指向新加的tasklet_struct对象，同时将列表头的tail指针的指针指向新加的tasklet_struct结构体的next指针的地址。代码如下
tasklet_struct * t; * _get_cpu_var(tasklet_vec).tail = t; _get_cpu_var(tasklet_vec).tail = &(t->next);
（8）tasklet类型的软中断唯一对应的action叫做tasklet_action（一般其他类型软中断的action都是由用户自己编写，但是tasklet不一样，Linux设计师已经帮我们实现了。所以也是因为这样，tasklet被广泛应用于驱动程序中）
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; __get_cpu_var(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); } local_irq_disable(); t->next = NULL; *__get_cpu_var(tasklet_vec).tail = t; __get_cpu_var(tasklet_vec).tail = &(t->next); __raise_softirq_irqoff(TASKLET_SOFTIRQ); local_irq_enable(); } }
（9）另一个tasklet非常重要的函数，就是tasklet_schedule，这个函数通常用于中断处理程序中，用于将tasklet_struct加入所在CPU的tasklet队列，同时将tasklet软中断挂起。
因为我们知道，在中断的上半部中的irq_exit函数中，会激活do_softirq函数，所以在中断处理程序中使用tasklet_schedule函数就显得特别必要。tasklet_schedule源代码如下，
static inline void tasklet_schedule(struct tasklet_struct *t) { if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state)) __tasklet_schedule(t); }
test_and_set_bit(TASKLET_STATE_SCHED, &t->state)：这个函数的目的是设置t->state的第TASKLET_STATE_SCHED（0）位，并返回t->state的第TASKLET_STATE_SCHED位原来的值。
（10）_tasklet_schedule函数：
void __tasklet_schedule(struct tasklet_struct *t) { unsigned long flags; local_irq_save(flags); t->next = NULL; *__get_cpu_var(tasklet_vec).tail = t; __get_cpu_var(tasklet_vec).tail = &(t->next); raise_softirq_irqoff(TASKLET_SOFTIRQ); local_irq_restore(flags); }
（11）我们驱动程序中若要使用tasklet，首先我们还必须要创建一个tasklet_struct对象，通常创建tasklet_struct对象一共有两种方式：
① 静态方式：
#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 }
② 动态方式：
static struct tasklet_struct my_tasklet; tasklet_init(&my_tasklet， tasklet_handler, 0); //count = 0，处于激活状态。
tasklet_init源码
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_schedule函数将tasklet对象加入到tasklet队列中即可。
