booti에서 ARM64 Linux로 handoff | U-Boot

QUESTION

booti에서 ARM64 Linux로 handoff 단계에서 실제로 바뀌는 상태는 무엇인가?

분기 직전에는 bootloader의 편의 기능보다 Linux boot protocol을 우선한다. x0의 FDT 주소, EL, MMU/cache 상태, reserved memory 반영을 체크한다.

kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다. 이 문장을 기준으로 코드를 위에서 아래로 읽으면, 함수 이름을 외우는 대신 어느 시점에 어떤 상태를 신뢰할 수 있는지 판단할 수 있다.

STRUCTURE

객체와 주소가 놓이는 구조

그림 1. booti에서 ARM64 Linux로 handoff에서 입력, 내부 상태, 출력의 경계

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

01ARM64 Image

02bootm_headers

03working FDT

04EL and register contract

INVARIANT

kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다.

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

CALL PATH

실행 흐름

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

booti command

Image header

bootm states

FDT/initrd setup

kernel entry

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

STATE LEDGER

단계별 입력과 출력

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

#	단계	진입 시 신뢰할 상태	성공 뒤 남아야 할 상태	다음 소비자
01	`booti command`	부트 CPU의 동기 실행 문맥	ARM64 Image	Image header
02	`Image header`	booti command 완료 상태	bootm_headers	bootm states
03	`bootm states`	Image header 완료 상태	working FDT	FDT/initrd setup
04	`FDT/initrd setup`	bootm states 완료 상태	EL and register contract	kernel entry
05	`kernel entry`	FDT/initrd setup 완료 상태	EL and register contract	최종 최종 부트로더 이미지 또는 다음 stage

공통 불변 조건: kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다. 한 단계의 출력이 다음 단계의 입력 조건을 만족하지 않으면 오류가 실제로 드러난 위치보다 앞의 생산 단계부터 조사한다.

VISUAL WALKTHROUGH

주소와 객체의 이동을 그림으로 읽기

아래 그림은 호출 이름보다 주소, 객체 수명과 handoff 경계를 먼저 볼 수 있도록 구성했다. 실제 주소와 크기는 사용 중인 보드의 bdinfo, map과 linker symbol을 대입한다.

그림 3. kernel Image, initrd, DTB가 임시 적재 주소에서 최종 주소로 이동하는 과정

왼쪽은 storage나 network에서 읽은 직후의 staging 주소이고, 오른쪽은 Linux로 분기하기 직전의 최종 배치다. 주소는 개념도이며 실제 값은 보드의 DRAM map과 environment에 따라 달라진다.

01 · LOAD

임시 적재 주소

파일을 읽기 편한 빈 RAM에 우선 올린 상태

HIGHLOW

U-Boot runtimerelocaddr · malloc · stack

booti가 끝날 때까지 덮으면 안 되는 영역

사용 가능한 RAMstaging 사이의 빈 공간

아직 최종 배치가 확정되지 않은 공간

DTB sourcefdt_addr_r

storage에서 읽은 원본 DTB

initrd sourceramdisk_addr_r

initramfs archive와 size

kernel Image sourcekernel_addr_r / loadaddr

raw Image 또는 압축 Image의 입력 buffer

DRAM base사용 가능한 RAM의 시작

보드가 Linux에 공개할 물리 메모리

kernel Imagekernel_addr_rbooti_setup() + memmove images->ep

initrdramdisk_addr_rLMB + boot_ramdisk_high() final initrd range

DTBfdt_addr_rLMB + boot_relocate_fdt() working FDT

02 · HANDOFF

Linux 진입 직전의 최종 주소

실행 조건과 reserved range를 만족하도록 다시 배치

HIGHLOW

U-Boot runtimehandoff 전까지 유지

자기 stack·heap과 payload가 겹치지 않아야 함

working DTBfinal_fdt · 8-byte aligned

여유 공간을 확보하고 /chosen을 수정한 사본

final initrdinitrd_start .. initrd_end

kernel Image와 같은 허용 window 안의 보존 구간

kernel이 사용할 RAMLMB reservation 제외

부팅 뒤 page allocator에 넘길 수 있는 공간

final kernel Image2 MiB aligned base + text_offset

image_size 전체가 안전한 실행 위치

DRAM baseusable system RAM

가능하면 낮은 주소 쪽에 kernel을 배치

ARM64 Linux entry contract

PCfinal kernel entryCPU가 Image 첫 instruction으로 분기

x0final DTB addressLinux가 hardware와 bootargs를 읽는 물리 주소

/chosenlinux,initrd-start / linux,initrd-endinitrd 위치는 DTB property로 전달

x1-x30ARM64 Linux boot protocol의 reserved register

그림 4. booti가 세 payload의 최종 주소를 확정하는 순서

load 명령의 주소는 출발점일 뿐이다. Image header와 LMB reservation을 읽은 뒤에야 Linux가 실제로 볼 주소가 확정된다.

01kernel·initrd·DTB를 staging RAM에 load

02Image header의 text_offset·image_size 확인

03U-Boot·reserved-memory를 LMB에 예약

04kernel destination 계산과 copy/decompress

05initrd 최종 range 선택과 필요 시 copy

06DTB 확장·copy 후 /chosen 수정

07cache clean·MMU/interrupt 상태 정리

08x0=DTB, PC=kernel entry로 분기

그림 5. 처음 읽은 주소를 그대로 사용하지 않는 이유

staging 주소는 입출력 편의를 위한 위치이고, final 주소는 Linux boot protocol과 메모리 안전성을 만족해야 하는 위치다.

kernel 실행 위치 계약

문제가 되는 상태Image가 잘못된 base에서 시작

실패 결과초기 page table 또는 linear map 전제 불일치

2 MiB aligned base + text_offset, image_size 범위 확보

source와 destination 충돌 방지

문제가 되는 상태copy/decompress 출력이 입력 buffer를 덮음

실패 결과Image 후반부가 손상되어 early boot fault

두 반개구간 [start, end)의 교차 여부를 먼저 검사

DTB를 수정할 작업 공간

문제가 되는 상태원본 DTB 뒤에 여유 공간이 없음

실패 결과/chosen, memory, reserved-memory fixup 실패

writable buffer와 padding을 확보한 working FDT 사용

initrd 수명 보장

문제가 되는 상태kernel이 풀기 전에 다른 buffer가 initrd를 덮음

실패 결과invalid compressed data 또는 rootfs mount 실패

final range를 LMB로 예약하고 DTB /chosen에 기록

UPSTREAM SOURCE

원본 코드

아래 코드는 U-Boot v2026.07의 cmd/booti.c에서 88-176줄을 그대로 가져온 것이다. 설명을 위해 실제 코드를 가짜 의사 코드로 바꾸지 않았다.

commitece349ade2973e220f524ce59e59711cc919263fsymbolint do_booti(struct cmd_tbl *cmdtp

88	images->ep = relocated_addr;
89	images->os.start = relocated_addr;
90	images->os.end = relocated_addr + image_size;
91
92	ep_addr = (phys_addr_t)images->ep;
93	ret = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &ep_addr,
94			    le32_to_cpu(image_size), LMB_NONE);
95	if (ret) {
96		printf("Failed to allocate memory for the image at %#llx\n",
97		       (unsigned long long)images->ep);
98		return 1;
99	}
100
101	/*
102	 * Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not
103	 * have a header that provide this informaiton.
104	 */
105	if (bootm_find_images(image_load_addr, bmi->conf_ramdisk, bmi->conf_fdt,
106			      relocated_addr, image_size))
107		return 1;
108
109	return 0;
110}
111
112int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
113{
114	struct bootm_info bmi;
115	int states;
116	int ret;
117
118	/* Consume 'booti' */
119	argc--; argv++;
120
121	bootm_init(&bmi);
122	if (argc)
123		bmi.addr_img = argv[0];
124	if (argc > 1)
125		bmi.conf_ramdisk = argv[1];
126	if (argc > 2)
127		bmi.conf_fdt = argv[2];
128	bmi.boot_progress = true;
129	bmi.cmd_name = "booti";
130	/* do not set up argc and argv[] since nothing uses them */
131
132	if (booti_start(&bmi))
133		return 1;
134
135	/*
136	 * We are doing the BOOTM_STATE_LOADOS state ourselves, so must
137	 * disable interrupts ourselves
138	 */
139	bootm_disable_interrupts();
140
141	images.os.os = IH_OS_LINUX;
142	if (IS_ENABLED(CONFIG_RISCV_SMODE))
143		images.os.arch = IH_ARCH_RISCV;
144	else if (IS_ENABLED(CONFIG_ARM64))
145		images.os.arch = IH_ARCH_ARM64;
146
147	states = BOOTM_STATE_MEASURE | BOOTM_STATE_OS_PREP |
148		BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO;
149	if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))
150		states |= BOOTM_STATE_RAMDISK;
151
152	ret = bootm_run_states(&bmi, states);
153
154	return ret;
155}
156
157U_BOOT_LONGHELP(booti,
158	"[addr [initrd[:size]] [fdt]]\n"
159	"    - boot Linux flat or compressed 'Image' stored at 'addr'\n"
160	"\tThe argument 'initrd' is optional and specifies the address\n"
161	"\tof an initrd in memory. The optional parameter ':size' allows\n"
162	"\tspecifying the size of a RAW initrd.\n"
163	"\tCurrently only booting from gz, bz2, lzma and lz4 compression\n"
164	"\ttypes are supported. In order to boot from any of these compressed\n"
165	"\timages, user have to set kernel_comp_addr_r and kernel_comp_size environment\n"
166	"\tvariables beforehand.\n"
167#if defined(CONFIG_OF_LIBFDT)
168	"\tSince booting a Linux kernel requires a flat device-tree, a\n"
169	"\tthird argument providing the address of the device-tree blob\n"
170	"\tis required. To boot a kernel with a device-tree blob but\n"
171	"\twithout an initrd image, use a '-' for the initrd argument.\n"
172#endif
173	);
174
175U_BOOT_CMD(
176	booti,	CONFIG_SYS_MAXARGS,	1,	do_booti,

LINE BY LINE

88-176줄 해설

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

88images->ep = relocated_addr;

images->ep에 relocated_addr를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 booti command 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

89images->os.start = relocated_addr;

images->os.start에 relocated_addr를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 Image header 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

90images->os.end = relocated_addr + image_size;

images->os.end에 relocated_addr + image_size를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 bootm states 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

91(빈 줄)

images->os.end = relocated_addr + image_size;까지의 동작과 ep_addr = (phys_addr_t)images->ep;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

92ep_addr = (phys_addr_t)images->ep;

ep_addr에 (phys_addr_t)images->ep를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 ret = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &ep_addr,가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

93ret = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &ep_addr,

lmb_alloc_mem(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

94le32_to_cpu(image_size), LMB_NONE);

le32_to_cpu(image_size), LMB_NONE)를 호출한다. 반환 결과는 현재 줄 또는 다음 if (ret) {에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

95if (ret) {

ret를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

96printf("Failed to allocate memory for the image at %#llx\n",

printf(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

97(unsigned long long)images->ep);

(unsigned long long)images->ep)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

98return 1;

1를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

99}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

100(빈 줄)

}까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

