ARM64 start.S와 초기 실행 환경 | LK

QUESTION

ARM64 start.S와 초기 실행 환경 단계에서 실제로 바뀌는 상태는 무엇인가?

C 함수 호출 전의 stack 정렬과 zero-init 영역을 확인한다. primary CPU와 secondary CPU가 같은 label을 지나더라도 다음 경로는 달라질 수 있다.

lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다. 이 문장을 기준으로 코드를 위에서 아래로 읽으면, 함수 이름을 외우는 대신 어느 시점에 어떤 상태를 신뢰할 수 있는지 판단할 수 있다.

STRUCTURE

객체와 주소가 놓이는 구조

그림 1. ARM64 start.S와 초기 실행 환경에서 입력, 내부 상태, 출력의 경계

입력과 전제내부 상태외부로 공개되는 결과

01reset registers

02EL transition

03bootstrap stack

04C runtime

INVARIANT

`lk_main` 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다.

bootstrap stack / exception-level state를 중심에 놓고 왼쪽의 입력이 어떤 검사를 거쳐 오른쪽 결과로 공개되는지 표시했다. 실제 디버깅에서는 각 블록의 주소와 크기를 로그에 대입한다.

CALL PATH

실행 흐름

그림 2. 정상 경로의 주요 호출과 상태 전달

firmware

_start

EL setup

stack and BSS

lk_main

화살표는 단순 호출 순서만 뜻하지 않는다. 각 단계가 성공을 반환할 때 다음 단계가 읽을 수 있는 상태가 무엇인지 함께 확인한다. 오류 반환이 발생하면 바로 다음 화살표로 진행하지 않고 해당 단계의 정리 경로를 따라간다.

STATE LEDGER

단계별 입력과 출력

호출 순서를 함수 이름으로만 외우지 않고, 각 단계가 무엇을 받아 무엇을 공개하는지 적은 표다. 실제 소스에서 생산 필드가 다르면 표를 고치는 방식으로 사용한다.

#	단계	진입 시 신뢰할 상태	성공 뒤 남아야 할 상태	다음 소비자
01	`firmware`	reset 직후 어셈블리 문맥	reset registers	_start
02	`_start`	firmware 완료 상태	EL transition	EL setup
03	`EL setup`	_start 완료 상태	bootstrap stack	stack and BSS
04	`stack and BSS`	EL setup 완료 상태	C runtime	lk_main
05	`lk_main`	stack and BSS 완료 상태	C runtime	최종 최종 부트로더 이미지 또는 다음 stage

공통 불변 조건: lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다. 한 단계의 출력이 다음 단계의 입력 조건을 만족하지 않으면 오류가 실제로 드러난 위치보다 앞의 생산 단계부터 조사한다.

UPSTREAM SOURCE

원본 코드

아래 코드는 LK upstream 1eb9917의 arch/arm64/start.S에서 8-96줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

commit1eb99171efae98867d4be4a5bd6479ea03f43ac9symbolFUNCTION(_start)

