~/arch/arm/kernel/traps.c   line783

void __init early_trap_init(void)

{

#if defined(CONFIG_CPU_USE_DOMAINS)

         unsigned long vectors = CONFIG_VECTORS_BASE;                //vectors是中断向量基地址

#else

         unsigned long vectors = (unsigned long)vectors_page;

#endif

/*以下这些都在arch/arm/kernel/entry-armv.S下定义*/

         extern char __stubs_start[], __stubs_end[];

         extern char __vectors_start[], __vectors_end[];

         extern char __kuser_helper_start[], __kuser_helper_end[];

         int kuser_sz = __kuser_helper_end - __kuser_helper_start;

         /*

          * Copy the vectors, stubs and kuser helpers (in entry-armv.S)

          * into the vector page, mapped at 0xffff0000, and ensure these

          * are visible to the instruction stream.

          */

/*__vectors_end 至 __vectors_start之间为异常向量表。__stubs_end至
__stubs_start之间是异常处理的位置。这些变量定义都在arch/arm/kernel/entry-armv.S中*/

         memcpy((void *)vectors, __vectors_start, __vectors_end - __vectors_start);

         memcpy((void *)vectors + 0x200, __stubs_start, __stubs_end - __stubs_start);

         memcpy((void *)vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz);

         /*

          * Do processor specific fixups for the kuser helpers

          */

         kuser_get_tls_init(vectors);

         /*

          * Copy signal return handlers into the vector page, and

          * set sigreturn to be a pointer to these.

          */

         memcpy((void *)(vectors + KERN_SIGRETURN_CODE - CONFIG_VECTORS_BASE),

                sigreturn_codes, sizeof(sigreturn_codes));

         memcpy((void *)(vectors + KERN_RESTART_CODE - CONFIG_VECTORS_BASE),

                syscall_restart_code, sizeof(syscall_restart_code));

         flush_icache_range(vectors, vectors + PAGE_SIZE);

         modify_domain(DOMAIN_USER, DOMAIN_CLIENT);

} 

         .globl        __vectors_start                      
//异常向量表开始0xFFFF0000

