Linux Kernel: Interrupt

do_IRQ:
  // regs->orig_eax 保存着 irq - 256
  int irq = regs->orig_eax & 0xff;
  // 修改 thread_info->preempt_count, 后续通过 in_interrupt 可以判断出当
  // 前是否正在 interrupt 上下文中
  irq_enter();
  // 假设当前是 8K 的 kernel stack, 则 ISR 会借用进程的上下文. 若 kernel
  // stack 为 4K, 则这里会生成 ISR 自己的中断上下文
  __do_IRQ(irq, regs);
  irq_exit();
    sub_preempt_count(IRQ_EXIT_OFFSET);
    // 触发 softirq
    if (!in_interrupt() && local_softirq_pending()):
      invoke_softirq();

__do_IRQ:
  // irq_desc 是一个数组: irq_desc_t[NR_IRQS], irq_desc_t 中主要的成员是
  // 一个 irqaction 链表, 通过这个链表可以找到这个 IRQ 对应的所有 ISR
  irq_desc_t *desc = irq_desc + irq;
  // 调用 PIC 的 ack, 例如 mask_and_ack_8259A, 这个函数会通 INTA 给 PIC 发
  // ack, 同时在 PIC 上屏蔽对应的 IRQ. 所以 ISR 执行时可以保证对应的 IRQ
  // 是屏蔽的, ISR 不需要考虑重入的问题
  desc->handler->ack(irq);
  action_ret = handle_IRQ_event(irq, regs, desc->action);
    // SA_INTERRUPT 标记表示 ISR 会很快完成, 所以不需要开中断.
    //
    // 一般情况下这个 flag 没有置位, 所以 do_IRQ 会通过 local_irq_enable 调
    // 用 sti 开中断 (之前的 set_intr_gate 导致此时中断是关的)
    //
    // 所以通常情况下 ISR 执行时中断是开的, 但当前的 IRQ 是被屏蔽的
    if (!(action->flags & SA_INTERRUPT)):
      local_irq_enable();

    do:
      // 针对中断共享的情况, 依次调用每个 ISR, 直到某个 ISR 返回 IRQ_HANDLED
      ret = action->handler(irq, action->dev_id, regs);
      if (ret == IRQ_HANDLED)
        status |= action->flags;
      retval |= ret;
      action = action->next;
    while (action);
  // 调用 PIC 的 end, 例如 end_8259A_irq, 后者会去掉 IRQ 的屏蔽
  desc->handler->end(irq);

int request_irq(int irq, handler, irqflags):
  // 生成 irqaction
  struct irqaction * action;
  action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC);
  action->handler = handler;
  action->flags = irqflags;
  action->name = devname;
  action->next = NULL;
  action->dev_id = dev_id;
  // 做一些检查, 最后插入 irq_desc[irq]->action 链表中
  setup_irq(irq, action);
    struct irq_desc *desc = irq_desc + irq;
    p = &desc->action;
    if (!(old->flags & new->flags & SA_SHIRQ)):
      // 有些 action 支持 SA_SHIRQ (IRQ sharing) 但有些不支持, 则报错
      return -EBUSY;
    // 将新的 action 添加到链表末尾
    do:
      p = &old->next;
      old = *p;
    while (old);

    *p->irq = irq;

HI_SOFTIRQ,
TIMER_SOFTIRQ,
NET_TX_SOFTIRQ,
NET_RX_SOFTIRQ,
SCSI_SOFTIRQ,
TASKLET_SOFTIRQ

open_softirq(int nr, actions, data):
  softirq_vec[nr].data = data;
  softirq_vec[nr].action = action;

raise_softirq(nr):
  local_softirq_pending() |= 1UL << (nr)
  // 若当前不在中断上下文, 则唤醒 ksoftirqd, 否则, 等待 irq_exit 时处理      
  if (!in_interrupt()):
    wakeup_softirqd();

do_softirq:
  if (in_interrupt())
    return;

  local_irq_save(flags);
  pending = local_softirq_pending();
  if (pending)
    __do_softirq();
      pending = local_softirq_pending();
      h = softirq_vec;
      do:
        if (pending & 1):
          h->action(h);
        h++;
        pending >>= 1;
      while (pending);
      // 在 softirq_action 执行过程中, 有可能某些 action 本身会再次 raise
      // 自己造成再次 pending, 为了避免不停的执行这些 action, 这里主动结
      // 束, 并 wakeup_softirqd 让 ksoftirqd 来处理这些 pending
      // softirq_action, 毕竟 do_softirq 有可能是通过 irq_exit 被调用的      
      if (pending):
        wakeup_softirqd();
  local_irq_restore(flags);

asklet_init(t,func,data):
  t->next = NULL;
  t->state = 0;
  atomic_set(&t->count, 0);
  t->func = func;
  t->data = data;

__tasklet_schedule(struct tasklet_struct *t):
  local_irq_save(flags);
  // 将 tasklet_struct 添加于 tasklet_vec.list 链表头, 然后
  // raise_softirq(TASKLET_SOFTIRQ), TASKLET_SOFTIRQ 对应的
  // softirq_action (tasklet_action) 会处理这些 tasklet    
  t->next = __get_cpu_var(tasklet_vec).list;
  __get_cpu_var(tasklet_vec).list = t;
  raise_softirq_irqoff(TASKLET_SOFTIRQ);
  local_irq_restore(flags);

void foo(int signo) {
    printf("foo\n");
}

int main(int argc, char *argv[]) {
    signal(11, foo);
    *(int*)0 = 1;
    return 0;
}

void foo(int signo) {
    printf("foo\n");
}

int main(int argc, char *argv[]) {
    signal(11, foo);
    kill(getpid(), 11);
    return 0;
}