Exception -2- (ARM32 Handler 1)

<kernel v5.4>

Exception Entry

32bit ARM 프로세스에 exception이 발생하면 가상 벡터 주소의 각 exception을 담당하는 8개의  엔트리로 jump를 하게된다.

가장 첫 exception 엔트리가 reset 벡터가 있고 그 뒤로 나머지 7개의 exception 엔트리가 위치한다. 다음 8개의 exception 별로 호출되는 부분을 알아보자.

  • Reset
    • vector_rst 레이블로 jump 하고 swi 0을 호출하여 swi exception을 발생하게 한 후 이어서 vector_und: 레이블로 jump 한다.
  • Undefined
    • vector_und 레이블로 jump 하고 exception 당시의 프로세스 모드에 따라 __und_usr, __und_svc 또는 __und_invalid 레이블로 점프한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc 위치로 복귀한다.
  • SWI
    • 벡터 테이블 바로 다음 페이지에 위치한 첫 엔트리에 vector_swi 레이블의 위치가 담겨있고 이 위치로 jump 한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc-4 위치로 복귀한다.
  • Prefetch Abort
    • vector_pabt 레이블로 jump 하고 exception 당시의 프로세스 모드에 따라 __pabt_usr, __pabt_svc 또는 __pabt_invalid 레이블로 점프한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc-4 위치로 복귀한다.
  • Data Abort
    • vector_dabt 레이블로 jump 하고 exception 당시의 프로세스 모드에 따라 __dabt_usr, __dabt_svc 또는 __dabt_invalid 레이블로 점프한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc-8 위치로 복귀한다.
  • Address
    • vector_addrexcptn 레이블로 jump 한다. 이 주소는 현재 사용하지 않으므로 이 곳으로 진입하면 매우 위험하다.
  • IRQ
    • vector_irq 레이블로 jump 하고 exception 당시의 프로세스 모드에 따라 __irq_usr, __irq_svc 또는 __irq_invalid 레이블로 점프한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc-4 위치로 복귀한다.
  • FIQ
    • vector_fiq 레이블로 jump 하고 exception 당시의 프로세스 모드에 따라 __fiq_usr, __fiq_svc 또는 __fiq_abt  레이블로 점프한다.
    • exception 처리를 마치고 돌아가는 주소는 exception 당시의 pc-4 위치로 복귀한다.

 

Exception시 모드 전환

아래 그림은 exception 발생 시 모드의 변환과 주요 처리 내용을 보여준다.

  • swi에서 syscall 처리 후 전체 레지스터 중 r0는 제외한다. (r0는 syscall에 대한 결과 값)

 

Context 저장 및 복원

exception으로 인해 context(레지스터들)를 보호하기 위해 스택에 저장한다.

  • 리눅스 커널은 AEABI 규칙을 사용하므로 sp 주소 증가시 8바이트 정렬하여야 하다.

 

다음 그림은 커널(svc) 및 유저(usr) 동작 시 exception이 발생하여 context를 저장하는 크기를 비교하여 보여준다.

 

svc_pt_regs 구조체

arch/arm/include/asm/ptrace.h

struct svc_pt_regs {
        struct pt_regs regs;
        u32 dacr;
        u32 addr_limit;
};

커널(svc)에서 exception이 발생 시 dacr, addr_limit 및 pt_regs를 포함한 svc_pt_regs 구조체를 사용하여 저장과 복원을 한다.

 

pt_regs 구조체

arch/arm/include/asm/ptrace.h

struct pt_regs {
        unsigned long uregs[18];
};

context 백업 및 복원에 사용하는 레지스터들이다.

 

C 루틴에서 참고되는 매크로 레지스터들

include/uapi/asm/ptrace.h

#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_r8          uregs[8]
#define ARM_r7          uregs[7]
#define ARM_r6          uregs[6]
#define ARM_r5          uregs[5]
#define ARM_r4          uregs[4]
#define ARM_r3          uregs[3]
#define ARM_r2          uregs[2]
#define ARM_r1          uregs[1]
#define ARM_r0          uregs[0]
#define ARM_ORIG_r0     uregs[17]
  • uregs[0] ~ uregs[15]는 r0~r15 레지스터를 보관하는데 사용한다.
  • uregs[16]의 경우 cpsr 레지스터를 보관한다.
  • uregs[17]의 경우 호출 당시의 r0 레지스터를 보관한다.

 

Assembly 루틴에서 참고되는 매크로 상수들

arch/arm/kernel/asm-offsets.c

  DEFINE(S_R0,                  offsetof(struct pt_regs, ARM_r0));
  DEFINE(S_R1,                  offsetof(struct pt_regs, ARM_r1));
  DEFINE(S_R2,                  offsetof(struct pt_regs, ARM_r2));
  DEFINE(S_R3,                  offsetof(struct pt_regs, ARM_r3));
  DEFINE(S_R4,                  offsetof(struct pt_regs, ARM_r4));
  DEFINE(S_R5,                  offsetof(struct pt_regs, ARM_r5));
  DEFINE(S_R6,                  offsetof(struct pt_regs, ARM_r6));
  DEFINE(S_R7,                  offsetof(struct pt_regs, ARM_r7));
  DEFINE(S_R8,                  offsetof(struct pt_regs, ARM_r8));
  DEFINE(S_R9,                  offsetof(struct pt_regs, ARM_r9));
  DEFINE(S_R10,                 offsetof(struct pt_regs, ARM_r10));
  DEFINE(S_FP,                  offsetof(struct pt_regs, ARM_fp));
  DEFINE(S_IP,                  offsetof(struct pt_regs, ARM_ip));
  DEFINE(S_SP,                  offsetof(struct pt_regs, ARM_sp));
  DEFINE(S_LR,                  offsetof(struct pt_regs, ARM_lr));
  DEFINE(S_PC,                  offsetof(struct pt_regs, ARM_pc));
  DEFINE(S_PSR,                 offsetof(struct pt_regs, ARM_cpsr));
  DEFINE(S_OLD_R0,              offsetof(struct pt_regs, ARM_ORIG_r0));
  DEFINE(PT_REGS_SIZE,          sizeof(struct pt_regs));
  DEFINE(SVC_DACR,              offsetof(struct svc_pt_regs, dacr));
  DEFINE(SVC_ADDR_LIMIT,        offsetof(struct svc_pt_regs, addr_limit));
  DEFINE(SVC_REGS_SIZE,         sizeof(struct svc_pt_regs));
  • PT_REGS_SIZE
    • pt_regs 구조체 사이즈
  • SVC_REGS_SIZE
    • svc_pt_regs 구조체 사이즈

 


공통 핸들러

유저 모드에서 진입 시 레지스터 백업

usr_entry 매크로

arch/arm/kernel/entry-armv.S (THUMB 코드 생략)

/*
 * User mode handlers
 *
 * EABI note: sp_svc is always 64-bit aligned here, so should PT_REGS_SIZE
 */
