linux中断源码分析 - 中断发生(三)

# 代码地址:arch/x86/kernel/entry_32.S

# 开始
1:    pushl_cfi $(~vector+0x80)    /* Note: always in signed byte range */ # 先会执行这一句，将中断向量号取反然后加上0x80压入栈中
      .if ((vector-FIRST_EXTERNAL_VECTOR)%7) <> 6
    jmp 2f                                                     # 数字定义的标号为临时标号，可以任意重复定义，例如："2f"代表正向第一次出现的标号"2:"，3b代表反向第一次出现的标号"3:"
      .endif
      .previous                                             # .previous使汇编器返回到该自定义段之前的段进行汇编，则回到上面的数据段
    .long 1b                                                 # 在数据段中执行标号1的操作
      .section .entry.text, "ax"                             # 回到代码段
vector=vector+1 
    .endif 
  .endr
2:    jmp common_interrupt



common_interrupt:
    ASM_CLAC
    addl $-0x80,(%esp)       # 此时栈顶是(~vector + 0x80)，这里再加上-0x80，实际就是中断向量号取反，用于区别系统调用，系统调用是正数，中断向量是负数
    SAVE_ALL                 # 保存现场，将寄存器值压入栈中
    TRACE_IRQS_OFF           # 关闭中断跟踪
    movl %esp,%eax           # 将栈指针保存到eax寄存器，供do_IRQ使用
    call do_IRQ              # 调用do_IRQ
    jmp ret_from_intr        # 跳转到ret_from_intr，进行中断返回的一些处理
ENDPROC(common_interrupt)
    CFI_ENDPROC

__visible unsigned int __irq_entry do_IRQ(struct pt_regs *regs)
{
    /* 将栈顶地址保存到全局变量__irq_regs中，old_regs用于保存现在的__irq_regs值，这一行代码很重要，实现了嵌套中断情况下的现场保存与还原 */
    struct pt_regs *old_regs = set_irq_regs(regs);

    /* 获取中断向量号，因为中断向量号是以取反方式保存的，这里再次取反 */
    unsigned vector = ~regs->orig_ax;
    /* 中断向量号 */
    unsigned irq;

    /* 硬中断计数器增加，硬中断计数器保存在preempt_count */
    irq_enter();
    /* 这里开始禁止调度，因为preempt_count不为0 */

    /* 退出idle进程(如果当前进程是idle进程的情况下) */
    exit_idle();

    /* 根据中断向量号获取中断号 */
    irq = __this_cpu_read(vector_irq[vector]);

    /* 主要函数是handle_irq，进行中断服务例程的处理 */
    if (!handle_irq(irq, regs)) {
        /* EIO模式的应答 */
        ack_APIC_irq();

        /* 该中断号并没有发生过多次触发 */
        if (irq != VECTOR_RETRIGGERED) {
            pr_emerg_ratelimited("%s: %d.%d No irq handler for vector (irq %d)n",
                         __func__, smp_processor_id(),
                         vector, irq);
        } else {
            /* 将此中断向量号对应的vector_irq设置为未定义 */
            __this_cpu_write(vector_irq[vector], VECTOR_UNDEFINED);
        }
    }
    /* 硬中断计数器减少 */
    irq_exit();
    /* 这里开始允许调度 */

    /* 恢复原来的__irq_regs值 */
    set_irq_regs(old_regs);
    return 1;
}

bool handle_irq(unsigned irq, struct pt_regs *regs)
{
    struct irq_desc *desc;
    int overflow;

    /* 检查栈是否溢出 */
    overflow = check_stack_overflow();

    /* 获取中断描述符 */
    desc = irq_to_desc(irq);
    /* 检查是否获取到中断描述符 */
    if (unlikely(!desc))
        return false;

    /* 检查使用的栈，有两种情况，如果进程的内核栈配置为8K，则使用进程的内核栈，如果为4K，系统会专门为所有中断分配一个4K的栈专门用于硬中断处理栈，一个4K专门用于软中断处理栈，还有一个4K专门用于异常处理栈 */
    if (user_mode_vm(regs) || !execute_on_irq_stack(overflow, desc, irq)) {
        if (unlikely(overflow))
            print_stack_overflow();
        /* 执行handle_irq */
        desc->handle_irq(irq, desc);
    }

    return true;
}

