Chinaunix首页 | 论坛 | 博客

一天进步一点就可以了

首页　| 　博文目录　| 　关于我

zhangjy2008327

  • 博客访问： 483410
  • 博文数量： 285
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 629
  • 用 户 组： 普通用户
  • 注册时间： 2013-10-14 17:53
个人简介

相信自己，快乐每一天

文章分类

全部博文（285）

最近访客
推荐博文
相关博文
ARM Linux中断源码分析（2）——中断处理流程

分类： LINUX

2013-10-30 13:15:50

原文地址：ARM Linux中断源码分析（2）——中断处理流程 作者：wloveg

转载请注明出处：wloveg.blog.chinaunix.net

5.中断处理流程

回顾第一节所讲的内容，当一个异常或中断发生时，处理器会将PC设置为特定地址，从而跳转到已经初始化好的异常向量表。因此，要理清中断处理流程，先从异常向量表开始。对于ARM Linux而言，异常向量表和异常处理程序都存在arch/arm/kernel/entry_armv.S汇编文件中。

异常向量表的代码实现：

点击(此处)折叠或打开

  1. .globl    __vectors_start
  2. __vectors_start:
  3.     swi    SYS_ERROR0
  4.     b    vector_und + stubs_offset
  5.     ldr    pc, .LCvswi + stubs_offset
  6.     b    vector_pabt + stubs_offset
  7.     b    vector_dabt + stubs_offset
  8.     b    vector_addrexcptn + stubs_offset
  9.     b    vector_irq + stubs_offset @中断入口，vector_irq
  10.     b    vector_fiq + stubs_offset

  12.     .globl    __vectors_end
  13. __vectors_end:

vector_irq+stubs_offset为中断的入口点，此处之所以要加上stubs_offset是为了实现位置无关编程。首先分析一下stubs_offset是如何计算的：

.equ stubs_offset, __vectors_start + 0x200 - __stubs_start

在第3节中已经提到，内核启动时会将异常向量表拷贝到 0xFFFF_0000，将异常向量处理程序的 stub 拷贝到 0xFFFF_0200。图5-1描述了异常向量表和异常处理程序搬移前后的内存布局。

图5-1 异常向量表和异常处理程序搬移前后对比

当汇编器看到B指令后会把要跳转的标签转化为相对于当前PC的偏移量（±32M）写入指令码。由于内核启动时中断向量表和stubs都发生了代码搬移，所以如果中断向量表中仍然写成b vector_irq，那么实际执行的时候就无法跳转到搬移后的vector_irq处，因为指令码里写的是原来的偏移量，所以需要把指令码中的偏移量写成搬移后的。设搬移后的偏移量为offset，如图5-1所示，

offset = L1+L2

     = [0x200 - (irq_PC_X - __vectors_start_X)] + (vector_irq_X - __stubs_start_X)

     = [0x200 - (irq_PC - __vectors_start)] + (vector_irq - __stubs_start)

     = 0x200 - irq_PC + __vectors_start + vector_irq - __stubs_start

     = vector_irq + (__vectors_start + 0x200 - __stubs_start) - irq_PC

令stubs_offset = __vectors_start + 0x200 - __stubs_start

则offset = vector_irq + stubs_offset - irq_PC，所以中断入口点为“b       vector_irq + stubs_offset”，其中减去irq_PC是由汇编器在编译时完成的。