101/*

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

102* Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not

원본 주석이 'Handle the BOOTM_STATE_FINDOTHER state ourselves as we do not'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

103* have a header that provide this informaiton.

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

104*/

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

105if (bootm_find_images(image_load_addr, bmi->conf_ramdisk, bmi->conf_fdt,

bootm_find_images(인자 없음)를 호출한다. 반환 결과는 현재 줄 또는 다음 relocated_addr, image_size))에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

106relocated_addr, image_size))

원본 106번 줄의 relocated_addr, image_size))는 앞의 if (bootm_find_images(image_load_addr, bmi->conf_ramdisk, bmi->conf_fdt, 결과를 받아 다음 return 1;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

107return 1;

1를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

108(빈 줄)

return 1;까지의 동작과 return 0;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

109return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

110}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

111(빈 줄)

}까지의 동작과 int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

112int do_booti(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])

do_booti 함수 정의가 시작된다. 입력은 struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]이며, 부트 CPU의 동기 실행 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

113{

바로 위 함수·조건·초기화의 block이 열린다. 이 scope 안에서 만들어지는 지역 객체와 오류 이동 지점을 struct bootm_headers / ARM64 Image header의 수명에 맞춰 묶어 읽는다.

114struct bootm_info bmi;

struct bootm_info bmi를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

115int states;

int states를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

116int ret;

int ret를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

117(빈 줄)

int ret;까지의 동작과 /* Consume 'booti' */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

118/* Consume 'booti' */

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

119argc--; argv++;

원본 119번 줄의 argc--; argv++;는 앞의 /* Consume 'booti' */ 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

120(빈 줄)

argc--; argv++;까지의 동작과 bootm_init(&bmi);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

121bootm_init(&bmi);

bootm_init(&bmi)를 호출한다. 반환 결과는 현재 줄 또는 다음 if (argc)에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

122if (argc)

argc를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

123bmi.addr_img = argv[0];

bmi.addr_img에 argv[0]를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

124if (argc > 1)

argc > 1를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

125bmi.conf_ramdisk = argv[1];

bmi.conf_ramdisk에 argv[1]를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

126if (argc > 2)

argc > 2를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

127bmi.conf_fdt = argv[2];

bmi.conf_fdt에 argv[2]를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

128bmi.boot_progress = true;

bmi.boot_progress에 true를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

129bmi.cmd_name = "booti";

bmi.cmd_name에 "booti"를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

130/* do not set up argc and argv[] since nothing uses them */

원본 주석이 'do not set up argc and argv[] since nothing uses them'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

131(빈 줄)

/* do not set up argc and argv[] since nothing uses them */까지의 동작과 if (booti_start(&bmi))에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

132if (booti_start(&bmi))

booti_start(&bmi)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

133return 1;

1를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

134(빈 줄)

return 1;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

135/*

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

136* We are doing the BOOTM_STATE_LOADOS state ourselves, so must

원본 주석이 'We are doing the BOOTM_STATE_LOADOS state ourselves, so must'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

137* disable interrupts ourselves

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

138*/

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

139bootm_disable_interrupts();

bootm_disable_interrupts(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

140(빈 줄)

bootm_disable_interrupts();까지의 동작과 images.os.os = IH_OS_LINUX;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

141images.os.os = IH_OS_LINUX;

images.os.os에 IH_OS_LINUX를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

142if (IS_ENABLED(CONFIG_RISCV_SMODE))

IS_ENABLED(CONFIG_RISCV_SMODE)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

143images.os.arch = IH_ARCH_RISCV;

images.os.arch에 IH_ARCH_RISCV를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

144else if (IS_ENABLED(CONFIG_ARM64))

IS_ENABLED(CONFIG_ARM64)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

145images.os.arch = IH_ARCH_ARM64;

images.os.arch에 IH_ARCH_ARM64를 = 연산으로 반영해 struct bootm_headers / ARM64 Image header와 연결된 field를 갱신한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

146(빈 줄)

images.os.arch = IH_ARCH_ARM64;까지의 동작과 states = BOOTM_STATE_MEASURE | BOOTM_STATE_OS_PREP |에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

147states = BOOTM_STATE_MEASURE | BOOTM_STATE_OS_PREP |

원본 147번 줄의 states = BOOTM_STATE_MEASURE | BOOTM_STATE_OS_PREP |는 앞의 이전 block 경계 결과를 받아 다음 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

148BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO;

원본 148번 줄의 BOOTM_STATE_OS_FAKE_GO | BOOTM_STATE_OS_GO;는 앞의 states = BOOTM_STATE_MEASURE | BOOTM_STATE_OS_PREP | 결과를 받아 다음 if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

149if (IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH))

IS_ENABLED(CONFIG_SYS_BOOT_RAMDISK_HIGH)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

150states |= BOOTM_STATE_RAMDISK;

states에 BOOTM_STATE_RAMDISK를 |= 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

151(빈 줄)

states |= BOOTM_STATE_RAMDISK;까지의 동작과 ret = bootm_run_states(&bmi, states);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

152ret = bootm_run_states(&bmi, states);

ret에 bootm_run_states(&bmi, states)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

153(빈 줄)

ret = bootm_run_states(&bmi, states);까지의 동작과 return ret;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

154return ret;

ret를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

155}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

