U-Boot · source analysis

x86 reset entry, Cache-As-RAM과 gd

32비트 시작 코드는 GDT/IDT를 정리한 뒤 car_init_ret에서 갈린다. CONFIG_USE_CAR이면 CAR top으로 ESP를 설정하고, FSP1 경로는 전달된 임시 ESP를 사용해 GD를 예약한다.

v2026.07은 이 글의 U-Boot 소스 분석 기준이다. 실제 보드의 CONFIG_USE_CAR, FSP와 32/64비트 빌드 경로는 해당 설정·ELF로 확인한다.

Series
19 / 22
Baseline
v2026.07
Commit
ece349ade297
Source
arch/x86/cpu/start.S:29-174 (발췌 범위)

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 경로다.

ESP의 출처와 GD 예약

그림 1. 32비트 시작에서 두 stack 출처가 합쳐지는 지점
초기 진입조건부 ESP 출처공통 GD 초기화
01_start / _x86boot_start
02segment · blank IDT
03car_init_ret
04USE_CAR: CAR top
FSP1: 기존 ESP
05GD · early malloc 예약
06FS의 GD · board_init_f
CONTRACT

ESP는 선택된 경로에서 유효해야 한다. 분기별 상태 표

CAR 주소 상수로 ESP를 만드는 단계는 CONFIG_USE_CAR 안에만 있다. 공통 예약 함수는 전달된 현재 ESP를 입력으로 받는다. 64비트 start64.S는 기존 %rsp를 직접 사용하므로 이 32비트 그림에 포함하지 않는다.

32비트 시작의 조건부 흐름

그림 2. car_init_ret 뒤 ESP 분기와 공통 reserve
32비트 entry
_start / fail-safe
GDT segment
blank IDT
car_init
car_init_ret
USE_CAR: CAR top
그 외: 기존 ESP
GD · malloc 예약
GD 초기화
FS:0 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을 더 늘린다.

분기별 입력과 출력

CAR top 계산은 모든 32비트 경로의 공통 단계가 아니다. 아래 표는 조건과 공통 소비자를 분리한다.

#조건·단계진입 시 상태소스의 실제 동작다음 소비자
0132비트 entry_start: BIST EAX; _x86boot_start: 이전 loadercold reset은 EAX의 BIST를 EBP에 보존하고 fail-safe는 EBP를 0으로 둔다. 공통 경로에서 ECX table pointer를 ESI에 보존한다. segment를 적재하고 blank IDT를 설정한다.car_init
02CONFIG_USE_CARcar_init_ret, CAR 주소·크기 설정ESP = CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4; 설정되면 MRC 보존 영역만큼 뺀다.현재 ESP → reserve
03비-CAR FSP1첫 진입: 임시 ESP, ESI=0; FSP 뒤 재진입: HOB 주소가 ESICAR 주소 상수로 ESP를 다시 설정하지 않는다.상속 ESP → reserve
04공통 reserve선택된 경로의 현재 ESPboard_init_f_alloc_reserve()가 조건부 early malloc을 먼저 빼고 GD를 정렬해 예약한다. board_init_f_init_reserve()가 GD와 FS 연결을 초기화한다.GD와 새 ESP
05FSP1 HOB 조건CONFIG_USE_HOB && !CONFIG_USE_CARESI가 0이 아닐 때만 HOB list를 GD에 저장하고, 그 안에서 CONFIG_HAVE_FSP이면 추가 malloc 영역을 확보한다.GD_HOB_LIST · GD_MALLOC_BASE
0632비트 C 진입FS:0에서 GD pointer, EBP에서 BISTGD에 BIST와 HOB 또는 table pointer를 기록한 뒤 board_init_f(0) 호출pre-relocation init

경로 선택을 확인한 뒤 ESP·GD 범위를 계산한다. 64비트 직접 진입은 start64.S에서 기존 RSP로 reserve를 호출하는 별도 경로다.

조건부 stack과 공통 GD 초기화를 그림으로 읽기

현재 빌드의 CONFIG_USE_CAR와 FSP/HOB 설정을 먼저 확인한다. 그 뒤 debugger에서 car_init_ret의 ESP, ESI와 board_init_f 직전 GD 주소를 기록한다.

그림 3. CONFIG_USE_CAR과 FSP1 임시 stack의 두 경로

두 열은 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 확장

그림 4. x86 U-Boot의 32-bit entry 두 경로

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에서 공통 설정

그림 5. 32비트 entry에서 board_init_f까지

ESP 선택은 조건부다. 두 갈래가 같은 reserve·GD 초기화로 합쳐진다.

01_start /
_x86boot_start
02GDT segment
blank IDT
03car_init
car_init_ret
04USE_CAR: CAR top
FSP1: 기존 ESP
05alloc_reserve
init_reserve
06FS:0 GD
BIST·HOB/table
07board_init_f(0)

원본 코드

아래 코드는 U-Boot v2026.07의 arch/x86/cpu/start.S에서 29-174줄을 그대로 가져온 것이다.

