有种中断是软的

发表于 3年以前 | 总阅读数：313 次

[Workqueue] 工作队列是利用内核线程来异步执行工作任务的通用机制，利用进程上下文来执行中断处理中耗时的任务，因此它允许睡眠。而 Softirq 和 Tasklet 在处理任务时不能睡眠。Softirq 是内核中常见的一种下半部机制，适合系统对性能和实时响应要求很高的场合，比如网络子系统，块设备，高精度定时器，RCU 等。

注册软中断

中断处理流程中设备驱动通过request_irq/request_threaded_irq接口来注册中断处理函数，而在软中断处理流程中，通过 open_softirq 接口来注册。Linux 在系统初始化时注册了两种 softirq 处理函数，分别为 TASKLET_SOFTIRQ 和 HI_SOFTIRQ.

void __init softirq_init()
{
    ...
    open_softirq(TASKLET_SOFTIRQ, tasklet_action, NULL);
    open_softirq(HI_SOFTIRQ, tasklet_hi_action, NULL);
}

open_softirq 函数如下所示：

void open_softirq(int nr, void (*action)(struct softirq_action *))
{
 softirq_vec[nr].action = action;
}

可以看出将软中断描述符表中对应描述符的 handler 函数指针指向对应的函数即可，以便软中断到来时进行回调。

下面我们看下什么时候进行软中断函数回调？

处理软中断

软中断执行的入口就是 invoke_softirq。

static inline void invoke_softirq(void)
{
 if (ksoftirqd_running(local_softirq_pending()))
  return;

 //中断没有被强制线程化
 if (!force_irqthreads) {
  //软中断处理
  __do_softirq();
 } else {
    //中断线程化处理
  wakeup_softirqd();
 }
}

可以看出，invoke_softirq 函数中，根据中断处理是否线程化进行分类处理，如果中断已经进行了强制线程化处理（中断强制线程化，需要在启动的时候传入参数 threadirqs），那么直接通过 wakeup_softirqd 唤醒内核线程来执行，否则的话则调用 __do_softirq 函数来处理。

什么是中断线程化处理？上面我们讲到 Linux 内核会为每个 CPU 都创建一个内核线程 ksoftirqd，当需要中断线程化处理的时候，会通过 wakeup_softirqd 唤醒内核线程来执行。

static void wakeup_softirqd(void)
{
 struct task_struct *tsk = __this_cpu_read(ksoftirqd);

 if (tsk && tsk->state != TASK_RUNNING)
  //唤醒内核线程来处理软中断，运行内核线程中的执行函数 run_ksoftirqd
  wake_up_process(tsk);
}

通过 wake_up_process 来唤醒内核，即执行 run_ksoftirqd 函数，如果此时有软中断处理请求，就调用 __do_softirq 来进行处理。可见无论是否强制线程化，最终的核心处理都放置在 __do_softirq 函数中完成。


asmlinkage __visible void __softirq_entry __do_softirq(void)
{
  ......
 //读取 __softirq_pending 字段，用于判断是否有处理请求
 pending = local_softirq_pending();
 account_irq_enter_time(current);

 //关闭下半部
 __local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);
 in_hardirq = lockdep_softirq_start();

restart:
 //将 __softirq_pending 字段清零
 set_softirq_pending(0);

 //关闭本地中断
 local_irq_enable();

 h = softirq_vec;

 while ((softirq_bit = ffs(pending))) {
    ......
  //软中断处理
  h->action(h);
    ......
 }

 rcu_bh_qs();
 //打开本地中断
 local_irq_disable();

 pending = local_softirq_pending();
 //判断是否有新的请求
 if (pending) {
  if (time_before(jiffies, end) && !need_resched() &&
      --max_restart)
   goto restart;
  //唤醒内核线程来处理
  wakeup_softirqd();
 }
  ......
 //打开下半部
 __local_bh_enable(SOFTIRQ_OFFSET);
  ......
}

通过 h->action(h)，即执行软中断的处理。

触发软中断

硬件中断触发的时候是通过硬件设备的电信号，软中断的触发是通过函数 raise_softirq 或者 __raise_softirq_irqoff。

tasklet 机制

