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

# 开始

:    pushl_cfi $(~vector+0x80)    /* Note: always in signed byte range */ # 先会执行这一句，将中断向量号取反然后加上0x80压入栈中

      .if ((vector-FIRST_EXTERNAL_VECTOR)%) <>

    jmp 2f                                                     # 数字定义的标号为临时标号，可以任意重复定义，例如："2f"代表正向第一次出现的标号"2:"，3b代表反向第一次出现的标号"3:"

      .endif

      .previous                                             # .previous使汇编器返回到该自定义段之前的段进行汇编，则回到上面的数据段

    .long 1b                                                 # 在数据段中执行标号1的操作

      .section .entry.text, "ax"                             # 回到代码段

vector=vector+

    .endif

  .endr

:    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 ;

}

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 = , 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 interrupts\n",

                  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;

}