156(빈 줄)

}까지의 동작과 U_BOOT_LONGHELP(booti,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

157U_BOOT_LONGHELP(booti,

U_BOOT_LONGHELP(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

158"[addr [initrd[:size]] [fdt]]\n"

원본 158번 줄의 "[addr [initrd[:size]] [fdt]]\n"는 앞의 U_BOOT_LONGHELP(booti, 결과를 받아 다음 " - boot Linux flat or compressed 'Image' stored at 'addr'\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

159" - boot Linux flat or compressed 'Image' stored at 'addr'\n"

원본 159번 줄의 " - boot Linux flat or compressed 'Image' stored at 'addr'\n"는 앞의 "[addr [initrd[:size]] [fdt]]\n" 결과를 받아 다음 "\tThe argument 'initrd' is optional and specifies the address\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

160"\tThe argument 'initrd' is optional and specifies the address\n"

원본 160번 줄의 "\tThe argument 'initrd' is optional and specifies the address\n"는 앞의 " - boot Linux flat or compressed 'Image' stored at 'addr'\n" 결과를 받아 다음 "\tof an initrd in memory. The optional parameter ':size' allows\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

161"\tof an initrd in memory. The optional parameter ':size' allows\n"

원본 161번 줄의 "\tof an initrd in memory. The optional parameter ':size' allows\n"는 앞의 "\tThe argument 'initrd' is optional and specifies the address\n" 결과를 받아 다음 "\tspecifying the size of a RAW initrd.\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

162"\tspecifying the size of a RAW initrd.\n"

원본 162번 줄의 "\tspecifying the size of a RAW initrd.\n"는 앞의 "\tof an initrd in memory. The optional parameter ':size' allows\n" 결과를 받아 다음 "\tCurrently only booting from gz, bz2, lzma and lz4 compression\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

163"\tCurrently only booting from gz, bz2, lzma and lz4 compression\n"

원본 163번 줄의 "\tCurrently only booting from gz, bz2, lzma and lz4 compression\n"는 앞의 "\tspecifying the size of a RAW initrd.\n" 결과를 받아 다음 "\ttypes are supported. In order to boot from any of these compressed\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

164"\ttypes are supported. In order to boot from any of these compressed\n"

원본 164번 줄의 "\ttypes are supported. In order to boot from any of these compressed\n"는 앞의 "\tCurrently only booting from gz, bz2, lzma and lz4 compression\n" 결과를 받아 다음 "\timages, user have to set kernel_comp_addr_r and kernel_comp_size environment\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

165"\timages, user have to set kernel_comp_addr_r and kernel_comp_size environment\n"

원본 165번 줄의 "\timages, user have to set kernel_comp_addr_r and kernel_comp_size environment\n"는 앞의 "\ttypes are supported. In order to boot from any of these compressed\n" 결과를 받아 다음 "\tvariables beforehand.\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

166"\tvariables beforehand.\n"

원본 166번 줄의 "\tvariables beforehand.\n"는 앞의 "\timages, user have to set kernel_comp_addr_r and kernel_comp_size environment\n" 결과를 받아 다음 #if defined(CONFIG_OF_LIBFDT)로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

167#if defined(CONFIG_OF_LIBFDT)

#if 전처리 지시문으로 이 줄 아래의 code가 binary에 존재할지를 결정한다. 관련 설정은 CONFIG_OF_LIBFDT이다. 현재 .config와 compiler의 -dD -E 출력에서 실제로 남은 branch를 확인한 뒤 line-by-line 흐름에 포함한다.

168"\tSince booting a Linux kernel requires a flat device-tree, a\n"

원본 168번 줄의 "\tSince booting a Linux kernel requires a flat device-tree, a\n"는 앞의 #if defined(CONFIG_OF_LIBFDT) 결과를 받아 다음 "\tthird argument providing the address of the device-tree blob\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

169"\tthird argument providing the address of the device-tree blob\n"

원본 169번 줄의 "\tthird argument providing the address of the device-tree blob\n"는 앞의 "\tSince booting a Linux kernel requires a flat device-tree, a\n" 결과를 받아 다음 "\tis required. To boot a kernel with a device-tree blob but\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

170"\tis required. To boot a kernel with a device-tree blob but\n"

원본 170번 줄의 "\tis required. To boot a kernel with a device-tree blob but\n"는 앞의 "\tthird argument providing the address of the device-tree blob\n" 결과를 받아 다음 "\twithout an initrd image, use a '-' for the initrd argument.\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

171"\twithout an initrd image, use a '-' for the initrd argument.\n"

원본 171번 줄의 "\twithout an initrd image, use a '-' for the initrd argument.\n"는 앞의 "\tis required. To boot a kernel with a device-tree blob but\n" 결과를 받아 다음 #endif로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

172#endif

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

173);

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

174(빈 줄)

);까지의 동작과 U_BOOT_CMD(에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

175U_BOOT_CMD(

U_BOOT_CMD(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

176booti, CONFIG_SYS_MAXARGS, 1, do_booti,

원본 176번 줄의 booti, CONFIG_SYS_MAXARGS, 1, do_booti,는 앞의 U_BOOT_CMD( 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

RELATED SOURCE

함께 읽어야 하는 원본 코드

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

01. ARM64 Image header에서 최종 kernel 주소를 계산하는 booti_setup

arch/arm/lib/image.c 21-80줄이다.

filearch/arm/lib/image.canchorint booti_setup(ulong image

21	uint64_t	text_offset;	/* Image load offset, LE */
22	uint64_t	image_size;	/* Effective Image size, LE */
23	uint64_t	flags;		/* Kernel flags, LE */
24	uint64_t	res2;		/* reserved */
25	uint64_t	res3;		/* reserved */
26	uint64_t	res4;		/* reserved */
27	uint32_t	magic;		/* Magic number */
28	uint32_t	res5;
29};
30
31int booti_setup(ulong image, ulong *relocated_addr, ulong *size,
32		bool force_reloc)
33{
34	struct Image_header *ih;
35	uint64_t dst;
36	uint64_t image_size, text_offset;
37
38	*relocated_addr = image;
39
40	ih = (struct Image_header *)map_sysmem(image, 0);
41
42	if (ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)) {
43		puts("Bad Linux ARM64 Image magic!\n");
44		return 1;
45	}
46
47	/*
48	 * Prior to Linux commit a2c1d73b94ed, the text_offset field
49	 * is of unknown endianness.  In these cases, the image_size
50	 * field is zero, and we can assume a fixed value of 0x80000.
51	 */
52	if (ih->image_size == 0) {
53		puts("Image lacks image_size field, assuming 16MiB\n");
54		image_size = 16 << 20;
55		text_offset = 0x80000;
56	} else {
57		image_size = le64_to_cpu(ih->image_size);
58		text_offset = le64_to_cpu(ih->text_offset);
59	}
60
61	*size = image_size;
62
63	/*
64	 * If bit 3 of the flags field is set, the 2MB aligned base of the
65	 * kernel image can be anywhere in physical memory, so respect
66	 * images->ep.  Otherwise, relocate the image to the base of RAM
67	 * since memory below it is not accessible via the linear mapping.
68	 */
69	if (!force_reloc && (le64_to_cpu(ih->flags) & BIT(3)))
70		dst = image - text_offset;
71	else
72		dst = gd->bd->bi_dram[0].start;
73
74	*relocated_addr = ALIGN(dst, SZ_2M) + text_offset;
75
76	unmap_sysmem(ih);
77
78	return 0;
79}
80

21-80줄 해설

21uint64_t text_offset; /* Image load offset, LE */

원본 21번 줄의 uint64_t text_offset; /* Image load offset, LE */는 앞의 이전 block 경계 결과를 받아 다음 uint64_t image_size; /* Effective Image size, LE */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

22uint64_t image_size; /* Effective Image size, LE */

원본 22번 줄의 uint64_t image_size; /* Effective Image size, LE */는 앞의 uint64_t text_offset; /* Image load offset, LE */ 결과를 받아 다음 uint64_t flags; /* Kernel flags, LE */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

23uint64_t flags; /* Kernel flags, LE */

원본 23번 줄의 uint64_t flags; /* Kernel flags, LE */는 앞의 uint64_t image_size; /* Effective Image size, LE */ 결과를 받아 다음 uint64_t res2; /* reserved */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

24uint64_t res2; /* reserved */

원본 24번 줄의 uint64_t res2; /* reserved */는 앞의 uint64_t flags; /* Kernel flags, LE */ 결과를 받아 다음 uint64_t res3; /* reserved */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

25uint64_t res3; /* reserved */

원본 25번 줄의 uint64_t res3; /* reserved */는 앞의 uint64_t res2; /* reserved */ 결과를 받아 다음 uint64_t res4; /* reserved */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

26uint64_t res4; /* reserved */

원본 26번 줄의 uint64_t res4; /* reserved */는 앞의 uint64_t res3; /* reserved */ 결과를 받아 다음 uint32_t magic; /* Magic number */로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

27uint32_t magic; /* Magic number */

원본 27번 줄의 uint32_t magic; /* Magic number */는 앞의 uint64_t res4; /* reserved */ 결과를 받아 다음 uint32_t res5;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

28uint32_t res5;

원본 28번 줄의 uint32_t res5;는 앞의 uint32_t magic; /* Magic number */ 결과를 받아 다음 };로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

29};

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

30(빈 줄)

};까지의 동작과 int booti_setup(ulong image, ulong *relocated_addr, ulong *size,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

31int booti_setup(ulong image, ulong *relocated_addr, ulong *size,

booti_setup(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

32bool force_reloc)

원본 32번 줄의 bool force_reloc)는 앞의 int booti_setup(ulong image, ulong *relocated_addr, ulong *size, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

33{

34struct Image_header *ih;

struct Image_header *ih를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

35uint64_t dst;

원본 35번 줄의 uint64_t dst;는 앞의 struct Image_header *ih; 결과를 받아 다음 uint64_t image_size, text_offset;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

36uint64_t image_size, text_offset;

원본 36번 줄의 uint64_t image_size, text_offset;는 앞의 uint64_t dst; 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

37(빈 줄)

uint64_t image_size, text_offset;까지의 동작과 *relocated_addr = image;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

38*relocated_addr = image;

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

39(빈 줄)

*relocated_addr = image;까지의 동작과 ih = (struct Image_header *)map_sysmem(image, 0);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

40ih = (struct Image_header *)map_sysmem(image, 0);

ih = (struct Image_header *)map_sysmem(image, 0)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

41(빈 줄)

ih = (struct Image_header *)map_sysmem(image, 0);까지의 동작과 if (ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

42if (ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)) {

ih->magic != le32_to_cpu(LINUX_ARM64_IMAGE_MAGIC)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

43puts("Bad Linux ARM64 Image magic!\n");

puts("Bad Linux ARM64 Image magic!\n")를 호출한다. 반환 결과는 현재 줄 또는 다음 return 1;에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

44return 1;

1를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

45}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

46(빈 줄)

}까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

47/*

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

48* Prior to Linux commit a2c1d73b94ed, the text_offset field

원본 주석이 'Prior to Linux commit a2c1d73b94ed, the text_offset field'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

49* is of unknown endianness. In these cases, the image_size

원본 주석이 'is of unknown endianness. In these cases, the image_size'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

50* field is zero, and we can assume a fixed value of 0x80000.

원본 주석이 'field is zero, and we can assume a fixed value of 0x80000.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

51*/

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

52if (ih->image_size == 0) {

ih->image_size == 0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

53puts("Image lacks image_size field, assuming 16MiB\n");

puts("Image lacks image_size field, assuming 16MiB\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

54image_size = 16 << 20;

image_size에 16 << 20를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

55text_offset = 0x80000;

text_offset에 0x80000를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

56} else {

원본 56번 줄의 } else {는 앞의 text_offset = 0x80000; 결과를 받아 다음 image_size = le64_to_cpu(ih->image_size);로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

57image_size = le64_to_cpu(ih->image_size);

image_size에 le64_to_cpu(ih->image_size)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

58text_offset = le64_to_cpu(ih->text_offset);

text_offset에 le64_to_cpu(ih->text_offset)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

59}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

60(빈 줄)

}까지의 동작과 *size = image_size;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

61*size = image_size;

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

62(빈 줄)

*size = image_size;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

63/*

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

64* If bit 3 of the flags field is set, the 2MB aligned base of the

원본 주석이 'If bit 3 of the flags field is set, the 2MB aligned base of the'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

65* kernel image can be anywhere in physical memory, so respect

원본 주석이 'kernel image can be anywhere in physical memory, so respect'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

66* images->ep. Otherwise, relocate the image to the base of RAM

원본 주석이 'images->ep. Otherwise, relocate the image to the base of RAM'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

67* since memory below it is not accessible via the linear mapping.

원본 주석이 'since memory below it is not accessible via the linear mapping.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

68*/

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

69if (!force_reloc && (le64_to_cpu(ih->flags) & BIT(3)))

!force_reloc && (le64_to_cpu(ih->flags) & BIT(3))를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

70dst = image - text_offset;

dst에 image - text_offset를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

71else

원본 71번 줄의 else는 앞의 dst = image - text_offset; 결과를 받아 다음 dst = gd->bd->bi_dram[0].start;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

72dst = gd->bd->bi_dram[0].start;

dst에 gd->bd->bi_dram[0].start를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

73(빈 줄)

dst = gd->bd->bi_dram[0].start;까지의 동작과 *relocated_addr = ALIGN(dst, SZ_2M) + text_offset;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

74*relocated_addr = ALIGN(dst, SZ_2M) + text_offset;

원본 주석이 'relocated_addr = ALIGN(dst, SZ_2M) + text_offset;'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

75(빈 줄)

*relocated_addr = ALIGN(dst, SZ_2M) + text_offset;까지의 동작과 unmap_sysmem(ih);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

76unmap_sysmem(ih);

unmap_sysmem(ih)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

77(빈 줄)

unmap_sysmem(ih);까지의 동작과 return 0;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

78return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

79}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

80(빈 줄)

}까지의 동작과 다음 block 경계에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

02. initrd_high와 LMB로 initrd 최종 구간을 정하는 boot_ramdisk_high

boot/image-board.c 520-632줄이다.

fileboot/image-board.canchorint boot_ramdisk_high(ulong rd_data

520 * boot_ramdisk_high - relocate init ramdisk
521 * @rd_data: ramdisk data start address
522 * @rd_len: ramdisk data length
523 * @initrd_start: pointer to a ulong variable, will hold final init ramdisk
524 *      start address (after possible relocation)
525 * @initrd_end: pointer to a ulong variable, will hold final init ramdisk
526 *      end address (after possible relocation)
527 *
528 * boot_ramdisk_high() takes a relocation hint from "initrd_high" environment
529 * variable and if requested ramdisk data is moved to a specified location.
530 *
531 * Initrd_start and initrd_end are set to final (after relocation) ramdisk
532 * start/end addresses if ramdisk image start and len were provided,
533 * otherwise set initrd_start and initrd_end set to zeros.
534 *
535 * returns:
536 *      0 - success
537 *     -1 - failure
538 */
539int boot_ramdisk_high(ulong rd_data, ulong rd_len, ulong *initrd_start,
540		      ulong *initrd_end)
541{
542	int err;
543	char	*s;
544	phys_addr_t initrd_high;
545	int	initrd_copy_to_ram = 1;
546
547	s = env_get("initrd_high");
548	if (s) {
549		/* a value of "no" or a similar string will act like 0,
550		 * turning the "load high" feature off. This is intentional.
551		 */
552		initrd_high = hextoul(s, NULL);
553		if (initrd_high == ~0)
554			initrd_copy_to_ram = 0;
555	} else {
556		initrd_high = env_get_bootm_mapsize() + env_get_bootm_low();
557	}
558
559	debug("## initrd_high = 0x%llx, copy_to_ram = %d\n",
560	      (u64)initrd_high, initrd_copy_to_ram);
561
562	if (rd_data) {
563		if (!initrd_copy_to_ram) {	/* zero-copy ramdisk support */
564			phys_addr_t initrd_addr;
565
566			debug("   in-place initrd\n");
567			*initrd_start = rd_data;
568			*initrd_end = rd_data + rd_len;
569			initrd_addr = (phys_addr_t)rd_data;
570			err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &initrd_addr,
571					    rd_len, LMB_NONE);
572			if (err) {
573				puts("in-place initrd alloc failed\n");
574				goto error;
575			}
576		} else {
577			enum lmb_mem_type type = initrd_high ?
578				LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;
579
580			err = lmb_alloc_mem(type, 0x1000, &initrd_high, rd_len,
581					    LMB_NONE);
582			if (err) {
583				puts("ramdisk - allocation error\n");
584				goto error;
585			}
586
587			*initrd_start = (ulong)initrd_high;
588			bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);
589
590			*initrd_end = *initrd_start + rd_len;
591			printf("   Loading Ramdisk to %08lx, end %08lx ... ",
592			       *initrd_start, *initrd_end);
593
594			memmove_wd((void *)*initrd_start,
595				   (void *)rd_data, rd_len, CHUNKSZ);
596
597			/*
598			 * Ensure the image is flushed to memory to handle
599			 * AMP boot scenarios in which we might not be
600			 * HW cache coherent
601			 */
602			if (IS_ENABLED(CONFIG_MP)) {
603				flush_cache((unsigned long)*initrd_start,
604					    ALIGN(rd_len, ARCH_DMA_MINALIGN));
605			}
606			puts("OK\n");
607		}
608	} else {
609		*initrd_start = 0;
610		*initrd_end = 0;
611	}
612	debug("   ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",
613	      *initrd_start, *initrd_end);
614
615	return 0;
616
617error:
618	return -1;
619}
620
621int boot_get_setup(struct bootm_headers *images, u8 arch,
622		   ulong *setup_start, ulong *setup_len)
623{
624	if (!CONFIG_IS_ENABLED(FIT))
625		return -ENOENT;
626
627	return boot_get_setup_fit(images, arch, setup_start, setup_len);
628}
629
630int boot_get_fpga(struct bootm_headers *images)
631{
632	ulong tmp_img_addr, img_data, img_len;

520-632줄 해설

520* boot_ramdisk_high - relocate init ramdisk

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

521* @rd_data: ramdisk data start address

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

522* @rd_len: ramdisk data length

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

523* @initrd_start: pointer to a ulong variable, will hold final init ramdisk

원본 주석이 '@initrd_start: pointer to a ulong variable, will hold final init ramdisk'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

524* start address (after possible relocation)

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

525* @initrd_end: pointer to a ulong variable, will hold final init ramdisk

원본 주석이 '@initrd_end: pointer to a ulong variable, will hold final init ramdisk'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

526* end address (after possible relocation)

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

527*

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

528* boot_ramdisk_high() takes a relocation hint from "initrd_high" environment

원본 주석이 'boot_ramdisk_high() takes a relocation hint from "initrd_high" environment'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

529* variable and if requested ramdisk data is moved to a specified location.

원본 주석이 'variable and if requested ramdisk data is moved to a specified location.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

530*

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

531* Initrd_start and initrd_end are set to final (after relocation) ramdisk

원본 주석이 'Initrd_start and initrd_end are set to final (after relocation) ramdisk'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

532* start/end addresses if ramdisk image start and len were provided,

원본 주석이 'start/end addresses if ramdisk image start and len were provided,'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

533* otherwise set initrd_start and initrd_end set to zeros.

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

534*

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

535* returns:

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

536* 0 - success

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

537* -1 - failure

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

538*/

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

539int boot_ramdisk_high(ulong rd_data, ulong rd_len, ulong *initrd_start,

boot_ramdisk_high(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

540ulong *initrd_end)

원본 540번 줄의 ulong *initrd_end)는 앞의 int boot_ramdisk_high(ulong rd_data, ulong rd_len, ulong *initrd_start, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

541{

542int err;

int err를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

543char *s;

원본 543번 줄의 char *s;는 앞의 int err; 결과를 받아 다음 phys_addr_t initrd_high;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

544phys_addr_t initrd_high;

원본 544번 줄의 phys_addr_t initrd_high;는 앞의 char *s; 결과를 받아 다음 int initrd_copy_to_ram = 1;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

545int initrd_copy_to_ram = 1;

int initrd_copy_to_ram = 1를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

546(빈 줄)

int initrd_copy_to_ram = 1;까지의 동작과 s = env_get("initrd_high");에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

547s = env_get("initrd_high");

s에 env_get("initrd_high")를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 if (s) {가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

548if (s) {

s를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

549/* a value of "no" or a similar string will act like 0,

원본 주석이 'a value of "no" or a similar string will act like 0,'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

550* turning the "load high" feature off. This is intentional.

원본 주석이 'turning the "load high" feature off. This is intentional.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

551*/

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

552initrd_high = hextoul(s, NULL);

initrd_high에 hextoul(s, NULL)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 if (initrd_high == ~0)가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

553if (initrd_high == ~0)

initrd_high == ~0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

554initrd_copy_to_ram = 0;

initrd_copy_to_ram에 0를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

555} else {

원본 555번 줄의 } else {는 앞의 initrd_copy_to_ram = 0; 결과를 받아 다음 initrd_high = env_get_bootm_mapsize() + env_get_bootm_low();로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

556initrd_high = env_get_bootm_mapsize() + env_get_bootm_low();

initrd_high에 env_get_bootm_mapsize() + env_get_bootm_low()를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

557}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

558(빈 줄)

}까지의 동작과 debug("## initrd_high = 0x%llx, copy_to_ram = %d\n",에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

559debug("## initrd_high = 0x%llx, copy_to_ram = %d\n",

debug(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

560(u64)initrd_high, initrd_copy_to_ram);

원본 560번 줄의 (u64)initrd_high, initrd_copy_to_ram);는 앞의 debug("## initrd_high = 0x%llx, copy_to_ram = %d\n", 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

561(빈 줄)

(u64)initrd_high, initrd_copy_to_ram);까지의 동작과 if (rd_data) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

562if (rd_data) {

rd_data를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

563if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */

원본 563번 줄의 if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */는 앞의 if (rd_data) { 결과를 받아 다음 phys_addr_t initrd_addr;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

564phys_addr_t initrd_addr;

원본 564번 줄의 phys_addr_t initrd_addr;는 앞의 if (!initrd_copy_to_ram) { /* zero-copy ramdisk support */ 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

565(빈 줄)

phys_addr_t initrd_addr;까지의 동작과 debug(" in-place initrd\n");에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

566debug(" in-place initrd\n");

debug(" in-place initrd\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

567*initrd_start = rd_data;

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

568*initrd_end = rd_data + rd_len;

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

569initrd_addr = (phys_addr_t)rd_data;

initrd_addr에 (phys_addr_t)rd_data를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &initrd_addr,가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

570err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &initrd_addr,

571rd_len, LMB_NONE);

원본 571번 줄의 rd_len, LMB_NONE);는 앞의 err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &initrd_addr, 결과를 받아 다음 if (err) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

572if (err) {

err를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

573puts("in-place initrd alloc failed\n");

puts("in-place initrd alloc failed\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

574goto error;

'goto error;'로 직선 경로를 벗어난다. 이동 대상에서 struct bootm_headers / ARM64 Image header에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

575}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

576} else {

원본 576번 줄의 } else {는 앞의 } 결과를 받아 다음 enum lmb_mem_type type = initrd_high ?로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

577enum lmb_mem_type type = initrd_high ?

enum lmb_mem_type type = initrd_high ?를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

578LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;

원본 578번 줄의 LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;는 앞의 enum lmb_mem_type type = initrd_high ? 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

579(빈 줄)

LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;까지의 동작과 err = lmb_alloc_mem(type, 0x1000, &initrd_high, rd_len,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

580err = lmb_alloc_mem(type, 0x1000, &initrd_high, rd_len,

581LMB_NONE);

원본 581번 줄의 LMB_NONE);는 앞의 err = lmb_alloc_mem(type, 0x1000, &initrd_high, rd_len, 결과를 받아 다음 if (err) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

582if (err) {

583puts("ramdisk - allocation error\n");

puts("ramdisk - allocation error\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

584goto error;

585}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

586(빈 줄)

}까지의 동작과 *initrd_start = (ulong)initrd_high;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

587*initrd_start = (ulong)initrd_high;

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

588bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);

bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

589(빈 줄)

bootstage_mark(BOOTSTAGE_ID_COPY_RAMDISK);까지의 동작과 *initrd_end = *initrd_start + rd_len;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

590*initrd_end = *initrd_start + rd_len;

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

591printf(" Loading Ramdisk to %08lx, end %08lx ... ",

592*initrd_start, *initrd_end);

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

593(빈 줄)

*initrd_start, *initrd_end);까지의 동작과 memmove_wd((void *)*initrd_start,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

594memmove_wd((void *)*initrd_start,

memmove_wd((void *)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

595(void *)rd_data, rd_len, CHUNKSZ);

원본 595번 줄의 (void *)rd_data, rd_len, CHUNKSZ);는 앞의 memmove_wd((void *)*initrd_start, 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

596(빈 줄)

(void *)rd_data, rd_len, CHUNKSZ);까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

597/*

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

598* Ensure the image is flushed to memory to handle

원본 주석이 'Ensure the image is flushed to memory to handle'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

599* AMP boot scenarios in which we might not be

원본 주석이 'AMP boot scenarios in which we might not be'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

600* HW cache coherent

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

601*/

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

602if (IS_ENABLED(CONFIG_MP)) {

IS_ENABLED(CONFIG_MP)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

603flush_cache((unsigned long)*initrd_start,

flush_cache((unsigned long)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

604ALIGN(rd_len, ARCH_DMA_MINALIGN));

ALIGN(rd_len, ARCH_DMA_MINALIGN))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

605}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

606puts("OK\n");

puts("OK\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

607}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

608} else {

원본 608번 줄의 } else {는 앞의 } 결과를 받아 다음 *initrd_start = 0;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

609*initrd_start = 0;

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

610*initrd_end = 0;

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

611}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

612debug(" ramdisk load start = 0x%08lx, ramdisk load end = 0x%08lx\n",

613*initrd_start, *initrd_end);

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

614(빈 줄)

*initrd_start, *initrd_end);까지의 동작과 return 0;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

615return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

616(빈 줄)

return 0;까지의 동작과 error:에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

617error:

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

618return -1;

-1를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

619}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

620(빈 줄)

}까지의 동작과 int boot_get_setup(struct bootm_headers *images, u8 arch,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

621int boot_get_setup(struct bootm_headers *images, u8 arch,

boot_get_setup(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

622ulong *setup_start, ulong *setup_len)

원본 622번 줄의 ulong *setup_start, ulong *setup_len)는 앞의 int boot_get_setup(struct bootm_headers *images, u8 arch, 결과를 받아 다음 {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

623{

624if (!CONFIG_IS_ENABLED(FIT))

!CONFIG_IS_ENABLED(FIT)를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

625return -ENOENT;

-ENOENT를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

626(빈 줄)

return -ENOENT;까지의 동작과 return boot_get_setup_fit(images, arch, setup_start, setup_len);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

627return boot_get_setup_fit(images, arch, setup_start, setup_len);

boot_get_setup_fit(images, arch, setup_start, setup_len)를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

628}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

629(빈 줄)

}까지의 동작과 int boot_get_fpga(struct bootm_headers *images)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

630int boot_get_fpga(struct bootm_headers *images)

boot_get_fpga 함수 정의가 시작된다. 입력은 struct bootm_headers *images이며, 부트 CPU의 동기 실행 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

631{

632ulong tmp_img_addr, img_data, img_len;

ulong tmp_img_addr, img_data, img_len를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

03. fdt_high와 padding을 반영해 working FDT를 만드는 boot_relocate_fdt

boot/image-fdt.c 141-261줄이다.

fileboot/image-fdt.canchorint boot_relocate_fdt(char **of_flat_tree

141
142/**
143 * boot_relocate_fdt - relocate flat device tree
144 * @of_flat_tree: pointer to a char* variable, will hold fdt start address
145 * @of_size: pointer to a ulong variable, will hold fdt length
146 *
147 * boot_relocate_fdt() allocates a region of memory within the bootmap and
148 * relocates the of_flat_tree into that region, even if the fdt is already in
149 * the bootmap.  It also expands the size of the fdt by CONFIG_SYS_FDT_PAD
150 * bytes.
151 *
152 * of_flat_tree and of_size are set to final (after relocation) values
153 *
154 * returns:
155 *      0 - success
156 *      1 - failure
157 */
158int boot_relocate_fdt(char **of_flat_tree, ulong *of_size)
159{
160	u64	start, size, usable, low, mapsize;
161	void	*fdt_blob = *of_flat_tree;
162	void	*of_start = NULL;
163	char	*fdt_high;
164	ulong	of_len = 0;
165	int	bank;
166	int	err;
167	int	disable_relocation = 0;
168	phys_addr_t addr;
169
170	/* nothing to do */
171	if (*of_size == 0)
172		return 0;
173
174	if (fdt_check_header(fdt_blob) != 0) {
175		fdt_error("image is not a fdt");
176		goto error;
177	}
178
179	/* position on a 4K boundary before the alloc_current */
180	/* Pad the FDT by a specified amount */
181	of_len = *of_size + CONFIG_SYS_FDT_PAD;
182
183	/* If fdt_high is set use it to select the relocation address */
184	fdt_high = env_get("fdt_high");
185	if (fdt_high) {
186		ulong high_addr = hextoul(fdt_high, NULL);
187
188		if (high_addr == ~0UL) {
189			/* All ones means use fdt in place */
190			of_start = fdt_blob;
191			addr = map_to_sysmem(fdt_blob);
192			printf("WARNING:\n"
193			       "The 'fdt_high' environment variable is set to ~0. This is known to cause\n"
194			       "boot failures due to placement of DT at non-8-byte-aligned addresses.\n"
195			       "This system will likely fail to boot. Unset the 'fdt_high' environment\n"
196			       "variable and submit a fix upstream.\n");
197
198			err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &addr,
199					    of_len, LMB_NONE);
200			if (err) {
201				printf("Failed to reserve memory for fdt at %#llx\n",
202				       (u64)addr);
203				goto error;
204			}
205
206			disable_relocation = 1;
207		} else {
208			enum lmb_mem_type type = high_addr ?
209				LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;
210
211			addr = high_addr;
212			err = lmb_alloc_mem(type, 0x1000, &addr, of_len,
213					    LMB_NONE);
214			if (err) {
215				puts("Failed to allocate memory for Device Tree relocation\n");
216				goto error;
217			}
218			of_start = map_sysmem(addr, of_len);
219		}
220	} else {
221		mapsize = env_get_bootm_mapsize();
222		low = env_get_bootm_low();
223		of_start = NULL;
224
225		for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {
226			start = gd->bd->bi_dram[bank].start;
227			size = gd->bd->bi_dram[bank].size;
228
229			/* DRAM bank addresses are too low, skip it. */
230			if (start + size < low)
231				continue;
232
233			/*
234			 * At least part of this DRAM bank is usable, try
235			 * using the DRAM bank up to 'usable' address limit
236			 * for LMB allocation.
237			 */
238			usable = min(start + size, low + mapsize);
239			addr = usable;
240			err = lmb_alloc_mem(LMB_MEM_ALLOC_MAX, 0x1000,
241					    &addr, of_len, LMB_NONE);
242			if (!err) {
243				of_start = map_sysmem(addr, of_len);
244				/* Allocation succeeded, use this block. */
245				if (of_start)
246					break;
247			}
248
249			/*
250			 * Reduce the mapping size in the next bank
251			 * by the size of attempt in current bank.
252			 */
253			mapsize -= usable - max(start, low);
254			if (!mapsize)
255				break;
256		}
257	}
258
259	if (of_start == NULL) {
260		puts("device tree - allocation error\n");
261		goto error;

141-261줄 해설

141(빈 줄)

이전 block 경계까지의 동작과 /**에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 ARM64 Image 상태가 아래 블록의 입력으로 사용되는 경계다.

142/**

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

143* boot_relocate_fdt - relocate flat device tree

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

144* @of_flat_tree: pointer to a char* variable, will hold fdt start address

원본 주석이 '@of_flat_tree: pointer to a char* variable, will hold fdt start address'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

145* @of_size: pointer to a ulong variable, will hold fdt length

원본 주석이 '@of_size: pointer to a ulong variable, will hold fdt length'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

146*

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

147* boot_relocate_fdt() allocates a region of memory within the bootmap and

원본 주석이 'boot_relocate_fdt() allocates a region of memory within the bootmap and'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

148* relocates the of_flat_tree into that region, even if the fdt is already in

원본 주석이 'relocates the of_flat_tree into that region, even if the fdt is already in'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

149* the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD

원본 주석이 'the bootmap. It also expands the size of the fdt by CONFIG_SYS_FDT_PAD'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

150* bytes.

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

151*

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

152* of_flat_tree and of_size are set to final (after relocation) values

원본 주석이 'of_flat_tree and of_size are set to final (after relocation) values'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

153*

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

154* returns:

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

155* 0 - success

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

156* 1 - failure

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

157*/

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

158int boot_relocate_fdt(char **of_flat_tree, ulong *of_size)

boot_relocate_fdt 함수 정의가 시작된다. 입력은 char **of_flat_tree, ulong *of_size이며, 부트 CPU의 동기 실행 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

159{

160u64 start, size, usable, low, mapsize;

원본 160번 줄의 u64 start, size, usable, low, mapsize;는 앞의 { 결과를 받아 다음 void *fdt_blob = *of_flat_tree;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

161void *fdt_blob = *of_flat_tree;

void *fdt_blob에 *of_flat_tree를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

162void *of_start = NULL;

void *of_start에 NULL를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

163char *fdt_high;

원본 163번 줄의 char *fdt_high;는 앞의 void *of_start = NULL; 결과를 받아 다음 ulong of_len = 0;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

164ulong of_len = 0;

ulong of_len = 0를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

165int bank;

int bank를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

166int err;

167int disable_relocation = 0;

int disable_relocation = 0를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

168phys_addr_t addr;

원본 168번 줄의 phys_addr_t addr;는 앞의 int disable_relocation = 0; 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

169(빈 줄)

phys_addr_t addr;까지의 동작과 /* nothing to do */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

170/* nothing to do */

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

171if (*of_size == 0)

*of_size == 0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

172return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

173(빈 줄)

return 0;까지의 동작과 if (fdt_check_header(fdt_blob) != 0) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

174if (fdt_check_header(fdt_blob) != 0) {

fdt_check_header(fdt_blob) != 0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

175fdt_error("image is not a fdt");

fdt_error("image is not a fdt")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

176goto error;

177}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

178(빈 줄)

}까지의 동작과 /* position on a 4K boundary before the alloc_current */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

179/* position on a 4K boundary before the alloc_current */

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

180/* Pad the FDT by a specified amount */

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

181of_len = *of_size + CONFIG_SYS_FDT_PAD;

of_len에 *of_size + CONFIG_SYS_FDT_PAD를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

182(빈 줄)

of_len = *of_size + CONFIG_SYS_FDT_PAD;까지의 동작과 /* If fdt_high is set use it to select the relocation address */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

183/* If fdt_high is set use it to select the relocation address */

원본 주석이 'If fdt_high is set use it to select the relocation address'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

184fdt_high = env_get("fdt_high");

fdt_high에 env_get("fdt_high")를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 if (fdt_high) {가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

185if (fdt_high) {

fdt_high를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

186ulong high_addr = hextoul(fdt_high, NULL);

ulong high_addr = hextoul(fdt_high, NULL)를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

187(빈 줄)

ulong high_addr = hextoul(fdt_high, NULL);까지의 동작과 if (high_addr == ~0UL) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

188if (high_addr == ~0UL) {

high_addr == ~0UL를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

189/* All ones means use fdt in place */

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

190of_start = fdt_blob;

of_start에 fdt_blob를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

191addr = map_to_sysmem(fdt_blob);

addr에 map_to_sysmem(fdt_blob)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

192printf("WARNING:\n"

193"The 'fdt_high' environment variable is set to ~0. This is known to cause\n"

원본 193번 줄의 "The 'fdt_high' environment variable is set to ~0. This is known to cause\n"는 앞의 printf("WARNING:\n" 결과를 받아 다음 "boot failures due to placement of DT at non-8-byte-aligned addresses.\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

194"boot failures due to placement of DT at non-8-byte-aligned addresses.\n"

원본 194번 줄의 "boot failures due to placement of DT at non-8-byte-aligned addresses.\n"는 앞의 "The 'fdt_high' environment variable is set to ~0. This is known to cause\n" 결과를 받아 다음 "This system will likely fail to boot. Unset the 'fdt_high' environment\n"로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

195"This system will likely fail to boot. Unset the 'fdt_high' environment\n"

원본 195번 줄의 "This system will likely fail to boot. Unset the 'fdt_high' environment\n"는 앞의 "boot failures due to placement of DT at non-8-byte-aligned addresses.\n" 결과를 받아 다음 "variable and submit a fix upstream.\n");로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

196"variable and submit a fix upstream.\n");

원본 196번 줄의 "variable and submit a fix upstream.\n");는 앞의 "This system will likely fail to boot. Unset the 'fdt_high' environment\n" 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

197(빈 줄)

"variable and submit a fix upstream.\n");까지의 동작과 err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &addr,에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

198err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &addr,

199of_len, LMB_NONE);

원본 199번 줄의 of_len, LMB_NONE);는 앞의 err = lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &addr, 결과를 받아 다음 if (err) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

200if (err) {

201printf("Failed to reserve memory for fdt at %#llx\n",

202(u64)addr);

원본 202번 줄의 (u64)addr);는 앞의 printf("Failed to reserve memory for fdt at %#llx\n", 결과를 받아 다음 goto error;로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

203goto error;

204}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

205(빈 줄)

}까지의 동작과 disable_relocation = 1;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

206disable_relocation = 1;

disable_relocation에 1를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

207} else {

원본 207번 줄의 } else {는 앞의 disable_relocation = 1; 결과를 받아 다음 enum lmb_mem_type type = high_addr ?로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

208enum lmb_mem_type type = high_addr ?

enum lmb_mem_type type = high_addr ?를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

209LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;

원본 209번 줄의 LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;는 앞의 enum lmb_mem_type type = high_addr ? 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

210(빈 줄)

LMB_MEM_ALLOC_MAX : LMB_MEM_ALLOC_ANY;까지의 동작과 addr = high_addr;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

211addr = high_addr;

addr에 high_addr를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 err = lmb_alloc_mem(type, 0x1000, &addr, of_len,가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

212err = lmb_alloc_mem(type, 0x1000, &addr, of_len,

213LMB_NONE);

원본 213번 줄의 LMB_NONE);는 앞의 err = lmb_alloc_mem(type, 0x1000, &addr, of_len, 결과를 받아 다음 if (err) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

214if (err) {

215puts("Failed to allocate memory for Device Tree relocation\n");

puts("Failed to allocate memory for Device Tree relocation\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

216goto error;

217}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

218of_start = map_sysmem(addr, of_len);

of_start에 map_sysmem(addr, of_len)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

219}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

220} else {

원본 220번 줄의 } else {는 앞의 } 결과를 받아 다음 mapsize = env_get_bootm_mapsize();로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

221mapsize = env_get_bootm_mapsize();

mapsize에 env_get_bootm_mapsize()를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

222low = env_get_bootm_low();

low에 env_get_bootm_low()를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

223of_start = NULL;

of_start에 NULL를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

224(빈 줄)

of_start = NULL;까지의 동작과 for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

225for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {

'for (bank = 0; bank < CONFIG_NR_DRAM_BANKS; bank++) {'가 목록이나 후보를 순회한다. 반복 중 struct bootm_headers / ARM64 Image header를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

226start = gd->bd->bi_dram[bank].start;

start에 gd->bd->bi_dram[bank].start를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

227size = gd->bd->bi_dram[bank].size;

size에 gd->bd->bi_dram[bank].size를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

228(빈 줄)

size = gd->bd->bi_dram[bank].size;까지의 동작과 /* DRAM bank addresses are too low, skip it. */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

229/* DRAM bank addresses are too low, skip it. */

원본 주석이 'DRAM bank addresses are too low, skip it.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

230if (start + size < low)

start + size < low를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

231continue;

'continue;'로 직선 경로를 벗어난다. 이동 대상에서 struct bootm_headers / ARM64 Image header에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

232(빈 줄)

continue;까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

233/*

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

234* At least part of this DRAM bank is usable, try

원본 주석이 'At least part of this DRAM bank is usable, try'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

235* using the DRAM bank up to 'usable' address limit

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

236* for LMB allocation.

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

237*/

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

238usable = min(start + size, low + mapsize);

usable에 min(start + size, low + mapsize)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 addr = usable;가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

239addr = usable;

addr에 usable를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

240err = lmb_alloc_mem(LMB_MEM_ALLOC_MAX, 0x1000,

241&addr, of_len, LMB_NONE);

원본 241번 줄의 &addr, of_len, LMB_NONE);는 앞의 err = lmb_alloc_mem(LMB_MEM_ALLOC_MAX, 0x1000, 결과를 받아 다음 if (!err) {로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

242if (!err) {

!err를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

243of_start = map_sysmem(addr, of_len);

244/* Allocation succeeded, use this block. */

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

245if (of_start)

of_start를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

246break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 struct bootm_headers / ARM64 Image header에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

247}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

248(빈 줄)

}까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

249/*

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

250* Reduce the mapping size in the next bank

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

251* by the size of attempt in current bank.

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

252*/

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

253mapsize -= usable - max(start, low);

mapsize에 usable - max(start, low)를 -= 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 if (!mapsize)가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

254if (!mapsize)

!mapsize를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

255break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 struct bootm_headers / ARM64 Image header에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

256}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

257}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

258(빈 줄)

}까지의 동작과 if (of_start == NULL) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

259if (of_start == NULL) {

of_start == NULL를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

260puts("device tree - allocation error\n");

puts("device tree - allocation error\n")를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

261goto error;

04. 최종 initrd 주소를 /chosen에 기록하는 fdt_initrd

boot/fdt_support.c 212-283줄이다.

fileboot/fdt_support.canchorint fdt_initrd(void *fdt

212			printf("WARNING: could not set serial-number %s.\n",
213			       fdt_strerror(err));
214			return err;
215		}
216	}
217
218	return 0;
219}
220
221int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)
222{
223	int   nodeoffset;
224	int   err, j, total;
225	int is_u64;
226	uint64_t addr, size;
227
228	/* just return if the size of initrd is zero */
229	if (initrd_start == initrd_end)
230		return 0;
231
232	/* find or create "/chosen" node. */
233	nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");
234	if (nodeoffset < 0)
235		return nodeoffset;
236
237	total = fdt_num_mem_rsv(fdt);
238
239	/*
240	 * Look for an existing entry and update it.  If we don't find
241	 * the entry, we will j be the next available slot.
242	 */
243	for (j = 0; j < total; j++) {
244		err = fdt_get_mem_rsv(fdt, j, &addr, &size);
245		if (addr == initrd_start) {
246			fdt_del_mem_rsv(fdt, j);
247			break;
248		}
249	}
250
251	err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);
252	if (err < 0) {
253		printf("fdt_initrd: %s\n", fdt_strerror(err));
254		return err;
255	}
256
257	is_u64 = (fdt_address_cells(fdt, 0) == 2);
258
259	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",
260			      (uint64_t)initrd_start, is_u64);
261
262	if (err < 0) {
263		printf("WARNING: could not set linux,initrd-start %s.\n",
264		       fdt_strerror(err));
265		return err;
266	}
267
268	err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",
269			      (uint64_t)initrd_end, is_u64);
270
271	if (err < 0) {
272		printf("WARNING: could not set linux,initrd-end %s.\n",
273		       fdt_strerror(err));
274
275		return err;
276	}
277
278	return 0;
279}
280
281int fdt_kaslrseed(void *fdt, bool overwrite)
282{
283	int len, err, nodeoffset;

212-283줄 해설

212printf("WARNING: could not set serial-number %s.\n",

printf(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 ARM64 Image 항목과 대조한다.

213fdt_strerror(err));

fdt_strerror(err))를 호출한다. 반환 결과는 현재 줄 또는 다음 return err;에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 bootm_headers 항목과 대조한다.

214return err;

err를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

215}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