tasklet 机制是基于 softirq 机制的，tasklet 机制其实就是一个任务队列，然后通过 softirq 执行。在 Linux 内核中有两种 tasklet，一种是高优先级 tasklet，一种是普通 tasklet。这两种 tasklet 的实现基本一致，唯一不同的就是执行的优先级，高优先级 tasklet 会先于普通 tasklet 执行。

tasklet 本质是一个队列，通过结构体 tasklet_head 存储，并且每个 CPU 有一个这样的队列，我们来看看结构体 tasklet_head 的定义。

struct tasklet_head
{
    struct tasklet_struct *list;
};

struct tasklet_struct
{
    struct tasklet_struct *next;
    unsigned long state;
    atomic_t count;
    void (*func)(unsigned long);
    unsigned long data;
};

从 tasklet_head 的定义可以知道，tasklet_head 结构是 tasklet_struct 结构队列的头部，而 tasklet_struct 结构的 func 字段正式任务要执行的函数指针。Linux定义了两种的tasklet队列，分别为 tasklet_vec 和 tasklet_hi_vec，定义如下:

struct tasklet_head tasklet_vec[NR_CPUS];
struct tasklet_head tasklet_hi_vec[NR_CPUS];

可以看出，tasklet_vec 和 tasklet_hi_vec 都是数组，数组的元素个数为 CPU 的核心数，也就是每个 CPU 核心都有一个普通 tasklet 队列和高优先级 tasklet 队列。

调度 tasklet

如果我们有一个 tasklet 需要执行，那么高优先级 tasklet 可以通过 tasklet_hi_schedule 函数调度，而普通 tasklet 可以通过 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);
}

void __tasklet_schedule(struct tasklet_struct *t)
{
 unsigned long flags;

 //关闭本地中断
 local_irq_save(flags);
 t->next = NULL;
 //将 tasklet 添加到本地 CPU 的 tasklet_vec 中
 *__this_cpu_read(tasklet_vec.tail) = t;
 __this_cpu_write(tasklet_vec.tail, &(t->next));
 //触发软中断，执行 tasklet_action
 raise_softirq_irqoff(TASKLET_SOFTIRQ);
 //打开本地中断
 local_irq_restore(flags);
}

可见调用 raise_softirq_irqoff 来触发软中断的执行函数 tasklet_action，下面我们看下这个函数的具体实现：

static __latent_entropy void tasklet_action(struct softirq_action *a)
{
 struct tasklet_struct *list;

 //将 tasklet_vec 中的 tasklet 链表移动到临时链表 list 中
 local_irq_disable();
 list = __this_cpu_read(tasklet_vec.head);
 __this_cpu_write(tasklet_vec.head, NULL);
 __this_cpu_write(tasklet_vec.tail, this_cpu_ptr(&tasklet_vec.head));
 local_irq_enable();

 while (list) {
  struct tasklet_struct *t = list;

  list = list->next;

  //确保只在一个 CPU 上运行
  if (tasklet_trylock(t)) {
   if (!atomic_read(&t->count)) {
    if (!test_and_clear_bit(TASKLET_STATE_SCHED,
       &t->state))
     BUG();
        //调用 tasklet 的处理函数
    t->func(t->data);
    tasklet_unlock(t);
    continue;
   }
   tasklet_unlock(t);
  }

  //没有执行的 tasklet 继续添加回原来的 tasklet_vec 中，再次触发（如果tasklet没有被调度则进行调度处理，将该tasklet添加到CPU对应的链表中，然后调用raise_softirq_irqoff来触发软中断执行）
  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_action 函数很简单，就是遍历 tasklet_vec 队列，然后通过 t->func(t->data)，调用 tasklet 的处理函数。

tasklet 相关的接口

/* 静态分配tasklet */
DECLARE_TASKLET(name, func, data)

/* 动态分配tasklet */
void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data);

/* 禁止tasklet被执行，本质上是增加tasklet_struct->count值，以便在调度时不满足执行条件 */
void tasklet_disable(struct tasklet_struct *t);

/* 使能tasklet，与tasklet_diable对应 */
void tasklet_enable(struct tasklet_struct *t);

/* 调度tasklet，通常在设备驱动的中断函数里调用 */
void tasklet_schedule(struct tasklet_struct *t);

/* 杀死tasklet，确保不被调度和执行， 主要是设置state状态位 */
void tasklet_kill(struct tasklet_struct *t)；