x86 image copy, ELF relocation과 CAR 종료

01. U-Boot image byte를 gd->relocaddr로 복사

arch/x86/lib/relocate.c 19-59줄이다.

19#include <asm/global_data.h>
20#include <asm/u-boot-x86.h>
21#include <asm/sections.h>
22#include <elf.h>
23
24DECLARE_GLOBAL_DATA_PTR;
25
26int copy_uboot_to_ram(void)
27{
28	size_t len = (uintptr_t)__data_end - (uintptr_t)__text_start;
29
30	if (gd->flags & GD_FLG_SKIP_RELOC)
31		return 0;
32	memcpy((void *)gd->relocaddr, (void *)__text_start, len);
33
34	return 0;
35}
36
37#ifndef CONFIG_EFI_APP
38int clear_bss(void)
39{
40	ulong dst_addr = (ulong)__bss_start + gd->reloc_off;
41	size_t len = (uintptr_t)__bss_end - (uintptr_t)__bss_start;
42
43	if (gd->flags & GD_FLG_SKIP_RELOC)
44		return 0;
45	memset((void *)dst_addr, 0x00, len);
46
47	return 0;
48}
49#endif
50
51#if CONFIG_IS_ENABLED(X86_64)
52static void do_elf_reloc_fixups64(unsigned int text_base, uintptr_t size,
53				  Elf64_Rela *re_src, Elf64_Rela *re_end)
54{
55	Elf64_Addr *offset_ptr_rom, *last_offset = NULL;
56	Elf64_Addr *offset_ptr_ram;
57
58	do {
59		unsigned long long type = ELF64_R_TYPE(re_src->r_info);

주요 구문 해설

02. x86-64 ELF relocation entry를 새 image에 적용

arch/x86/lib/relocate.c 47-120줄이다.

47	return 0;
48}
49#endif
50
51#if CONFIG_IS_ENABLED(X86_64)
52static void do_elf_reloc_fixups64(unsigned int text_base, uintptr_t size,
53				  Elf64_Rela *re_src, Elf64_Rela *re_end)
54{
55	Elf64_Addr *offset_ptr_rom, *last_offset = NULL;
56	Elf64_Addr *offset_ptr_ram;
57
58	do {
59		unsigned long long type = ELF64_R_TYPE(re_src->r_info);
60
61		if (type != R_X86_64_RELATIVE) {
62			printf("%s: unsupported relocation type 0x%llx "
63			       "at %p, ", __func__, type, re_src);
64			printf("offset = 0x%llx\n", re_src->r_offset);
65			continue;
66		}
67
68		/* Get the location from the relocation entry */
69		offset_ptr_rom = (Elf64_Addr *)(uintptr_t)re_src->r_offset;
70
71		/* Check that the location of the relocation is in .text */
72		if (offset_ptr_rom >= (Elf64_Addr *)(uintptr_t)text_base &&
73		    offset_ptr_rom > last_offset) {
74			/* Switch to the in-RAM version */
75			offset_ptr_ram = (Elf64_Addr *)((ulong)offset_ptr_rom +
76							gd->reloc_off);
77
78			/* Check that the target points into .text */
79			if (*offset_ptr_ram >= text_base &&
80			    *offset_ptr_ram <= text_base + size) {
81				*offset_ptr_ram = gd->reloc_off +
82							re_src->r_addend;
83			} else {
84				debug("   %p: %lx: rom reloc %lx, ram %p, value %lx, limit %lX\n",
85				      re_src, (ulong)re_src->r_info,
86				      (ulong)re_src->r_offset, offset_ptr_ram,
87				      (ulong)*offset_ptr_ram, text_base + size);
88			}
89		} else {
90			debug("   %p: %lx: rom reloc %lx, last %p\n", re_src,
91			      (ulong)re_src->r_info, (ulong)re_src->r_offset,
92			      last_offset);
93		}
94		last_offset = offset_ptr_rom;
95
96	} while (++re_src < re_end);
97}
98#else
99static void do_elf_reloc_fixups32(unsigned int text_base, uintptr_t size,
100				  Elf32_Rel *re_src, Elf32_Rel *re_end)
101{
102	Elf32_Addr *offset_ptr_rom, *last_offset = NULL;
103	Elf32_Addr *offset_ptr_ram;
104
105	do {
106		unsigned int type = ELF32_R_TYPE(re_src->r_info);
107
108		if (type != R_386_RELATIVE) {
109			printf("%s: unsupported relocation type 0x%x "
110			       "at %p, ", __func__, type, re_src);
111			printf("offset = 0x%x\n", re_src->r_offset);
112			continue;
113		}
114
115		/* Get the location from the relocation entry */
116		offset_ptr_rom = (Elf32_Addr *)(uintptr_t)re_src->r_offset;
117
118		/* Check that the location of the relocation is in .text */
119		if (offset_ptr_rom >= (Elf32_Addr *)(uintptr_t)text_base &&
120		    offset_ptr_rom > last_offset) {

주요 구문 해설

03. x86 relocation initcall의 실제 순서

common/board_f.c 990-1051줄이다.

990    CONFIG_IS_ENABLED(OF_INITIAL_DTB_READONLY)
991	INITCALL(reloc_fdt);
992	INITCALL(fix_fdt);
993#endif
994	INITCALL(reserve_bootstage);
995	INITCALL(reserve_bloblist);
996	INITCALL(reserve_arch);
997	INITCALL(reserve_stacks);
998	INITCALL(dram_init_banksize);
999	INITCALL(show_dram_config);
1000	WATCHDOG_RESET();
1001	INITCALL(setup_bdinfo);
1002	INITCALL(display_new_sp);
1003	WATCHDOG_RESET();
1004#if !CONFIG_IS_ENABLED(OF_BOARD_FIXUP) || \
1005    !CONFIG_IS_ENABLED(INITIAL_DTB_READONLY)
1006	INITCALL(reloc_fdt);
1007#endif
1008	INITCALL(reloc_bootstage);
1009	INITCALL(reloc_bloblist);
1010	INITCALL(setup_reloc);
1011#if CONFIG_IS_ENABLED(X86) || CONFIG_IS_ENABLED(ARC)
1012	INITCALL(copy_uboot_to_ram);
1013	INITCALL(do_elf_reloc_fixups);
1014#endif
1015	INITCALL(clear_bss);
1016	/*
1017	 * Deregister all cyclic functions before relocation, so that
1018	 * gd->cyclic_list does not contain any references to pre-relocation
1019	 * devices. Drivers will register their cyclic functions anew when the
1020	 * devices are probed again.
1021	 *
1022	 * This should happen as late as possible so that the window where a
1023	 * watchdog device is not serviced is as small as possible.
1024	 */
1025	INITCALL(cyclic_unregister_all);
1026#if !CONFIG_IS_ENABLED(ARM) && !CONFIG_IS_ENABLED(SANDBOX)
1027	INITCALL(jump_to_copy);
1028#endif
1029}
1030
1031void board_init_f(ulong boot_flags)
1032{
1033	struct board_f boardf;
1034
1035	gd->flags = boot_flags;
1036	gd->flags &= ~GD_FLG_HAVE_CONSOLE;
1037	gd->boardf = &boardf;
1038
1039	initcall_run_f();
1040
1041#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX) && \
1042		!defined(CONFIG_EFI_APP) && !CONFIG_IS_ENABLED(X86_64) && \
1043		!defined(CONFIG_ARC)
1044	/* NOTREACHED - jump_to_copy() does not return */
1045	hang();
1046#endif
1047}
1048
1049#if defined(CONFIG_X86) || defined(CONFIG_ARC)
1050/*
1051 * For now this code is only used on x86.

04. 64-bit 새 stack과 gd를 받는 trampoline

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

26	call	board_init_f
27	call	board_init_f_r
28
29	/* Should not return here */
30	jmp	.
31
32.globl board_init_f_r_trampoline64
33.type board_init_f_r_trampoline64, @function
34board_init_f_r_trampoline64:
35	/*
36	 * SDRAM has been initialised, U-Boot code has been copied into
37	 * RAM, BSS has been cleared and relocation adjustments have been
38	 * made. It is now time to jump into the in-RAM copy of U-Boot
39	 *
40	 * %eax = Address of top of new stack
41	 */
42
43	/* Stack grows down from top of SDRAM */
44	movq	%rsi, %rsp
45
46	/* New gd is in rdi */
47
48	/* Re-enter U-Boot by calling board_init_f_r() */
49	call	board_init_f_r

주요 구문 해설

05. 새 gd와 stack을 architecture trampoline으로 넘기는 jump_to_copy

common/board_f.c 744-785줄이다.

744{
745	return board_fix_fdt((void *)gd->fdt_blob);
746}
747#endif
748
749/* ARM calls relocate_code from its crt0.S */
750#if !defined(CONFIG_ARM) && !defined(CONFIG_SANDBOX)
751
752static int jump_to_copy(void)
753{
754	if (gd->flags & GD_FLG_SKIP_RELOC)
755		return 0;
756	/*
757	 * x86 is special, but in a nice way. It uses a trampoline which
758	 * enables the dcache if possible.
759	 *
760	 * For now, other archs use relocate_code(), which is implemented
761	 * similarly for all archs. When we do generic relocation, hopefully
762	 * we can make all archs enable the dcache prior to relocation.
763	 */
764#if defined(CONFIG_X86) || defined(CONFIG_ARC)
765	/*
766	 * SDRAM and console are now initialised. The final stack can now
767	 * be setup in SDRAM. Code execution will continue in Flash, but
768	 * with the stack in SDRAM and Global Data in temporary memory
769	 * (CPU cache)
770	 */
771	arch_setup_gd(gd->new_gd);
772# if CONFIG_IS_ENABLED(X86_64)
773		board_init_f_r_trampoline64(gd->new_gd, gd->start_addr_sp);
774# else
775		board_init_f_r_trampoline(gd->start_addr_sp);
776# endif
777#else
778	relocate_code(gd->start_addr_sp, gd->new_gd, gd->relocaddr);
779#endif
780
781	return 0;
782}
783#endif
784
785/* Record the board_init_f() bootstage (after arch_cpu_init()) */

주요 구문 해설