216}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

217(빈 줄)

}까지의 동작과 return 0;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

218return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

219}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

220(빈 줄)

}까지의 동작과 int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

221int fdt_initrd(void *fdt, ulong initrd_start, ulong initrd_end)

fdt_initrd 함수 정의가 시작된다. 입력은 void *fdt, ulong initrd_start, ulong initrd_end이며, 부트 CPU의 동기 실행 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

222{

223int nodeoffset;

int nodeoffset를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

224int err, j, total;

int err, j, total를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

225int is_u64;

int is_u64를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

226uint64_t addr, size;

원본 226번 줄의 uint64_t addr, size;는 앞의 int is_u64; 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

227(빈 줄)

uint64_t addr, size;까지의 동작과 /* just return if the size of initrd is zero */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

228/* just return if the size of initrd is zero */

원본 주석이 'just return if the size of initrd is zero'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

229if (initrd_start == initrd_end)

initrd_start == initrd_end를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

230return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

231(빈 줄)

return 0;까지의 동작과 /* find or create "/chosen" node. */에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

232/* find or create "/chosen" node. */

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

233nodeoffset = fdt_find_or_add_subnode(fdt, 0, "chosen");

nodeoffset에 fdt_find_or_add_subnode(fdt, 0, "chosen")를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 바로 다음 if (nodeoffset < 0)가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

234if (nodeoffset < 0)

nodeoffset < 0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

235return nodeoffset;

nodeoffset를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

236(빈 줄)

return nodeoffset;까지의 동작과 total = fdt_num_mem_rsv(fdt);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

237total = fdt_num_mem_rsv(fdt);

total에 fdt_num_mem_rsv(fdt)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

238(빈 줄)

total = fdt_num_mem_rsv(fdt);까지의 동작과 /*에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

239/*

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

240* Look for an existing entry and update it. If we don't find

원본 주석이 'Look for an existing entry and update it. If we don't find'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

241* the entry, we will j be the next available slot.

원본 주석이 'the entry, we will j be the next available slot.'라고 기록한 줄이다. 바로 아래 구현이 이 전제와 같은 순서·단위를 사용하는지 대조한다.

242*/

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

243for (j = 0; j < total; j++) {

'for (j = 0; j < total; j++) {'가 목록이나 후보를 순회한다. 반복 중 struct bootm_headers / ARM64 Image header를 제거·추가하는 호출이 있는지와 loop 종료 뒤 iterator가 유효한지 확인한다.

244err = fdt_get_mem_rsv(fdt, j, &addr, &size);

err에 fdt_get_mem_rsv(fdt, j, &addr, &size)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 주소·크기 값이면 단위와 정렬, 덧셈 overflow를 함께 검산한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

245if (addr == initrd_start) {

addr == initrd_start를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

246fdt_del_mem_rsv(fdt, j);

fdt_del_mem_rsv(fdt, j)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

247break;

'break;'로 직선 경로를 벗어난다. 이동 대상에서 struct bootm_headers / ARM64 Image header에 걸린 lock, allocation, list 등록을 어디까지 되돌리는지 이어서 확인한다.

248}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

249}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

250(빈 줄)

}까지의 동작과 err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

