一、引言
当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不能睡眠、不能阻塞,它们的代码中不能含有导致睡眠的动作,如减少信号量、从用户空间拷贝数据或手工分配内存等。原因可以参考: