Linux內核SoftIrq源代碼分析

我們在分析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);
}