251err = fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start);

err에 fdt_add_mem_rsv(fdt, initrd_start, initrd_end - initrd_start)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 바로 다음 if (err < 0) {가 이 값을 다시 읽으므로 그 전까지 완성된 값이어야 한다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

252if (err < 0) {

err < 0를 검사해 진행 여부를 가른다. 거짓 경로와 참 경로 중 어느 쪽이 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건을 보존하는지 다음 return 또는 goto까지 따라간다.

253printf("fdt_initrd: %s\n", fdt_strerror(err));

fdt_strerror(err))를 호출한다. 반환 결과는 현재 줄 또는 다음 return err;에서 검사되는 흐름이다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

254return err;

255}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

256(빈 줄)

}까지의 동작과 is_u64 = (fdt_address_cells(fdt, 0) == 2);에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

257is_u64 = (fdt_address_cells(fdt, 0) == 2);

is_u64에 (fdt_address_cells(fdt, 0) == 2)를 = 연산으로 반영해 현재 scope의 계산 결과를 저장한다. 이후 kernel entry 단계가 이 값을 처음 소비하는 지점을 찾는다. 실패 경로가 이 field를 이전 값으로 되돌리거나 객체 전체를 폐기하는지도 확인한다.

258(빈 줄)

is_u64 = (fdt_address_cells(fdt, 0) == 2);까지의 동작과 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

