QUESTION
32비트 시작 코드가 GD를 예약할 때 ESP는 어디에서 오는가?
start.S의 _start와 _x86boot_start는 32비트 경로다. GDT segment와 blank IDT를 준비한 뒤 car_init을 거쳐 car_init_ret에 도달한다. CONFIG_USE_CAR이면 코드가 CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4로 ESP를 명시적으로 설정한다.
CONFIG_USE_CAR가 아니면 이 설정을 하지 않는다. 소스 주석의 FSP1 경로는 첫 진입에서 이미 유효한 임시 ESP와 ESI=0을 받고, FSP 뒤 재진입에서는 HOB 주소를 ESI로 받는다. 두 경우 모두 현재 ESP를 board_init_f_alloc_reserve()에 넘겨 GD와 조건부 early malloc을 예약한 뒤 board_init_f()로 간다. 64비트 직접 시작은 별도 start64.S 경로다.
STRUCTURE
ESP의 출처와 GD 예약
FSP1: 기존 ESP
ESP는 선택된 경로에서 유효해야 한다. 분기별 상태 표
CAR 주소 상수로 ESP를 만드는 단계는 CONFIG_USE_CAR 안에만 있다. 공통 예약 함수는 전달된 현재 ESP를 입력으로 받는다. 64비트 start64.S는 기존 %rsp를 직접 사용하므로 이 32비트 그림에 포함하지 않는다.
CALL PATH
32비트 시작의 조건부 흐름
_start / fail-safe
blank IDT
car_init_ret
그 외: 기존 ESP
GD 초기화
board_init_f
CONFIG_USE_CAR에서는 CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4에 ESP를 놓고 조건부 MRC 영역을 뺀다. 그렇지 않은 FSP1 경로는 car_init_done() 또는 fsp_init_done()에서 받은 임시 ESP를 그대로 공통 reserve에 전달한다. HOB 주소가 있는 재진입에서 GD에 HOB를 기록하며, 이 분기 안에서 CONFIG_HAVE_FSP이면 early malloc을 더 늘린다.
STATE LEDGER
분기별 입력과 출력
CAR top 계산은 모든 32비트 경로의 공통 단계가 아니다. 아래 표는 조건과 공통 소비자를 분리한다.
| # | 조건·단계 | 진입 시 상태 | 소스의 실제 동작 | 다음 소비자 |
|---|---|---|---|---|
| 01 | 32비트 entry | _start: BIST EAX; _x86boot_start: 이전 loader | cold reset은 EAX의 BIST를 EBP에 보존하고 fail-safe는 EBP를 0으로 둔다. 공통 경로에서 ECX table pointer를 ESI에 보존한다. segment를 적재하고 blank IDT를 설정한다. | car_init |
| 02 | CONFIG_USE_CAR | car_init_ret, CAR 주소·크기 설정 | ESP = CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4; 설정되면 MRC 보존 영역만큼 뺀다. | 현재 ESP → reserve |
| 03 | 비-CAR FSP1 | 첫 진입: 임시 ESP, ESI=0; FSP 뒤 재진입: HOB 주소가 ESI | CAR 주소 상수로 ESP를 다시 설정하지 않는다. | 상속 ESP → reserve |
| 04 | 공통 reserve | 선택된 경로의 현재 ESP | board_init_f_alloc_reserve()가 조건부 early malloc을 먼저 빼고 GD를 정렬해 예약한다. board_init_f_init_reserve()가 GD와 FS 연결을 초기화한다. | GD와 새 ESP |
| 05 | FSP1 HOB 조건 | CONFIG_USE_HOB && !CONFIG_USE_CAR | ESI가 0이 아닐 때만 HOB list를 GD에 저장하고, 그 안에서 CONFIG_HAVE_FSP이면 추가 malloc 영역을 확보한다. | GD_HOB_LIST · GD_MALLOC_BASE |
| 06 | 32비트 C 진입 | FS:0에서 GD pointer, EBP에서 BIST | GD에 BIST와 HOB 또는 table pointer를 기록한 뒤 board_init_f(0) 호출 | pre-relocation init |
경로 선택을 확인한 뒤 ESP·GD 범위를 계산한다. 64비트 직접 진입은 start64.S에서 기존 RSP로 reserve를 호출하는 별도 경로다.
VISUAL WALKTHROUGH
조건부 stack과 공통 GD 초기화를 그림으로 읽기
현재 빌드의 CONFIG_USE_CAR와 FSP/HOB 설정을 먼저 확인한다. 그 뒤 debugger에서 car_init_ret의 ESP, ESI와 board_init_f 직전 GD 주소를 기록한다.
두 열은 car_init_ret 직후의 ESP 출처를 비교한다. 이후 공통 함수가 그 ESP를 받아 GD를 예약한다.
CONFIG_USE_CAR
01CAR top - 4를 ESP로 설정
02MRC 영역은 설정 시 먼저 제외
03top → 조건부 malloc → GD → stack
04CAR 범위 안에서 충돌 여부 검산
FSP1 · !CONFIG_USE_CAR
01첫 진입: 기존 임시 ESP, ESI=0
02재진입: FSP가 준 ESP, ESI=HOB
03현재 ESP에서 GD·조건부 malloc 예약
04ESI≠0에서 HOB·조건부 malloc 확장
cold reset과 fail-safe의 초기 metadata는 다르지만 label 1 이후 GDT/IDT와 car_init 경로로 합쳐진다.
Cold reset _start
01start16에서 protected mode 진입
02EAX의 BIST를 EBP에 보존
03ECX table pointer를 ESI에 보존
04label 1에서 공통 설정
Fail-safe _x86boot_start
01이전 loader의 32-bit 환경
02cache 상속 상태 정리
03BIST를 0으로 둠
04label 1에서 공통 설정
ESP 선택은 조건부다. 두 갈래가 같은 reserve·GD 초기화로 합쳐진다.
_x86boot_start
blank IDT
car_init_ret
FSP1: 기존 ESP
init_reserve
BIST·HOB/table
UPSTREAM SOURCE
원본 코드
아래 코드는 U-Boot v2026.07의 arch/x86/cpu/start.S에서 29-174줄을 그대로 가져온 것이다.
29#include <generated/asm-offsets.h>
30#include <linux/linkage.h>
31
32.section .text.start
33.code32
34.globl _start
35.type _start, @function
36.globl _x86boot_start
37_x86boot_start:
38 /*
39 * This is the fail-safe 32-bit bootstrap entry point.
40 *
41 * This code is used when booting from another boot loader like
42 * coreboot or EFI. So we repeat some of the same init found in
43 * start16.
44 */
45 cli
46 cld
47
48 /* Turn off cache (this might require a 486-class CPU) */
49 movl %cr0, %eax
50 orl $(X86_CR0_NW | X86_CR0_CD), %eax
51 movl %eax, %cr0
52 wbinvd
53
54 /*
55 * Zero the BIST (Built-In Self Test) value since we don't have it.
56 * It must be 0 or the previous loader would have reported an error.
57 */
58 movl $0, %ebp
59
60 jmp 1f
61
62 /* Add a way for tools to discover the _start entry point */
63 .align 4
64 .long 0x12345678
65_start:
66 /* This is the 32-bit cold-reset entry point, coming from start16 */
67
68 /* Save BIST */
69 movl %eax, %ebp
701:
71
72 /* Save table pointer */
73 movl %ecx, %esi
74
75#ifdef CONFIG_X86_LOAD_FROM_32_BIT
76 lgdt gdt_ptr2
77#endif
78
79 /* Load the segment registers to match the GDT loaded in start16.S */
80 movl $(X86_GDT_ENTRY_32BIT_DS * X86_GDT_ENTRY_SIZE), %eax
81 movw %ax, %fs
82 movw %ax, %ds
83 movw %ax, %gs
84 movw %ax, %es
85 movw %ax, %ss
86
87 /* Clear the interrupt vectors */
88 lidt blank_idt_ptr
89
90#ifdef CONFIG_USE_EARLY_BOARD_INIT
91 /*
92 * Critical early platform init - generally not used, we prefer init
93 * to happen later when we have a console, in case something goes
94 * wrong.
95 */
96 jmp early_board_init
97.globl early_board_init_ret
98early_board_init_ret:
99#endif
100
101 post_code(POST_START)
102
103 /* Initialise Cache-As-RAM */
104 jmp car_init
105.globl car_init_ret
106car_init_ret:
107#ifdef CONFIG_USE_CAR
108 /*
109 * We now have CONFIG_SYS_CAR_SIZE bytes of Cache-As-RAM (or SRAM,
110 * or fully initialised SDRAM - we really don't care which)
111 * starting at CONFIG_SYS_CAR_ADDR to be used as a temporary stack
112 * and early malloc() area. The MRC requires some space at the top.
113 *
114 * Stack grows down from top of CAR. We have:
115 *
116 * top-> CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE
117 * MRC area
118 * global_data with x86 global descriptor table
119 * early malloc area
120 * stack
121 * bottom-> CONFIG_SYS_CAR_ADDR
122 */
123 movl $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %esp
124#ifdef CONFIG_DCACHE_RAM_MRC_VAR_SIZE
125 subl $CONFIG_DCACHE_RAM_MRC_VAR_SIZE, %esp
126#endif
127#else
128 /*
129 * Instructions for FSP1, but not FSP2:
130 * U-Boot enters here twice. For the first time it comes from
131 * car_init_done() with esp points to a temporary stack and esi
132 * set to zero. For the second time it comes from fsp_init_done()
133 * with esi holding the HOB list address returned by the FSP.
134 */
135#endif
136 /* Set up global data */
137 mov %esp, %eax
138 call board_init_f_alloc_reserve
139 mov %eax, %esp
140 call board_init_f_init_reserve
141
142#ifdef CONFIG_DEBUG_UART
143 call debug_uart_init
144#endif
145
146 /* Get address of global_data */
147 mov %fs:0, %edx
148#if defined(CONFIG_USE_HOB) && !defined(CONFIG_USE_CAR)
149 /* Store the HOB list if we have one */
150 test %esi, %esi
151 jz skip_hob
152 movl %esi, GD_HOB_LIST(%edx)
153
154#ifdef CONFIG_HAVE_FSP
155 /*
156 * After fsp_init() returns, the stack has already been switched to a
157 * place within system memory as defined by CONFIG_FSP_TEMP_RAM_ADDR.
158 * Enlarge the size of malloc() pool before relocation since we have
159 * plenty of memory now.
160 */
161 subl $CONFIG_FSP_SYS_MALLOC_F_LEN, %esp
162 movl %esp, GD_MALLOC_BASE(%edx)
163#endif
164skip_hob:
165#else
166 /* Store table pointer */
167 movl %esi, GD_TABLE(%edx)
168#endif
169 /* Store BIST */
170 movl %ebp, GD_BIST(%edx)
171
172 /* Set parameter to board_init_f() to boot flags */
173 post_code(POST_START_DONE)
174 xorl %eax, %eax
READING CONTRACT
발췌 범위와 읽기 기준
원문 29–174줄에는 앞뒤 문맥이 포함된다. _start는 L65이고, L37은 _x86boot_start다. 발췌 첫 줄은 함수 정의의 시작이 아니다.
이 발췌의 CONFIG_USE_CAR 분기에서만 CAR top으로 ESP를 설정한다. FSP1 경로는 전달된 ESP를 사용한다. 시작 stage와 32/64비트 entry를 확인한 뒤 선택된 stack 범위에서 GD·early malloc 예약을 계산한다.
_start:16-bit cold-reset path가 32-bit protected mode를 만든 뒤 도착하는 고정 entry다. fail-safe _x86boot_start와 label 1에서 합쳐진다.
movl %eax, %ebpcold reset 경로에서 firmware/CPU BIST 결과를 callee-saved EBP에 보존한다.
movl %ecx, %esicoreboot table 또는 firmware가 넘긴 table pointer를 board_init_f 전까지 보존한다.
lidt blank_idt_ptrlimit/base가 0인 IDT를 적재한다. 정상 handler가 없다는 뜻이며 LIDT 자체가 interrupt를 마스킹하는 것은 아니다. fail-safe 진입의 CLI와 구분한다. 이 상태에서 예외가 생기면 정상 처리되지 못할 수 있다.
jmp car_initplatform 초기화를 거쳐 car_init_ret로 온다. 이후 CONFIG_USE_CAR에 따라 ESP 설정이 갈린다.
movl $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %espCONFIG_USE_CAR에서만 CAR top으로 ESP를 설정한다. FSP1의 #else에는 이 명령이 없다.
call board_init_f_alloc_reserveCAR 또는 FSP1이 제공한 현재 ESP에서 조건부 early malloc과 GD를 예약한다.
mov %fs:0, %edxx86 segment 기반 global-data pointer를 읽는다. FS selector/GDT가 이 주소 계산의 일부다.
RELATED SOURCE
함께 읽어야 하는 원본 코드
첫 코드 조각만으로 동작이 완성되지 않는 경우 호출 매크로, 객체 정의와 실제 실행 목록을 같은 페이지에 묶었다. 각 조각은 같은 기준 commit에서 가져왔다.
01. 64-bit loader가 기존 stack에서 직접 시작하는 entry
arch/x86/cpu/start64.S 7-49줄이다.
7 */
8
9#include <config.h>
10
11.section .text.start
12.code64
13.globl _start
14.type _start, @function
15_start:
16 /* Set up memory using the existing stack */
17 mov %rsp, %rdi
18 call board_init_f_alloc_reserve
19
20 mov %rax, %rsp
21 mov %rsp, %rdi
22
23 call board_init_f_init_reserve
24
25 xor %rdi, %rdi
26 call board_init_f
27 call board_init_f_r
28
29 /* Should not return here */
30 jmp .
31
32.globl board_init_f_r_trampoline64
33.type board_init_f_r_trampoline64, @function
34board_init_f_r_trampoline64:
35 /*
36 * SDRAM has been initialised, U-Boot code has been copied into
37 * RAM, BSS has been cleared and relocation adjustments have been
38 * made. It is now time to jump into the in-RAM copy of U-Boot
39 *
40 * %eax = Address of top of new stack
41 */
42
43 /* Stack grows down from top of SDRAM */
44 movq %rsi, %rsp
45
46 /* New gd is in rdi */
47
48 /* Re-enter U-Boot by calling board_init_f_r() */
49 call board_init_f_r
주요 구문 해설
_start:start64.S의 별도 64비트 직접 진입점이다. 이미 유효한 %rsp를 reserve 함수에 넘기며 32비트 start.S의 label 1을 거치지 않는다.
call board_init_f_alloc_reserve기존 RSP 아래에 GD를 예약한다. early malloc을 먼저 빼는 것은 SYS_MALLOC_F가 켜지고 CFG_MALLOC_F_ADDR가 없는 경우에 한한다.
call board_init_f64비트 직접 진입의 C 초기화를 호출한다. 이 파일은 함수가 반환하면 이어서 board_init_f_r()를 호출하는 코드도 둔다.
02. 현재 stack top에서 GD와 조건부 malloc_f를 예약하는 공통 helper
common/init/board_init.c 74-135줄이다.
74 * alignment constraint of the architecture for which we are bulding.
75 *
76 * - GD is allocated last, so that the return value of this functions is
77 * both the bottom of the reserved area and the address of GD, should
78 * the calling context need it.
79 */
80
81ulong board_init_f_alloc_reserve(ulong top)
82{
83 /* Reserve early malloc arena */
84#ifndef CFG_MALLOC_F_ADDR
85#if CONFIG_IS_ENABLED(SYS_MALLOC_F)
86 top -= CONFIG_VAL(SYS_MALLOC_F_LEN);
87#endif
88#endif
89 /* LAST : reserve GD (rounded up to a multiple of 16 bytes) */
90 top = rounddown(top-sizeof(struct global_data), 16);
91
92 return top;
93}
94
95/*
96 * Initialize reserved space (which has been safely allocated on the C
97 * stack from the C runtime environment handling code).
98 *
99 * Notes:
100 *
101 * Actual reservation was done by the caller; the locations from base
102 * to base+size-1 (where 'size' is the value returned by the allocation
103 * function above) can be accessed freely without risk of corrupting the
104 * C runtime environment.
105 *
106 * IMPORTANT:
107 *
108 * Upon return from the allocation function above, on some architectures
109 * the caller will set gd to the lowest reserved location. Therefore, in
110 * this initialization function, the global data MUST be placed at base.
111 *
112 * ALSO IMPORTANT:
113 *
114 * On some architectures, gd will already be good when entering this
115 * function. On others, it will only be good once arch_setup_gd() returns.
116 * Therefore, global data accesses must be done:
117 *
118 * - through gd_ptr if before the call to arch_setup_gd();
119 *
120 * - through gd once arch_setup_gd() has been called.
121 *
122 * Do not use 'gd->' until arch_setup_gd() has been called!
123 *
124 * IMPORTANT TOO:
125 *
126 * Initialization for each "chunk" (GD, early malloc arena...) ends with
127 * an incrementation line of the form 'base += <some size>'. The last of
128 * these incrementations seems useless, as base will not be used any
129 * more after this incrementation; but if/when a new "chunk" is appended,
130 * this increment will be essential as it will give base right value for
131 * this new chunk (which will have to end with its own incrementation
132 * statement). Besides, the compiler's optimizer will silently detect
133 * and remove the last base incrementation, therefore leaving that last
134 * (seemingly useless) incrementation causes no code increase.
135 */
03. x86이 FS segment에 gd pointer를 연결하는 초기화
arch/x86/cpu/i386/cpu.c 118-167줄이다.
118
119 gdt.len = (num_entries * X86_GDT_ENTRY_SIZE) - 1;
120 gdt.ptr = (ulong)boot_gdt;
121
122 asm volatile("lgdtl %0\n" : : "m" (gdt));
123}
124
125void arch_setup_gd(gd_t *new_gd)
126{
127 u64 *gdt_addr;
128
129 gdt_addr = new_gd->arch.gdt;
130
131 /*
132 * CS: code, read/execute, 4 GB, base 0
133 *
134 * Some OS (like VxWorks) requires GDT entry 1 to be the 32-bit CS
135 */
136 gdt_addr[X86_GDT_ENTRY_UNUSED] = GDT_ENTRY(0xc09b, 0, 0xfffff);
137 gdt_addr[X86_GDT_ENTRY_32BIT_CS] = GDT_ENTRY(0xc09b, 0, 0xfffff);
138
139 /* DS: data, read/write, 4 GB, base 0 */
140 gdt_addr[X86_GDT_ENTRY_32BIT_DS] = GDT_ENTRY(0xc093, 0, 0xfffff);
141
142 /*
143 * FS: data, read/write, sizeof (Global Data Pointer),
144 * base (Global Data Pointer)
145 */
146 new_gd->arch.gd_addr = new_gd;
147 gdt_addr[X86_GDT_ENTRY_32BIT_FS] = GDT_ENTRY(0x8093,
148 (ulong)&new_gd->arch.gd_addr,
149 sizeof(new_gd->arch.gd_addr) - 1);
150
151 /* 16-bit CS: code, read/execute, 64 kB, base 0 */
152 gdt_addr[X86_GDT_ENTRY_16BIT_CS] = GDT_ENTRY(0x009b, 0, 0x0ffff);
153
154 /* 16-bit DS: data, read/write, 64 kB, base 0 */
155 gdt_addr[X86_GDT_ENTRY_16BIT_DS] = GDT_ENTRY(0x0093, 0, 0x0ffff);
156
157 gdt_addr[X86_GDT_ENTRY_16BIT_FLAT_CS] = GDT_ENTRY(0x809b, 0, 0xfffff);
158 gdt_addr[X86_GDT_ENTRY_16BIT_FLAT_DS] = GDT_ENTRY(0x8093, 0, 0xfffff);
159 gdt_addr[X86_GDT_ENTRY_64BIT_CS] = GDT_ENTRY(0xaf9b, 0, 0xfffff);
160 gdt_addr[X86_GDT_ENTRY_64BIT_TS1] = GDT_ENTRY(0x8980, 0, 0xfffff);
161 gdt_addr[X86_GDT_ENTRY_64BIT_TS2] = 0;
162
163 load_gdt(gdt_addr, X86_GDT_NUM_ENTRIES);
164 load_ds(X86_GDT_ENTRY_32BIT_DS);
165 load_es(X86_GDT_ENTRY_32BIT_DS);
166 load_gs(X86_GDT_ENTRY_32BIT_DS);
167 load_ss(X86_GDT_ENTRY_32BIT_DS);
DETAILS
내부 동작을 더 깊게 읽기
먼저 32비트 시작 파일의 사용 stage를 고정한다
start.S 상단은 TPL이 있으면 TPL, SPL만 있으면 SPL, 둘 다 없으면 U-Boot proper에 이 파일을 쓴다고 설명한다. _start는 start16에서 오는 cold reset이고 _x86boot_start는 이전 loader에서 오는 fail-safe 진입이다.
start64.S의 직접 64비트 entry는 기존 RSP를 reserve에 넘긴다. 이 별도 경로를 32비트 car_init_ret 도식과 합치지 않는다.
car_init_ret 뒤 ESP를 누가 설정하는지 본다
CONFIG_USE_CAR이면 CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4가 ESP가 되고, CONFIG_DCACHE_RAM_MRC_VAR_SIZE가 있으면 이를 더 뺀다. 비-CAR FSP1 경로는 전달된 임시 ESP를 그대로 쓴다.
FSP1은 첫 진입에서 ESI=0, 재진입에서 ESI=HOB list라는 source 주석이 있다. HOB 저장과 조건부 malloc 확장은 이후 별도 분기다.
공통 reserve의 정확한 배치를 계산한다
board_init_f_alloc_reserve(top)는 SYS_MALLOC_F가 켜지고 고정 malloc 주소가 없을 때 early malloc 길이를 top에서 먼저 뺀다. 그 아래에 struct global_data를 16바이트 경계로 정렬해 예약한 값을 반환한다.
이 반환값을 ESP로 사용하고 board_init_f_init_reserve()가 GD를 초기화한다. x86의 초기 GDT는 GD 내부 arch.gdt에 있으므로 GDT 크기를 별도 예약분으로 다시 빼지 않는다.
GD 포인터와 metadata를 연결한다
arch_setup_gd()는 새 GD의 arch.gd_addr를 가리키는 FS descriptor를 설정한다. start.S는 %fs:0에서 GD 포인터를 읽고 BIST를 기록한다.
CONFIG_USE_HOB && !CONFIG_USE_CAR이면 ESI가 0이 아닐 때 HOB list를 저장한다. 컴파일 조건의 #else에서만 ESI의 table pointer를 GD에 기록한다. HOB 구성이 선택됐지만 ESI=0인 런타임 분기는 HOB와 table 모두 쓰지 않고 건너뛴다.
첫 C 진입과 예상 밖 반환을 구분한다
start.S는 EAX=0으로 board_init_f()를 호출한다. 바로 뒤 POST 0x85와 die는 이 32비트 경로에서 예상 밖의 반환을 포착한다. 이후 relocation 경로는 별도 분석 대상이다.
이 글에서의 초기 stack 범위 검사는 CONFIG_USE_CAR과 FSP1 선택을 확인한 뒤 해야 한다. 런타임 DM 상태나 relocation 후 bdinfo는 그 초기 ESP가 어디서 왔는지 증명하지 않는다.
IMPLEMENTATION NOTES
구현을 읽을 때 놓치기 쉬운 분기
CAR라는 함수 이름만으로 stack 주소를 단정하지 않는다
start.S는 car_init을 거쳐 car_init_ret에 도달하지만, ESP를 CAR 상수로 바꾸는 instruction은 #ifdef CONFIG_USE_CAR 안에 있다. #else에는 FSP1의 전달된 ESP 계약이 적혀 있다.
따라서 빌드 설정과 car_init_ret 전후 ESP를 함께 확인해야 어느 memory를 stack으로 썼는지 말할 수 있다.
FSP1 재진입에서 HOB와 malloc 변화가 생긴다
소스 주석은 car_init_done() 뒤 첫 진입에서 임시 ESP·ESI=0, fsp_init_done() 뒤 두 번째 진입에서 ESI=HOB 주소라고 구분한다. HOB 저장은 CONFIG_USE_HOB && !CONFIG_USE_CAR 안에서 ESI가 0이 아닐 때 실행된다.
같은 ESI≠0 분기 안에서 CONFIG_HAVE_FSP이면 FSP가 제공한 system memory의 ESP에서 CONFIG_FSP_SYS_MALLOC_F_LEN만큼 더 내려 GD malloc base를 갱신한다. 첫 FSP1 진입에 공통으로 실행되지는 않는다.
GD와 GDT의 예약 순서를 소스로 검산한다
board_init_f_alloc_reserve()는 조건부 early malloc을 먼저 예약하고 GD를 마지막에 정렬한다. board_init_f_init_reserve()는 GD를 0으로 만들고 arch_setup_gd()를 부른다. x86 arch_setup_gd()는 GD 내부의 arch.gdt를 사용한다.
예약 helper는 top에서 크기를 빼고 정렬할 뿐 CAR bottom 검사나 할당 실패 반환을 하지 않는다. 호출자가 충분한 범위와 정렬 여유를 보장해야 한다.
CAR 경로라면 높은 주소부터 조건부 MRC, early malloc, GD, 아래로 자라는 stack 순서다. 비-CAR FSP1도 같은 helper를 쓰지만 주소 범위는 전달된 ESP에 달려 있다.
blank IDT와 FS:0은 각각 다른 경계다
lidt blank_idt_ptr는 정상 예외 handler를 준비하는 단계가 아니다. reserve 뒤에는 arch_setup_gd()가 FS descriptor를 새 GD 포인터 필드에 연결하고 %fs:0에서 이 pointer를 읽는다.
breakpoint에서는 GDTR·IDTR·FS selector뿐 아니라 ESP와 FS base가 선택된 임시 memory 안에 있는지 확인한다.
32비트와 64비트 진입을 분리해 비교한다
start64.S는 기존 %rsp를 board_init_f_alloc_reserve()에 넘기고 car_init 또는 32비트 segment 설정을 거치지 않는다. 32비트 start.S의 board_init_f 뒤에는 예상 밖 반환용 POST/die가 있다.
같은 reserve 함수명을 공유해도 stack 생산자와 호출 후 제어 흐름은 파일별로 확인해야 한다.
실측은 선택된 branch 안에서 한다
CAR 빌드에서만 CAR 주소·크기와 MRC 예약을 이용해 남은 stack budget을 계산한다. FSP1 빌드는 상속 ESP, FSP temporary RAM 범위, 첫 진입과 HOB 재진입을 각각 기록한다.
둘 모두 car_init_ret, reserve 직후, board_init_f 직전 ESP와 GD를 비교하면 설정 오류와 포인터 초기화 오류를 구분할 수 있다.
OBJECT LIFETIME
객체와 주소 범위
| 대상 | 생성·전달 시점 | 유효 범위 | 확인할 조건 |
|---|---|---|---|
CONFIG_USE_CAR ESP | car_init_ret의 CAR top 설정 | CAR 범위 내 초기 reserve·호출 동안 | MRC 영역과 GD·malloc·stack 충돌 여부 |
| FSP1 임시 ESP | car_init_done() 또는 fsp_init_done()에서 전달 | 해당 진입의 reserve·호출 동안 | ESP source와 HOB 재진입 여부 |
struct global_data | alloc_reserve 반환 주소에 init_reserve가 초기화 | pre-relocation 초기화 동안 | FS:0 pointer, BIST, HOB/table 보존 |
| early malloc 영역 | 설정 시 reserve의 GD 위쪽에 배치 | 초기 allocator 사용 동안 | SYS_MALLOC_F, 고정 주소 여부, FSP 추가 확장 |
| x86 초기 GDT | arch_setup_gd()에서 GD 내부 arch.gdt 구성 | 초기 FS/GD 접근 동안 | GD와 별도 예약분으로 이중 계산하지 않음 |
FAILURE PATH
분기별 실패 지점
| # | 조건 | 관찰·의미 | 먼저 볼 지점 |
|---|---|---|---|
| 01 | blank IDT 구간의 예외 | 정상 handler가 없어 reset될 수 있음 | lidt blank_idt_ptr 전후 |
| 02 | CAR 빌드에서 용량 부족 | MRC·malloc·GD·stack 범위가 겹침 | CAR top과 alloc_reserve 결과 |
| 03 | FSP1의 전달 ESP 무효 | 공통 reserve가 잘못된 top에서 내려감 | car_init_done/fsp_init_done 뒤 ESP |
| 04 | FS descriptor/GD pointer 오류 | %fs:0가 잘못된 GD를 가리킴 | arch_setup_gd(), FS base |
| 05 | FSP1 HOB metadata 손실 | 재진입 후 필요한 HOB 주소가 GD에 저장되지 않음 | ESI와 GD_HOB_LIST 조건 |
CAR 주소를 확인하는 진단은 CONFIG_USE_CAR에만 적용한다. FSP1에서는 재진입 여부와 넘겨받은 ESP·ESI를 먼저 기록한다.
EVIDENCE
빌드와 초기 실행에서 확인할 증거
relocation 뒤 명령 출력보다 pre-relocation 어셈블리와 debugger의 ESP·ESI·FS 값을 먼저 대조한다.
| # | 목적 | 명령 또는 계측 | 판정 기준 |
|---|---|---|---|
| 01 | 빌드 분기 | grep -E 'CONFIG_(USE_CAR|USE_HOB|HAVE_FSP|X86_64|DCACHE_RAM_MRC_VAR_SIZE)=' .config | CAR/FSP1·HOB 및 32/64비트 경로를 먼저 고정한다. |
| 02 | 실제 instruction | ${CROSS_COMPILE}objdump -dr u-boot | grep -A40 'car_init_ret' | 선택된 stage ELF에서 ESP를 CAR 상수로 설정하는지, 아니면 기존 ESP를 쓰는지 확인한다. |
| 03 | ESP 출처 | car_init_ret 진입과 board_init_f_alloc_reserve 직전/직후 breakpoint | 첫 ESP, reserve 반환값과 GD 시작 주소를 기록한다. |
| 04 | FSP1 재진입 | 두 번째 car_init_ret에서 ESP·ESI·HOB 주소 기록 | ESI=0인 첫 진입과 HOB 재진입을 구분한다. |
| 05 | GD 연결 | board_init_f 직전 FS base, %fs:0, GD_BIST·GD_HOB_LIST/GD_TABLE 기록 | 선택된 stack 안의 GD와 metadata가 맞는지 확인한다. |
LAB
직접 확인할 실험
- 01CAR 빌드의 stack 예산 계산
CONFIG_USE_CAR에서 CAR top에서 조건부 MRC를 빼고, early malloc과 GD reserve 결과를 기록한다. 남은 stack 범위가 CAR bottom을 넘지 않는지 확인한다. - 02FSP1의 두 진입 비교
car_init_ret첫 진입과 HOB 재진입의 ESP·ESI를 나란히 기록한다. 이 경로에는 CAR 상수로 ESP를 설정하는 instruction이 없어야 한다. - 03GD와 FS 주소 검산
board_init_f_init_reserve()뒤 GD 주소,arch.gdt, FS descriptor base,%fs:0값을 대조한다. - 0464비트 직접 진입과 분리
start64.S의%rsp전달과 32비트start.S의 조건부 ESP 경로를 빌드 결과에서 별도로 확인한다.
PRIMARY REFERENCES