#if defined(CONFIG_AEABI) && (__LINUX_ARM_ARCH__ >= 5) && (PT_REGS_SIZE & 7)
#error "sizeof(struct pt_regs) must be a multiple of 8"
#endif
        .macro  usr_entry, trace=1, uaccess=1
 UNWIND(.fnstart        )
 UNWIND(.cantunwind     )       @ don't unwind the user space
        sub     sp, sp, #PT_REGS_SIZE
 ARM(   stmib   sp, {r1 - r12}  )

 ATRAP( mrc     p15, 0, r7, c1, c0, 0)
 ATRAP( ldr     r8, .LCcralign)

        ldmia   r0, {r3 - r5}
        add     r0, sp, #S_PC           @ here for interlock avoidance
        mov     r6, #-1                 @  ""  ""     ""        ""

        str     r3, [sp]                @ save the "real" r0 copied
                                        @ from the exception stack

 ATRAP( ldr     r8, [r8, #0])

        @
        @ 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}
 ARM(   stmdb   r0, {sp, lr}^                   )

        .if \uaccess
        uaccess_disable ip
        .endif

        @ Enable the alignment trap while in kernel mode
 ATRAP( teq     r8, r7)
 ATRAP( mcrne   p15, 0, r8, c1, c0, 0)

        @
        @ Clear FP to mark the first stack frame
        @
        zero_fp

        .if     \trace
#ifdef CONFIG_TRACE_IRQFLAGS
        bl      trace_hardirqs_off
#endif
        ct_user_exit save = 0
        .endif
        .endm

유저 프로세스에 exception이 발생한 경우이다. 레지스터들을 스택에 백업한다.

  • 해당 exception 모드(fiq, irq, pabt, dabt, und)에서 3개의 레지스터를 3 word로 구성된 mini stack에 백업한다.
  • svc 모드로 전환하고 다음과 같이 처리한다.
    • 스택에 18개의 레지스터를 보관할 수 있는 pt_regs 구조체 사이즈만큼 키운 후 레지스터들을 백업한다.
    • alignment trap을 enable하기 위해 cr_alignment 값을 읽어 SCTLR에 저장한다.
    • 그 외 irq disable된 기간 및 컨텍스트  트래킹 등을 수행한다.

 

  • 코드 라인 4에서 스택을 pt_regs 구조체 사이즈만큼 키운다. (grows down)
  • 코드 라인 5에서 r1~r12 레지스터들의 정보를 스택의 pt_regs 영역에 저장한다.
    • stmib (Store Memory Increment Before)를 사용하여 sp를 워드만큼 먼저 증가 시킨 후 레지스터들을 저장한다.
  • 코드 라인 7~8에서 SCTLR 값을 r7 레지스터에 읽어오고 전역 변수 cr_alignment 주소를 r8 레지스터에 대입한다.
    • ATRAP() 매크로는 CONFIG_ALIGNMENT_TRAP 커널 옵션이 사용되는 아키텍처에서 사용된다. (대부분의 arm에 적용됨)
    • 잠시 후 매크로 종료전에 cr_alignment 값과 SCTLR 값을 비교하여 alignment trap을 enable하기 위해 cr_alignment 값을 읽어서 SCTLR에 저장한다.
  • 코드 라인 10에서 mini 스택에서 백업한 값들을 r3~r5 레지스터에 로드한다.
  • 코드 라인 11에서 r0에  스택의 &ptregs.pc 주소를 알아온다.
  • 코드 라인 12에서 r6에 -1 값을 대입한다.
  • 코드 라인 14에서 r3(original r0) 레지스터 값을 pt_regs의 가장 첫 엔트리(r0)에 저장한다.
  • 코드 라인 17에서 전역 변수 cr_alignment 값을 읽어서 r8 레지스터에 저장한다.
  • 코드 라인 28에서 교정된 lr 값, psr 값, -1 값을 pt_regs 구조체의 pc, psr, old-rq에 순서대로 저장한다.
  • 코드 라인 29에서 sp와 lr 값을 pt_regs 구조체의 sp와 lr 위치에 그대로 저장한다.
  • 코드 라인 31~33에서 커널에서 유저 영역의 액세스를 제한한다. 그 전의 액세스 여부 값을 ip 레지스터에 담아온다.
  • 코드 라인 36~37에서 SCTLR 값을 읽은 r7 레지스터와 cr_alignment 값을 읽은 r8 레지스터 값을 비교해서 다른 경우에만 cr_alignment 값을 SCTLR에 저장한다.
    • SCTLR을 저장하는데 약 100 사이클 정도의 시간이 걸리므로 성능을 위해 변경 사항이 있는 경우에만 저장한다.
  • 코드 라인 42에서 fp 레지스터를 0으로 설정한다.
    • gcc 툴에서 tracing에 사용하는 fp 레지스터를 0으로 초기화한다.
    • exception 모드가 바뀌면 그 전 stack back trace 정보를 사용할 수 없으므로 이 시점에서 초기화한다.
  • 코드 라인 44~47에서 CONFIG_IRQSOFF_TRACER 커널 옵션이 사용되는 경우  얼마나 오랫동안 인터럽트가 disable 되었는지 그 주기를 알아보기 위한 트래킹 디버깅을 수행한다.
  • 코드 라인 48에서 컨텍스트 트래킹 디버깅이 enable된 경우에 수행된다.

 

다음 그림은 유저 모드에서 exception에 의해 해당 모드에 진입 시 레지스터들을 백업하는 usr_entry 매크로의 기능을 보여준다.

zero_fp 매크로

arch/arm/kernel/entry-header.S

        .macro  zero_fp
#ifdef CONFIG_FRAME_POINTER
        mov     fp, #0
#endif
        .endm

CONFIG_FRAME_POINTER 커널 옵션을 사용하는 경우 커널에서 문제가 발생했을 때 다양한 보고가 가능하도록 한다. 이 커널 옵션을 사용하지 않으면 보고되는 정보가 심각하게 제한된다.

 

trace_hardirqs_off()

kernel/trace/trace_irqsoff.c

void trace_hardirqs_off(void)
{
        if (!preempt_trace() && irq_trace())
                start_critical_timing(CALLER_ADDR0, CALLER_ADDR1);
}
EXPORT_SYMBOL(trace_hardirqs_off);

얼마나 오랫동안 인터럽트가 disable 되었는지 그 주기를 알아보기 위한 트래킹 디버깅을 수행한다.

 

ct_user_exit 매크로

arch/arm/kernel/entry-header.S

/*
 * Context tracking subsystem.  Used to instrument transitions
 * between user and kernel mode.
 */     
        .macro ct_user_exit, save = 1
#ifdef CONFIG_CONTEXT_TRACKING
        .if     \save
        stmdb   sp!, {r0-r3, ip, lr}
        bl      context_tracking_user_exit
        ldmia   sp!, {r0-r3, ip, lr}
        .else
        bl      context_tracking_user_exit
        .endif
#endif
        .endm

CONFIG_CONTEXT_TRACKING 커널 옵션을 사용하면서 전역 static key 변수 context_tracking_enabled이 설정된 경우 컨텍스트 트래킹에 관련한  후처리 디버그 활동을 수행한다.

 

SVC 모드에서 진입 시 레지스터 백업

svc_entry

arch/arm/kernel/entry-armv.S (THUMB 코드 생략)

/*
 * SVC mode handlers
 */
        .macro  svc_entry, stack_hole=0, trace=1, uaccess=1
 UNWIND(.fnstart                )
 UNWIND(.save {r0 - pc}         )
        sub     sp, sp, #(SVC_REGS_SIZE + \stack_hole - 4)
 SPFIX( tst     sp, #4          )
 SPFIX( subeq   sp, sp, #4      )
        stmia   sp, {r1 - r12}

        ldmia   r0, {r3 - r5}
        add     r7, sp, #S_SP - 4       @ here for interlock avoidance
        mov     r6, #-1                 @  ""  ""      ""       ""
        add     r2, sp, #(SVC_REGS_SIZE + \stack_hole - 4)
 SPFIX( addeq   r2, r2, #4      )
        str     r3, [sp, #-4]!          @ save the "real" r0 copied
                                        @ from the exception stack

        mov     r3, lr

        @
        @ We are now ready to fill in the remaining blanks on the stack:
        @
        @  r2 - sp_svc
        @  r3 - lr_svc
        @  r4 - lr_<exception>, already fixed up for correct return/restart
        @  r5 - spsr_<exception>
        @  r6 - orig_r0 (see pt_regs definition in ptrace.h)
        @
        stmia   r7, {r2 - r6}

        get_thread_info tsk
        ldr     r0, [tsk, #TI_ADDR_LIMIT]
        mov     r1, #TASK_SIZE
        str     r1, [tsk, #TI_ADDR_LIMIT]
        str     r0, [sp, #SVC_ADDR_LIMIT]

        uaccess_save r0
        .if \uaccess
        uaccess_disable r0
        .endif

        .if \trace
#ifdef CONFIG_TRACE_IRQFLAGS
        bl      trace_hardirqs_off
#endif
        .endif
        .endm

커널(svc) 처리 중 exception이 발생한 경우이다. 레지스터들을 스택에 백업한다.

  • 해당 exception 모드(fiq, irq, pabt, dabt, und)에서 3개의 레지스터를 3 word로 구성된 mini stack에 백업한다.
  • svc 모드로 전환하고 다음과 같이 처리한다.
    • 스택을 18개의 레지스터를 포함하여 보관할 수 있는 svc_pt_regs 구조체 사이즈만큼 키운 후 레지스터들을 백업한다.
    • 그 외 irq disable된 기간 및 컨텍스트  트래킹 등을 수행한다. (for debug)

 

  • 코드 라인 4에서 스택을 svc_pt_regs 구조체 크기 + stack_hole – 4 만큼  확보한다.
    • stack_hole을 추가하는 이유
      • __und_svc() 레이블에서만 사용되는데 CONFIG_KPROBES 커널 옵션을 사용하고 kprobe를 이용하여 디버깅을 할 때 “stmdb sp!, {…}” 등의 문장에서 single step으로 디버깅을 하면 스택이 깨지는 문제가 발생하여 그러한 경우를 피하고자 64바이트(멀티 store 명령으로 최대 16개 레지스터를 저장할 수 있는 공간 크기)의 hole을 더 준비하였다.
      • 참고: ARM kprobes: don’t let a single-stepped stmdb corrupt the exception stack
    • -4를 하는 이유
      • r0를 제외한 스택 주소가 아래에서 설명하는 AEABI 규격으로 인해 정렬되어야 한다.루틴의 마지막 즈음에서 4 바이트를 증가시켜 짝수 워드로 정렬시킬 예정이므로 지금은 홀수 워드로 정렬되어야 한다.
  • 코드 라인 5~6에서 AEABI(ARM Embedded Application Binary Interface) 규격에 맞게 스택을 사용 시 64비트(8 바이트) 정렬을 해야 한다.
  • 코드 라인 7에서 r1에서 r12까지 레지스터를 모두 스택에 확보된 pt_regs에서 r1 위치부터 저장한다.
  • 코드 라인 9에서 기존 루틴에서 미니 스택에 저장해 놓은 old r0, 교정된 lr, spsr 값을 r3~r5 레지스터에 읽어 온다.
  • 코드 라인 10에서 r7 레지스터가 pt_regs의 sp 주소를 가리키게 한다.
  • 코드 라인 11에서 r6 레지스터에 -1을 대입한다.
  • 코드 라인 12~13에서 r2 레지스터가 stack_hole을 가리키게 한다. 만일 sp가 64비트 정렬을 한 경우라면 stack_hole 위치도 4 바이트만큼 위로 올린다. (stack_hole이 4바이트 커진다.)
  • 코드 라인 14에서 original r0를 읽어온 r3 레지스터의 내용을 pt_regs의 r0 주소에 저장한다. sp 주소는 4바이트 주소를 밑으로 이동시켜 정상적으로 sp가 pt_regs의 처음을 가리키게 한다.
  • 코드 라인 17~28에서 r3 레지스터에 lr_svc를 대입하고 sp_svc, lr_svc, lr_<exception>, spsr_<exception>, original r0 값이 담긴 r2~r6 레지스터 값을 pt_regs의 sp 주소부터 저장한다.
  • 코드 라인 30~34에서 현재 태스크의 thread_info.addr_limit 값을 읽어 스택에 위치한 svc_pt_regs.addr_limit에 백업하고, TASK 사이즈로 변경한다.
  • 코드 라인 36~39에서 유저 영역의 액세스 여부를 svc_pt_regs.dacr 에 백업하고, @uaccess가 요청된 경우 보안을 위해 커널에서 유저 영역의 액세스를 제한한다.
  • 코드 라인 41~44에서  CONFIG_TRACE_IRQFLAGS 커널 옵션이 사용되는 경우  얼마나 오랫동안 인터럽트가 disable 되었는지 그 주기를 알아보기 위한 트래킹 디버깅을 수행한다.

다음 그림과 같이 커널이 v4.9-rc1으로 버전업되면서 svc 모드에서 진입된 레지스터들을 백업하는데 기존 pt_regs를 사용하지 않고 svc_pt_regs를 사용한다.

 

레지스터 복구하고 서비스 모드로 복귀

svc_exit 매크로

arch/arm/kernel/entry-header.S (THUMB 코드 생략)

        .macro  svc_exit, rpsr, irq = 0
        .if     \irq != 0
        @ IRQs already off
#ifdef CONFIG_TRACE_IRQFLAGS
        @ The parent context IRQs must have been enabled to get here in
        @ the first place, so there's no point checking the PSR I bit.
        bl      trace_hardirqs_on
#endif
        .else
        @ IRQs off again before pulling preserved data off the stack
        disable_irq_notrace
#ifdef CONFIG_TRACE_IRQFLAGS
        tst     \rpsr, #PSR_I_BIT
        bleq    trace_hardirqs_on
        tst     \rpsr, #PSR_I_BIT
        blne    trace_hardirqs_off
#endif
        .endif
        ldr     r1, [sp, #SVC_ADDR_LIMIT]
        uaccess_restore
        str     r1, [tsk, #TI_ADDR_LIMIT]

        @ ARM mode SVC restore
        msr     spsr_cxsf, \rpsr
#if defined(CONFIG_CPU_V6) || defined(CONFIG_CPU_32v6K)
        @ We must avoid clrex due to Cortex-A15 erratum #830321
        sub     r0, sp, #4                      @ uninhabited address
        strex   r1, r2, [r0]                    @ clear the exclusive monitor
#endif
        ldmia   sp, {r0 - pc}^                  @ load r0 - pc, cpsr
        .endm

exception 전의 svc 모드로 다시 복귀하기 위해 백업해두었던 레지스터들을 복구한다.

  • 코드 라인 2~7에서 irq exception에 대한 ISR을 수행 후 종료 전에 hard irq에 대한 latency 트래킹을 수행한다.
    • __irq_svc에서 irq=1로 호출된다.
  • 코드 라인 9~18에서 irq=0으로 설정되는 경우 현재 cpu에 대해 irq를 mask하여 인터럽트가 진입하지 못하게 한다. @rpsr은 exception 되었을 때 SPSR 값이 담겨있다. 즉 복귀 전 모드에서 irq가 enable 상태인 경우 hardirq에 대한 trace on을 수행하고, 그렇지 않은 경우 trace off를 수행한다.
  • 코드 라인 19에서 스택에 위치한 svc_pt_regs.addr_limit 값을 r1 레지스터에 알아온다.
  • 코드 라인 20에서 커널에서 유저 모드 액세스 여부에 대한 값을 스택으로부터 복구한다.
  • 코드 라인 21에서 읽어온 addr_limit 값을 태스크의 thread_info.addr_limit에 기록한다.
  • 코드 라인 24에서 spsr에 \rpsr을 대입한다.
  • 코드 라인 25~29에서 strex로 clrex 기능을 수행한다. (erratum for Cortex-A15)
  • 코드 라인 30에서 스택으로부터 r0~pc까지 레지스터를 복구한다.
    • pc 위치에 이미 correction된 lr을 백업했었다.

 

허용하지 않은 모드에서 진입 시 레지스터 백업

inv_entry

arch/arm/kernel/entry-armv.S

/*
 * Invalid mode handlers
 */
        .macro  inv_entry, reason
        sub     sp, sp, #PT_REGS_SIZE
 ARM(   stmib   sp, {r1 - lr}           )
 THUMB( stmia   sp, {r0 - r12}          )
 THUMB( str     sp, [sp, #S_SP]         )
 THUMB( str     lr, [sp, #S_LR]         )
        mov     r1, #\reason
        .endm

스택에 레지스터들을 백업하기 위한 공간(struct pt_regs)을 확보하고  r1~r14(lr)까지 백업해둔다. r1 레지스터에는 reason 값을 대입한다.

    • pt_regs에 백업되지 않은 나머지 레지스터들은 common_invalid 레이블에서 백업을 계속 진행한다.

 

 

common_invalid

arch/arm/kernel/entry-armv.S

@
@ common_invalid - generic code for failed exception (re-entrant version of handlers)
@
common_invalid:
        zero_fp

        ldmia   r0, {r4 - r6}
        add     r0, sp, #S_PC           @ here for interlock avoidance
        mov     r7, #-1                 @  ""   ""    ""        ""
        str     r4, [sp]                @ save preserved r0
        stmia   r0, {r5 - r7}           @ lr_<exception>,
                                        @ cpsr_<exception>, "old_r0"

        mov     r0, sp
        b       bad_mode
ENDPROC(__und_invalid)

각 exception 핸들러들에서 허용하지 않은 모드에서 진입하여 실패처리를 위한 루틴이다.

  • 코드 라인 2에서 fp 레지스터에 0을 대입한다.
  • 코드 라인 4에서 스택에 백업해두었던 old r0, 교정된 lr, spsr 값을 r4~r6 레지스터로 읽어온다.
  • 코드 라인 5에서 스택에 백업해두었던 pt_regs 구조체 영역에서 pc 주소를 r0에 대입한다.
  • 코드 라인 6에서 r7에 -1을 대입한다.
  • 코드 라인 7에서 old r0 값을 읽어온 r4 레지스터 값을 pt_regs의 가장 첫 위치 r0에 저장한다.
  • 코드 라인 8에서 교정된 lr, spsr, -1 값을 담고 있는 r5~r7 레지스터 값을 스택의 pt_regs 위치 중 old r0, cpsr, r15(pc) 주소에 저장한다.
  • 코드 라인 11에서 스택 값을 r0에 대입한다.
  • 코드 라인 12에서 bad_mode 레이블로 이동하여 “Oops” 출력 및 panic() 처리한다.

 

 

bad_mode()

arch/arm/kernel/traps.c

/*
 * bad_mode handles the impossible case in the vectors.  If you see one of
 * these, then it's extremely serious, and could mean you have buggy hardware.
 * It never returns, and never tries to sync.  We hope that we can at least
 * dump out some state information...
 */
asmlinkage void bad_mode(struct pt_regs *regs, int reason, unsigned int esr)
{
        console_verbose();

        pr_crit("Bad mode in %s handler detected on CPU%d, code 0x%08x -- %s\n",
                handler[reason], smp_processor_id(), esr,
                esr_get_class_string(esr));

        local_daif_mask();
        panic("bad mode");
}

허용하지 않은 모드에서 진입 시 “Oops – bad mode”를 출력하고 panic 처리 한다.

  • /proc/sys/kernel/panic” 초(secs) 만큼 대기하였다가 셀프 부팅한다. (0인 경우 그냥 부팅없이 정지해있다.)

 

kuser_cmpxchg_check

arch/arm/kernel/entry-armv.S

        .macro  kuser_cmpxchg_check
#if !defined(CONFIG_CPU_32v6K) && defined(CONFIG_KUSER_HELPERS) && \
    !defined(CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG)
#ifndef CONFIG_MMU
#warning "NPTL on non MMU needs fixing"
#else
        @ Make sure our user space atomic helper is restarted
        @ if it was interrupted in a critical region.  Here we
        @ perform a quick test inline since it should be false
        @ 99.9999% of the time.  The rest is done out of line.
        cmp     r4, #TASK_SIZE
        blhs    kuser_cmpxchg64_fixup
#endif
#endif
        .endm

Kernel-provided User Helper code 중 시스템이 POSIX syscall을 이용하여 cmpxchg를 이용하는 방식인 경우 커널 space에서 exception되어 이 루틴에 진입하게 되면 kuser_cmpchg64_fixup을 수행하고 온다.

  • r4에는 exception 처리 후 되돌아갈 주소(lr)이 담겨 있기 때문에 이 값을 TASK_SIZE와 비교하여 user space에서 진입하였는지 아니면 kernel space에서 진입하였는지 구분할 수 있다.
  • 참고: Kernel-provided User Helper | 문c

 

get_thread_info 매크로

include/asm/assembler.h

/*
 * Get current thread_info.
 */
        .macro  get_thread_info, rd
 ARM(   mov     \rd, sp, lsr #THREAD_SIZE_ORDER + PAGE_SHIFT    )
 THUMB( mov     \rd, sp                 )
 THUMB( lsr     \rd, \rd, #THREAD_SIZE_ORDER + PAGE_SHIFT       )
        mov     \rd, \rd, lsl #THREAD_SIZE_ORDER + PAGE_SHIFT
        .endm

현재 프로세스의 스택 하위에 위치한 thread_info 객체의 주소를 인수 @rd에 반환한다.

 


IRQ 핸들러

arm 아키텍처는 nested 인터럽트를 처리할 수 있게 설계되어 있다. 그러나 현재 까지 arm 리눅스에서는 FIQ를 제외하고는 중첩하여 처리하지 못하게 하였다. 당연히 arm 리눅스가 아닌 펌웨어 레벨의 os에서는 사용자가 nested 인터럽트를 구현하여 사용할 수 있다.

 

다음 그림은 irq exception이 발생한 후 인터럽트 컨트롤러의 인터럽트 핸들러까지 흐름을 보여준다.

  • CONFIG_GENERIC_IRQ_MULTI_HANDLER
    • 런타임에 등록하는 multi irq 핸들러이다.
    • Device Tree를 사용하는 경우 런타임에 해당 인터럽트 컨트롤러의 초기화 및 각 인트럽트에 대한 처리 방법 및 핸들러등을 준비해야 한다.
    • 전역 handle_arch_irq 변수는 set_handle_irq() 함수에 의해 핸들러 주소가 설정된다.
      • rpi2: Device Tree용 armctrl_of_init() 초기화 함수에서 두 개의 인터럽트 컨트롤러 초기화 함수를 호출하는데 그 중 부모 인터럽트 콘트롤러를 초기화할 때 핸들러로 bcm2836_arm_irqchip_handle_irq() 함수가 설정된다.

 

__irq_usr

arch/arm/kernel/entry-armv.S

        .align  5
__irq_usr:
        usr_entry
        kuser_cmpxchg_check
        irq_handler
        get_thread_info tsk
        mov     why, #0
        b       ret_to_user_from_irq
 UNWIND(.fnend          )
ENDPROC(__irq_usr)

유저 태스크 처리 중 인터럽트가 발생되어 irq exception 모드에서 3개의 레지스터를 3 word로 구성된 mini stack에 백업한 후 svc 모드에 진입하였고 그 이후 이 레이블에 진입을하면 관련 인터럽트 번호에 등록되어 있는 1개 이상의 ISR(Interrupt Service Routing)을 호출한다.

  • 코드 라인 3에서 전체 레지스터를 스택에 백업한다.
  • 코드 라인 4에서 atomic 연산을 지원하지 못하는 아키텍처에서 atomic 하게 처리해야 하는 구간에서 인터럽트를 맞이하고 복귀할 때 그 atomic operation 구간의 시작부분으로 다시 돌아가도록 pt_regs의 pc를 조작한다.
  • 코드 라인 5에서 관련 인터럽트 번호에 등록되어 있는 1개 이상의 ISR(Interrupt Service Routing)을 호출한다
  • 코드 라인 6에서 tsk 레지스터에 thread_info 객체의 주소를 알아온다.
  • 코드 라인 7~8에서  스택에 백업해둔 레지스터들을 다시 불러 읽은 후 user 모드로 복귀한다.

 

__irq_svc

arch/arm/kernel/entry-armv.S

        .align  5
__irq_svc:
        svc_entry
        irq_handler

#ifdef CONFIG_PREEMPT
        ldr     r8, [tsk, #TI_PREEMPT]          @ get preempt count
        ldr     r0, [tsk, #TI_FLAGS]            @ get flags
        teq     r8, #0                          @ if preempt count != 0
        movne   r0, #0                          @ force flags to 0
        tst     r0, #_TIF_NEED_RESCHED
        blne    svc_preempt
#endif

        svc_exit r5, irq = 1                    @ return from exception
 UNWIND(.fnend          )
ENDPROC(__irq_svc)

커널 처리 중 인터럽트가 발생되어 irq exception 모드에서 3개의 레지스터를 3 word로 구성된 mini stack에 백업한 후 svc 모드에 진입하였고 그 이후 이 레이블에 진입을하면 관련 인터럽트 번호에 등록되어 있는 1개 이상의 처리 핸들러를 호출한다.

  • 코드 라인 3에서 전체 레지스터를 포함한 svc_pt_regs 구조체를 스택에 백업한다.
  • 코드 라인 4에서 관련 인터럽트 번호에 등록되어 있는 1개 이상의 ISR(Interrupt Service Routing)을 호출한다
  • 코드 라인 7~12에서 preempt 커널에서 현재 프로세스 컨텍스트가 preempt 허용(preempt 카운트가 0) 상태인 경우에 한해 리스케쥴(_TIF_NEED_RESCHED) 요청이 있는 경우 리스케쥴을 위해 svc_preempt 레이블로 이동한다.
    • thread_info->preempt가 0인 경우 preempt 가능한 상태이다.
    • flags에 _TIF_NEED_RESCHED 설정된 경우 리스케쥴 요청이 들어온 경우이다.
  • 코드 라인 15에서 스택에 백업해둔 레지스터들을 다시 불러 읽은 후 svc 모드로 복귀한다.

 

svc_preempt 레이블

arch/arm/kernel/entry-armv.S

#ifdef CONFIG_PREEMPT
svc_preempt:
        mov     r8, lr
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
        reteq   r8                              @ go again
        b       1b
#endif

더 이상의 리스케쥴 요청이 없을 때까지 preemption 리스케쥴을 수행한다.

  • 코드 라인 3에서 r8 레지스터에 복귀할 주소를 담고 있는 lr 레지스터를 백업해둔다.
  • 코드 라인 4에서 현 태스크의 preemption을 포함한 리스케쥴을 수행한다.
    • 리스케쥴되어 현재 태스크보다 더 우선 순위 높은 태스크가 실행되는 경우 현재의 태스크는 잠든다. 그 후 깨어난 후 계속 진행한다.
  • 코드 라인 5~8에서 현재 프로세서 컨텍스트에 리스케쥴 요청이 있으면 다시 1: 레이블로 이동하여 계속 처리하고, 리스케쥴 요청이 없으면 루틴을 끝마치고 복귀한다.

 

irq_handler 매크로

arch/arm/kernel/entry-armv.S

/*
 * Interrupt handling.
 */
        .macro  irq_handler
#ifdef CONFIG_GENERIC_IRQ_MULTI_HANDLER
        ldr     r1, =handle_arch_irq
        mov     r0, sp
        badr    lr, 9997f
        ldr     pc, [r1]
#else
        arch_irq_handler_default
#endif
9997:
        .endm

아키텍처에 따른 irq 핸들러를 호출한다.

  • CONFIG_MULTI_IRQ_HANDLER 커널 옵션을 사용 여부에 따라
  • 설정한 경우 커널이 여러 개의 머신에 해당하는 IRQ 핸들러 함수를 같이 컴파일하고 실제 커널 부팅 시 IRQ 관련하여 선택한 호출 함수를 handle_arch_irq에 저장하여야 한다.
  • 설정하지 않은 경우 현재 커널이 IRQ 처리 방식을 고정한 경우로 컴파일 시 결정된 arch_irq_handler_default 매크로를 호출한다.

 

인터럽트 핸들러 for rpi2

 

ret_to_user_from_irq 및 no_work_pending 레이블

arch/arm/kernel/entry-common.S

ENTRY(ret_to_user_from_irq)
        ldr     r2, [tsk, #TI_ADDR_LIMIT]
        cmp     r2, #TASK_SIZE
        blne    addr_limit_check_failed
        ldr     r1, [tsk, #TI_FLAGS]
        tst     r1, #_TIF_WORK_MASK
        bne     slow_work_pending
no_work_pending:
        asm_trace_hardirqs_on save = 0

        /* perform architecture specific actions before user return */
        arch_ret_to_user r1, lr
        ct_user_enter save = 0

        restore_user_regs fast = 0, offset = 0
ENDPROC(ret_to_user_from_irq)

irq 처리를 마치고 유저로 복귀하기 전에 pending된 작업이 있으면 수행한 후 백업해 두었던 레지스터들을 다시 읽어 들인 후 복귀한다.

  • 코드 라인 2~4에서 thread_info->addr_limit값이 태스크 사이즈를 초과하는 경우 addr_limit_check_failed 레이블로 이동한다.
  • 코드 라인 5~7에서 thread_info->flags를 검사하여 _TIF_WORK_MASK에 속한 플래그가 있는 경우 slow_work_pending 레이블로 이동한다.
    • _TIF_WORK_MASK
      • _TIF_NEED_RESCHED | _TIF_SIGPENDING | _TIF_NOTIFY_RESUME | _TIF_UPROBE
  • 코드 라인 12에서 user process로 다시 복귀 전에 처리할 아키텍처 specific한 일이 있는 경우 수행한다.
    • rpi2: 없음
  • 코드 라인 13에서 CONFIG_CONTEXT_TRACKING 커널 옵션을 사용한 context 트래킹 디버그가 필요한 경우 수행한다.
  • 코드 라인 15에서 백업해 두었던 레지스터들을 읽어들이며 다시 user space로 복귀한다.

 

지연 작업 처리

slow_work_pending

arch/arm/kernel/entry-common.S

slow_work_pending:
        mov     r0, sp                          @ 'regs'
        mov     r2, why                         @ 'syscall'
        bl      do_work_pending
        cmp     r0, #0
        beq     no_work_pending
        movlt   scno, #(__NR_restart_syscall - __NR_SYSCALL_BASE)
        ldmia   sp, {r0 - r6}                   @ have to reload r0 - r6
        b       local_restart                   @ ... and off we go
ENDPROC(ret_fast_syscall)

지연된 작업이 있는 경우 완료 시킨 후 no_work_pending 레이블로 이동하는데 pending 시그널을 처리하다 restart 에러가 발생한 경우 local_restart 레이블로 이동한다.

  • 코드 라인 2~4에서 do_work_pending() 함수를 호출하여 지연된 작업을 수행한다.
  • 코드 라인 5~6에서 더 이상 할 작업이 없는 경우 no_work_pending 레이블로 이동한다.
  • 코드 라인 7에서 결과가 음수인 경우 scno에 sys_restart_syscall() 함수를 처리하기 위한 syscall 인덱스 번호를 대입한다.
    • EABI(Embedded Application Binary Interface)를 사용하는 경우 0x0 – 0x0을 적용하여 0이된다.
    • OABI(Old Application Binary Interface)를 사용하는 경우 0x90000 – 0x90000을 적용하여 0이된다.
  • 코드 라인 8~9에서 스택으로부터 r0~r6 레지스터에 로드한 후 local_restart 레이블로 이동한다.

 

do_work_pending()

arch/arm/kernel/signal.c

asmlinkage int
do_work_pending(struct pt_regs *regs, unsigned int thread_flags, int syscall)
{
        /*
         * The assembly code enters us with IRQs off, but it hasn't
         * informed the tracing code of that for efficiency reasons.
         * Update the trace code with the current status.
         */
        trace_hardirqs_off();
        do {
                if (likely(thread_flags & _TIF_NEED_RESCHED)) {
                        schedule();
                } else {
                        if (unlikely(!user_mode(regs)))
                                return 0;
                        local_irq_enable();
                        if (thread_flags & _TIF_SIGPENDING) {
                                int restart = do_signal(regs, syscall);
                                if (unlikely(restart)) {
                                        /*
                                         * Restart without handlers.
                                         * Deal with it without leaving
                                         * the kernel space.
                                         */
                                        return restart;
                                }
                                syscall = 0;
                        } else if (thread_flags & _TIF_UPROBE) {
                                uprobe_notify_resume(regs);
                        } else {
                                clear_thread_flag(TIF_NOTIFY_RESUME);
                                tracehook_notify_resume(regs);
                                rseq_handle_notify_resume(NULL, regs);
                        }
                }
                local_irq_disable();
                thread_flags = current_thread_info()->flags;
        } while (thread_flags & _TIF_WORK_MASK);
        return 0;
}

지연된 작업이 있는 경우 완료될 때까지 처리한다. 정상 처리되면 0을 반환하는데 만일 pending 시그널을 처리하다 에러가 발생한 경우 restart 값을 반환한다.

  • 코드 라인 9에서 harirq 트레이스를 off한다.
  • 코드 라인 11~12에서 현재 태스크의 플래그들 중 리스케쥴 요청(_TIF_NEED_RESCHED 플래그)이 있는 경우 리스케쥴한다.
    •  인터럽트 처리를 빠져나가기 전에 이 코드가 실제 preemption 요청을 처리하는 곳이다.
  • 코드 라인 14~15에서 낮은 확률로 유저 모드 진입이 아닌 경우 그냥 빠져나간다.
  • 코드 라인 17~27에서 pending 시그널(_TIF_SIGPENDING 플래그) 이 있는 경우 시그널을 처리한다. 만일 restart 응답을 받은 경우 restart 값으로 함수를 빠져나간다.
  • 코드 라인 28~29에서 uprobe break point가 hit(_TIF_UPROBE 플래그)되어 진입된 경우이었던 경우 resume 관련 처리를 수행한다.
  • 코드 라인 30~34에서 4개의 pending 관련 비트들 중 마지막 플래그 TIF_NOTIFY_RESUME를 클리어한다. 이 플래그는 user로 되돌아가기 전에 호출할 콜백함수들을 수행하게 한다.
    • task_work_add() 함수에서 인수 notify가 설정되어 요청한 경우 task->task_works 리스트에 추가된 콜백 함수들을 수행한다.
  • 코드 라인 37~38에서 현재 프로세서의 플래그에 pending 작업이 존재한다고 표시된 경우 계속 루프를 돈다.
  • 코드 라인 39에서 펜딩 작업이 더 이상 없으므로 0을 반환한다.

 

restore_user_regs 매크로

arch/arm/kernel/entry-header.S (THUMB 코드 생략)

        .macro  restore_user_regs, fast = 0, offset = 0
        uaccess_enable r1, isb=0
        @ ARM mode restore
        mov     r2, sp
        ldr     r1, [r2, #\offset + S_PSR]      @ get calling cpsr
        ldr     lr, [r2, #\offset + S_PC]!      @ get pc
        tst     r1, #PSR_I_BIT | 0x0f
        bne     1f
        msr     spsr_cxsf, r1                   @ save in spsr_svc
#if defined(CONFIG_CPU_V6) || defined(CONFIG_CPU_32v6K)
        @ We must avoid clrex due to Cortex-A15 erratum #830321
        strex   r1, r2, [r2]                    @ clear the exclusive monitor
#endif
        .if     \fast
        ldmdb   r2, {r1 - lr}^                  @ get calling r1 - lr
        .else
        ldmdb   r2, {r0 - lr}^                  @ get calling r0 - lr
        .endif
        mov     r0, r0                          @ ARMv5T and earlier require a nop
                                                @ after ldm {}^
        add     sp, sp, #\offset + PT_REGS_SIZE
        movs    pc, lr                          @ return & move spsr_svc into cpsr
1:      bug     "Returning to usermode but unexpected PSR bits set?", \@
#elif defined(CONFIG_CPU_V7M)
        @ V7M restore.
        @ Note that we don't need to do clrex here as clearing the local
        @ monitor is part of the exception entry and exit sequence.
        .if     \offset
        add     sp, #\offset
        .endif
        v7m_exception_slow_exit ret_r0 = \fast
        .endm

백업해 두었던 레지스터들을 읽어들인 후 다시 user space로 복귀한다.

  • 코드 라인 2에서 커널의 유저 액세스를 허용하게 한다.
  • 코드 라인 4~9에서 스택에 백업해둔 pt_regs의 cpsr을 r1 레지스터를 통해 spsr 레지스터에 저장하고, pc 값을 lr 레지스터에 대입한다.
    • 만일 백업한 cpsr의 irq 비트가 마스크되어 있는 경우 1f 레이블에서 버그 출력을 한다.
  • 코드 라인 12에서 Cortex-A15 아키텍처에서 strex를 사용하여 clrex를 대신하였다.
  • 코드 라인 14~18에서 fast 요청이 있는 경우 스택에 백업해 둔 pt_regs의 r1~lr 까지의 레지스터를 읽어오고 fast 요청이 아닌 경우 r0 레지스터를 포함해서 불러온다.
  • 코드 라인 19에서 ARMv5T 및 그 이전 arm 아키텍처에서 multiple load 명령을 사용 후 nop을 사용해야 한다.
  • 코드 라인 21~22에서 스택에서 pt_regs를 제외시킨 후 user space로 복귀한다.

 

preempt_schedule_irq()

kernel/sched/core.c

/*
 * this is the entry point to schedule() from kernel preemption
 * off of irq context.
 * Note, that this is called and return with irqs disabled. This will
 * protect us against recursive calling from irq.
 */
asmlinkage __visible void __sched preempt_schedule_irq(void)
{
        enum ctx_state prev_state;

        /* Catch callers which need to be fixed */
        BUG_ON(preempt_count() || !irqs_disabled());

        prev_state = exception_enter();

        do {
                preempt_disable();
                local_irq_enable();
                __schedule(true);
                local_irq_disable();
                sched_preempt_enable_no_resched();
        } while (need_resched());

        exception_exit(prev_state);
}

리스케쥴 요청이 있는 동안 인터럽트는 허용하되 preemption은 허용되지 않게 한 후 스케쥴한다.

  • 코드 라인 8에서 리스케쥴 전에 context 트래킹 디버깅을 위한 선 처리 작업을 한다.
  • 코드 라인 10~14에서 인터럽트는 허용하되 preemption은 허용되지 active 구간을 증가시킨다. 않게 한 후 스케쥴한다. 완료 후 다시 인터럽트를 막고 preemption이 허용되도록 active 구간을 감소시킨다.
  • 코드 라인 15~16에서 리스케쥴 요청이 없을 때까지 반복한다.
  • 코드 라인 18에서리스케쥴이 완료되었으므로 context 트래킹 디버깅을 위한 후 처리 작업을 한다.

 


FIQ 핸들러

 

__fiq_usr

arch/arm/kernel/entry-armv.S

        .align  5
__fiq_usr:
        usr_entry trace=0
        kuser_cmpxchg_check
        mov     r0, sp                          @ struct pt_regs *regs
        bl      handle_fiq_as_nmi
        get_thread_info tsk
        restore_user_regs fast = 0, offset = 0
 UNWIND(.fnend          )
ENDPROC(__fiq_usr)

유저모드에서 fiq가 발생되어 fiq exception 모드로 진입하였고, 3개의 레지스터를 3 word로 구성된 mini stack에 백업한 후 svc 모드에 진입한 상황이다. 그 이후 이 레이블에 진입하여 관련 fiq 핸들러를 호출한다. (ARM에서는 기본적으로 fiq 관련 처리는 비어있는 상태이다)

  • 코드 라인 3에서 전체 레지스터를 스택에 백업한다. 속도를 중시하므로 trace를 제한한다.
  • 코드 라인 4에서 atomic 연산을 지원하지 못하는 아키텍처에서 atomic 하게 처리해야 하는 구간에서 인터럽트를 맞이하고 복귀할 때 그 atomic operation 구간의 시작부분으로 다시 돌아가도록 pt_regs의 pc를 조작한다.
  • 코드 라인 5~6에서 fiq 관련 등록된 ISR을 수행한다.
  • 코드 라인 7에서 tsk 레지스터에 thread_info 객체의 주소를 알아온다.
  • 코드 라인 8에서 스택에 백업해둔 레지스터들을 다시 불러 읽은 후 user 모드로 복귀한다.

 

handle_fiq_as_nmi()

arch/arm/kernel/traps.c

/*
 * Handle FIQ similarly to NMI on x86 systems.
 *
 * The runtime environment for NMIs is extremely restrictive
 * (NMIs can pre-empt critical sections meaning almost all locking is
 * forbidden) meaning this default FIQ handling must only be used in
 * circumstances where non-maskability improves robustness, such as
 * watchdog or debug logic.
 *
 * This handler is not appropriate for general purpose use in drivers
 * platform code and can be overrideen using set_fiq_handler.
 */
asmlinkage void __exception_irq_entry handle_fiq_as_nmi(struct pt_regs *regs)
{
        struct pt_regs *old_regs = set_irq_regs(regs);

        nmi_enter();

        /* nop. FIQ handlers for special arch/arm features can be added here. */

        nmi_exit();

        set_irq_regs(old_regs);
}

arm 아키텍처에서는 fiq 처리를 위한 루틴이 비어있다. 필요한 경우 임베디드 개발자가 추가하게 되어 있다.

 

nmi_enter()

include/linux/hardirq.h

#define nmi_enter()                                             \
        do {                                                    \
                arch_nmi_enter();                               \
                printk_nmi_enter();                             \
                lockdep_off();                                  \
                ftrace_nmi_enter();                             \
                BUG_ON(in_nmi());                               \
                preempt_count_add(NMI_OFFSET + HARDIRQ_OFFSET); \
                rcu_nmi_enter();                                \
                trace_hardirq_enter();                          \
        } while (0)

nmi 처리 시작 진입점에서 수행해야 할 일들을 처리한다. preempt count를 증가시켜 preemption되지 않도록 하고 nmi가 진행 중임을 rcu가 알 수 있도록 한다.

  • 코드 라인 3에서 nmi 처리 직전 아키텍처 specific 한 처리가 필요할 때 수행한다. (arm32는 없음)
  • 코드 라인 4에서 CONFIG_PRINTK_NMI를 지원하는 시스템에서 현재 cpu의 printk_context에 PRINTK_NMI_CONTEXT_MASK 마스크를 추가한다.
  • 코드 라인 5에서 lockdep 디버그를 끈다.
  • 코드 라인 6에서 nmi 처리 전에 대한 ftrace 트래킹을 지원한다.
  • 코드 라인 7에서 nmi 처리 중에 재진입된 경우 버그 처리한다.
  • 코드 라인 8에서 nmi 및 hard irq에 대한 preempt 카운터를 증가시킨다.
  • 코드 라인 9에서 nmi 처리 중인 것을 RCU도 알아야하기 때문에 &rcu_dynticks->dynticks를 1로 설정한다.
  • 코드 라인 10에서 nmi 처리 전 hard irq 처리에 대한 trace 출력을 한다.

 

nmi_exit()

include/linux/hardirq.h

#define nmi_exit()                                              \
        do {                                                    \
                trace_hardirq_exit();                           \
                rcu_nmi_exit();                                 \
                BUG_ON(!in_nmi());                              \
                preempt_count_sub(NMI_OFFSET + HARDIRQ_OFFSET); \
                ftrace_nmi_exit();                              \
                lockdep_on();                                   \
                printk_nmi_exit();                              \
                arch_nmi_exit();                                \
        } while (0)

nmi 처리 종료 후 수행해야 할 일들을 처리한다. rcu도 종료를 알 수 있도록 보고하고, 처리 전 증가된 preempt count도 감소시킨다.

  • 코드 라인 3에서 nmi 처리 후 hard irq 처리에 대한 trace 출력을 한다.
  • 코드 라인 4에서 nmi 처리 완료된 것을 RCU도 알아야하기 때문에 &rcu_dynticks->dynticks를 0으로 클리어한다.
  • 코드 라인 5에서 여전히 nmi 처리 중인 경우 버그 처리한다.
  • 코드 라인 6에서 nmi 및 hard irq에 대한 preempt 카운터를 감소시킨다.
  • 코드 라인 7에서 nmi 처리 완료에 대한 ftrace 트래킹을 지원한다.
  • 코드 라인 8에서 lockdep 디버그를 다시 켠다.
  • 코드 라인 9에서 CONFIG_PRINTK_NMI를 지원하는 시스템에서 현재 cpu의 printk_context에 PRINTK_NMI_CONTEXT_MASK 마스크를 제거한다.
  • 코드 라인 10에서 nmi 처리 완료 후 아키텍처 specific 한 처리가 필요할 때 수행한다. (arm32는 없음)

 

set_irq_regs()

include/asm-generic/irq_regs.h

static inline struct pt_regs *set_irq_regs(struct pt_regs *new_regs)
{
        struct pt_regs *old_regs;

        old_regs = __this_cpu_read(__irq_regs);
        __this_cpu_write(__irq_regs, new_regs);
        return old_regs;
}

pt_regs 레지스터들을 백업하고 기존 레지스터들을 반환한다.

 

__fiq_svc

arch/arm/kernel/entry-armv.S

        .align  5
__fiq_svc:
        svc_entry trace=0
        mov     r0, sp                          @ struct pt_regs *regs
        bl      handle_fiq_as_nmi
        svc_exit_via_fiq
 UNWIND(.fnend          )
ENDPROC(__fiq_svc)

커널 처리 중 fiq가 발생되어 fiq exception 모드로 진입하였고, 3개의 레지스터를 3 word로 구성된 mini stack에 백업한 후 svc 모드에 진입한 상황이다. 그 이후 이 레이블에 진입을하여 관련 ifiq 핸들러를 호출한다. (ARM에서는 기본적으로 fiq 관련 처리는 비어있는 상태이다)

  • 코드 라인 3에서 전체 레지스터를 스택에 백업한다. 속도를 중시하므로 trace를 제한한다.
  • 코드 라인 4~5에서 fiq 관련 등록된 ISR을 수행한다.
  • 코드 라인 6에서 스택에 백업해둔 레지스터들을 다시 불러 읽은 후 exception 전 해당 모드로 복귀한다.

 

svc_exit_via_fiq 매크로

arch/arm/kernel/entry-header.S (THUMB 코드 생략)

.       @
        @ svc_exit_via_fiq - like svc_exit but switches to FIQ mode before exit
        @
        @ This macro acts in a similar manner to svc_exit but switches to FIQ
        @ mode to restore the final part of the register state.
        @
        @ We cannot use the normal svc_exit procedure because that would
        @ clobber spsr_svc (FIQ could be delivered during the first few
        @ instructions of vector_swi meaning its contents have not been
        @ saved anywhere).
        @
        @ Note that, unlike svc_exit, this macro also does not allow a caller
        @ supplied rpsr. This is because the FIQ exceptions are not re-entrant
        @ and the handlers cannot call into the scheduler (meaning the value
        @ on the stack remains correct).
        @
.       .macro  svc_exit_via_fiq
        ldr     r1, [sp, #SVC_ADDR_LIMIT]
        uaccess_restore
        str     r1, [tsk, #TI_ADDR_LIMIT]
        @ ARM mode restore
        mov     r0, sp
        ldmib   r0, {r1 - r14}  @ abort is deadly from here onward (it will
                                @ clobber state restored below)
        msr     cpsr_c, #FIQ_MODE | PSR_I_BIT | PSR_F_BIT
        add     r8, r0, #S_PC
        ldr     r9, [r0, #S_PSR]
        msr     spsr_cxsf, r9
        ldr     r0, [r0, #S_R0]
        ldmia   r8, {pc}^
        .endm

exception 전의 모드로 다시 복귀하기 위해 백업해두었던 레지스터들을 복구한다. (종료 전에 fiq 모드로 switch하는 것만 제외하고 svc_exit와 유사하다)

  • 코드 라인 2에서 스택에 저장된 svc_pt_regs.addr_limit 값을 r1 레지스터에 읽어온다.
  • 코드 라인 3에서 스택에 저장된 유저 액세스 여부를 백업한다.
  • 코드 라인 4에서 읽어온 addr_limit 값을 태스크에 기록한다.
  • 코드 라인 6~7에서 스택으로 부터 r1 ~ r14 레지스터까지 복구한다.
  • 코드 라인 9에서 irq, fiq bit를 마스크한 상태로 fiq mode로 진입한다.
  • 코드 라인 10에서 r8에 스택에서 pt_regs의 pc 값을 읽어온다.
    • 가장 마지막에 복귀할 주소가 담긴다.
  • 코드 라인 11~12에서 스택에서 pt_regs의 psr 값을 읽어 spsr에 대입하여 기존 모드로 복귀한다.
  • 코드 라인 13에서 다시 스택에서 pt_regs의 r0 값을 읽어 r0 레지스터에 복구한다.
  • 코드 라인 14에서 복귀할 주소가 담긴 r8레지스터 값 주소로 jump 한다.

 

__fiq_abt

arch/arm/kernel/entry-armv.S (THUMB 코드 생략)

/*
 * Abort mode handlers
 */

@
@ Taking a FIQ in abort mode is similar to taking a FIQ in SVC mode
@ and reuses the same macros. However in abort mode we must also
@ save/restore lr_abt and spsr_abt to make nested aborts safe.
@
        .align 5
__fiq_abt:
        svc_entry trace=0

 ARM(   msr     cpsr_c, #ABT_MODE | PSR_I_BIT | PSR_F_BIT )
        mov     r1, lr          @ Save lr_abt
        mrs     r2, spsr        @ Save spsr_abt, abort is now safe
 ARM(   msr     cpsr_c, #SVC_MODE | PSR_I_BIT | PSR_F_BIT )
        stmfd   sp!, {r1 - r2}

        add     r0, sp, #8                      @ struct pt_regs *regs
        bl      handle_fiq_as_nmi

        ldmfd   sp!, {r1 - r2}
 ARM(   msr     cpsr_c, #ABT_MODE | PSR_I_BIT | PSR_F_BIT )
        mov     lr, r1          @ Restore lr_abt, abort is unsafe
        msr     spsr_cxsf, r2   @ Restore spsr_abt
 ARM(   msr     cpsr_c, #SVC_MODE | PSR_I_BIT | PSR_F_BIT )

        svc_exit_via_fiq
 UNWIND(.fnend          )
ENDPROC(__fiq_abt)

abt 모드에서 fiq exception이 발생되어 3개의 레지스터를 3 word로 구성된 mini stack에 백업한 후 svc 모드에 진입하였고 그 이후 이 레이블에 진입을하면 관련 fiq 핸들러를 수행한다. (ARM에서는 기본적으로 fiq 관련 처리는 비어있는 상태이다)

  • 코드 라인 3에서 전체 레지스터를 스택에 백업한다.
  • 코드 라인 5~9에서 abt 모드의 lr, spsr을 스택에 백업한다.
    • irq 및 fiq를 disable한 상태로 다시 abt 모드로 진입하여 abt 모드에서의 lr 및 spsr을 r1, r2 레지스터에 잠시 저장하고 svc 모드로 바꾼 후 스택에 백업한다.
  • 코드 라인 11~12에서 fiq 관련 등록된 ISR을 수행한다. (ARM에서는 기본적으로 등록되어 있지 않다)
  • 코드 라인 14~18에서 irq와 fiq를 금지한 상태로 abt 모드에 진입하고, 백업해 두었던 2개의 lr, spsr을 다시 복구한 후 svc 모드로 돌아온다.
  • 코드 라인 20에서 스택에 백업해둔 레지스터들을 다시 불러 읽은 후 exceptino 전 해당 모드로 복귀한다.

 


SWI 핸들러

arm에서 소프트 인터럽트 발생 시 호출되며 8개의 exception 벡터 주소가 있는 페이지의 바로 다음 페이지 첫 엔트리에 vector_swi 레이블 주소가 담겨 있고, 이 주소를 호출한다.

 

다음 그림은 유저 모드에서 syscall 호출 시 vector_swi 레이블부터 swi 처리에 대한 함수 호출 관계를 보여준다.

 

Fast syscall vs Slow syscall

syscall이 처리된 후 다시 유저로 복귀하기 전에 처리할 스케쥴 워크가 남아 있는 경우 이를 처리한다.  즉 곧바로 유저로 복귀하지 않고 우선 순위가 높아 먼저 처리할 태스크를 위해 스케쥴이 다시 재배치되면서 다른 태스크를 수행하고 돌아오게 된다. 이렇게 syscall 처리 후 곧바로 돌아오는 경우 fast syscall이라 하고 곧바로 돌아오지 못하고 preemption 되었다가 돌아오는 경우를 slow syscall이라한다. slow syscall 상태가 되면 유저 입장에서 보면 blocked 함수를 호출한 것처럼 느리게 처리된다.

  • Fast syscall
    • syscall 처리 후 곧바로 유저로 복귀
  • Slow syscall
    • syscall 처리 후 유저 복귀 전에 먼저 처리할 태스크를 수행하도록 스케쥴을 바꾼다.

 

vector_swi:

arch/arm/kernel/entry-common.S -1/2-

/*=============================================================================
 * SWI handler
 *-----------------------------------------------------------------------------
 */
        .align  5
ENTRY(vector_swi)
#ifdef CONFIG_CPU_V7M
        v7m_exception_entry
#else
        sub     sp, sp, #PT_REGS_SIZE
        stmia   sp, {r0 - r12}                  @ Calling r0 - r12
 ARM(   add     r8, sp, #S_PC           )
 ARM(   stmdb   r8, {sp, lr}^           )       @ Calling sp, lr
        mrs     saved_psr, spsr                 @ called from non-FIQ mode, so ok.
 TRACE( mov     saved_pc, lr            )
        str     saved_pc, [sp, #S_PC]           @ Save calling PC
        str     saved_psr, [sp, #S_PSR]         @ Save CPSR
        str     r0, [sp, #S_OLD_R0]             @ Save OLD_R0
#endif
        zero_fp
        alignment_trap r10, ip, __cr_alignment
        asm_trace_hardirqs_on save=0
        enable_irq_notrace
        ct_user_exit save=0

        /*
         * Get the system call number.
         */

#if defined(CONFIG_OABI_COMPAT)

        /*
         * If we have CONFIG_OABI_COMPAT then we need to look at the swi
         * value to determine if it is an EABI or an old ABI call.
         */
 USER(  ldr     r10, [saved_pc, #-4]    )       @ get SWI instruction
 ARM_BE8(rev    r10, r10)                       @ little endian instruction

#elif defined(CONFIG_AEABI)

        /*
         * Pure EABI user space always put syscall number into scno (r7).
         */
        /* Legacy ABI only. */
 USER(  ldr     scno, [saved_pc, #-4]   )       @ get SWI instruction
#endif

        /* saved_psr and saved_pc are now dead */

        uaccess_disable tbl

        adr     tbl, sys_call_table             @ load syscall table pointer

#if defined(CONFIG_OABI_COMPAT)
        /*
         * If the swi argument is zero, this is an EABI call and we do nothing.
         *
         * If this is an old ABI call, get the syscall number into scno and
         * get the old ABI syscall table address.
         */
        bics    r10, r10, #0xff000000
        eorne   scno, r10, #__NR_OABI_SYSCALL_BASE
        ldrne   tbl, =sys_oabi_call_table
#elif !defined(CONFIG_AEABI)
        bic     scno, scno, #0xff000000         @ mask off SWI op-code
        eor     scno, scno, #__NR_SYSCALL_BASE  @ check OS number
#endif
        get_thread_info tsk
        /*
         * Reload the registers that may have been corrupted on entry to
         * the syscall assembly (by tracing or context tracking.)
         */
 TRACE( ldmia   sp, {r0 - r3}           )

 

소프트 인터럽트 핸들러로 user space에서 POSIX 시스템 콜 호출을 하는 경우 커널에서 “sys_”로 시작하는 syscall 함수 및 arm용 syscall 함수를 호출한다.  (thumb 소스는 생략하였다)

  • 리눅스는 3개의 ABI(Application Binary Interface) 관련 모드를 준비하였다.
    • CONFIG_OABI_COMPAT 커널 옵션은 Old ABI(legacy ABI) 및 AEABI 두  방식을 동시에 지원하기 위해 제공한다.
    • CONFIG_AEABI 커널 옵션은 AEABI 방식만 제공한다.
    • 위 두 커널 옵션을 사용하지 않는 경우 OABI를 지원한다.
    • 참고: ABI(Application Binary Interface) | 문c

 

  • 코드 라인 6~7에서 PT_REGS_SIZE만큼 스택을 키운다. (grows down) 그런 후 r0~r12까지의 레지스터 값들을 스택에 저장한다.
  • 코드 라인 8~9에서 스택에 비워둔 레지스터 저장 장소 중 sp와 lr 레지스터 값을 해당 위치에 저장한다.
  • 코드 라인 10에서 스택의 pt_regs.psr 값을 읽어와 spsr에 대입한다.
  • 코드 라인 12~14에서 스택에 있는 pt_regs 구조체의 pc 위치에 돌아갈 주소가 담긴 lr을 저장하고, psr 위치에는 현재 모드의 spsr을 저장한다. 마지막으로 old_r0 위치에 r0 레지스터를 저장하다.
  • 코드 라인 16에서 fp 레지스터에 0을 대입한다
  • 코드 라인 17에서 CONFIG_ALIGNMENT_TRAP 커널 옵션을 사용하는 경우 alignment trap 기능을 적용한다.
  • 코드 라인 19에서 local irq를 enable 한다.
  • 코드 라인 20에서 컨텍스트 트래킹에 관련한  후처리 디버그 활동을 수행한다.
  • 코드 라인 26~63에서 ABI 모드에 따라 swi 호출당시의 syscall 번호를 scno(r7)에 대입하고 tbl(r8)에 syscall 테이블 주소를  대입한다.
    • CONFIG_OABI_COMPAT: AEABI 및 OABI 두 모드를 동시에 지원한다.
      • swi 호출 당시의 숫자 부분만을 떼어 r10에 대입하고 그 값에 따라
        • 0인 경우 AEABI로 인식하여 아무것도 수행하지 않는다. (AEABI 규약에 의거 swi 0 호출 전에 r7에 syscall 번호가 담겨온다)
        • 0이 아닌 경우 OABI로 인식하여 r10에서 __NR_OABI_SYSCALL_BASE(0x900000)값을 더한 후 scno(r7)에 대입하고 tbl(r8)에 sys_oabi_call_table을 지정한다.
    • CONFIG_AEABI: AEABI 모드만 지원한다.
      • 아무것도 수행하지 않는다. (AEABI 규약에 의거 swi 0 호출 전에 r7에 syscall 번호가 담겨온다)
    • CONFIG_OABI
      • swi 호출 당시의 숫자 부분만을 떼어 scno(r7)에 대입하고 __NR_SYSCALL_BASE(0x900000)값을 더한다.
  • 코드 라인 64에서 tsk(r9) 레지스터에 현재 cpu의 thread_info 주소를 알아온다.

 

arch/arm/kernel/entry-common.S -2/2-

local_restart:
        ldr     r10, [tsk, #TI_FLAGS]           @ check for syscall tracing
        stmdb   sp!, {r4, r5}                   @ push fifth and sixth args

        tst     r10, #_TIF_SYSCALL_WORK         @ are we tracing syscalls?
        bne     __sys_trace

        invoke_syscall tbl, scno, r10, __ret_fast_syscall

        add     r1, sp, #S_OFF
2:      cmp     scno, #(__ARM_NR_BASE - __NR_SYSCALL_BASE)
        eor     r0, scno, #__NR_SYSCALL_BASE    @ put OS number back
        bcs     arm_syscall
        mov     why, #0                         @ no longer a real syscall
        b       sys_ni_syscall                  @ not private func

#if defined(CONFIG_OABI_COMPAT) || !defined(CONFIG_AEABI)
        /*
         * We failed to handle a fault trying to access the page
         * containing the swi instruction, but we're not really in a
         * position to return -EFAULT. Instead, return back to the
         * instruction and re-enter the user fault handling path trying
         * to page it in. This will likely result in sending SEGV to the
         * current task.
         */
9001:
        sub     lr, saved_pc, #4
        str     lr, [sp, #S_PC]
        get_thread_info tsk
        b       ret_fast_syscall
#endif
ENDPROC(vector_swi)
local_restart 레이블
  • 코드 라인 2에서 현재 태스크의 플래그 값을 r10 레지스터로 읽어온다.
  • 코드 라인 3에서 syscall 호출 시의 5번째 인수와 6번째 인수를 스택에 저장한다.
  • 코드 라인 5~6에서 syscall tracing이 요청된 경우 트레이스 관련 함수를 호출하여 처리한다.
    • __sys_trace 레이블에서 slow_syscall 루틴이 동작한다. (코드 설명 생략)
  • 코드 라인 8에서 syscall 번호가 syscall 처리 범위 이내인 경우 syscall 테이블에서 해당 syscall 번호에 해당하는 “sys_”로 시작하는 함수로 jump 하고 수행이 완료된 후 ret_fast_syscall 레이블 주소로 이동한다.
    • 0번 syscall은 커널 내부 사용목적의 syscall 함수이다. (sys_restart_syscall())
  • 코드 라인 10~15에서 syscall 번호가 ARM용 syscall 범위이내인 경우 arm_syscall() 함수를 호출한다. 만일 범위를 벗어난 경우 sys_ni_syscall() 함수를 호출하여 private한 syscall을 처리하게 한다.  만일 특별히 private syscall을 등록하지 않은 경우 -ENOSYS 에러로 함수를 빠져나온다.
    • 커널 4.0 기준 5개의 ARM syscall 함수들이 등록되어 있다.
  • 코드 라인 27~30에서 OABI 사용 시 다른 cpu에 의해 swi 명령이 있는 페이지를 mkold한 상태와 동시에 현재 cpu에서 swi 호출 시 panic 되는 경우를 막기 위해 다시 한번 해당 명령으로 복귀한다.

 

alignment_trap 매크로

arch/arm/kernel/entry-header.S

        .macro  alignment_trap, rtmp1, rtmp2, label
#ifdef CONFIG_ALIGNMENT_TRAP
        mrc     p15, 0, \rtmp2, c1, c0, 0
        ldr     \rtmp1, \label
        ldr     \rtmp1, [\rtmp1]
        teq     \rtmp1, \rtmp2
        mcrne   p15, 0, \rtmp1, c1, c0, 0
#endif
        .endm

CONFIG_ALIGNMENT_TRAP 커널 옵션을 사용하는 경우 alignment trap 기능을 적용한다.

  • alignment trap을 사용하면 정렬되지 않은 주소 및 데이터에 접근 할 때 prefect abort 또는 data abort exception이 발생한다.
  • 기존에 저장해 두었던 cr_alignment 값과 SCTLR 값이 다른 경우에만 SCTLR에 cr_alignment 값을 저장하는 방식으로 성능 저하를 막는다.

 

ret_fast_syscall 레이블

arch/arm/kernel/entry-common.S

/*
 * This is the fast syscall return path.  We do as little as possible here,
 * such as avoiding writing r0 to the stack.  We only use this path if we
 * have tracing, context tracking and rseq debug disabled - the overheads
 * from those features make this path too inefficient.
 */
ret_fast_syscall:
__ret_fast_syscall:
 UNWIND(.fnstart        )
 UNWIND(.cantunwind     )
        disable_irq_notrace                     @ disable interrupts
        ldr     r2, [tsk, #TI_ADDR_LIMIT]
        cmp     r2, #TASK_SIZE
        blne    addr_limit_check_failed
        ldr     r1, [tsk, #TI_FLAGS]            @ re-check for syscall tracing
        tst     r1, #_TIF_SYSCALL_WORK | _TIF_WORK_MASK
        bne     fast_work_pending


        /* perform architecture specific actions before user return */
        arch_ret_to_user r1, lr

        restore_user_regs fast = 1, offset = S_OFF
 UNWIND(.fnend          )
ENDPROC(ret_fast_syscall)

syscall 처리를 마치고 복귀하기 전에 pending된 작업이 있으면 수행한 후 백업해 두었던 레지스터들을 다시 읽어 들인 후 복귀한다.

 

invoke_syscall 매크로

arch/arm/kernel/entry-header.S

        .macro  invoke_syscall, table, nr, tmp, ret, reload=0
#ifdef CONFIG_CPU_SPECTRE
        mov     \tmp, \nr
        cmp     \tmp, #NR_syscalls              @ check upper syscall limit
        movcs   \tmp, #0
        csdb
        badr    lr, \ret                        @ return address
        .if     \reload
        add     r1, sp, #S_R0 + S_OFF           @ pointer to regs
        ldmiacc r1, {r0 - r6}                   @ reload r0-r6
        stmiacc sp, {r4, r5}                    @ update stack arguments
        .endif
        ldrcc   pc, [\table, \tmp, lsl #2]      @ call sys_* routine
#else
        cmp     \nr, #NR_syscalls               @ check upper syscall limit
        badr    lr, \ret                        @ return address
        .if     \reload
        add     r1, sp, #S_R0 + S_OFF           @ pointer to regs
        ldmiacc r1, {r0 - r6}                   @ reload r0-r6
        stmiacc sp, {r4, r5}                    @ update stack arguments
        .endif
        ldrcc   pc, [\table, \nr, lsl #2]       @ call sys_* routine
#endif
        .endm

@nr 번호가 syscall 범위에 있는 경우 해당하는 syscall 함수를 호출한 후 @ret 주소로 복귀한다. 범위 밖인 경우 그냥 빠져나온다.

 

sys_ni_syscall()

kernel/sys_ni.c

/*
 * Non-implemented system calls get redirected here.
 */                    
asmlinkage long sys_ni_syscall(void)
{
        return -ENOSYS;
}

범위 밖의 syscall 요청이 수행되는 루틴이다. private syscall이 필요한 경우 이곳에 작성되는데 없으면 -ENOSYS 에러를 반환한다.

 

참고

 

 

2 thoughts to “Exception -2- (ARM32 Handler 1)”

댓글 남기기

이메일은 공개되지 않습니다. 필수 입력창은 * 로 표시되어 있습니다