8 *  x0-x3   Arguments
9 *  x9-x15  Scratch
10 *  x19-x28 Globals
11 */
12tmp                     .req x9
13tmp2                    .req x10
14wtmp2                   .req w10
15idx                     .req x11
16idx_shift               .req x12
17page_table              .req x13
18new_page_table          .req x14
19phys_offset             .req x15
20
21cpuid                   .req x19
22page_table1             .req x21
23mmu_initial_mapping     .req x22
24vaddr                   .req x23
25paddr                   .req x24
26mapping_size            .req x25
27size                    .req x26
28attr                    .req x27
29boot_el                 .req x28
30
31.section .text.boot
32FUNCTION(_start)
33.globl arm_reset
34arm_reset:
35    /* keep track of the boot EL */
36    mrs     boot_el, currentel
37
38    /* if we came in at higher than EL1, drop down to EL1 */
39    bl      arm64_elX_to_el1
40
41    /* disable EL1 FPU traps */
42    mov     tmp, #(0b11<<20)
43    msr     cpacr_el1, tmp
44
45#if WITH_KERNEL_VM
46    /* enable caches so atomics and spinlocks work */
47    mrs     tmp, sctlr_el1
48    orr     tmp, tmp, #(1<<12) /* Enable icache */
49    orr     tmp, tmp, #(1<<2)  /* Enable dcache/ucache */
50    orr     tmp, tmp, #(1<<3)  /* Enable Stack Alignment Check EL1 */
51    orr     tmp, tmp, #(1<<4)  /* Enable Stack Alignment Check EL0 */
52    bic     tmp, tmp, #(1<<1)  /* Disable Alignment Checking for EL1 EL0 */
53    msr     sctlr_el1, tmp
54
55    /* set up the mmu according to mmu_initial_mappings */
56
57    /* load the base of the translation table and clear the table */
58    adrp    page_table1, arm64_kernel_translation_table
59    add     page_table1, page_table1, #:lo12:arm64_kernel_translation_table
60
61#if WITH_SMP
62    /* if the cpu id is != 0 it's a secondary cpu */
63    mrs     cpuid, mpidr_el1
64    ubfx    cpuid, cpuid, #0, #SMP_CPU_ID_BITS
65    cbnz    cpuid, .Lmmu_enable_secondary
66
67    /* this path forward until .Lmmu_enable_secondary is the primary cpu only */
68
69#endif /* WITH_SMP */
70#endif /* WITH_KERNEL_VM */
71
72    /* save a copy of the boot args so x0-x3 are available for use */
73    adrp    tmp, arm64_boot_args
74    add     tmp, tmp, :lo12:arm64_boot_args
75    stp     x0, x1, [tmp], #16
76    stp     x2, x3, [tmp]
77
78    /* save the boot EL */
79    adrp    tmp, arm64_boot_el
80    str     boot_el, [tmp, #:lo12:arm64_boot_el]
81
82#if WITH_KERNEL_VM
83    /* walk through all the entries in the translation table, setting them up */
84    mov     tmp, #0
85.Lclear_top_page_table_loop:
86    str     xzr, [page_table1, tmp, lsl #3]
87    add     tmp, tmp, #1
88    cmp     tmp, #MMU_KERNEL_PAGE_TABLE_ENTRIES_TOP
89    bne     .Lclear_top_page_table_loop
90
91    /* load the address of the mmu_initial_mappings table and start processing */
92    adrp    mmu_initial_mapping, mmu_initial_mappings
93    add     mmu_initial_mapping, mmu_initial_mapping, #:lo12:mmu_initial_mappings
94
95.Linitial_mapping_loop:
96/* Read entry of mmu_initial_mappings (likely defined in platform.c) */

LINE BY LINE

8-96줄 해설

원본에 보이는 모든 줄을 순서대로 설명한다. 빈 줄도 block 경계로 남겨, 코드와 설명의 위치가 어긋나지 않게 했다.

8* x0-x3 Arguments

원본 주석이 'x0-x3 Arguments'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

9* x9-x15 Scratch

원본 주석이 'x9-x15 Scratch'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

10* x19-x28 Globals

원본 주석이 'x19-x28 Globals'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

11*/

원본 주석이 'block boundary'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

12tmp .req x9

원본 12번 줄의 tmp .req x9는 앞의 */ 결과를 받아 다음 tmp2 .req x10로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

13tmp2 .req x10

원본 13번 줄의 tmp2 .req x10는 앞의 tmp .req x9 결과를 받아 다음 wtmp2 .req w10로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

14wtmp2 .req w10

원본 14번 줄의 wtmp2 .req w10는 앞의 tmp2 .req x10 결과를 받아 다음 idx .req x11로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

15idx .req x11

원본 15번 줄의 idx .req x11는 앞의 wtmp2 .req w10 결과를 받아 다음 idx_shift .req x12로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

16idx_shift .req x12

원본 16번 줄의 idx_shift .req x12는 앞의 idx .req x11 결과를 받아 다음 page_table .req x13로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

17page_table .req x13

원본 17번 줄의 page_table .req x13는 앞의 idx_shift .req x12 결과를 받아 다음 new_page_table .req x14로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

18new_page_table .req x14

원본 18번 줄의 new_page_table .req x14는 앞의 page_table .req x13 결과를 받아 다음 phys_offset .req x15로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

19phys_offset .req x15

원본 19번 줄의 phys_offset .req x15는 앞의 new_page_table .req x14 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

20(빈 줄)

phys_offset .req x15까지의 동작과 cpuid .req x19에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

21cpuid .req x19

원본 21번 줄의 cpuid .req x19는 앞의 이전 block 경계 결과를 받아 다음 page_table1 .req x21로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

22page_table1 .req x21

원본 22번 줄의 page_table1 .req x21는 앞의 cpuid .req x19 결과를 받아 다음 mmu_initial_mapping .req x22로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

23mmu_initial_mapping .req x22

원본 23번 줄의 mmu_initial_mapping .req x22는 앞의 page_table1 .req x21 결과를 받아 다음 vaddr .req x23로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

24vaddr .req x23

원본 24번 줄의 vaddr .req x23는 앞의 mmu_initial_mapping .req x22 결과를 받아 다음 paddr .req x24로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

25paddr .req x24

원본 25번 줄의 paddr .req x24는 앞의 vaddr .req x23 결과를 받아 다음 mapping_size .req x25로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

26mapping_size .req x25

원본 26번 줄의 mapping_size .req x25는 앞의 paddr .req x24 결과를 받아 다음 size .req x26로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

27size .req x26

원본 27번 줄의 size .req x26는 앞의 mapping_size .req x25 결과를 받아 다음 attr .req x27로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

28attr .req x27

원본 28번 줄의 attr .req x27는 앞의 size .req x26 결과를 받아 다음 boot_el .req x28로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

29boot_el .req x28

원본 29번 줄의 boot_el .req x28는 앞의 attr .req x27 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

30(빈 줄)

boot_el .req x28까지의 동작과 .section .text.boot에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

31.section .text.boot

원본 31번 줄의 .section .text.boot는 앞의 이전 block 경계 결과를 받아 다음 FUNCTION(_start)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

32FUNCTION(_start)

'FUNCTION(_start)' 매크로가 진입 symbol 또는 정적 descriptor를 linker section에 놓는다. 단순 함수 호출이 아니므로 map 파일에서 실제 section과 주소를 찾는다.

33.globl arm_reset

원본 33번 줄의 .globl arm_reset는 앞의 FUNCTION(_start) 결과를 받아 다음 arm_reset:로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

34arm_reset:

'arm_reset' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

35/* keep track of the boot EL */

원본 주석이 'keep track of the boot EL'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

36mrs boot_el, currentel

mrs boot_el, currentel 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

37(빈 줄)

mrs boot_el, currentel까지의 동작과 /* if we came in at higher than EL1, drop down to EL1 */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

38/* if we came in at higher than EL1, drop down to EL1 */

원본 주석이 'if we came in at higher than EL1, drop down to EL1'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

39bl arm64_elX_to_el1

bl arm64_elX_to_el1 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

40(빈 줄)

bl arm64_elX_to_el1까지의 동작과 /* disable EL1 FPU traps */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

41/* disable EL1 FPU traps */

원본 주석이 'disable EL1 FPU traps'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

42mov tmp, #(0b11<<20)

mov tmp, #(0b11<<20) 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

43msr cpacr_el1, tmp

msr cpacr_el1, tmp 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

44(빈 줄)

msr cpacr_el1, tmp까지의 동작과 #if WITH_KERNEL_VM에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

45#if WITH_KERNEL_VM

#if 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

46/* enable caches so atomics and spinlocks work */

원본 주석이 'enable caches so atomics and spinlocks work'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

47mrs tmp, sctlr_el1

mrs tmp, sctlr_el1 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

48orr tmp, tmp, #(1<<12) /* Enable icache */

원본 48번 줄의 orr tmp, tmp, #(1<<12) /* Enable icache */는 앞의 mrs tmp, sctlr_el1 결과를 받아 다음 orr tmp, tmp, #(1<<2) /* Enable dcache/ucache */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

49orr tmp, tmp, #(1<<2) /* Enable dcache/ucache */

원본 49번 줄의 orr tmp, tmp, #(1<<2) /* Enable dcache/ucache */는 앞의 orr tmp, tmp, #(1<<12) /* Enable icache */ 결과를 받아 다음 orr tmp, tmp, #(1<<3) /* Enable Stack Alignment Check EL1 */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

50orr tmp, tmp, #(1<<3) /* Enable Stack Alignment Check EL1 */

원본 50번 줄의 orr tmp, tmp, #(1<<3) /* Enable Stack Alignment Check EL1 */는 앞의 orr tmp, tmp, #(1<<2) /* Enable dcache/ucache */ 결과를 받아 다음 orr tmp, tmp, #(1<<4) /* Enable Stack Alignment Check EL0 */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

51orr tmp, tmp, #(1<<4) /* Enable Stack Alignment Check EL0 */

원본 51번 줄의 orr tmp, tmp, #(1<<4) /* Enable Stack Alignment Check EL0 */는 앞의 orr tmp, tmp, #(1<<3) /* Enable Stack Alignment Check EL1 */ 결과를 받아 다음 bic tmp, tmp, #(1<<1) /* Disable Alignment Checking for EL1 EL0 */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

52bic tmp, tmp, #(1<<1) /* Disable Alignment Checking for EL1 EL0 */

원본 52번 줄의 bic tmp, tmp, #(1<<1) /* Disable Alignment Checking for EL1 EL0 */는 앞의 orr tmp, tmp, #(1<<4) /* Enable Stack Alignment Check EL0 */ 결과를 받아 다음 msr sctlr_el1, tmp로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

53msr sctlr_el1, tmp

msr sctlr_el1, tmp 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

54(빈 줄)

msr sctlr_el1, tmp까지의 동작과 /* set up the mmu according to mmu_initial_mappings */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

55/* set up the mmu according to mmu_initial_mappings */

원본 주석이 'set up the mmu according to mmu_initial_mappings'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

56(빈 줄)

/* set up the mmu according to mmu_initial_mappings */까지의 동작과 /* load the base of the translation table and clear the table */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

57/* load the base of the translation table and clear the table */

원본 주석이 'load the base of the translation table and clear the table'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

58adrp page_table1, arm64_kernel_translation_table

adrp page_table1, arm64_kernel_translation_table 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

59add page_table1, page_table1, #:lo12:arm64_kernel_translation_table

add page_table1, page_table1, #:lo12:arm64_kernel_translation_table 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

60(빈 줄)

add page_table1, page_table1, #:lo12:arm64_kernel_translation_table까지의 동작과 #if WITH_SMP에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

61#if WITH_SMP

62/* if the cpu id is != 0 it's a secondary cpu */

원본 주석이 'if the cpu id is != 0 it's a secondary cpu'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

63mrs cpuid, mpidr_el1

mrs cpuid, mpidr_el1 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

64ubfx cpuid, cpuid, #0, #SMP_CPU_ID_BITS

원본 64번 줄의 ubfx cpuid, cpuid, #0, #SMP_CPU_ID_BITS는 앞의 mrs cpuid, mpidr_el1 결과를 받아 다음 cbnz cpuid, .Lmmu_enable_secondary로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

65cbnz cpuid, .Lmmu_enable_secondary

cbnz cpuid, .Lmmu_enable_secondary 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

66(빈 줄)

cbnz cpuid, .Lmmu_enable_secondary까지의 동작과 /* this path forward until .Lmmu_enable_secondary is the primary cpu only */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

67/* this path forward until .Lmmu_enable_secondary is the primary cpu only */

원본 주석이 'this path forward until .Lmmu_enable_secondary is the primary cpu only'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

68(빈 줄)

/* this path forward until .Lmmu_enable_secondary is the primary cpu only */까지의 동작과 #endif /* WITH_SMP */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

69#endif /* WITH_SMP */

#endif 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. architecture 또는 build stage 조건을 여닫는다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

70#endif /* WITH_KERNEL_VM */

71(빈 줄)

#endif /* WITH_KERNEL_VM */까지의 동작과 /* save a copy of the boot args so x0-x3 are available for use */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

72/* save a copy of the boot args so x0-x3 are available for use */

원본 주석이 'save a copy of the boot args so x0-x3 are available for use'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

73adrp tmp, arm64_boot_args

adrp tmp, arm64_boot_args 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

74add tmp, tmp, :lo12:arm64_boot_args

add tmp, tmp, :lo12:arm64_boot_args 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

75stp x0, x1, [tmp], #16

stp x0, x1, [tmp], #16 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

76stp x2, x3, [tmp]

stp x2, x3, [tmp] 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

77(빈 줄)

stp x2, x3, [tmp]까지의 동작과 /* save the boot EL */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

78/* save the boot EL */

원본 주석이 'save the boot EL'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

79adrp tmp, arm64_boot_el

adrp tmp, arm64_boot_el 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

80str boot_el, [tmp, #:lo12:arm64_boot_el]

str boot_el, [tmp, #:lo12:arm64_boot_el] 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

81(빈 줄)

str boot_el, [tmp, #:lo12:arm64_boot_el]까지의 동작과 #if WITH_KERNEL_VM에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

82#if WITH_KERNEL_VM

83/* walk through all the entries in the translation table, setting them up */

원본 주석이 'walk through all the entries in the translation table, setting them up'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

84mov tmp, #0

mov tmp, #0 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

85.Lclear_top_page_table_loop:

'.Lclear_top_page_table_loop' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

86str xzr, [page_table1, tmp, lsl #3]

str xzr, [page_table1, tmp, lsl #3] 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

87add tmp, tmp, #1

add tmp, tmp, #1 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

88cmp tmp, #MMU_KERNEL_PAGE_TABLE_ENTRIES_TOP

cmp tmp, #MMU_KERNEL_PAGE_TABLE_ENTRIES_TOP 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

89bne .Lclear_top_page_table_loop

원본 89번 줄의 bne .Lclear_top_page_table_loop는 앞의 cmp tmp, #MMU_KERNEL_PAGE_TABLE_ENTRIES_TOP 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다' 조건이 유지되는지 확인한다.

90(빈 줄)

bne .Lclear_top_page_table_loop까지의 동작과 /* load the address of the mmu_initial_mappings table and start processing */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

91/* load the address of the mmu_initial_mappings table and start processing */

원본 주석이 'load the address of the mmu_initial_mappings table and start processing'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

92adrp mmu_initial_mapping, mmu_initial_mappings

adrp mmu_initial_mapping, mmu_initial_mappings 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

93add mmu_initial_mapping, mmu_initial_mapping, #:lo12:mmu_initial_mappings

add mmu_initial_mapping, mmu_initial_mapping, #:lo12:mmu_initial_mappings 명령이 register, memory 또는 PC를 직접 바꾼다. reset 직후 어셈블리 문맥에서 source operand의 이전 값과 destination operand의 새 값을 debugger로 확인한다.

94(빈 줄)

add mmu_initial_mapping, mmu_initial_mapping, #:lo12:mmu_initial_mappings까지의 동작과 .Linitial_mapping_loop:에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 C runtime 상태가 아래 블록의 입력으로 사용되는 경계다.

95.Linitial_mapping_loop:

'.Linitial_mapping_loop' label이다. 이곳을 참조하는 branch를 역검색하고 각 진입 경로의 register, stack, lock 조건이 같은지 확인한다.

96/* Read entry of mmu_initial_mappings (likely defined in platform.c) */

원본 주석이 'Read entry of mmu_initial_mappings (likely defined in platform.c)'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

DETAILS

내부 동작을 더 깊게 읽기

진입 조건을 먼저 고정한다

firmware에서 들어온 실행은 reset 직후 어셈블리 문맥에 놓여 있다. 이때 interrupt, MMU/cache, stack, heap 중 무엇이 이미 준비되었는지 소스의 호출자까지 올라가 확인한다. 같은 함수라도 SPL, relocation 전후, app thread처럼 호출 문맥이 달라지면 허용되는 API와 지연 시간이 달라진다.

C 함수 호출 전의 stack 정렬과 zero-init 영역을 확인한다. primary CPU와 secondary CPU가 같은 label을 지나더라도 다음 경로는 달라질 수 있다.

중심 객체의 생성과 공개를 나눈다

이 글의 중심 객체는 bootstrap stack / exception-level state다. 메모리를 확보한 시점, 필드를 채운 시점, 전역 list나 다른 subsystem에 공개한 시점을 구분한다. 공개 뒤 오류가 발생한다면 목록에서 제거하고 child, buffer, reference를 역순으로 정리하는지 확인한다.

빌드 산출물 관점에서는 최종 부트로더 이미지 안에 해당 symbol과 section이 실제로 포함되었는지도 map과 objdump로 검증한다.

주소, 크기와 정렬을 계산한다

부트 코드의 오류는 논리보다 주소 계산에서 먼저 드러나는 경우가 많다. source range, destination range, header가 말하는 payload size, block 또는 page 단위를 표로 적고 각 구간의 끝 주소를 직접 계산한다. 끝 주소는 start + size - 1인지 exclusive end인지 API 계약을 확인한다.

lk_main 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다.

성공 flag와 실제 완료 시점을 맞춘다

_start → EL setup → stack and BSS 구간에서는 부분 초기화 상태가 생길 수 있다. flag, list insertion, callback 등록, storage write 완료 중 무엇이 성공의 기준인지 찾는다. hardware write나 DMA가 포함되면 함수 반환과 장치 완료가 같은 시점인지도 확인한다.

다른 CPU, interrupt handler, USB completion 또는 shell command가 상태를 관찰할 수 있다면 memory ordering과 lock 범위도 함께 읽는다.

마지막 handoff의 계약을 적는다

정상 경로는 lk_main에서 끝난다. 이 단계가 함수 반환인지, scheduler 전환인지, 다른 image로의 비복귀 분기인지 구분한다. 비복귀 handoff라면 cache clean/invalidate, interrupt disable, 장치 quiesce, argument register와 FDT 또는 image address가 최종 점검 항목이다.

반환하는 경로라면 caller가 오류와 부분 성공을 구분하고 다음 후보 또는 복구 경로를 선택하는지 확인한다.

IMPLEMENTATION NOTES

구현을 읽을 때 놓치기 쉬운 부분

첫 assembly는 boot CPU와 secondary CPU의 경로를 갈라 놓는다

reset entry는 현재 CPU id와 platform handoff를 보존한 뒤 stack, exception vector와 초기 translation 조건을 만든다. SMP system에서 모든 CPU가 같은 stack과 BSS clear 경로로 들어가면 즉시 memory corruption이 발생한다.

boot CPU만 수행해야 하는 BSS 초기화와 global constructor 이전에 secondary가 공유 전역을 읽지 않도록 release protocol을 확인한다.

C 진입 전 stack과 exception level을 수치로 확인한다

SP 정렬, stack range, CurrentEL과 SPSR/DAIF를 첫 C 함수 직전에 기록한다. EL2에서 시작해 EL1로 내려가는 platform과 EL1에서 바로 시작하는 platform은 system register 설정이 다르다.

MMU와 cache가 켜져 들어오는 firmware handoff를 지원한다면 기존 mapping을 신뢰하는지 명시적으로 끄는지 확인한다.

early fault는 vector가 아니라 저장 frame까지 검증한다

vector branch가 맞아도 register save frame 크기와 stack pointer가 틀리면 C handler가 잘못된 ESR과 PC를 읽는다. exception entry 전후 SP, saved ELR, SPSR, ESR을 raw memory와 구조체 field 양쪽으로 대조한다.

UART보다 먼저 난 fault는 scratch register나 per-CPU buffer에 syndrome을 남기도록 계측한다.

OBJECT LIFETIME

객체와 수명

대상	만들어지는 시점	유효 범위	확인할 조건
`bootstrap stack / exception-level state`	_start	lk_main 또는 오류 정리 완료까지	`lk_main` 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다.
입력 buffer / metadata	firmware	parse와 검증이 끝날 때까지	길이, 정렬, 소유권, 변조 가능성
등록된 list / descriptor	EL setup	subsystem 종료 또는 image handoff까지	이중 등록, dangling pointer, 오류 unwind
hardware 또는 persistent state	실제 write/probe가 완료된 뒤	reset 또는 명시적 해제·갱신까지	flush, timeout, 전원 차단, rollback
`최종 부트로더 이미지`	link/image 생성 시점	다음 stage가 새 image로 교체할 때까지	load address, entry, section과 header 일치

FAILURE PATH

실패 지점과 증상

#	조건	관찰되는 증상	먼저 볼 단계
01	잘못된 EL 전환	system register fault	_start
02	BSS 미초기화	list head 오염	EL setup
03	secondary 경로 혼동	전역 init 중복	stack and BSS

로그가 끊긴 마지막 함수만 고치지 않는다. 그 함수가 받은 주소, size, flag가 만들어진 앞 단계까지 올라가고, 오류 뒤 등록 객체와 hardware 상태가 남았는지도 확인한다.

EVIDENCE

소스 밖에서 확인할 증거

소스 해석은 실제 빌드 산출물과 target 로그로 닫아야 한다. 아래 명령의 보드 이름과 toolchain prefix는 사용 중인 빌드 환경에 맞게 바꾼다.

#	목적	명령 또는 계측	판정 기준
01	빌드 구성	`make <project> -j1`	platform, target, app 선택과 linker 입력을 로그로 남긴다.
02	symbol과 주소	`nm -n build-*/lk.elf \| grep 'FUNCTION'`	init hook, app descriptor와 함수가 어느 주소에 놓였는지 확인한다.
03	어셈블리 대조	`objdump -drS build-*/lk.elf`	thread 전환과 interrupt disable 구간의 실제 명령을 확인한다.
04	초기화 순서	`init level 전후에 current_time_hires()와 함수 이름 기록`	level 내부 순서와 지연을 serial log로 남긴다.
05	문맥 확인	`current_thread, interrupt state, stack pointer 기록`	함수가 bootstrap thread인지 scheduler 이후 thread인지 구분한다.

LAB

직접 확인할 실험

01
QEMU에서 _start부터 lk_main까지 single-step
_start 진입 전후에 reset registers의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 `lk_main` 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다. 조건이 처음 깨지는 줄을 기록한다.
02
SP와 BSS 경계 심볼 기록
EL setup 진입 전후에 EL transition의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 `lk_main` 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다. 조건이 처음 깨지는 줄을 기록한다.
03
secondary CPU 활성화 시 진입 label 비교
stack and BSS 진입 전후에 bootstrap stack의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 `lk_main` 진입 시 C ABI, writable memory, BSS, current CPU의 stack이 모두 유효해야 한다. 조건이 처음 깨지는 줄을 기록한다.

PRIMARY REFERENCES

원문과 다음 글

arch/arm64/start.Supstream 1eb9917 원본 파일 LK source tree기준 commit 1eb99171efae