259err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start",

fdt_setprop_uxx(인자 없음)를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

260(uint64_t)initrd_start, is_u64);

원본 260번 줄의 (uint64_t)initrd_start, is_u64);는 앞의 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-start", 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

261(빈 줄)

(uint64_t)initrd_start, is_u64);까지의 동작과 if (err < 0) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

262if (err < 0) {

263printf("WARNING: could not set linux,initrd-start %s.\n",

264fdt_strerror(err));

265return err;

266}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

267(빈 줄)

}까지의 동작과 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

268err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end",

269(uint64_t)initrd_end, is_u64);

원본 269번 줄의 (uint64_t)initrd_end, is_u64);는 앞의 err = fdt_setprop_uxx(fdt, nodeoffset, "linux,initrd-end", 결과를 받아 다음 다음 block 경계로 넘기는 중간 연산이다. 이 줄이 바꾸는 register·field·list link를 찾고, 변경 뒤에도 'kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다' 조건이 유지되는지 확인한다.

270(빈 줄)

(uint64_t)initrd_end, is_u64);까지의 동작과 if (err < 0) {에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

271if (err < 0) {

272printf("WARNING: could not set linux,initrd-end %s.\n",

273fdt_strerror(err));

fdt_strerror(err))를 호출한다. 반환값을 직접 사용하지 않으므로 이 함수가 실패를 내부 처리하는지 확인해야 한다. pointer 인자는 struct bootm_headers / ARM64 Image header의 소유권을 넘기는지 호출 동안만 빌리는지 구분하고, 호출 뒤 공개되는 상태를 EL and register contract 항목과 대조한다.

274(빈 줄)

fdt_strerror(err));까지의 동작과 return err;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