/* 用于电平中断，电平中断特点:
 * 只要设备的中断请求引脚（中断线）保持在预设的触发电平，中断就会一直被请求，所以，为了避免同一中断被重复响应，必须在处理中断前先把mask irq，然后ack irq，以便复位设备的中断请求引脚，响应完成后再unmask irq
 */
void
handle_level_irq(unsigned int irq, struct irq_desc *desc)
{
    raw_spin_lock(&desc->lock);
    /* 通知中断控制器屏蔽该中断线，并设置中断描述符屏蔽该中断 */
    mask_ack_irq(desc);

    /* 检查此irq是否处于运行状态，也就是检查IRQD_IRQ_INPROGRESS标志和IRQD_WAKEUP_ARMED标志。大家可以看看，还会检查poll */
    if (!irq_may_run(desc))
        goto out_unlock;

    desc->istate &= ~(IRQS_REPLAY | IRQS_WAITING);
    /* 增加此中断号所在proc中的中断次数 */
    kstat_incr_irqs_this_cpu(irq, desc);

    /*
     * If its disabled or no action available
     * keep it masked and get out of here
     */
    /* 判断IRQ是否有中断服务例程(irqaction)和是否被系统禁用 */
    if (unlikely(!desc->action || irqd_irq_disabled(&desc->irq_data))) {
        desc->istate |= IRQS_PENDING;
        goto out_unlock;
    }

    /* 在里面执行中断服务例程 */
    handle_irq_event(desc);
    /* 通知中断控制器恢复此中断线 */
    cond_unmask_irq(desc);

out_unlock:
    raw_spin_unlock(&desc->lock);
}

irqreturn_t handle_irq_event(struct irq_desc *desc)
{
    struct irqaction *action = desc->action;
    irqreturn_t ret;

    desc->istate &= ~IRQS_PENDING;
    /* 设置该中断处理正在执行，设置此中断号的状态为IRQD_IRQ_INPROGRESS */
    irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
    raw_spin_unlock(&desc->lock);

    /* 主要，具体看 */
    ret = handle_irq_event_percpu(desc, action);

    raw_spin_lock(&desc->lock);
    /* 取消此中断号的IRQD_IRQ_INPROGRESS状态 */
    irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
    return ret;
}

irqreturn_t
handle_irq_event_percpu(struct irq_desc *desc, struct irqaction *action)
{
    irqreturn_t retval = IRQ_NONE;
    unsigned int flags = 0, irq = desc->irq_data.irq;

    /* desc中的action是一个链表，每个节点包含一个处理函数，这个循环是遍历一次action链表，分别执行一次它们的处理函数 */
    do {
        irqreturn_t res;

        /* 用于中断跟踪 */
        trace_irq_handler_entry(irq, action);
        /* 执行处理，在驱动中定义的中断处理最后就是被赋值到中断服务例程action的handler指针上，这里就执行了驱动中定义的中断处理 */
        res = action->handler(irq, action->dev_id);
        trace_irq_handler_exit(irq, action, res);

        if (WARN_ONCE(!irqs_disabled(),"irq %u handler %pF enabled interruptsn",
                  irq, action->handler))
            local_irq_disable();

        /* 中断返回值处理 */
        switch (res) {
        /* 需要唤醒该中断处理例程的中断线程 */
        case IRQ_WAKE_THREAD:
            /*
             * Catch drivers which return WAKE_THREAD but
             * did not set up a thread function
             */
            /* 该中断服务例程没有中断线程 */
            if (unlikely(!action->thread_fn)) {
                warn_no_thread(irq, action);
                break;
            }
            /* 唤醒线程 */
            __irq_wake_thread(desc, action);

            /* Fall through to add to randomness */
        case IRQ_HANDLED:
            flags |= action->flags;
            break;

        default:
            break;
        }

        retval |= res;
        /* 下一个中断服务例程 */
        action = action->next;
    } while (action);

    add_interrupt_randomness(irq, flags);
    
    /* 中断调试会使用 */
    if (!noirqdebug)
        note_interrupt(irq, desc, retval);
    return retval;
}