在分析vector_irq处理函数之前，先了解一下当一个异常或中断导致处理器模式改变时，ARM处理器内核的处理流程如下图所示：
       
        在__stubs_start和__stubs_end之间找到vector_irq处理函数的定义vector_stub         irq, IRQ_MODE, 4，其中vector_stub是一个宏（在arch/arm/kernel/entry_armv.S中定义），为了分析更直观，我们将vector_stub宏展开如下：

  1. /*
  2.  * Interrupt dispatcher
  3.  */
  4.     vector_irq:
  5.     .if 4
  6.     sub    lr, lr, #4 @在中断发生时，lr指向最后执行的指令地址加上8。只有在当前指令执行完毕后，才进入中断处理，所以返回地址应指向下一条指令，即（lr-4）处。
  7.     .endif

  9. @
  10.     @ Save r0, lr_<exception> (parent PC) and spsr_<exception>
  11.     @ (parent CPSR)
  12.     @
  13.     stmia    sp, {r0, lr}        @ 保存r0, lr到irq模式下的栈中
  14.     mrs    lr, spsr
  15.     str    lr, [sp, #8]        @保存spsr到irq模式下的栈中

  17.     @
  18.     @ Prepare for SVC32 mode. IRQs remain disabled.
  19.     @
  20.     mrs    r0, cpsr
  21.     eor    r0, r0, #( IRQ_MODE ^ SVC_MODE) @设置成SVC模式，但未切换
  22.     msr    spsr_cxsf, r0 @保存到spsr_irq中

  24.     @
  25.     @ the branch table must immediately follow this code
  26.     @
  27.     and    lr, lr, #0x0f @lr存储着上一个处理器模式的cpsr值，lr = lr & 0x0f取出用于判断发生中断前是用户态还是核心态的信息，该值用于下面跳转表的索引。
  28.     mov    r0, sp @将irq模式下的sp保存到r0，作为参数传递给即将调用的__irq_usr或__irq_svc
  29.     ldr    lr, [pc, lr, lsl #2] @pc指向当前执行指令地址加8，即跳转表的基址。lr作为索引，由于是4字节对齐，所以lr = lr << 2.
  30.     movs    pc, lr @ branch to handler in SVC mode
  31.                   @当mov指令后加“s”且目标寄存器为pc时，当前模式下的spsr会被复制到cpsr，从而完成模式切换（从irq切换到svc）并且跳转到pc指向的指令继续执行
  32. ENDPROC(vector_irq)

  34.     .long    __irq_usr            @ 0 (USR_26 / USR_32)
  35.     .long    __irq_invalid            @ 1 (FIQ_26 / FIQ_32)
  36.     .long    __irq_invalid            @ 2 (IRQ_26 / IRQ_32)
  37.     .long    __irq_svc            @ 3 (SVC_26 / SVC_32)
  38.     .long    __irq_invalid            @ 4
  39.     .long    __irq_invalid            @ 5
  40.     .long    __irq_invalid            @ 6
  41.     .long    __irq_invalid            @ 7
  42.     .long    __irq_invalid            @ 8
  43.     .long    __irq_invalid            @ 9
  44.     .long    __irq_invalid            @ a
  45.     .long    __irq_invalid            @ b
  46.     .long    __irq_invalid            @ c
  47.     .long    __irq_invalid            @ d
  48.     .long    __irq_invalid            @ e
  49.     .long    __irq_invalid            @ f
如果发生中断前处于用户态则进入__irq_usr，其定义如下（arch/arm/kernel/entry_armv.S）： 

  1. .align    5
  2. __irq_usr:
  3.     usr_entry @保存中断上下文，稍后分析
  4.     kuser_cmpxchg_check
  5. #ifdef CONFIG_TRACE_IRQFLAGS
  6.     bl    trace_hardirqs_off
  7. #endif
  8.     get_thread_info tsk @获取当前进程的进程描述符中的成员变量thread_info的地址，并将该地址保存到寄存器tsk（r9）（在entry-header.S中定义）
  9. #ifdef CONFIG_PREEMPT @如果定义了抢占，增加抢占数值
  10.     ldr    r8, [tsk, #TI_PREEMPT]        @ 获取preempt计数器值
  11.     add    r7, r8, #1            @ preempt加1，标识禁止抢占
  12.     str    r7, [tsk, #TI_PREEMPT] @将加1后的结果写入进程内核栈的变量中
  13. #endif
  14.     irq_handler @调用中断处理程序，稍后分析
  15. #ifdef CONFIG_PREEMPT
  16.     ldr    r0, [tsk, #TI_PREEMPT] @获取preempt计数器值
  17.     str    r8, [tsk, #TI_PREEMPT] @将preempt恢复到中断前的值
  18.     teq    r0, r7 @比较中断前后preempt是否相等
  19.     strne    r0, [r0, -r0] @如果不等，则产生异常（向地址0写入数据）？
  20. #endif
  21. #ifdef CONFIG_TRACE_IRQFLAGS
  22.     bl    trace_hardirqs_on
  23. #endif
  24.     mov    why, #0 @r8=0
  25.     b    ret_to_user @中断处理完成，恢复中断上下文并返回中断产生的位置，稍后分析
  26.  UNWIND(.fnend        )
  27. ENDPROC(__irq_usr)

上面代码中的usr_entry是一个宏定义，主要用于保护上下文到栈中：

  1. .macro    usr_entry
  2.  UNWIND(.fnstart    )
  3.  UNWIND(.cantunwind    )    @ dont unwind the user space
  4.     sub    sp, sp, #S_FRAME_SIZE @ATPCS中，堆栈被定义为递减式满堆栈，所以首先让sp向下移动#S_FRAME_SIZE（pt_regs结构体size），准备向栈中存放数据。此处的sp是svc模式下的栈指针。
  5.     stmib    sp, {r1 - r12}

  7.     ldmia    r0, {r1 - r3}
  8.     add    r0, sp, #S_PC        @ here for interlock avoidance
  9.     mov    r4, #-1            @ "" "" "" ""

  11.     str    r1, [sp]        @ save the "real" r0 copied
  12.                     @ from the exception stack

  14.     @
  15.     @ We are now ready to fill in the remaining blanks on the stack:
  16.     @
  17.     @ r2 - lr_<exception>, already fixed up for correct return/restart
  18.     @ r3 - spsr_<exception>
  19.     @ r4 - orig_r0 (see pt_regs definition in ptrace.h)
  20.     @
  21.     @ Also, separately save sp_usr and lr_usr
  22.     @
  23.     stmia    r0, {r2 - r4}
  24.     stmdb    r0, {sp, lr}^ @将user模式下的sp和lr保存到svc模式的栈中

  26.     @
  27.     @ Enable the alignment trap while in kernel mode
  28.     @
  29.     alignment_trap r0

  31.     @
  32.     @ Clear FP to mark the first stack frame
  33.     @
  34.     zero_fp
  35.     .endm
上面的这段代码主要是在填充结构体pt_regs ，在include/asm/ptrace.h中定义：

  1. struct pt_regs {
  2.     long uregs[18];
  3. };

  5. #define ARM_cpsr    uregs[16]
  6. #define ARM_pc        uregs[15]
  7. #define ARM_lr        uregs[14]
  8. #define ARM_sp        uregs[13]
  9. #define ARM_ip        uregs[12]
  10. #define ARM_fp        uregs[11]
  11. #define ARM_r10        uregs[10]
  12. #define ARM_r9        uregs[9]
  13. #define ARM_r8        uregs[8]
  14. #define ARM_r7        uregs[7]
  15. #define ARM_r6        uregs[6]
  16. #define ARM_r5        uregs[5]
  17. #define ARM_r4        uregs[4]
  18. #define ARM_r3        uregs[3]
  19. #define ARM_r2        uregs[2]
  20. #define ARM_r1        uregs[1]
  21. #define ARM_r0        uregs[0]
  22. #define ARM_ORIG_r0    uregs[17]

usr_entry宏填充pt_regs结构体的过程如图5-2所示，先将r1～r12保存到ARM_r1～ARM_ip（绿色部分），然后将产生中断时的r0寄存器内容保存到ARM_r0（蓝色部分），接下来将产生中断时的下一条指令地址lr_irq、spsr_irq和r4保存到ARM_pc、ARM_cpsr和ARM_ORIG_r0（红色部分），最后将用户模式下的sp和lr保存到ARM_sp 和ARM_lr 中。

图5-2 usr_entry宏填充pt_regs结构体

如果发生中断前处于核心态则进入__irq_svc，其定义如下（arch/arm/kernel/entry_armv.S）：


  1. .align    5
  2. __irq_svc:
  3.     svc_entry @保存中断上下文

  5. #ifdef CONFIG_TRACE_IRQFLAGS
  6.     bl    trace_hardirqs_off
  7. #endif
  8. #ifdef CONFIG_PREEMPT
  9.     get_thread_info tsk
  10.     ldr    r8, [tsk, #TI_PREEMPT]        @ 获取preempt计数器值
  11.     add    r7, r8, #1            @ preempt加1，标识禁止抢占
  12.     str    r7, [tsk, #TI_PREEMPT] @将加1后的结果写入进程内核栈的变量中
  13. #endif

  15.     irq_handler @调用中断处理程序，稍后分析
  16. #ifdef CONFIG_PREEMPT
  17.     str    r8, [tsk, #TI_PREEMPT]        @ 恢复中断前的preempt计数器
  18.     ldr    r0, [tsk, #TI_FLAGS]        @ 获取flags
  19.     teq    r8, #0                @ 判断preempt是否等于0
  20.     movne    r0, #0                @ 如果preempt不等于0，r0=0
  21.     tst    r0, #_TIF_NEED_RESCHED @将r0与#_TIF_NEED_RESCHED做“与操作”
  22.     blne    svc_preempt @如果不等于0，说明发生内核抢占，需要重新调度。
  23. #endif

  25.     ldr    r0, [sp, #S_PSR]        @ irqs are already disabled
  26.     msr    spsr_cxsf, r0
  27. #ifdef CONFIG_TRACE_IRQFLAGS
  28.     tst    r0, #PSR_I_BIT
  29.     bleq    trace_hardirqs_on
  30. #endif
  31.     svc_exit r4     @恢复中断上下文，稍后分析。
  32.  UNWIND(.fnend        )
  33. ENDPROC(__irq_svc)
其中svc_entry是一个宏定义，主要用于保护中断上下文到栈中：

  1. .macro    svc_entry, stack_hole=0
  2.  UNWIND(.fnstart        )
  3.  UNWIND(.save {r0 - pc}        )
  4.     sub    sp, sp, #(S_FRAME_SIZE + \stack_hole)
  5.  SPFIX(    tst    sp, #4        )
  6.  SPFIX(    bicne    sp, sp, #4    )
  7.     stmib    sp, {r1 - r12}

  9.     ldmia    r0, {r1 - r3}
  10.     add    r5, sp, #S_SP        @ here for interlock avoidance
  11.     mov    r4, #-1            @ "" "" "" ""
  12.     add    r0, sp, #(S_FRAME_SIZE + \stack_hole)
  13.  SPFIX(    addne    r0, r0, #4    )
  14.     str    r1, [sp]        @ save the "real" r0 copied
  15.                     @ from the exception stack

  17.     mov    r1, lr

  19.     @
  20.     @ We are now ready to fill in the remaining blanks on the stack:
  21.     @
  22.     @ r0 - sp_svc
  23.     @ r1 - lr_svc
  24.     @ r2 - lr_<exception>, already fixed up for correct return/restart
  25.     @ r3 - spsr_<exception>
  26.     @ r4 - orig_r0 (see pt_regs definition in ptrace.h)
  27.     @
  28.     stmia    r5, {r0 - r4}
  29.     .endm
svc_entry宏填充pt_regs结构体的过程如图5-2所示，先将r1～r12保存到ARM_r1～ARM_ip（绿色部分），然后将产生中断时的r0寄存器内容保存到ARM_r0（蓝色部分），由于是在svc模式下产生的中断，所以最后将sp_svc、lr_svc、lr_irq、spsr_irq和r4保存到ARM_sp、ARM_lr、ARM_pc、ARM_cpsr和ARM_ORIG_r0（红色部分）。

图5-3 svc_entry宏填充pt_regs结构体


上述的中断上下文保存过程共涉及了3种栈指针，分别是：用户空间栈指针sp_usr，内核空间栈指针sp_svc和irq模式下的栈栈指针sp_irq。sp_usr指向在setup_arg_pages函数中创建的用户空间栈。sp_svc指向在alloc_thread_info函数中创建的内核空间栈。sp_irq在cpu_init函数中被赋值，指向全局变量stacks.irq[0]。

保存中断上下文后则进入中断处理程序——irq_handler，定义在arch/arm/kernel/entry_armv.S文件中：


  1. .macro    irq_handler
  2.     get_irqnr_preamble r5, lr
  3. 1:    get_irqnr_and_base r0, r6, r5, lr @获取中断号，存到r0中，稍后分析
  4.     movne    r1, sp @如果中断号不等于0，将r1=sp，即pt_regs结构体首地址
  5.     @
  6.     @ routine called with r0 = irq number, r1 = struct pt_regs *
  7.     @
  8.     adrne    lr, 1b @如果r0(中断号)不等于0， lr(返回地址)等于标号1处，即get_irqnr_and_base r0, r6, r5, lr的那行,即循环处理所有的中断。
  9.     bne    asm_do_IRQ @进入中断处理，稍后分析。
  10. ……
  11.     .endm

get_irqnr_and_base用于判断当前发生的中断号（与CPU紧密相关），此处不再分析。如果获取的中断号不等于0，则将中断号存入r0寄存器作为第一个参数，pt_regs结构体地址存入r1寄存器作为第二个参数，跳转到c语言函数asm_do_IRQ做进一步处理。为了不让大家在汇编语言和C语言之间来回切换，还是先把最后一点汇编语言代码（中断返回汇编代码）分析了再去分析asm_do_IRQ吧。回看__irq_usr和__irq_svc标号处的代码，在完成了irq_handler中断处理函数后，要完成从中断异常处理程序返回到中断点的工作。如果中断产生于用户空间，则调用ret_to_user来恢复中断现场并返回用户空间继续运行：

  1. arch/arm/kernel/entry_armv.S
  2. ENTRY(ret_to_user)
  3. ret_slow_syscall:
  4.     disable_irq    @ disable interrupts，此处不明白，disable_irq应该接受irq中断号作为参数，来禁止指定的irq号中断线。但是此处调用disable_irq之前并没有将irq中断号存入r0寄存器，这是为什么？
  5.     ldr    r1, [tsk, #TI_FLAGS] @获取thread_info->flags
  6.     tst    r1, #_TIF_WORK_MASK @判断是否有待处理的work
  7.     bne    work_pending @如果有，则进入work_pending进一步处理，主要是完成用户进程抢占相关处理。
  8. no_work_pending: @如果没有work待处理，则准备恢复中断现场，返回用户空间。
  9.     /* perform architecture specific actions before user return */
  10.     arch_ret_to_user r1, lr @调用体系结构相关的代码

  12.     restore_user_regs fast = 0, offset = 0 @调用restore_user_regs
  13. ENDPROC(ret_to_user)

  15. 以下是恢复中断现场寄存器的宏，就是将发生中断时保存在内核空间堆栈上的寄存器还原，可以对照图5-2所示的内核空间堆栈保存的内容来理解下面代码：
  16. .macro    restore_user_regs, fast = 0, offset = 0
  17.     ldr    r1, [sp, #\offset + S_PSR]    @ 从内核栈中获取发生中断时的cpsr值
  18.     ldr    lr, [sp, #\offset + S_PC]!    @ 从内核栈中获取发生中断时的下一条指令地址
  19.     msr    spsr_cxsf, r1            @ 将r1保存到spsr_svc
  20. #if defined(CONFIG_CPU_32v6K)
  21.     clrex                    @ clear the exclusive monitor
  22. #elif defined (CONFIG_CPU_V6)
  23.     strex    r1, r2, [sp]            @ clear the exclusive monitor
  24. #endif
  25.     .if    \fast
  26.     ldmdb    sp, {r1 - lr}^    @ get calling r1 - lr
  27.     .else
  28.     ldmdb    sp, {r0 - lr}^ @ 存在^，所以将内核栈保存的内容恢复到用户空间的r0～lr寄存器
  29.     .endif
  30.     add    sp, sp, #S_FRAME_SIZE - S_PC
  31.     movs    pc, lr    @将发生中断时的下一条指令地址存入pc，从而返回中断点继续执行，并且将发生中断时的cpsr内容恢复到cpsr寄存器中（开启中断）。
  32.     .endm

如果中断产生于内核空间，则调用svc_exit来恢复中断现场：


  1. arch/arm/kernel/ entry-header.S
  2. .macro    svc_exit, rpsr
  3.     msr    spsr_cxsf, \rpsr
  4. #if defined(CONFIG_CPU_32v6K)
  5.     clrex                    @ clear the exclusive monitor
  6.     ldmia    sp, {r0 - pc}^            @ load r0 - pc, cpsr
  7. #elif defined (CONFIG_CPU_V6)
  8.     ldr    r0, [sp]
  9.     strex    r1, r2, [sp]            @ clear the exclusive monitor
  10.     ldmib    sp, {r1 - pc}^            @ load r1 - pc, cpsr
  11. #else
  12.     ldmia    sp, {r0 - pc}^            @ 返回内核空间时，恢复中断现场比较简单，就是将r0-pc以及cpsr恢复即可，同时中断也被开启。
  13. #endif
  14.     .endm

ok，分析完所有与中断相关的汇编语言代码后，下面开始分析C语言代码：

在arch/arm/kernel/irq.c文件中找到asm_do_IRQ函数定义：


  1. asmlinkage void __exception asm_do_IRQ(unsigned int irq, struct pt_regs *regs)
  2. {
  3.     /*保存新的寄存器集合指针到全局cpu变量，方便后续处理程序访问寄存器集合。*/
  4.     struct pt_regs *old_regs = set_irq_regs(regs);

  6.     irq_enter();

  8.     /*
  9.      * Some hardware gives randomly wrong interrupts. Rather
  10.      * than crashing, do something sensible.
  11.      */
  12.     if (unlikely(irq >= NR_IRQS)) { //判断中断号
  13.         if (printk_ratelimit())
  14.             printk(KERN_WARNING "Bad IRQ%u\n", irq);
  15.         ack_bad_irq(irq);
  16.     } else {
  17.         generic_handle_irq(irq); //调用中断处理函数
  18.     }

  20.     /* AT91 specific workaround */
  21.     irq_finish(irq);

  23.     irq_exit();
  24.     set_irq_regs(old_regs);
  25. }

asm_do_IRQ是中断处理的C入口函数，主要负责调用request_irq注册的中断处理函数，其流程如图5-4所示：


图5-4 asm_do_IRQ流程

其中，set_irq_regs将指向寄存器结构体的指针保存在一个全局的CPU变量中，后续的程序可以通过该变量访问寄存器结构体。所以在进入中断处理前，先将全局CPU变量中保存的旧指针保留下来，等到中断处理结束后再将其恢复。irq_enter负责更新一些统计量：


  1. <kernel/softirq.c>
  2. void irq_enter(void)
  3. {
  4.     int cpu = smp_processor_id();

  6.     rcu_irq_enter();
  7.     if (idle_cpu(cpu) && !in_interrupt()) {
  8.         __irq_enter();
  9.         tick_check_idle(cpu);
  10.     } else
  11.         __irq_enter();
  12. }

如果系统开启动态时钟特性且很长时间没有产生时钟中断，则调用tick_check_idle更新全局变量jiffies（关于动态时钟特性，在后续的总结中再进行分析）。宏__irq_enter()定义如下：


  1. #define __irq_enter()                    \
  2.     do {                        \
  3.         account_system_vtime(current);        \
  4.         add_preempt_count(HARDIRQ_OFFSET);    \
  5.         trace_hardirq_enter();            \
  6.     } while (0)

add_preempt_count(HARDIRQ_OFFSET)使表示中断处理程序嵌套层次的计数器加1。计数器保存在当前进程thread_info结构的preempt_count字段中：

图5-5 preempt_count结构

内核将preempt_count分成5部分：bit0~7与PREEMPT相关，bit8~15用作软中断计数器，bit16~25用作硬中断计数器，bit26用作不可屏蔽中断计数器，bit28用作PREEMPT_ACTIVE标志。

generic_handle_irq是体系结构无关函数，用来调用desc->handle_irq，该函数指针在中断初始化时指向了电流处理函数（handle_level_irq或handle_edge_irq），针对不同的中断触发类型（边沿触发或电平触发）做相应的处理。然后调用handle_IRQ_event遍历action链表从而调用该中断号对应的一个或多个中断处理程序action->handler，而action->handler就是通过request_irq初始化的。

首先分析一下handle_level_irq函数：


  1. <kernel/irq/chip.c>
  2. void handle_level_irq(unsigned int irq, struct irq_desc *desc)
  3. {
  4.     struct irqaction *action;
  5.     irqreturn_t action_ret;

  7.     spin_lock(&desc->lock); /*访问desc内容之前先加自旋锁*/
  8.     mask_ack_irq(desc, irq); /*屏蔽与irq号对应的中断线 */

  10. /* 在多处理器系统上，为了避免多cpu同时处理同一中断。
  11. *当desc->status包含IRQ_INPROGRESS标志时，说明该中断
  12. *正在另一个cpu上处理，因此当前cpu可以直接放弃处理。
  13. */
  14.     if (unlikely(desc->status & IRQ_INPROGRESS))
  15.         goto out_unlock;
  16.     desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
  17.     kstat_incr_irqs_this_cpu(irq, desc);

  19.     /*
  20.      *如果没有对该中断注册处理程序，即desc->action为NULL。
  21.      * 或者desc->status设置为IRQ_DISABLED，表示该中断是被禁止的。
  22.      * 以上两种情况只要出现一种即可放弃处理。
  23. */
  24.     action = desc->action;
  25.     if (unlikely(!action || (desc->status & IRQ_DISABLED)))
  26.         goto out_unlock;

  28.     desc->status |= IRQ_INPROGRESS; /*标识中断状态为正在处理*/
  29.     spin_unlock(&desc->lock); /*释放自旋锁*/

  31.     /*调用由request_irq注册的处理函数，稍后分析。*/
  32.     action_ret = handle_IRQ_event(irq, action);
  33.     if (!noirqdebug)
  34.         note_interrupt(irq, desc, action_ret);

  36.     spin_lock(&desc->lock); /*访问desc内容前加自旋锁*/
  37.     desc->status &= ~IRQ_INPROGRESS; /*清除“正在处理”的标识*/

  39. /*如果desc->status 包含IRQ_ONESHOT，
  40. *则将desc->status设置为IRQ_MASKED，使该中断仍处于被屏蔽状态。 */
  41.     if (unlikely(desc->status & IRQ_ONESHOT))
  42.         desc->status |= IRQ_MASKED;
  43. /*如果中断处理函数中未对desc->status 设置为IRQ_ DISABLED，
  44. *且desc->chip->unmask不为空，则desc->chip->unmask所指向的芯片相关函数，
  45. *解除对该中断的屏蔽。
  46. */
  47.     else if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask)
  48.         desc->chip->unmask(irq);
  49. out_unlock:
  50.     spin_unlock(&desc->lock); /*释放自旋锁*/
  51. }

再来介绍一下handle_edge_irq函数，相对于handle_level_irq要复杂一点：


  1. <kernel/irq/chip.c>
  2. void handle_edge_irq(unsigned int irq, struct irq_desc *desc)
  3. {
  4.     spin_lock(&desc->lock);
  5.     desc->status &= ~(IRQ_REPLAY | IRQ_WAITING);
  6.     /*
  7.      * 如果该中断正在被其他cpu处理，或者是该中断已被禁止，
  8.      * 则不处理该中断，但要将其标识为pending状态且屏蔽该中断以便后续处理
  9.      */
  10.     if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) ||
  11.          !desc->action)) {
  12.         desc->status |= (IRQ_PENDING | IRQ_MASKED);
  13.         mask_ack_irq(desc, irq);
  14.         goto out_unlock;
  15.     }
  16.     kstat_incr_irqs_this_cpu(irq, desc);

  18.     /* Start handling the irq */
  19.     if (desc->chip->ack)
  20.         desc->chip->ack(irq);

  22.     /* 标识该中断状态为“正在处理”*/
  23.     desc->status |= IRQ_INPROGRESS;

  25.     do {
  26.         struct irqaction *action = desc->action;
  27.         irqreturn_t action_ret;

  29.         if (unlikely(!action)) {
  30.             desc->chip->mask(irq);
  31.             goto out_unlock;
  32.         }

  34.         /*
  35.          * 如果当处理该中断时有另一个中断到达，
  36.          * 那么当时可能屏蔽了该中断。
  37.          * 如果该中断没有被禁止，则解除对该中断的屏蔽。
  38.          */
  39.         if (unlikely((desc->status &
  40.              (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) ==
  41.              (IRQ_PENDING | IRQ_MASKED))) {
  42.             desc->chip->unmask(irq);
  43.             desc->status &= ~IRQ_MASKED;
  44.         }

  46.         desc->status &= ~IRQ_PENDING;
  47.         spin_unlock(&desc->lock);
  48.         /*调用由request_irq注册的处理函数，稍后分析。*/
  49.         action_ret = handle_IRQ_event(irq, action);
  50.         if (!noirqdebug)
  51.             note_interrupt(irq, desc, action_ret);
  52.         spin_lock(&desc->lock);
  53.         /*如果该中断没有被禁止，并且有其他中断等待处理（IRQ_PENDING），
  54. *则循环处理其他中断。
  55. */
  56.     } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING);

  58.     desc->status &= ~IRQ_INPROGRESS;
  59. out_unlock:
  60.     spin_unlock(&desc->lock);
  61. }

不管是电平触发还是边沿触发，最终都会通过handle_IRQ_event来调用注册的中断处理函数。


  1. <kernel/irq/handle.c>
  2. irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
  3. {
  4.     irqreturn_t ret, retval = IRQ_NONE;
  5.     unsigned int status = 0;

  7. /*如果注册中断时没有设置IRQF_DISABLED 标志，则在此处开启硬中断！开启后允许硬中断嵌套。从2.6.36版本内核开始，IRQF_DISABLED 标志被废除，此处不再开启硬中断，以防止中断嵌套可能造成栈溢出的潜在风险。详细信息参见：http://lwn.net/Articles/380931/*/
  8.     if (!(action->flags & IRQF_DISABLED))
  9.         local_irq_enable_in_hardirq();

  11.     do {
  12.         trace_irq_handler_entry(irq, action);
  13.         /*调用由request_irq注册的中断处理函数*/
  14. ret = action->handler(irq, action->dev_id);
  15.         trace_irq_handler_exit(irq, action, ret);

  17.         switch (ret) {
  18.         case IRQ_WAKE_THREAD:/*进行中断线程化处理*/
  19.             /*
  20.              * Set result to handled so the spurious check
  21.              * does not trigger.
  22.              */
  23.             ret = IRQ_HANDLED;

  25.             if (unlikely(!action->thread_fn)) {
  26.                 warn_no_thread(irq, action);
  27.                 break;
  28.             }

  30.             if (likely(!test_bit(IRQTF_DIED,
  31.                      &action->thread_flags))) {
  32.                 set_bit(IRQTF_RUNTHREAD, &action->thread_flags);
  33.             /*唤醒由request_threaded_irq注册的中断处理线程*/
  34.                 wake_up_process(action->thread);
  35.             }

  37.             /* Fall through to add to randomness */
  38.         case IRQ_HANDLED: /*中断处理函数正常返回*/
  39.             status |= action->flags;
  40.             break;

  42.         default:
  43.             break;
  44.         }

  46.         retval |= ret;
  47.         action = action->next; /*指向下一个中断处理函数*/
  48.     } while (action); /*循环调用注册在同一中断线上的中断处理函数（共享中断线）*/

  50. /*如果注册中断时指定了IRQF_SAMPLE_RANDOM 标识，
  51. *则调用add_interrupt_randomness函数，
  52. *将发生中断的时间作为随机数产生器的熵 */
  53.     if (status & IRQF_SAMPLE_RANDOM)
  54.         add_interrupt_randomness(irq);
  55. /*由于中断的开启和禁止不是嵌套的，所以与之前中断是否禁止不相关，
  56.  *由于进入handle_IRQ_event之前是禁止中断的，所以在退出时也应该禁止中断。
  57. */
  58.     local_irq_disable();

  60.     return retval;
  61. }

完成中断处理函数调用后，返回到asm_do_IRQ继续执行，其中最重要的是执行中断退出函数irq_exit：


  1. <kernel/softirq.c>
  2. void irq_exit(void)
  3. {
  4.     account_system_vtime(current);
  5.     trace_hardirq_exit();
  6.     sub_preempt_count(IRQ_EXIT_OFFSET);
  7.     if (!in_interrupt() && local_softirq_pending())
  8.         invoke_softirq();

  10. #ifdef CONFIG_NO_HZ
  11.     /* Make sure that timer wheel updates are propagated */
  12.     rcu_irq_exit();
  13.     if (idle_cpu(smp_processor_id()) && !in_interrupt() && !need_resched())
  14.         tick_nohz_stop_sched_tick(0);
  15. #endif
  16.     preempt_enable_no_resched();
  17. }

irq_exit函数首先将preempt_count计数器减去IRQ_EXIT_OFFSET，用来标识退出硬中断，这与irq_enter函数中的add_preempt_count相对应。在没有开启内核抢占特性的系统中，IRQ_EXIT_OFFSET=HARDIRQ_OFFSET，否则IRQ_EXIT_OFFSET=(HARDIRQ_OFFSET-1)，意味着如果开启内核抢占则在退出硬中断时内核要暂时禁止抢占，因为紧接着可能要处理软中断。

之后irq_exit会通过宏in_interrupt()判断当前是否处在中断（interrupt）中：

  1. #define irq_count()    (preempt_count() & (HARDIRQ_MASK | SOFTIRQ_MASK | NMI_MASK))
  2. #define in_interrupt()        (irq_count())


通过分析宏in_interrupt()可知，内核认为HARDIRQ、SOFTIRQ和NMI都属于中断（interrupt）。所以当irq_exit判断当前不处于中断且有软中断正等待处理，则调用invoke_softirq()来触发软中断处理函数，稍后分析。

处理完软中断后，如果内核支持动态时钟，irq_exit会做一些动态时钟相关的处理，然后会调用preempt_enable_no_resched()函数开启内核抢占。返回asm_do_IRQ，该函数最后通过set_irq_regs(old_regs)将寄存器集合指针恢复到发生中断之前的值。asm_do_IRQ结束后会返回入口点，再次回到汇编语言代码。详见前面对汇编代码的分析。


参考资料：

[1] Andrew N.Sloss, Dominic Symes, Chris Wright. ARM嵌入式系统开发——软件设计与优化. 沈建华, 译.

[2] Daniel P.Bovet, Marco Cesati. 深入理解Linux内核（第三版）. 陈莉君, 张琼声, 张宏伟, 译.

[3] Pobert Love. Linux内核设计与实现. 陈莉君, 康华, 张波, 译.

[4] Wolfgang Mauerer. 深入Linux内核架构. 郭旭, 译.

[5] 陈学松. 深入Linux设备驱动程序内核机制.

[6] ARM Architecture Reference Manual

[7] The ARM-THUMB Procedure Call Standard

















阅读(402) | 评论(0) | 转发(0) |
0

上一篇：ARM Linux中断源码分析（1）——中断初始化与注册

下一篇：ARM Linux中断源码分析（3）——软中断softirq

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6