275return err;

276}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

277(빈 줄)

}까지의 동작과 return 0;에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

278return 0;

0를 호출자에게 반환한다. caller가 이 값을 검사한 뒤 부분 초기화된 struct bootm_headers / ARM64 Image header를 정리하거나 다음 단계로 진행하는지 확인한다.

279}

현재 block, initializer 또는 호출의 경계를 닫는다. 이 지점까지 획득한 resource가 성공 경로와 실패 경로에서 대칭인지 점검한다.

280(빈 줄)

}까지의 동작과 int fdt_kaslrseed(void *fdt, bool overwrite)에서 시작하는 동작을 나누는 빈 줄이다. 앞 블록이 만든 EL and register contract 상태가 아래 블록의 입력으로 사용되는 경계다.

281int fdt_kaslrseed(void *fdt, bool overwrite)

fdt_kaslrseed 함수 정의가 시작된다. 입력은 void *fdt, bool overwrite이며, 부트 CPU의 동기 실행 문맥에서 호출된다는 전제로 반환 전까지의 상태 변화를 읽는다.

282{

283int len, err, nodeoffset;

int len, err, nodeoffset를 선언한다. 함수 안 선언이면 현재 stack frame, file scope와 static이면 image의 data/BSS에 놓인다. 이 값이 struct bootm_headers / ARM64 Image header를 직접 소유하는지 pointer만 빌리는지, 부트 CPU의 동기 실행 문맥를 벗어난 뒤에도 참조되는지 다음 대입과 callback 등록까지 따라간다.

DETAILS

내부 동작을 더 깊게 읽기

진입 조건을 먼저 고정한다

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

분기 직전에는 bootloader의 편의 기능보다 Linux boot protocol을 우선한다. x0의 FDT 주소, EL, MMU/cache 상태, reserved memory 반영을 체크한다.

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

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

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

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

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

kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다.

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

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

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

마지막 handoff의 계약을 적는다

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

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

IMPLEMENTATION NOTES

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

booti는 Image 배치와 bootm state machine을 연결한다

ARM64 Image header에서 text offset, image size와 flags를 읽고 현재 주소에서 실행 가능한지, 이동이나 압축 해제가 필요한지 계산한다. source와 destination이 겹칠 때 memmove 방향과 scratch 공간을 확인한다.

kernel, initrd, FDT 세 구간과 U-Boot runtime, reserved memory가 겹치지 않도록 LMB reservation을 대조한다.

FDT fixup은 Linux가 보는 hardware 계약을 마지막으로 바꾼다

memory node, chosen bootargs, initrd start/end, reserved-memory와 MAC address가 handoff 직전에 수정될 수 있다. 원본 DTB와 최종 DTB를 dump해 어떤 코드가 값을 바꿨는지 분리한다.

FDT 여유 공간이 부족한 실패를 무시하면 일부 property만 반영된 tree를 넘길 수 있다. 각 fixup return을 확인한다.

마지막 분기 전에 CPU와 device 상태를 닫는다

cache clean/invalidate, interrupt disable, secondary CPU와 DMA 정지, watchdog 정책을 architecture handoff 코드에서 확인한다. Linux entry register 계약상 x0는 FDT 주소이고 다른 argument register 조건도 지켜야 한다.

커널 첫 instruction fault는 image 자체뿐 아니라 잘못된 EL, MMU/cache 잔존 상태나 FDT 주소에서 올 수 있으므로 마지막 U-Boot PC와 첫 kernel PC를 연속으로 기록한다.

OBJECT LIFETIME

객체와 수명

대상	만들어지는 시점	유효 범위	확인할 조건
`struct bootm_headers / ARM64 Image header`	Image header	kernel entry 또는 오류 정리 완료까지	kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다.
입력 buffer / metadata	booti command	parse와 검증이 끝날 때까지	길이, 정렬, 소유권, 변조 가능성
등록된 list / descriptor	bootm states	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	Image magic 불일치	명령 거부	Image header
02	FDT relocation 충돌	early boot hang	bootm states
03	cache clean 누락	kernel이 오래된 DT/코드 관찰	FDT/initrd setup

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

EVIDENCE

소스 밖에서 확인할 증거

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

#	목적	명령 또는 계측	판정 기준
01	전처리 결과	`make <board>_defconfig && make V=1`	선택된 CONFIG와 실제 compile/link 명령을 보관한다.
02	symbol과 section	`${CROSS_COMPILE}nm -n u-boot \| grep 'int do_booti'`	symbol 주소가 기대한 stage와 image에 들어갔는지 확인한다.
03	어셈블리 대조	`${CROSS_COMPILE}objdump -drS u-boot`	C 한 줄이 실제 branch, relocation, memory access로 어떻게 바뀌었는지 본다.
04	주소 배치	`bdinfo`	relocaddr, malloc, FDT, stack과 DRAM bank 주소를 한 번에 기록한다.
05	runtime 관찰	`dm tree; dm uclass; printenv`	driver model과 환경이 이 단계에서 실제로 공개되었는지 확인한다.

LAB

직접 확인할 실험

01
booti 직전 booti_start/size 로그 추가
Image header 진입 전후에 ARM64 Image의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다. 조건이 처음 깨지는 줄을 기록한다.
02
FDT chosen과 initrd 주소를 kernel early log와 대조
bootm states 진입 전후에 bootm_headers의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다. 조건이 처음 깨지는 줄을 기록한다.
03
분기 직전 CurrentEL, SCTLR, x0 기록
FDT/initrd setup 진입 전후에 working FDT의 주소·크기·반환값과 timestamp를 함께 남긴다. 결과는 정상 부팅 여부로 끝내지 말고 kernel entry가 보는 Image, FDT, initrd는 서로 겹치지 않고 ARM64 boot protocol의 register와 CPU 상태를 만족해야 한다. 조건이 처음 깨지는 줄을 기록한다.

PRIMARY REFERENCES

원문과 다음 글

cmd/booti.cv2026.07 원본 파일 U-Boot source tree기준 commit ece349ade297