commitece349ade2973e220f524ce59e59711cc919263fanchor · L65_start:
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

발췌 범위와 읽기 기준

원문 29–174줄에는 앞뒤 문맥이 포함된다. _start는 L65이고, L37은 _x86boot_start다. 발췌 첫 줄은 함수 정의의 시작이 아니다.

이 발췌의 CONFIG_USE_CAR 분기에서만 CAR top으로 ESP를 설정한다. FSP1 경로는 전달된 ESP를 사용한다. 시작 stage와 32/64비트 entry를 확인한 뒤 선택된 stack 범위에서 GD·early malloc 예약을 계산한다.

65_start:

16-bit cold-reset path가 32-bit protected mode를 만든 뒤 도착하는 고정 entry다. fail-safe _x86boot_start와 label 1에서 합쳐진다.

69 movl %eax, %ebp

cold reset 경로에서 firmware/CPU BIST 결과를 callee-saved EBP에 보존한다.

73 movl %ecx, %esi

coreboot table 또는 firmware가 넘긴 table pointer를 board_init_f 전까지 보존한다.

88 lidt blank_idt_ptr

limit/base가 0인 IDT를 적재한다. 정상 handler가 없다는 뜻이며 LIDT 자체가 interrupt를 마스킹하는 것은 아니다. fail-safe 진입의 CLI와 구분한다. 이 상태에서 예외가 생기면 정상 처리되지 못할 수 있다.

104 jmp car_init

platform 초기화를 거쳐 car_init_ret로 온다. 이후 CONFIG_USE_CAR에 따라 ESP 설정이 갈린다.

123 movl $(CONFIG_SYS_CAR_ADDR + CONFIG_SYS_CAR_SIZE - 4), %esp

CONFIG_USE_CAR에서만 CAR top으로 ESP를 설정한다. FSP1의 #else에는 이 명령이 없다.

138 call board_init_f_alloc_reserve

CAR 또는 FSP1이 제공한 현재 ESP에서 조건부 early malloc과 GD를 예약한다.

147 mov %fs:0, %edx

x86 segment 기반 global-data pointer를 읽는다. FS selector/GDT가 이 주소 계산의 일부다.

함께 읽어야 하는 원본 코드

첫 코드 조각만으로 동작이 완성되지 않는 경우 호출 매크로, 객체 정의와 실제 실행 목록을 같은 페이지에 묶었다. 각 조각은 같은 기준 commit에서 가져왔다.

01. 64-bit loader가 기존 stack에서 직접 시작하는 entry

arch/x86/cpu/start64.S 7-49줄이다.

filearch/x86/cpu/start64.Sanchor · L15_start:
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

주요 구문 해설

15_start:

start64.S의 별도 64비트 직접 진입점이다. 이미 유효한 %rsp를 reserve 함수에 넘기며 32비트 start.S의 label 1을 거치지 않는다.

18 call board_init_f_alloc_reserve

기존 RSP 아래에 GD를 예약한다. early malloc을 먼저 빼는 것은 SYS_MALLOC_F가 켜지고 CFG_MALLOC_F_ADDR가 없는 경우에 한한다.

26 call board_init_f

64비트 직접 진입의 C 초기화를 호출한다. 이 파일은 함수가 반환하면 이어서 board_init_f_r()를 호출하는 코드도 둔다.

02. 현재 stack top에서 GD와 조건부 malloc_f를 예약하는 공통 helper

common/init/board_init.c 74-135줄이다.

filecommon/init/board_init.canchor · L81ulong board_init_f_alloc_reserve(ulong top)
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줄이다.

filearch/x86/cpu/i386/cpu.canchor · L125void arch_setup_gd(gd_t *new_gd)
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);

내부 동작을 더 깊게 읽기

01

먼저 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 도식과 합치지 않는다.

02

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 확장은 이후 별도 분기다.

03

공통 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 크기를 별도 예약분으로 다시 빼지 않는다.

04

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 모두 쓰지 않고 건너뛴다.

05

첫 C 진입과 예상 밖 반환을 구분한다

start.S는 EAX=0으로 board_init_f()를 호출한다. 바로 뒤 POST 0x85와 die는 이 32비트 경로에서 예상 밖의 반환을 포착한다. 이후 relocation 경로는 별도 분석 대상이다.

이 글에서의 초기 stack 범위 검사는 CONFIG_USE_CAR과 FSP1 선택을 확인한 뒤 해야 한다. 런타임 DM 상태나 relocation 후 bdinfo는 그 초기 ESP가 어디서 왔는지 증명하지 않는다.

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

01

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으로 썼는지 말할 수 있다.

02

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 진입에 공통으로 실행되지는 않는다.

03

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에 달려 있다.

04

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 안에 있는지 확인한다.

05

32비트와 64비트 진입을 분리해 비교한다

start64.S는 기존 %rsp를 board_init_f_alloc_reserve()에 넘기고 car_init 또는 32비트 segment 설정을 거치지 않는다. 32비트 start.S의 board_init_f 뒤에는 예상 밖 반환용 POST/die가 있다.

