一、引言
当CPU收到一个中断时，会调用驱动程序中注册的中断处理程序，中断处理程序一般要先关闭中断，因为中断处理程序一般是不可重入的，此时CPU不会收到其他中断，无论是同类的中断还是其他类型中断，CPU也不能执行其他进程，意味着此时的CPU被中断处理程序独占了。
一般的中断处理过程如下：
1、硬件设备向CPU产生中断，并通知内核；
2、如果内核没有处理其他的中断，内核会处理该中断；
3、中断处理程序中关闭本地CPU的中断，并处理中断处理程序中的其他相关内容；
4、执行完中断处理程序后退出中断，重新使能中断。
从上面可以看出，中断处理程序应该尽可能快的处理完，因为此时本地CPU的中断是关闭的，如果长时间关闭中断的话，则会丢失很多中断，这会导致数据的丢失。有些中断，比如敲击键盘，内核可以很快处理完该中断，而其他如网卡设备产生的中断，内核需要做很多工作：分配sk_buff缓存、拷贝收到的数据包到该缓存中、同时初始化该结构中的一些参数等等，这些动作会耗费很长的CPU时间。
基于上述原因，linux内核中有所谓的上半部（top half）和下半部（bottom half），中断处理程序只需要在上半部完成一些很紧急的工作，比如置一些标志位等，而大部分工作可以放到下半部中来完成，这样CPU就不用长时间的关闭中断而导致丢失数据了：
1、内核收到硬件的中断（硬中断）；
2、内核执行中断处理程序的上半部：关闭中断，处理一些紧急的工作，最后再打开中断。一般上半部完成以下工作：保存一些信息、置一些标识位等，比如一个硬件的多个设备共享一个中断，此时可以读中断状态寄存器，记录是哪个设备产生了中断，以便下半部做出相应的处理；
3、调用下半部处理其他工作（软中断）。
内核提供的不同的机制实现下半部，软中断和tasklet就是其中之一，还有其他的机制比如工作队列等等。
二、内核的实现
内核中有以下几种类型的软中断：
enum
{
HI_SOFTIRQ=0,//用于实现高优先级的软中断
TIMER_SOFTIRQ,//用于实现定时器
NET_TX_SOFTIRQ,//用于网络子系统中发送数据包
NET_RX_SOFTIRQ,//用于网络子系统中接收数据包
BLOCK_SOFTIRQ,//用于实现块设备的软中断
BLOCK_IOPOLL_SOFTIRQ,
TASKLET_SOFTIRQ//用于实现tasklet
};从上面可以看出，tasklet实际上是软中断的一种，但是软中断与tasklet有以下不同点：
1、tasklet可以被单独的使能或者禁止，通过两个API：tasklet_disable和tasklet_enable；而所以软中断只能被整体的使能或者禁止，通过两个API：local_bh_disable和local_bh_enable，不能单独禁止其他的某一种软中断，此时的tasklet也不能运行；
2、不同的tasklet可以同时运行在不同的CPU上并发执行，但是同一个tasklet会始终在调度自己的同一个CPU上运行，这样可以提高运行效率；而每种软中断只能有一个实例同时运行在一个CPU上，同一个软中断能同时运行在不同的CPU上。
如何注册软中断处理函数？
内核中最多有32种类型的软中断，但只使用了上面的7种：
static struct softirq_action softirq_vec[32] __cacheline_aligned_in_smp;//最多支持32种软中断结构softirq_action很简单：
struct softirq_action
{
void (*action)(struct softirq_action *);//注册的函数
void *data;//参数
};
内核使用open_softirq函数注册软中断，该函数只是把函数指针和参数拷贝到全局变量softirq_vec中：
void open_softirq(int nr, void (*action)(struct softirq_action*), void *data)
{
softirq_vec[nr].data = data;
softirq_vec[nr].action = action;
}
比如，注册网络子系统中处理数据包接收和发送软中断：
open_softirq(NET_TX_SOFTIRQ, net_tx_action, NULL);
open_softirq(NET_RX_SOFTIRQ, net_rx_action, NULL);
tasklet
内核中定义了两个PER_CPU变量tasklet_vec和tasklet_hi_vec（这种变量每个CPU都保存该变量的副本，访问这种变量几乎不需要锁定，因为每个CPU在自己的副本上工作，互不干扰），分对应普通优先级和高优先级的tasklet，类型为struct tasklet_head。
这样每个CPU都保存了一个tasklet_head类型链表，可以定义很多个tasklet，只需要往该链表中添加实例就可以了。
static DEFINE_PER_CPU(struct tasklet_head, tasklet_vec) = { NULL };
static DEFINE_PER_CPU(struct tasklet_head, tasklet_hi_vec) = { NULL };
struct tasklet_head
{
struct tasklet_struct *list;
};
内核已经注册了tasklet的处理函数tasklet_action和tasklet_hi_action，最终会调用这两个函数去处理提交的tasklet：
void __init softirq_init(void)
{
open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);
open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);
}
以上是内核的实现，用户可以通过如下函数tasklet_init或者宏DECLARE_TASKLET来初始化一个tasklet：
struct tasklet_struct
{
struct tasklet_struct *next;//用于将同一个CPU上的tasklet链接到一起
unsigned long state;//该tasklet的状态，有两个值：TASKLET_STATE_SCHED和TASKLET_STATE_RUN
atomic_t count;//0表示该tasklet被禁止，非0表示是使能的
void (*func)(unsigned long);//注册的函数
unsigned long 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;
}
#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }通过下面的函数来调度普通优先级和高优先级的tasklet：
static inline void tasklet_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
__tasklet_schedule(t);
}
static inline void tasklet_hi_schedule(struct tasklet_struct *t)
{
if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
__tasklet_hi_schedule(t);
}
虽然说函数名中有schedule，但是实际上此时并没有被执行（真正执行是通过调用__do_softirq函数），此处只是将该tasklet实例加入到PER_CPU变量tasklet_vec和tasklet_vec_hi中的链表的表头中去了，同时操作一个PER_CPU变量irq_stat[cpu].__softirq_pending中的相应位，该变量是32位的，对应内核中的支持的32个软中断（只使用了7个），__tasklet_schedule函数如下：
void fastcall __tasklet_schedule(struct tasklet_struct *t)
{
unsigned long flags;
local_irq_save(flags);//保存中断状态，再关闭中断
t->next = __get_cpu_var(tasklet_vec).list;
__get_cpu_var(tasklet_vec).list = t;//将该tasklet加入到链表中，真正调度软中断的时候会遍历该链表
raise_softirq_irqoff(TASKLET_SOFTIRQ);//置位32位位图变量__softirq_pending中的TASKLET_SOFT位
local_irq_restore(flags);//使能中断
}
刚刚提到的32位位图变量就是下面结构体中的成员__softirq_pending，因为内核中最多支持32个软中断，所以该变量也是32位的：
typedef struct {
unsigned int __softirq_pending;//位图变量
unsigned long idle_timestamp;
unsigned int __nmi_count; /* arch dependent */
unsigned int apic_timer_irqs; /* arch dependent */
} ____cacheline_aligned irq_cpustat_t;
DECLARE_PER_CPU(irq_cpustat_t, irq_stat);上文提到内核中已经注册了处理tasklet的函数tasklet_action，这里分析普通优先级的tasklet：
static void tasklet_action(struct softirq_action *a)
{
struct tasklet_struct *list;
local_irq_disable();//关闭中断
list = __get_cpu_var(tasklet_vec).list;//获取PER_CPU变量tasklet_vec中的链表头
__get_cpu_var(tasklet_vec).list = NULL;
local_irq_enable();//使能中断
while (list) {//变量链表
struct tasklet_struct *t = list;
list = list->next;//下一个
if (tasklet_trylock(t)) {//判断tasklet是否已经运行
if (!atomic_read(&t->count)) {//判断该tasklet是否使能
if (!test_and_clear_bit(TASKLET_STATE_SCHED, &t->state))//清除状态 BUG();
trace_irq_tasklet_low_entry(t);
t->func(t->data);//执行相应的函数
trace_irq_tasklet_low_exit(t);
tasklet_unlock(t);
continue;
}
tasklet_unlock(t);
}
/*如果因为tasklet已经被调度或者被禁止，那么把该tasklet又放回链表，以便下次调度的时候还可以执行该tasklet*/
local_irq_disable();
t->next = __get_cpu_var(tasklet_vec).list;
__get_cpu_var(tasklet_vec).list = t;
__raise_softirq_irqoff(TASKLET_SOFTIRQ);
local_irq_enable();
}
}
那软中断或者tasklet何时被调度呢？
三、软中断的调度
以下几种情况，__do_softirq会被调用：
1、调用do_IRQ函数。
该函数在产生硬中断后会被调用，去执行驱动中注册的中断服务程序。该函数的最后中调用了irq_exit，最后会调用__do_softirq。
为什么在此处调用__do_softirq呢？因为有很多的软中断请求是在硬中断服务程序中提交的，在此处调用__do_softirq使得硬中断发生后可以在很短的时间内可以执行软中断。
asmlinkage unsigned int do_IRQ(unsigned int irq, struct pt_regs *regs)
{
irq_enter();
__DO_IRQ_SMTC_HOOK();
__do_IRQ(irq, regs);
irq_exit();
return 1;
}
void irq_exit(void)
{
account_system_vtime(current);
trace_hardirq_exit();
sub_preempt_count(IRQ_EXIT_OFFSET);
if (!in_interrupt() && local_softirq_pending())/*CPU只有处于非硬中断、非软中断且可以抢占，同时有软中断请求的情况下才调用__do_softirq*/
invoke_softirq();//最终调用__do_softirq
preempt_enable_no_resched();
}
刚才提到，在调用__do_softirq之前会判断当前CPU是否处于软中断中，刚才只是提到了一点，实际上，在调用该函数之前，判断了3种情况：硬中断、软中断、是否允许抢占。CPU只有处于非硬中断、非软中断并且可以抢占的情况下才会调用__do_softirq，这样确保了同一个CPU同一时间内__do_softirq只会被调用一次，而不会出现重复进入__do_softirq的情况，该函数的执是串行的，不允许嵌套。
2、从中断或者异常返回。
在/arch/xxx/kernel/entry.S中有如下代码：
/* check if we need to do software interrupts */
tstl irq_stat+CPUSTAT_SOFTIRQ_PENDING
jeq .Lret_from_exception
pea ret_from_exception
jra do_softirq 这种情况跟内核中断实现有关，不熟悉。
3、调用local_bh_enable函数。
void local_bh_enable(void)
{
#ifdef CONFIG_TRACE_IRQFLAGS
unsigned long flags;
WARN_ON_ONCE(in_irq());
#endif
WARN_ON_ONCE(irqs_disabled());
#ifdef CONFIG_TRACE_IRQFLAGS
local_irq_save(flags);
#endif
/*
* Are softirqs going to be turned on now:
*/
if (softirq_count() == SOFTIRQ_OFFSET)
trace_softirqs_on((unsigned long)__builtin_return_address(0));
/*
* Keep preemption disabled until we are done with
* softirq processing:
*/
sub_preempt_count(SOFTIRQ_OFFSET - 1);
if (unlikely(!in_interrupt() && local_softirq_pending()))
do_softirq();//执行软中断
dec_preempt_count();
#ifdef CONFIG_TRACE_IRQFLAGS
local_irq_restore(flags);
#endif
preempt_check_resched();
}
4、内核线程ksoftirqd。
内核在CPU启动阶段，为每个CPU创建了一个内核线程ksoftirqd/0~ksoftirqd/n，n是CPU的个数减1。（/kernel/softirq.c）
p = kthread_create(ksoftirqd, hcpu, "ksoftirqd/%d", hotcpu); 可以在系统下用ps命令查看这几个内核线程：
[root@root ~]# ps aux | grep "softirq"
root 3 0.0 0.0 0 0 ? SN 10:12 0:00 [ksoftirqd/0]
root 6 0.0 0.0 0 0 ? SN 10:12 0:00 [ksoftirqd/1]
root 9 0.0 0.0 0 0 ? SN 10:12 0:00 [ksoftirqd/2]
root 12 0.0 0.0 0 0 ? SN 10:12 0:00 [ksoftirqd/3]
root 5644 0.0 0.0 65328 780 pts/1 S+ 14:37 0:00 grep softirq
内核线程的处理函数ksoftirqd如下：
static int ksoftirqd(void * __bind_cpu)
{
set_user_nice(current, 19);
current->flags |= PF_NOFREEZE;
set_current_state(TASK_INTERRUPTIBLE);
while (!kthread_should_stop()) {
preempt_disable();
if (!local_softirq_pending()) {
preempt_enable_no_resched();
schedule();
preempt_disable();
}
__set_current_state(TASK_RUNNING);
while (local_softirq_pending()) {//情况a
/* Preempt disable stops cpu going offline.
If already offline, we'll be on wrong CPU:
don't process */
if (cpu_is_offline((long)__bind_cpu))//情况b
goto wait_to_die;
do_softirq();//调用软中断
preempt_enable_no_resched();
cond_resched();
preempt_disable();
}
preempt_enable();
set_current_state(TASK_INTERRUPTIBLE);
}
__set_current_state(TASK_RUNNING);
return 0;
wait_to_die:
preempt_enable();
/* Wait for kthread_stop */
set_current_state(TASK_INTERRUPTIBLE);
while (!kthread_should_stop()) {
schedule();
set_current_state(TASK_INTERRUPTIBLE);
}
__set_current_state(TASK_RUNNING);
return 0;
} 一旦内核线程运行，会一直调用do_softirq直到以下任何一种条件发生：
a、没有任何软中断请求了；
在这种情下，内核线程主动让出CPU（调用schedule），同时设置其状态为TASK_INTERRUPTIBLE（可中断），此后，如果有新的软中断请求可以通过wakeup_softirqd函数唤醒该内核线程。例如在函数__do_softirq和raise_softirq_irqoff中都会去唤醒该内核线程。
__do_softirq：
if (pending)
wakeup_softirqd();
raise_softirq_irqoff：
if (!in_interrupt())
wakeup_softirqd(); b、该内核线程运行太久了，被要求释放CPU；
四、使用时应注意的
软中断和tasklet不能睡眠、不能阻塞，它们的代码中不能含有导致睡眠的动作，如减少信号量、从用户空间拷贝数据或手工分配内存等。原因可以参考：
2214
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
