]>
Commit | Line | Data |
---|---|---|
cb149c66 AG |
1 | /* |
2 | * EFI image loader | |
3 | * | |
4 | * based partly on wine code | |
5 | * | |
6 | * Copyright (c) 2016 Alexander Graf | |
7 | * | |
8 | * SPDX-License-Identifier: GPL-2.0+ | |
9 | */ | |
10 | ||
11 | #include <common.h> | |
12 | #include <efi_loader.h> | |
13 | #include <pe.h> | |
14 | #include <asm/global_data.h> | |
15 | ||
16 | DECLARE_GLOBAL_DATA_PTR; | |
17 | ||
9975fe96 | 18 | const efi_guid_t efi_global_variable_guid = EFI_GLOBAL_VARIABLE_GUID; |
cb149c66 AG |
19 | const efi_guid_t efi_guid_device_path = DEVICE_PATH_GUID; |
20 | const efi_guid_t efi_guid_loaded_image = LOADED_IMAGE_GUID; | |
2a92080d RC |
21 | const efi_guid_t efi_simple_file_system_protocol_guid = |
22 | EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID; | |
23 | const efi_guid_t efi_file_info_guid = EFI_FILE_INFO_GUID; | |
cb149c66 | 24 | |
da684a64 | 25 | static efi_status_t efi_loader_relocate(const IMAGE_BASE_RELOCATION *rel, |
cb149c66 AG |
26 | unsigned long rel_size, void *efi_reloc) |
27 | { | |
28 | const IMAGE_BASE_RELOCATION *end; | |
29 | int i; | |
30 | ||
31 | end = (const IMAGE_BASE_RELOCATION *)((const char *)rel + rel_size); | |
32 | while (rel < end - 1 && rel->SizeOfBlock) { | |
33 | const uint16_t *relocs = (const uint16_t *)(rel + 1); | |
34 | i = (rel->SizeOfBlock - sizeof(*rel)) / sizeof(uint16_t); | |
35 | while (i--) { | |
b1237c6e | 36 | uint32_t offset = (uint32_t)(*relocs & 0xfff) + |
cb149c66 AG |
37 | rel->VirtualAddress; |
38 | int type = *relocs >> EFI_PAGE_SHIFT; | |
39 | unsigned long delta = (unsigned long)efi_reloc; | |
40 | uint64_t *x64 = efi_reloc + offset; | |
41 | uint32_t *x32 = efi_reloc + offset; | |
42 | uint16_t *x16 = efi_reloc + offset; | |
43 | ||
44 | switch (type) { | |
45 | case IMAGE_REL_BASED_ABSOLUTE: | |
46 | break; | |
47 | case IMAGE_REL_BASED_HIGH: | |
48 | *x16 += ((uint32_t)delta) >> 16; | |
49 | break; | |
50 | case IMAGE_REL_BASED_LOW: | |
51 | *x16 += (uint16_t)delta; | |
52 | break; | |
53 | case IMAGE_REL_BASED_HIGHLOW: | |
54 | *x32 += (uint32_t)delta; | |
55 | break; | |
56 | case IMAGE_REL_BASED_DIR64: | |
57 | *x64 += (uint64_t)delta; | |
58 | break; | |
59 | default: | |
60 | printf("Unknown Relocation off %x type %x\n", | |
61 | offset, type); | |
da684a64 | 62 | return EFI_LOAD_ERROR; |
cb149c66 AG |
63 | } |
64 | relocs++; | |
65 | } | |
66 | rel = (const IMAGE_BASE_RELOCATION *)relocs; | |
67 | } | |
da684a64 | 68 | return EFI_SUCCESS; |
cb149c66 AG |
69 | } |
70 | ||
71 | void __weak invalidate_icache_all(void) | |
72 | { | |
73 | /* If the system doesn't support icache_all flush, cross our fingers */ | |
74 | } | |
75 | ||
76 | /* | |
77 | * This function loads all sections from a PE binary into a newly reserved | |
78 | * piece of memory. On successful load it then returns the entry point for | |
79 | * the binary. Otherwise NULL. | |
80 | */ | |
81 | void *efi_load_pe(void *efi, struct efi_loaded_image *loaded_image_info) | |
82 | { | |
83 | IMAGE_NT_HEADERS32 *nt; | |
84 | IMAGE_DOS_HEADER *dos; | |
85 | IMAGE_SECTION_HEADER *sections; | |
86 | int num_sections; | |
87 | void *efi_reloc; | |
88 | int i; | |
89 | const IMAGE_BASE_RELOCATION *rel; | |
90 | unsigned long rel_size; | |
91 | int rel_idx = IMAGE_DIRECTORY_ENTRY_BASERELOC; | |
92 | void *entry; | |
93 | uint64_t image_size; | |
94 | unsigned long virt_size = 0; | |
95 | bool can_run_nt64 = true; | |
96 | bool can_run_nt32 = true; | |
4657a3f1 | 97 | uint16_t image_type; |
cb149c66 AG |
98 | |
99 | #if defined(CONFIG_ARM64) | |
100 | can_run_nt32 = false; | |
101 | #elif defined(CONFIG_ARM) | |
102 | can_run_nt64 = false; | |
103 | #endif | |
104 | ||
105 | dos = efi; | |
106 | if (dos->e_magic != IMAGE_DOS_SIGNATURE) { | |
107 | printf("%s: Invalid DOS Signature\n", __func__); | |
108 | return NULL; | |
109 | } | |
110 | ||
111 | nt = (void *) ((char *)efi + dos->e_lfanew); | |
112 | if (nt->Signature != IMAGE_NT_SIGNATURE) { | |
113 | printf("%s: Invalid NT Signature\n", __func__); | |
114 | return NULL; | |
115 | } | |
116 | ||
117 | /* Calculate upper virtual address boundary */ | |
118 | num_sections = nt->FileHeader.NumberOfSections; | |
119 | sections = (void *)&nt->OptionalHeader + | |
120 | nt->FileHeader.SizeOfOptionalHeader; | |
121 | ||
122 | for (i = num_sections - 1; i >= 0; i--) { | |
123 | IMAGE_SECTION_HEADER *sec = §ions[i]; | |
124 | virt_size = max_t(unsigned long, virt_size, | |
125 | sec->VirtualAddress + sec->Misc.VirtualSize); | |
126 | } | |
127 | ||
128 | /* Read 32/64bit specific header bits */ | |
129 | if (can_run_nt64 && | |
130 | (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC)) { | |
131 | IMAGE_NT_HEADERS64 *nt64 = (void *)nt; | |
132 | IMAGE_OPTIONAL_HEADER64 *opt = &nt64->OptionalHeader; | |
133 | image_size = opt->SizeOfImage; | |
134 | efi_reloc = efi_alloc(virt_size, EFI_LOADER_DATA); | |
135 | if (!efi_reloc) { | |
136 | printf("%s: Could not allocate %ld bytes\n", | |
137 | __func__, virt_size); | |
138 | return NULL; | |
139 | } | |
140 | entry = efi_reloc + opt->AddressOfEntryPoint; | |
141 | rel_size = opt->DataDirectory[rel_idx].Size; | |
142 | rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress; | |
4657a3f1 | 143 | image_type = opt->Subsystem; |
cb149c66 AG |
144 | } else if (can_run_nt32 && |
145 | (nt->OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC)) { | |
146 | IMAGE_OPTIONAL_HEADER32 *opt = &nt->OptionalHeader; | |
147 | image_size = opt->SizeOfImage; | |
148 | efi_reloc = efi_alloc(virt_size, EFI_LOADER_DATA); | |
149 | if (!efi_reloc) { | |
150 | printf("%s: Could not allocate %ld bytes\n", | |
151 | __func__, virt_size); | |
152 | return NULL; | |
153 | } | |
154 | entry = efi_reloc + opt->AddressOfEntryPoint; | |
155 | rel_size = opt->DataDirectory[rel_idx].Size; | |
156 | rel = efi_reloc + opt->DataDirectory[rel_idx].VirtualAddress; | |
4657a3f1 | 157 | image_type = opt->Subsystem; |
cb149c66 AG |
158 | } else { |
159 | printf("%s: Invalid optional header magic %x\n", __func__, | |
160 | nt->OptionalHeader.Magic); | |
161 | return NULL; | |
162 | } | |
163 | ||
4657a3f1 RC |
164 | switch (image_type) { |
165 | case IMAGE_SUBSYSTEM_EFI_APPLICATION: | |
166 | loaded_image_info->image_code_type = EFI_LOADER_CODE; | |
167 | loaded_image_info->image_data_type = EFI_LOADER_DATA; | |
168 | break; | |
169 | case IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: | |
170 | loaded_image_info->image_code_type = EFI_BOOT_SERVICES_CODE; | |
171 | loaded_image_info->image_data_type = EFI_BOOT_SERVICES_DATA; | |
172 | break; | |
173 | case IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: | |
174 | case IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER: | |
175 | loaded_image_info->image_code_type = EFI_RUNTIME_SERVICES_CODE; | |
176 | loaded_image_info->image_data_type = EFI_RUNTIME_SERVICES_DATA; | |
177 | break; | |
178 | default: | |
179 | printf("%s: invalid image type: %u\n", __func__, image_type); | |
180 | break; | |
181 | } | |
182 | ||
cb149c66 AG |
183 | /* Load sections into RAM */ |
184 | for (i = num_sections - 1; i >= 0; i--) { | |
185 | IMAGE_SECTION_HEADER *sec = §ions[i]; | |
186 | memset(efi_reloc + sec->VirtualAddress, 0, | |
187 | sec->Misc.VirtualSize); | |
188 | memcpy(efi_reloc + sec->VirtualAddress, | |
189 | efi + sec->PointerToRawData, | |
190 | sec->SizeOfRawData); | |
191 | } | |
192 | ||
193 | /* Run through relocations */ | |
da684a64 | 194 | if (efi_loader_relocate(rel, rel_size, efi_reloc) != EFI_SUCCESS) { |
195 | efi_free_pages((uintptr_t) efi_reloc, | |
196 | (virt_size + EFI_PAGE_MASK) >> EFI_PAGE_SHIFT); | |
197 | return NULL; | |
198 | } | |
cb149c66 AG |
199 | |
200 | /* Flush cache */ | |
d0d90993 SG |
201 | flush_cache((ulong)efi_reloc, |
202 | ALIGN(virt_size, CONFIG_SYS_CACHELINE_SIZE)); | |
cb149c66 AG |
203 | invalidate_icache_all(); |
204 | ||
205 | /* Populate the loaded image interface bits */ | |
206 | loaded_image_info->image_base = efi; | |
207 | loaded_image_info->image_size = image_size; | |
208 | ||
209 | return entry; | |
210 | } |