__vectors_start:

 ARM(     swi   SYS_ERROR0   )

 THUMB(         svc   #0             )

 THUMB(         nop                    )

         W(b)         vector_und + stubs_offset

         W(ldr)      pc, .LCvswi + stubs_offset

         W(b)         vector_pabt + stubs_offset

         W(b)         vector_dabt + stubs_offset

         W(b)         vector_addrexcptn + stubs_offset

         W(b)         vector_irq + stubs_offset       //中断发生后的跳转地址0xFFFF0018

         W(b)         vector_fiq + stubs_offset

         .globl        __vectors_end

__vectors_end:

.align       5

vector_irq:

       sub  lr, lr, 4                                        //因为异常发生时，cpu将pc地址+4赋值给lr，这里做修正。     

       @ Save r0, lr_<exception> (parent PC) and spsr_<exception>

       @ (parent CPSR)

       @

       stmia       sp, {r0, lr}      
//保存r0, lr，到irq堆栈中（每个异常都有属于自己的堆栈）

       mrs  lr, spsr                                
//lr保存spsr_irq的值，即usr状态的cpsr的值（见2.1）

       str   lr, [sp, #8]            
// 保存 spsr到[sp+8]处

       @ Prepare for SVC32 mode.  IRQs remain disabled.

       @

       mrs  r0, cpsr

       eor   r0, r0,#( IRQ_MODE ^ SVC_MODE| PSR_ISETSTATE)    //  PSR_ISETSTATE：选择ARM/Thumb指令集
                                            

       msr  spsr_cxsf, r0                            
 //这里的cxsf表示从低到高分别占用的4个8bit的数据域

       @ the branch table must immediately follow this code

       and  lr, lr, #0x0f              
//提取发生异常前的处理器模式，这里也就是usr模式

       mov  r0, sp              

       ldr   lr, [pc, lr, lsl #2]                                             

       movs      pc, lr 
                  

/*

 * Interrupt dispatcher以下跳转表必须紧跟在vector_irq之后

 */

vector_stub                                                                         irq, IRQ_MODE, 4   //生成vector_irq

 /* 从用户态进入中断的处理函数 */

.long                                                                                     __irq_usr                    @  0  (USR_26 / USR_32)

.long                                                                                     __irq_invalid                       @  1  (FIQ_26 / FIQ_32)

.long                                                                                     __irq_invalid                       @  2  (IRQ_26 / IRQ_32)

   /* 从SVC进入中断的处理函数 */

.long                                                                                     __irq_svc                    @  3  (SVC_26 / SVC_32)

.long                                                                                     __irq_invalid                       @  4

.long                                                                                     __irq_invalid                       @  5

.long                                                                                     __irq_invalid                       @  6

         .align        5

__irq_usr:

         usr_entry         //用于用户模式下发生中断时初始化中断处理堆栈，同时保存所有SVC态寄存器到堆栈。

         kuser_cmpxchg_check   //对低版本的ARM核来说，用户态无法实现原子比较交换。如果用户态在处理原

                        //子比较交换的过程中发生中断，需要特殊处理，略过

         get_thread_info tsk   //根据当前sp指针，将该指针最右边13位清0，获得当前任务的thread_info

#ifdef CONFIG_PREEMPT   //如果可以抢占，递增任务的抢占计数

         ldr    r8, [tsk, #TI_PREEMPT]           //T被定义为offsetof(struct thread_info, preempt_count)，显然通过tsk就

                                                                     可以很容易得到进程preempt_count成员的地址了

         add  r7, r8, #1                   @ increment it

         str    r7, [tsk, #TI_PREEMPT]

#endif

         irq_handler              //中断服务例程，后面分析

#ifdef CONFIG_PREEMPT 

         ldr    r0, [tsk, #TI_PREEMPT]   // 获得当前的抢占计数

         str    r8, [tsk, #TI_PREEMPT]  //并将r8中的值保存回去。相当于将前一步递增的抢占计数减回去了

         teq   r0, r7                                 
//r0,r7是调用irq_handler前后的抢占计数，这里进行比较，是防止驱动的ISR

                            //程序没有配对操作抢占计数导致系统错误。

 ARM(     strne        r0, [r0, -r0]      ) //如果抢占计数被破坏，则强制写入0.

 THUMB(         movne     r0, #0                )

 THUMB(         strne        r0, [r0]     )

#endif

         mov why, #0

         b       ret_to_user     //返回到用户态

 UNWIND(.fnend            )

ENDPROC(__irq_usr)

arch/arm/include/asm/ptrace.h

struct pt_regs {

         unsigned long uregs[18];

};

#endif /* __KERNEL__ */

#define ARM_cpsr           uregs[16]

#define ARM_pc              uregs[15]

#define ARM_lr                uregs[14]

#define ARM_sp              uregs[13]

#define ARM_ip               uregs[12]

#define ARM_fp              uregs[11]

#define ARM_r10            uregs[10]

#define ARM_r9              uregs[9]

……

#define ARM_ORIG_r0   uregs[17]

.macro      usr_entry  //usr_entry宏定义

 UNWIND(.fnstart )

 UNWIND(.cantunwind )        @ don't unwind the user space

sub sp, sp, #S_FRAME_SIZE          @ S_FRAME_SIZE定义在 trimslice-kernel\arch\arm\kernel\arm-offsets.c中S_FRAME_SIZE被定义为
sizeof(struct pt_regs)的大小=18*4=72字节，将svc32堆栈指针向低地址方向移动一个pt_regs结构大小，用于保存svc模式下的寄存器现场。

ARM(        stmib        sp, {r1 - r12}    )  @向svc32堆栈中保存寄存器现场

 THUMB(         stmia        sp, {r0 - r12}    )

         ldmia        r0, {r3 - r5}     
@前面r0存放的是irq模式下的栈指针sp的值，从栈中取出r0-r2存放到r3-r5中

         add  r0, sp, #S_PC           
@ here for interlock avoidance；S_PC定义为offsetof(struct pt_regs, ARM_pc)，所

                                                    以这里通过add指令将r0指向ARM_pc

         mov r6, #-1                       @ 
r6中保存-1

         str    r3, [sp]             @ save the "real" r0 copied从中断栈中取出真实的r0存放到pt_regs->r0中。

                                            @ from the exception stack

         @ We are now ready to fill in the remaining blanks on the stack:

         @

         @  r4 - lr_<exception>, already fixed up for correct return/restart

         @  r5 - spsr_<exception>

         @  r6 - orig_r0 (see pt_regs definition in ptrace.h)

         @

         @ Also, separately save sp_usr and lr_usr

         @

         stmia        r0, {r4 - r6}  
//stmia将svc模式下的寄存器r4-r6保存到ARM_pc，ARM_cpsr和

                                                             ARM_ORIG_r0,显然ARM_ORIG_r0保存了-1（r6）这个常量

 ARM(     stmdb      r0, {sp, lr}^                        )
//stmdb指令的^标志表示存储发生中断的模式下的sp,lr寄存器

                                                                    到ARM_sp和ARM_lr中。

 THUMB(         store_user_sp_lr r0, r1, S_SP - S_PC      )

         @ Enable the alignment trap while in kernel mode

         alignment_trap r0          
//alignment_trap在配置CONFIG_ALIGNMENT_TRAP时有效，如果开启了该选

                                                     //项，中断处理中将支持对齐跟踪

         @ Clear FP to mark the first stack frame

         zero_fp                             
//zero_fp用来设置fp栈帧寄存器为0

#ifdef CONFIG_IRQSOFF_TRACER

         bl      trace_hardirqs_off

#endif

         .endm                       
@usr_entry宏定义结束

arch/arm/kernel/entry-header.S

  .macro  get_thread_info, rd

  mov     \rd, sp, lsr #13

  mov     \rd, \rd, lsl #13

  .endm

linux/arch/arm/kernel/entry-armv.S

/*

 * Interrupt handling.  Preserves r7, r8, r9

 */

         .macro     irq_handler

#ifdef CONFIG_MULTI_IRQ_HANDLER

         ldr    r5, =handle_arch_irq

         mov r0, sp

         ldr    r5, [r5]

         adr   lr, BSYM(9997f)

         teq   r5, #0

         movne     pc, r5

#endif

         arch_irq_handler_default

9997:

         .endm

arch/arm/include/asm/entry_macro_multi.S

/*

 * Interrupt handling.  Preserves r7, r8, r9

 */

         .macro     arch_irq_handler_default    //get_irqnr_preamble用来获取中断状态寄存器基地址

         get_irqnr_preamble  r5, lr   //将中断控制器的状态寄存器的地址存储到r5

1:     get_irqnr_and_base r0, r6, r5, lr //判断中断号，通过r0返回

         movne     r1, sp  //如果还存在中断，就将sp作为第二个参数，调用asm_do_IRQ。sp目前指向pt_regs

         @

         @ routine called with r0 = irq number, r1 = struct pt_regs *

         @

         adrne       lr, BSYM(1b) //这里将lr设置为get_irqnr_and_base的第二条指令，因为第二次循环时，不必执行其第一条指令(加载寄存器基址)

         bne  asm_do_IRQ   //将中断号、pt_regs(中断前的寄存器现场)传递给asm_do_IRQ。asm_do_IRQ返回时，

                                            //会返回到get_irqnr_and_base处，直到所有中断都已经处理完毕才退出循环。

#ifdef CONFIG_SMP  //针对SMP系统的处理

         /*

          * this macro assumes that irqstat (r6) and base (r5) are

          * preserved from get_irqnr_and_base above

          */

         ALT_SMP(test_for_ipi r0, r6, r5, lr) //
这里是从寄存器中读取ipi标志

         ALT_UP_B(9997f)

         movne     r1, sp

         adrne       lr, BSYM(1b)  //同理，这里也是将返回地址设置为ALT_SMP的第二条指令，构造成一个循环

         bne  do_IPI    //只要存在IPI就调用do_IPI，并循环直到处理完所有IPI

#ifdef CONFIG_LOCAL_TIMERS   // 同理，这里循环处理多核系统中的本地时钟中断。

         test_for_ltirq r0, r6, r5, lr

         movne     r0, sp

         adrne       lr, BSYM(1b)

         bne  do_local_timer

#endif

#endif

9997:

         .endm

/* arch/arm/mach-tegra/include/mach/entry-macro.S     

         /* Uses the GIC interrupt controller built into the cpu */

#define ICTRL_BASE (IO_CPU_VIRT + 0x40100)  // #define IO_CPU_VIRT     0xFE000000

.macro     get_irqnr_preamble, base, tmp

         movw \base, #(ICTRL_BASE & 0x0000ffff)

         movt \base, #((ICTRL_BASE & 0xffff0000) >> 16)

         .endm

/* arch/arm/mach-tegra/include/mach/entry-macro.S     

.macro     get_irqnr_and_base, irqnr, irqstat, base, tmp

         ldr \irqnr, [\base, #0x20]        @ EVT_IRQ_STS

         cmp \irqnr, #0x80

         .endm

linux/arch/arm/kernel/irq.c

asmlinkage void __exception_irq_entry

asm_do_IRQ(unsigned int irq, struct pt_regs *regs)

{

         struct pt_regs *old_regs = set_irq_regs(regs);
//获得寄存器值

         irq_enter();  

         /*

          * Some hardware gives randomly wrong interrupts.  Rather

          * than crashing, do something sensible.

          */

         if (unlikely(irq >= nr_irqs)) {

                  if (printk_ratelimit())

                          printk(KERN_WARNING "Bad IRQ%u\n", irq);

                  ack_bad_irq(irq);

         } else {

                  generic_handle_irq(irq);

         }

         /* AT91 specific workaround */

         irq_finish(irq);

         irq_exit();

         set_irq_regs(old_regs);

}

linux/kernel/softirq.c

void irq_enter(void)

{

         int cpu = smp_processor_id();

         rcu_irq_enter();

         if (idle_cpu(cpu) && !in_interrupt()) {

                  /* Prevent raise_softirq from needlessly waking up ksoftirqd

                   * here, as softirq will be serviced on return from interrupt.*/

                  local_bh_disable();

                  tick_check_idle(cpu);

                  _local_bh_enable();

         }

         __irq_enter();

}

#define __irq_enter()                                        \

         do {                                             \

                  account_system_vtime(current);           \

                  add_preempt_count(HARDIRQ_OFFSET);     \

                  trace_hardirq_enter();                     \

         } while (0)

~/include /linux/Irqdesc.h

/*

 * Architectures call this to let the generic IRQ layer

 * handle an interrupt. If the descriptor is attached to an

 * irqchip-style controller then we call the ->handle_irq() handler,

 * and it calls __do_IRQ() if it's attached to an irqtype-style controller.

 */

static inline void generic_handle_irq_desc(unsigned int irq,
struct irq_desc *desc)

{

         desc->handle_irq(irq, desc);  //调用该irq注册的函数处理，该函数在注册中断时填写irq_desc结构体时指定。

}                                                           
// handle_irq是个函数指针，它用来实现中断处理器的电流处理。电流处理分为边

                                                             //沿跳变处理和电平处理。

static inline void generic_handle_irq(unsigned int irq) //该函数是与体系结构无关的通用逻辑层API

{

         generic_handle_irq_desc(irq, irq_to_desc(irq));

}

arch/arm/kernel/entry-common.S

/*

 * "slow" syscall return path.  "why" tells us if this was a real syscall.

 */

ENTRY(ret_to_user)

ret_slow_syscall:

         disable_irq                                 @ disable interrupts

         ldr    r1, [tsk, #TI_FLAGS]   //从任务的TI_FLAGS标志判断是否需要处理抢占或者信号。

         tst    r1, #_TIF_WORK_MASK

         bne  work_pending    //处理抢占或者信号

no_work_pending:         //没有抢占或者信号需要处理，或者已经处理完毕，开始退回用户态

#if defined(CONFIG_IRQSOFF_TRACER)  //退回用户态必然会打开中断，这里记录下打开中断的事实，供调试用。

         asm_trace_hardirqs_on

#endif

         /* perform architecture specific actions before user return */

         arch_ret_to_user r1, lr   //在返回用户态前，处理各个体系结构的钩子

         restore_user_regs fast = 0, offset = 0  //恢复寄存器现场，并切回用户态。这里不再具体分析恢复方式。

ENDPROC(ret_to_user)