我們在分析linux內核中斷剖析時,簡單的聊了一下SOFTIRQ, 而沒有進行深入分析. Linux內核講對一個外部設備中斷的處理分成兩大部分HARDIRQ以及SOFTIRQ, HARDIRQ部分在執行時處理器的中斷是關閉的,所以驅動程序的中斷處理例程只應該完成一些關鍵的中斷操作,而將耗時的操作放到SOFTIRQ部分執行, 本篇文章我們將對這部分進行深入討論.

SoftIrq的應用非常廣泛, 例如我們常見的網卡在做網絡包的收發, 封裝好用來做延遲操作的tasklet的實現等.

SoftIrq源代碼分析

首先看一下linux內核當中的irq類型, 而在softirq中維護著struct softirq_action softirq_vec[NR_SOFTIRQS]這樣一個類型的數組.

//include/linux/interrupt.h 
enum
{
  HI_SOFTIRQ=0,
  TIMER_SOFTIRQ,
  NET_TX_SOFTIRQ,//網絡端口TX
  NET_RX_SOFTIRQ,//網絡端口RX
  BLOCK_SOFTIRQ,
  IRQ_POLL_SOFTIRQ,
  TASKLET_SOFTIRQ,//tasklet實現時使用的irq
  SCHED_SOFTIRQ,
  HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the numbering. Sigh! */
  RCU_SOFTIRQ,    /* Preferable RCU should always be the last softirq */
  NR_SOFTIRQS
};

在kernel_start 的時候,在做完中斷時間等初始化后,會進行softirq的初始化動作:

//init/main.c 
asmlinkage __visible void __init start_kernel(void){
  ...
  init_IRQ();
  ...
  init_timers();
  hrtimers_init();
  softirq_init(); //softirq初始化動作
  ...
}

softirq_init的動作很簡單,做了兩件事情, 第一件事情:為每個核創建分別創建了tasklet_vec(對應TASKLET_SOFTIRQ類型軟中斷)和tasklet_hi_vec(對應HI_SOFTIRQ類型軟中斷)鏈表. 第二件事情就是給數組對應的softirq_vec[NR_SOFTIRQS]中TASKLET_SOFTIRQ和HI_SOFTIRQ兩種類型的softirq_action初始化自己的softirq_action的回調處理函數

//kernel/softirq.c 
static struct softirq_action softirq_vec[NR_SOFTIRQS] __cacheline_aligned_in_smp;
void open_softirq(int nr, void (*action)(struct softirq_action *))
{
  softirq_vec[nr].action = action;
}


void __init softirq_init(void)
{
  int cpu;
  //第一件事情,給每個核創建一個對應鏈表.
  for_each_possible_cpu(cpu) {
    per_cpu(tasklet_vec, cpu).tail =
      &per_cpu(tasklet_vec, cpu).head;
    per_cpu(tasklet_hi_vec, cpu).tail =
      &per_cpu(tasklet_hi_vec, cpu).head;
  }
  //第二件事情,注冊兩個不同類型softirq的回調處理函數
  open_softirq(TASKLET_SOFTIRQ, tasklet_action);
  open_softirq(HI_SOFTIRQ, tasklet_hi_action);
}

