[ARM&Linux]Linux下中断处理的上下文保存与切换的一些细节
我
们这里讨论ARM体系下的Linux中断处理的上下文切换部分的细节。我们只讨论底层汇编处理细节，不考虑上层。
首先，Linux的中断处理程序是经过搬移的，向量表和处理程序距离很近，这是在系统初始化的时候
就完成的。这个地方我们不做深入讨论。
Linux的向量表通过MMU安排在0xffff0000的位置，向量表如下：
.globl __vectors_start
__vectors_start:
swi SYS_ERROR0
b vector_und + stubs_offset
ldr pc, .LCvswi + stubs_offset
b vector_pabt + stubs_offset
b vector_dabt + stubs_offset
b vector_addrexcptn + stubs_offset
b vector_irq + stubs_offset
b vector_fiq + stubs_offset
其中stubs_offset定义为__vectors_start + 0x200 - __stubs_start。
这个__vectors_start就是刚才的这个向量表，而__stubs_start为中断处理程序的开始地址。
向量表在trap_init函数中建立，该函数在start_kernel中较后的位置被建立。
---------------------- --- __kuser_helper_end
/ \
| |
| | --- __kuser_helper_start -
| | |
------------------------ --- __stubs_end 0xe00
| | |
| | --- __stubs_start -
| | ^
| | |
------------------------ --- __vectos_end 0x200
| | |
| | vector 32字节 |
| | |
\ / |
---------------------- --- __vectors_start -
整个__stubs的代码如下：
.globl __stubs_start
__stubs_start:
/* 这些都是宏，IRQ_MODE等所有宏都在ptrace.h当中 */
vector_stub irq, IRQ_MODE, 4
.long __irq_usr @ 0 (USR_26 / USR_32)
.long __irq_invalid @ 1 (FIQ_26 / FIQ_32)
.long __irq_invalid @ 2 (IRQ_26 / IRQ_32)
.long __irq_svc @ 3 (SVC_26 / SVC_32)
.long __irq_invalid @ 4
.long __irq_invalid @ 5
.long __irq_invalid @ 6
.long __irq_invalid @ 7
.long __irq_invalid @ 8
.long __irq_invalid @ 9
.long __irq_invalid @ a
.long __irq_invalid @ b
.long __irq_invalid @ c
.long __irq_invalid @ d
.long __irq_invalid @ e
.long __irq_invalid @ f
/* 这些都是宏 */
vector_stub dabt, ABT_MODE, 8
.long __dabt_usr @ 0 (USR_26 / USR_32)
.long __dabt_invalid @ 1 (FIQ_26 / FIQ_32)
.long __dabt_invalid @ 2 (IRQ_26 / IRQ_32)
.long __dabt_svc @ 3 (SVC_26 / SVC_32)
.long __dabt_invalid @ 4
.long __dabt_invalid @ 5
.long __dabt_invalid @ 6
.long __dabt_invalid @ 7
.long __dabt_invalid @ 8
.long __dabt_invalid @ 9
.long __dabt_invalid @ a
.long __dabt_invalid @ b
.long __dabt_invalid @ c
.long __dabt_invalid @ d
.long __dabt_invalid @ e
.long __dabt_invalid @ f
/* 这些都是宏 */
vector_stub pabt, ABT_MODE, 4
.long __pabt_usr @ 0 (USR_26 / USR_32)
.long __pabt_invalid @ 1 (FIQ_26 / FIQ_32)
.long __pabt_invalid @ 2 (IRQ_26 / IRQ_32)
.long __pabt_svc @ 3 (SVC_26 / SVC_32)
.long __pabt_invalid @ 4
.long __pabt_invalid @ 5
.long __pabt_invalid @ 6
.long __pabt_invalid @ 7
.long __pabt_invalid @ 8
.long __pabt_invalid @ 9
.long __pabt_invalid @ a
.long __pabt_invalid @ b
.long __pabt_invalid @ c
.long __pabt_invalid @ d
.long __pabt_invalid @ e
.long __pabt_invalid @ f
/* 这些都是宏 */
vector_stub und, UND_MODE
.long __und_usr @ 0 (USR_26 / USR_32)
.long __und_invalid @ 1 (FIQ_26 / FIQ_32)
.long __und_invalid @ 2 (IRQ_26 / IRQ_32)
.long __und_svc @ 3 (SVC_26 / SVC_32)
.long __und_invalid @ 4
.long __und_invalid @ 5
.long __und_invalid @ 6
.long __und_invalid @ 7
.long __und_invalid @ 8
.long __und_invalid @ 9
.long __und_invalid @ a
.long __und_invalid @ b
.long __und_invalid @ c
.long __und_invalid @ d
.long __und_invalid @ e
.long __und_invalid @ f
.align 5
/* Linux不支持FIQ */
vector_fiq:
disable_fiq
subs pc, lr, #4
/* 这个实际上是v7引入的hypervisor入口 */
vector_addrexcptn:
b vector_addrexcptn
.align 5
.LCvswi:
.word vector_swi
.globl __stubs_end
__stubs_end:
对于上面的代码我们有以下几个结论：
1. Linux不支持FIQ，因为FIQ这东西是ARM特有的，为了保证代码的通用性，我们不应该使用这些特有的玩意儿。
不过上面并不是理由，最大的理由是，采用现成Linux中断处理框架的话，没法保证寄存器不被corrupt。
2. 对于中断/异常前的状态，Linux是分类处理的。如果位于内核态（svc模式下）那么执行__xxx_svc的代码。
如果位于用户态(usr模式下)那么执行__xxx_usr的代码。
我们下面来看vector_stub这个宏，gcc的宏相当强大：
.macro vector_stub, name, mode, correction=0
.align 5
vector_\name:
/* 如果需要修正返回地址，那么修正吧 */
.if \correction
sub lr, lr, #\correction
.endif
/* 保存r0,lr,spsr，但是sp不变，sp始终指向了r0 */
stmia sp, {r0, lr} @ save r0, lr
mrs lr, spsr
str lr, [sp, #8] @ save spsr
/* 将SVC模式的CPSR保存到SPSR中 */
mrs r0, cpsr
eor r0, r0, #(\mode ^ SVC_MODE)
msr spsr_cxsf, r0
/* 有趣的代码，lr保存的是进入中断之前的模式，根据这个模式分别让lr为__xxx_usr和__xxx_svc */
and lr, lr, #0x0f
mov r0, sp
ldr lr, [pc, lr, lsl #2]
/* 跳转的同时将spsr写入cpsr */
movs pc, lr
.endm
上面的代码会调用__xxx_usr或__xxx_svc。为了简单起见，我们只看irq的处理。
并且假设启用了CONFIG_PREEMPT，未启用TRACE_IRQFLAGS。
我们先看__irq_usr：
注意一点，现在状态位SVC，中断未开启。
.align 5
__irq_usr:
usr_entry
get_thread_info tsk
ldr r8, [tsk, #TI_PREEMPT]
add r7, r8, #1
str r7, [tsk, #TI_PREEMPT]
irq_handler
ldr r0, [tsk, #TI_PREEMPT]
str r8, [tsk, #TI_PREEMPT]
teq r0, r7
strne r0, [r0, -r0]
mov why, #0
b ret_to_user
.ltorg
Linux的特色就是大量使用宏，这点我很讨厌。
首先是usr_entry这个宏：
.macro usr_entry
/* 定义在asm-offsets.c中，也就是struct pt_regs的大小18*4字节 */
sub sp, sp, #S_FRAME_SIZE
/* 先保存r1-r12,r0保存的是IRQ状态下的堆栈指针，这个堆栈中从高到低保存的是被中断前的cpsr，中断返回地址lr，中断前的r0寄存器 */
stmib sp, {r1 - r12}
/* r1 = 中断前的r0，r2 = 中断返回地址lr，r3 = 中断前的cpsr */
ldmia r0, {r1 - r3}
/* PC在struct pt_regs（定义在ptrace.h中）中的偏移，应该是0x3c */
add r0, sp, #S_PC
mov r4, #-1
/* 保存中断前的r0 */
str r1, [sp]
/* 中断返回地址赋给PC这个空，中断前CPSR赋给CPSR这个空，中断前r0为-1，r0继续指向PC */
stmia r0, {r2 - r4}
/* 将当前的sp和lr保存给lr和sp这两个空 */
stmdb r0, {sp, lr}^
/* 定义在entry_header.S中，如果没定义CONFIG_ALIGNMENT_TRAP，这边都为空，一般就是读取LCcralign的值，然后写给CP15的系统控制寄存器 */
alignment_trap r0
/* r11/fp = 0 */
zero_fp
.endm
经过这个宏，我们在SVC中开辟了一个空间来保存pt_regs，然后我们保存了r0到r12，现在r0指向了pt_regs中的PC，r4为-1，r2为
中断返回地址lr，r3为中断前的cpsr，r11为0。
回到__irq_usr，接下来的宏是get_thread_info tsk。
这个宏也定义在entry_head.S中。我们看看：
tsk .req r9 @ current thread_info
.macro get_thread_info, rd
/* 清低13位，也就是对齐到8K，我们知道SVC状态下所有任务的thread_info都保存在连续8K内存的开头 */
mov \rd, sp, lsr #13
mov \rd, \rd, lsl #13
.endm
再次回到__irq_usr。
/* 读取thread_info中的preempt_count变量 */
ldr r8, [tsk, #TI_PREEMPT]
/* preempt_count加1 */
add r7, r8, #1
str r7, [tsk, #TI_PREEMPT]
/* 进入irq处理函数 */
irq_handler
...
现在我们的情况是r7保存了当前preempt_count的值，我们知道当这个值为0的时候将发生重调度。
我们接着进入irq_handler这个宏。
.macro irq_handler
get_irqnr_preamble r5, lr
1: get_irqnr_and_base r0, r6, r5, lr
movne r1, sp
adrne lr, 1b
bne asm_do_IRQ
test_for_ipi r0, r6, r5, lr
movne r0, sp
adrne lr, 1b
bne do_IPI
test_for_ltirq r0, r6, r5, lr
movne r0, sp
adrne lr, 1b
bne do_local_timer
.endm
依旧由很多宏构成，我们先分析从get_irq_nr_preamble r5,lr到bne asm_do_IRQ
get_irq_nr_preamble定义在和具体体系相关的文件中，一般具体体系都有个entry-macro.S
以我们内核和2440的SOC为例，这里get_irq_nr_preamble为空。
get_irqnr_and_base宏用于获得中断num，保存在r0中。
后面adrne lr,1b会将1标号的地址保存在lr中。之后调用asm_do_IRQ函数。
参数有点意思，现在r0为中断号，r1为SVC的堆栈，也就是指向struct pt_regs的r0。
asm_do_IRQ这个函数定义在体系相关的kernel/irq.c中。我们不讨论这个函数的实现，我们仅需要知道这个
函数用来处理中断。函数返回时会退到标号1处，在标号1处再次判断有没有中断产生，如果没有就退出，有的话
就继续刚才的过程。
如果是SMP平台的话，还要检查核间中断，核间中断的处理是由do_IPI实现的。
LOCAL_TIMER也是SMP平台定义的，这个我们都不用关系，我们只关心中断处理的底层过程。
下面回到__irq_usr中：
/* 再次读取preempt_count信息 */
ldr r0, [tsk, #TI_PREEMPT]
/* aapcs-linux保证r8不会被改动，r8最早为进入中断前的preempt_count */
str r8, [tsk, #TI_PREEMPT]
/* r7也不会发生改动，r7最早为r8+1 */
/* 如果r0 == r7，说明中断处理函数没有变动preempt_count */
teq r0, r7
/* 如果r0 != r7，说明中断处理函数中变动了preempt_count */
strne r0, [r0, -r0]
/* why == r8 */
mov why, #0
b ret_to_user
.ltorg
上面代码并不奇怪，最后直接调用ret_to_user，我们看看这个函数的实现：
ENTRY(ret_to_user)
ret_slow_syscall:
/* 如果中断开的话，关掉中断，有些体系压根不用实现这个，因为本身Linux自己都不是中断可嵌套的 */
disable_irq
/* 获得thread_info的flags成员 */
ldr r1, [tsk, #TI_FLAGS]
/* 是否有需要处理的，有的话跳到work_pending */
tst r1, #_TIF_WORK_MASK
bne work_pending
...
我们一路追踪到了work_pending，我们进入这个函数看看。
work_pending:
/* 判断是否要重调度 */
tst r1, #_TIF_NEED_RESCHED
/* work_resched用于重调度 */
bne work_resched
/* 这两个标志前面那个_TIF_NOTIFY_RESUME用来实现一个notification的机制，这个机制可以
让内核在从内核态切换到和用户态的时候执行一些操作，后者用于实现signal */
tst r1, #_TIF_NOTIFY_RESUME | _TIF_SIGPENDING
/* 没有设置的话直接回到前面的函数中 */
beq no_work_pending
/* why == r8 */
mov r0, sp @ 'regs'
mov r2, why @ 'syscall'
/* 运行notification */
bl do_notify_resume
/* 准备返回 */
b ret_slow_syscall @ Check work again
这里work_resched用于上下文切换，而do_notify_resume用于实现signal。
work_resched函数直接调用schedule函数进行上下文切换。
我们这边只关心ret_slow_syscall，这个函数其实就是ret_to_user。
继续测试是否需要重调度，如果不需要的话，函数继续执行下去
no_work_pending:
arch_ret_to_user r1, lr
/* 从上面一路下来，我们的堆栈还是平衡的，现在sp指向的是struct pt_regs的r0 */
ldr r1, [sp, #S_PSR] @ get calling cpsr
/* sp 指向PC */
ldr lr, [sp, #S_PC]! @ get pc
msr spsr_cxsf, r1 @ save in spsr_svc
/* 全部恢复，注意只有当寄存器列表包括PC时，才将spsr赋值给cpsr，这里标识有^表示，该
指令将把r0-lr加载到用户/系统模式下的r0-lr中去。这个^不能再usr和sys模式下使用！ */
ldmdb sp, {r0 - lr}^ @ get calling r1 - lr
mov r0, r0
/* 堆栈恢复平衡 */
add sp, sp, #S_FRAME_SIZE - S_PC
movs pc, lr @ return & move spsr_svc into cpsr
首先又来了一个arch_ret_to_user的宏。这个宏是SOC相关的，比如我们用的2440这个宏就是
个空的。
至此__irq_usr就全部分析完毕，我们接下来分析__irq_svc。__irq_svc运行在SVC模式下，当前r0
为irq模式下的堆栈，堆栈情况如下：
cpsr_svc@被中断前的cpsr
lr@中断返回地址
r0@中断前的r0
此处我们仍考虑配置了内核抢占，__irq_svc全貌如下，我们分几个部分来研究：
1. svc_entry
2. get_thread_info tsk 到 irq_handler
3. irq_handler 到 svc_prempt
4. preempt_return
.align 5
__irq_svc:
svc_entry
get_thread_info tsk
ldr r8, [tsk, #TI_PREEMPT] @ get preempt count
add r7, r8, #1 @ increment it
str r7, [tsk, #TI_PREEMPT]
irq_handler
ldr r0, [tsk, #TI_FLAGS] @ get flags
tst r0, #_TIF_NEED_RESCHED
blne svc_preempt
preempt_return:
ldr r0, [tsk, #TI_PREEMPT] @ read preempt value
str r8, [tsk, #TI_PREEMPT] @ restore preempt count
teq r0, r7
strne r0, [r0, -r0] @ bug()
ldr r0, [sp, #S_PSR] @ irqs are already disabled
msr spsr_cxsf, r0
ldmia sp, {r0 - pc}^ @ load r0 - pc, cpsr
.ltorg
我们先来研究第一部分，svc_entry这个宏作用类似于usr_entry
.macro svc_entry
/* 定义在asm-offsets.c中，也就是struct pt_regs的大小18*4字节 */
sub sp, sp, #S_FRAME_SIZE
/* 先保存r1-r12 */
stmib sp, {r1 - r12}
/* r0为irq_sp，现在r1为中断前的r0，r2为中断返回地址，r3为中断前的cpsr */
ldmia r0, {r1 - r3}
/* r5指向SP这个SLOT，具体见struct pt_regs */
add r5, sp, #S_SP
mov r4, #-1
/* r0指向SVC中断前的栈 */
add r0, sp, #S_FRAME_SIZE
/* 将中断前的r0保存到r0这个SLOT */
str r1, [sp]
/* 保存中断前的lr */
mov r1, lr
/* 分别保存-1，CPSR到CPSR，中断返回地址到PC，中断前lr到LR，中断前堆栈到sp */
stmia r5, {r0 - r4}
.endm
svc_entry操作完成后，pt_regs已经保存了中断前的所有数据用于返回中断时使用。
下面我们来研究第二部分。
/* 这个没啥好说的，前面说过了，tsk为r9 */
get_thread_info tsk
/* 读取当前任务抢占计数 */
ldr r8, [tsk, #TI_PREEMPT] @ get preempt count
/* 抢占计数+1 */
add r7, r8, #1 @ increment it
/* 保存进去，进行irq_handler */
str r7, [tsk, #TI_PREEMPT]
irq_handler
这一部分代码和usr_entry完全一样。下面我们来研究第三部分
/* 读取是否需要重调度标志 */
ldr r0, [tsk, #TI_FLAGS] @ get flags
/* 测试是否需要重调度 */
tst r0, #_TIF_NEED_RESCHED
/* 如果需要则跳转到svc_preempt函数 */
blne svc_preempt
我们来看看svc_preempt，这个场景是内核态任务抢占。
svc_preempt:
/* 中断前抢占计数是否为0 */
teq r8, #0 @ was preempt count = 0
/* irq_stat是一个irq_cpustat_t结构体，LCirq_stat保存了这个结构体的地址 */
ldreq r6, .LCirq_stat
/* 非0不进行内核抢占 */
movne pc, lr @ no
ldr r0, [r6, #4] @ local_irq_count
ldr r1, [r6, #8] @ local_bh_count
/* local_irq_count和local_bh_count都为0 */
adds r0, r0, r1
/* 不为0的话不进行上下文切换 */
movne pc, lr
/* 将抢占计数清位0 */
mov r7, #0 @ preempt_schedule_irq
str r7, [tsk, #TI_PREEMPT] @ expects preempt_count == 0
/* 调用preempt_schedule_irq */
1: bl preempt_schedule_irq @ irq en/disable is done inside
/* 切换到另一个任务 */
ldr r0, [tsk, #TI_FLAGS] @ get new tasks TI_FLAGS
/* 测试这个任务是否需要重调度 */
tst r0, #_TIF_NEED_RESCHED
/* 不需要就直接preempt_return */
beq preempt_return @ go again
/* 否则继续任务切换 */
b 1b
这一块代码都非常清晰，我们直接回到了preempt_return。
preempt_return:
/* 再次读抢占计数 */
ldr r0, [tsk, #TI_PREEMPT] @ read preempt value
/* 还原最早的抢占计数 */
str r8, [tsk, #TI_PREEMPT] @ restore preempt count
/* 抢占计数变化了么？ */
teq r0, r7
/* 变化了就奇怪了 */
strne r0, [r0, -r0] @ bug()
/* 读取中断前的CPSR */
ldr r0, [sp, #S_PSR] @ irqs are already disabled
/* 保存到spsr */
msr spsr_cxsf, r0
/* 恢复所有寄存器，返回中断前的状态 */
ldmia sp, {r0 - pc}^ @ load r0 - pc, cpsr