같은 reserve 함수명을 공유해도 stack 생산자와 호출 후 제어 흐름은 파일별로 확인해야 한다.

06

실측은 선택된 branch 안에서 한다

CAR 빌드에서만 CAR 주소·크기와 MRC 예약을 이용해 남은 stack budget을 계산한다. FSP1 빌드는 상속 ESP, FSP temporary RAM 범위, 첫 진입과 HOB 재진입을 각각 기록한다.

둘 모두 car_init_ret, reserve 직후, board_init_f 직전 ESP와 GD를 비교하면 설정 오류와 포인터 초기화 오류를 구분할 수 있다.

객체와 주소 범위

대상생성·전달 시점유효 범위확인할 조건
CONFIG_USE_CAR ESPcar_init_ret의 CAR top 설정CAR 범위 내 초기 reserve·호출 동안MRC 영역과 GD·malloc·stack 충돌 여부
FSP1 임시 ESPcar_init_done() 또는 fsp_init_done()에서 전달해당 진입의 reserve·호출 동안ESP source와 HOB 재진입 여부
struct global_dataalloc_reserve 반환 주소에 init_reserve가 초기화pre-relocation 초기화 동안FS:0 pointer, BIST, HOB/table 보존
early malloc 영역설정 시 reserve의 GD 위쪽에 배치초기 allocator 사용 동안SYS_MALLOC_F, 고정 주소 여부, FSP 추가 확장
x86 초기 GDTarch_setup_gd()에서 GD 내부 arch.gdt 구성초기 FS/GD 접근 동안GD와 별도 예약분으로 이중 계산하지 않음

분기별 실패 지점

#조건관찰·의미먼저 볼 지점
01blank IDT 구간의 예외정상 handler가 없어 reset될 수 있음lidt blank_idt_ptr 전후
02CAR 빌드에서 용량 부족MRC·malloc·GD·stack 범위가 겹침CAR top과 alloc_reserve 결과
03FSP1의 전달 ESP 무효공통 reserve가 잘못된 top에서 내려감car_init_done/fsp_init_done 뒤 ESP
04FS descriptor/GD pointer 오류%fs:0가 잘못된 GD를 가리킴arch_setup_gd(), FS base
05FSP1 HOB metadata 손실재진입 후 필요한 HOB 주소가 GD에 저장되지 않음ESI와 GD_HOB_LIST 조건

CAR 주소를 확인하는 진단은 CONFIG_USE_CAR에만 적용한다. FSP1에서는 재진입 여부와 넘겨받은 ESP·ESI를 먼저 기록한다.

빌드와 초기 실행에서 확인할 증거

relocation 뒤 명령 출력보다 pre-relocation 어셈블리와 debugger의 ESP·ESI·FS 값을 먼저 대조한다.

#목적명령 또는 계측판정 기준
01빌드 분기grep -E 'CONFIG_(USE_CAR|USE_HOB|HAVE_FSP|X86_64|DCACHE_RAM_MRC_VAR_SIZE)=' .configCAR/FSP1·HOB 및 32/64비트 경로를 먼저 고정한다.
02실제 instruction${CROSS_COMPILE}objdump -dr u-boot | grep -A40 'car_init_ret'선택된 stage ELF에서 ESP를 CAR 상수로 설정하는지, 아니면 기존 ESP를 쓰는지 확인한다.
03ESP 출처car_init_ret 진입과 board_init_f_alloc_reserve 직전/직후 breakpoint첫 ESP, reserve 반환값과 GD 시작 주소를 기록한다.
04FSP1 재진입두 번째 car_init_ret에서 ESP·ESI·HOB 주소 기록ESI=0인 첫 진입과 HOB 재진입을 구분한다.
05GD 연결board_init_f 직전 FS base, %fs:0, GD_BIST·GD_HOB_LIST/GD_TABLE 기록선택된 stack 안의 GD와 metadata가 맞는지 확인한다.

직접 확인할 실험

  1. 01
    CAR 빌드의 stack 예산 계산

    CONFIG_USE_CAR에서 CAR top에서 조건부 MRC를 빼고, early malloc과 GD reserve 결과를 기록한다. 남은 stack 범위가 CAR bottom을 넘지 않는지 확인한다.

  2. 02
    FSP1의 두 진입 비교

    car_init_ret 첫 진입과 HOB 재진입의 ESP·ESI를 나란히 기록한다. 이 경로에는 CAR 상수로 ESP를 설정하는 instruction이 없어야 한다.

  3. 03
    GD와 FS 주소 검산

    board_init_f_init_reserve() 뒤 GD 주소, arch.gdt, FS descriptor base, %fs:0 값을 대조한다.

  4. 04
    64비트 직접 진입과 분리

    start64.S의 %rsp 전달과 32비트 start.S의 조건부 ESP 경로를 빌드 결과에서 별도로 확인한다.

원문과 다음 글