接下來我們重點看一下softirq的處理核心函數__do_softirq, 它被調用的時間點是處理完中斷函數后會調用irq_exit(關于這點不清楚的可以回顧一下之前的文章: Linux內核中斷剖析--外部中斷(上)時進行處理,這里就不再做過多介紹.我們直接分析核心函數__do_softirq

//kernel/softirq.c
void irq_exit(void)
{
#ifndef __ARCH_IRQ_EXIT_IRQS_DISABLED
  local_irq_disable();
#else
  lockdep_assert_irqs_disabled();
#endif
  account_irq_exit_time(current);
  preempt_count_sub(HARDIRQ_OFFSET);//表示HARDIRQ 
  if (!in_interrupt() && local_softirq_pending())//表示當前沒有在軟硬和不可中斷中才可以進入,防止中斷嵌套.
    invoke_softirq();//這里面會call到關鍵函數


  tick_irq_exit();
  rcu_irq_exit();
  trace_hardirq_exit(); /* must be last! */
}


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


  if (!force_irqthreads) {
#ifdef CONFIG_HAVE_IRQ_EXIT_ON_IRQ_STACK
    /*
     * We can safely execute softirq on the current stack if
     * it is the irq stack, because it should be near empty
     * at this stage.
     */
    __do_softirq();
#else
    /*
     * Otherwise, irq_exit() is called on the task stack that can
     * be potentially deep already. So call softirq in its own stack
     * to prevent from any overrun.
     */
    do_softirq_own_stack();//內部實現也是__do_softirq.
#endif
  } else {
    wakeup_softirqd();
  }
}
//重點中的重點!!!
asmlinkage __visible void __softirq_entry __do_softirq(void)
{
  unsigned long end = jiffies + MAX_SOFTIRQ_TIME;
  unsigned long old_flags = current- >flags;
  int max_restart = MAX_SOFTIRQ_RESTART;
  struct softirq_action *h;
  bool in_hardirq;
  __u32 pending;
  int softirq_bit;


  /*
   * Mask out PF_MEMALLOC as the current task context is borrowed for the
   * softirq. A softirq handled, such as network RX, might set PF_MEMALLOC
   * again if the socket is related to swapping.
   */
  current- >flags &= ~PF_MEMALLOC;


  pending = local_softirq_pending();//獲取被置起來的中斷類型,以類型為對應的bit位
  account_irq_enter_time(current);


  __local_bh_disable_ip(_RET_IP_, SOFTIRQ_OFFSET);//表示進入softirq上下文
  in_hardirq = lockdep_softirq_start();


restart:
  /* Reset the pending bitmask before enabling irqs */
  set_softirq_pending(0);//清空被置起需要處理類型的軟中斷類型.


  local_irq_enable();


  h = softirq_vec;
  //ffs函數為找到對應pending的第一個bit不為0 的bit位. 
  //實際就是遍歷一遍softirq_vec中被置起來的soft.
  while ((softirq_bit = ffs(pending))) {
    unsigned int vec_nr;
    int prev_count;


    h += softirq_bit - 1;


    vec_nr = h - softirq_vec;
    prev_count = preempt_count();


    kstat_incr_softirqs_this_cpu(vec_nr);


    trace_softirq_entry(vec_nr);
    h- >action(h);//調用到我們的注冊的action
    trace_softirq_exit(vec_nr);
    if (unlikely(prev_count != preempt_count())) {
      pr_err("huh, entered softirq %u %s %p with preempt_count %08x, exited with %08x?\\n",
             vec_nr, softirq_to_name[vec_nr], h- >action,
             prev_count, preempt_count());
      preempt_count_set(prev_count);
    }
    h++;
    pending > >= softirq_bit;
  }


  if (__this_cpu_read(ksoftirqd) == current)
    rcu_softirq_qs();
  local_irq_disable();


  pending = local_softirq_pending();
  if (pending) {
    if (time_before(jiffies, end) && !need_resched() &&
        --max_restart)
      goto restart;


    wakeup_softirqd();
  }


  lockdep_softirq_end(in_hardirq);
  account_irq_exit_time(current);
  __local_bh_enable(SOFTIRQ_OFFSET);
  WARN_ON_ONCE(in_interrupt());
  current_restore_flags(old_flags, PF_MEMALLOC);
}

總結一些__do_softirq 就是 在某個時間點對應類型的softirq會被置起(稍后我們以tasklet為例來進行說明,tasklet常常用在中斷中的上半部進行置起)就是對應pending的bit位(每個bit位對應一個softirq的類型)上面代碼第62行, 然后根據pending的bit遍歷(77行)調用對應的action(89行),以開頭softirq_init時注冊的TASKLET_SOFTIRQ和HI_SOFTIRQ為例, 這個時候如果被置起調用的就是tasklet_action 與tasklet_hi_action 兩個函數.

我們這里只剖析TASKLET_SOFIRQ類型對應的action: tasklet_action(HI_SOFTIRQ的類似), tasklet_action做的事情很簡單,就是將當前核的tasklet_struct 的list列表遍歷一遍, 調用所對應的注冊函數(下面第29行). 我們在tasklet的使用分析時再討論(也可以參考Linux內核中斷剖析--外部中斷(下)當中的tasklet部分.

//kernel/softirq.c
static __latent_entropy void tasklet_action(struct softirq_action *a)
{
  tasklet_action_common(a, this_cpu_ptr(&tasklet_vec), TASKLET_SOFTIRQ);
}
//重點函數
static void tasklet_action_common(struct softirq_action *a,
          struct tasklet_head *tl_head,
          unsigned int softirq_nr)
{
  struct tasklet_struct *list;


  local_irq_disable();
  list = tl_head- >head;
  tl_head- >head = NULL;
  tl_head- >tail = &tl_head- >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;
    *tl_head- >tail = t;
    tl_head- >tail = &t- >next;
    __raise_softirq_irqoff(softirq_nr);
    local_irq_enable();
  }
}

SoftIrq的使用示例tasklet

還記得我們在Linux內核中斷剖析--外部中斷(下)當中tasklet的使用模板嗎? 我們這里再拿過來如下代碼段.

//tasklet模板
void mangodan_do_tasklet(unsigned long);
DECLARE_TASKLET(mangodan_tasklet,mangodan_do_tasklet,0);
/**中斷處理下半部*/
void mangodan_do_tasklet(unsigned long){  
  ...
}
/*中斷處理上半部分*/
irqreturn_t mangodan_interrupt(int irq, void *dev_id){
   ...
   tasklet_schedule(&mangodan_tasklet);
   ...
}

我們繼續從源代碼分析一下, 首先是聲明DECLARE_TASKLET, 就是初始化了一個tasklet_struct 的結構體. 注冊了對應的回調函數mangodan_do_tasklet , 這個函數就是上述tasklet_action_common遍歷tasklet_struct的鏈表中的t->func(t->data)(上述第29行);

//include/linux/interrupt.h
struct tasklet_struct
{
  struct tasklet_struct *next;
  unsigned long state;
  atomic_t count;
  void (*func)(unsigned long);
  unsigned long data;
};


#define DECLARE_TASKLET(name, func, data) \\
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

那么聲明的tasklet它是何時告知類型為TASKLET_SOFTIRQ的softirq需要被置起的呢?以上述示例為例就在于響應中斷上半部時的tasklet_schedule, 這個函數干了兩件事情: 將自己定義的tasklet_struct 加入到對應鏈表和置起TASKLET_SOFTIRQ類型, 在退出exit_irq時, __do_softirq中就會調用對應TASKLET_SOFTIRQ類型的action, 處理對應action里面就會遍歷對應的tasklet_struct的list,調用對應的func注冊函數.

//include/linux/interrupt.h
extern void __tasklet_schedule(struct tasklet_struct *t);


static inline void tasklet_schedule(struct tasklet_struct *t)
{
  if (!test_and_set_bit(TASKLET_STATE_SCHED, &t- >state))
    __tasklet_schedule(t);
}


//kernel/softirq.c
void __tasklet_schedule(struct tasklet_struct *t)
{
  __tasklet_schedule_common(t, &tasklet_vec,
          TASKLET_SOFTIRQ); //注意傳參類型
}
EXPORT_SYMBOL(__tasklet_schedule);


static void __tasklet_schedule_common(struct tasklet_struct *t,
              struct tasklet_head __percpu *headp,
              unsigned int softirq_nr)
{
  struct tasklet_head *head;
  unsigned long flags;


  local_irq_save(flags);
  head = this_cpu_ptr(headp);
  t- >next = NULL;
  *head- >tail = t;
  head- >tail = &(t- >next);
  raise_softirq_irqoff(softirq_nr);//置起TASKLET_SOFTIRQ,在軟中斷會觸發對應的action
  local_irq_restore(flags);
}
//置起對應類型的softirq為pending狀態
void __raise_softirq_irqoff(unsigned int nr)
{
  trace_softirq_raise(nr);
  or_softirq_pending(1UL < < nr);
}

總結

軟中斷(SoftIrq)使用廣泛, 在網絡包收發,tasklet 等一些基礎功能的實現上都有在廣泛使用, 深入了解會對我們更深刻的認識這些基礎功能以及避坑有很大的幫助.