1 /** @file 2 * 3 * Copyright (c) 2014, ARM Limited. All rights reserved. 4 * 5 * This program and the accompanying materials 6 * are licensed and made available under the terms and conditions of the BSD License 7 * which accompanies this distribution. The full text of the license may be found at 8 * http://opensource.org/licenses/bsd-license.php 9 * 10 * THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 * 13 **/ 14 15 #include <Library/BaseLib.h> 16 #include <Library/BaseMemoryLib.h> 17 #include <Library/MemoryAllocationLib.h> 18 #include <Library/DebugLib.h> 19 #include <Library/UefiLib.h> 20 21 #include "ArmShellCmdRunAxf.h" 22 #include "ElfLoader.h" 23 #include "elf_common.h" 24 #include "elf32.h" 25 #include "elf64.h" 26 27 28 // Put the functions the #ifdef. We only use the appropriate one for the platform. 29 // This prevents 'defined but not used' compiler warning. 30 #ifdef MDE_CPU_ARM 31 STATIC 32 BOOLEAN 33 IsArmElf ( 34 IN CONST VOID *Buf 35 ) 36 { 37 Elf32_Ehdr *Hdr = (Elf32_Ehdr*)Buf; 38 39 if (Hdr->e_ident[EI_CLASS] != ELFCLASS32) { 40 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_32), gRunAxfHiiHandle); 41 return FALSE; 42 } 43 44 if (Hdr->e_machine != EM_ARM) { 45 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_32), gRunAxfHiiHandle); 46 return FALSE; 47 } 48 49 // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA]) 50 51 return TRUE; 52 } 53 #elif defined(MDE_CPU_AARCH64) 54 STATIC 55 BOOLEAN 56 IsAarch64Elf ( 57 IN CONST VOID *Buf 58 ) 59 { 60 Elf64_Ehdr *Hdr = (Elf64_Ehdr*)Buf; 61 62 if (Hdr->e_ident[EI_CLASS] != ELFCLASS64) { 63 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_64), gRunAxfHiiHandle); 64 return FALSE; 65 } 66 67 if (Hdr->e_machine != EM_AARCH64) { 68 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_64), gRunAxfHiiHandle); 69 return FALSE; 70 } 71 72 // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA]) 73 74 return TRUE; 75 } 76 #endif // MDE_CPU_ARM , MDE_CPU_AARCH64 77 78 79 /** 80 Support checking 32 and 64bit as the header could be valid, we might just 81 not support loading it. 82 **/ 83 STATIC 84 EFI_STATUS 85 ElfCheckHeader ( 86 IN CONST VOID *Buf 87 ) 88 { 89 Elf32_Ehdr *Hdr32 = (Elf32_Ehdr*)Buf; 90 91 if (!IS_ELF (*Hdr32)) { 92 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFMAGIC), gRunAxfHiiHandle); 93 return EFI_INVALID_PARAMETER; 94 } 95 96 if (Hdr32->e_type != ET_EXEC) { 97 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOTEXEC), gRunAxfHiiHandle); 98 return EFI_INVALID_PARAMETER; 99 } 100 101 if (Hdr32->e_ident[EI_CLASS] == ELFCLASS32) { 102 if ((Hdr32->e_phoff == 0) || (Hdr32->e_phentsize == 0) || (Hdr32->e_phnum == 0)) { 103 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle); 104 return EFI_INVALID_PARAMETER; 105 } 106 107 if (Hdr32->e_flags != 0) { 108 DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n")); 109 } 110 111 DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr32->e_entry)); 112 DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr32->e_phoff)); 113 DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr32->e_phentsize)); 114 DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr32->e_phnum)); 115 } else if (Hdr32->e_ident[EI_CLASS] == ELFCLASS64) { 116 Elf64_Ehdr *Hdr64 = (Elf64_Ehdr*)Buf; 117 118 if ((Hdr64->e_phoff == 0) || (Hdr64->e_phentsize == 0) || (Hdr64->e_phnum == 0)) { 119 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle); 120 return EFI_INVALID_PARAMETER; 121 } 122 123 if (Hdr64->e_flags != 0) { 124 DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n")); 125 } 126 127 DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr64->e_entry)); 128 DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr64->e_phoff)); 129 DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr64->e_phentsize)); 130 DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr64->e_phnum)); 131 } else { 132 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS), gRunAxfHiiHandle); 133 return EFI_INVALID_PARAMETER; 134 } 135 136 return EFI_SUCCESS; 137 } 138 139 140 /** 141 Load an ELF segment into memory. 142 143 This function assumes the ELF file is valid. 144 This function is meant to be called for PT_LOAD type segments only. 145 **/ 146 STATIC 147 EFI_STATUS 148 ElfLoadSegment ( 149 IN CONST VOID *ElfImage, 150 IN CONST VOID *PHdr, 151 IN LIST_ENTRY *LoadList 152 ) 153 { 154 VOID *FileSegment; 155 VOID *MemSegment; 156 UINTN ExtraZeroes; 157 UINTN ExtraZeroesCount; 158 RUNAXF_LOAD_LIST *LoadNode; 159 160 #ifdef MDE_CPU_ARM 161 Elf32_Phdr *ProgramHdr; 162 ProgramHdr = (Elf32_Phdr *)PHdr; 163 #elif defined(MDE_CPU_AARCH64) 164 Elf64_Phdr *ProgramHdr; 165 ProgramHdr = (Elf64_Phdr *)PHdr; 166 #endif 167 168 ASSERT (ElfImage != NULL); 169 ASSERT (ProgramHdr != NULL); 170 171 FileSegment = (VOID *)((UINTN)ElfImage + ProgramHdr->p_offset); 172 MemSegment = (VOID *)ProgramHdr->p_vaddr; 173 174 // If the segment's memory size p_memsz is larger than the file size p_filesz, 175 // the "extra" bytes are defined to hold the value 0 and to follow the 176 // segment's initialised area. 177 // This is typically the case for the .bss segment. 178 // The file size may not be larger than the memory size. 179 if (ProgramHdr->p_filesz > ProgramHdr->p_memsz) { 180 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADFORMAT), gRunAxfHiiHandle); 181 return EFI_INVALID_PARAMETER; 182 } 183 184 // Load the segment in memory. 185 if (ProgramHdr->p_filesz != 0) { 186 DEBUG ((EFI_D_INFO, "Loading segment from 0x%lx to 0x%lx (size = %ld)\n", 187 FileSegment, MemSegment, ProgramHdr->p_filesz)); 188 189 LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST)); 190 if (LoadNode == NULL) { 191 return EFI_OUT_OF_RESOURCES; 192 } 193 LoadNode->MemOffset = (UINTN)MemSegment; 194 LoadNode->FileOffset = (UINTN)FileSegment; 195 LoadNode->Length = (UINTN)ProgramHdr->p_filesz; 196 InsertTailList (LoadList, &LoadNode->Link); 197 } 198 199 ExtraZeroes = ((UINTN)MemSegment + ProgramHdr->p_filesz); 200 ExtraZeroesCount = ProgramHdr->p_memsz - ProgramHdr->p_filesz; 201 DEBUG ((EFI_D_INFO, "Completing segment with %d zero bytes.\n", ExtraZeroesCount)); 202 if (ExtraZeroesCount > 0) { 203 // Extra Node to add the Zeroes. 204 LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST)); 205 if (LoadNode == NULL) { 206 return EFI_OUT_OF_RESOURCES; 207 } 208 LoadNode->MemOffset = (UINTN)ExtraZeroes; 209 LoadNode->Zeroes = TRUE; 210 LoadNode->Length = ExtraZeroesCount; 211 InsertTailList (LoadList, &LoadNode->Link); 212 } 213 214 return EFI_SUCCESS; 215 } 216 217 218 /** 219 Check that the ELF File Header is valid and Machine type supported. 220 221 Not all information is checked in the ELF header, only the stuff that 222 matters to us in our simplified ELF loader. 223 224 @param[in] ElfImage Address of the ELF file to check. 225 226 @retval EFI_SUCCESS on success. 227 @retval EFI_INVALID_PARAMETER if the header is invalid. 228 @retval EFI_UNSUPPORTED if the file type/platform is not supported. 229 **/ 230 EFI_STATUS 231 ElfCheckFile ( 232 IN CONST VOID *ElfImage 233 ) 234 { 235 EFI_STATUS Status; 236 237 ASSERT (ElfImage != NULL); 238 239 // Check that the ELF header is valid. 240 Status = ElfCheckHeader (ElfImage); 241 if (EFI_ERROR(Status)) { 242 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADHEADER), gRunAxfHiiHandle); 243 return EFI_INVALID_PARAMETER; 244 } 245 246 #ifdef MDE_CPU_ARM 247 if (IsArmElf (ElfImage)) { 248 return EFI_SUCCESS; 249 } 250 #elif defined(MDE_CPU_AARCH64) 251 if (IsAarch64Elf (ElfImage)) { 252 return EFI_SUCCESS; 253 } 254 #endif 255 256 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_BAD_ARCH), gRunAxfHiiHandle); 257 return EFI_UNSUPPORTED; 258 } 259 260 261 /** 262 Load a ELF file. 263 264 @param[in] ElfImage Address of the ELF file in memory. 265 266 @param[out] EntryPoint Will be filled with the ELF entry point address. 267 268 @param[out] ImageSize Will be filled with the ELF size in memory. This will 269 effectively be equal to the sum of the segments sizes. 270 271 This functon assumes the header is valid and supported as checked with 272 ElfCheckFile(). 273 274 @retval EFI_SUCCESS on success. 275 @retval EFI_INVALID_PARAMETER if the ELF file is invalid. 276 **/ 277 EFI_STATUS 278 ElfLoadFile ( 279 IN CONST VOID *ElfImage, 280 OUT VOID **EntryPoint, 281 OUT LIST_ENTRY *LoadList 282 ) 283 { 284 EFI_STATUS Status; 285 UINT8 *ProgramHdr; 286 UINTN Index; 287 UINTN ImageSize; 288 289 #ifdef MDE_CPU_ARM 290 Elf32_Ehdr *ElfHdr; 291 Elf32_Phdr *ProgramHdrPtr; 292 293 ElfHdr = (Elf32_Ehdr*)ElfImage; 294 #elif defined(MDE_CPU_AARCH64) 295 Elf64_Ehdr *ElfHdr; 296 Elf64_Phdr *ProgramHdrPtr; 297 298 ElfHdr = (Elf64_Ehdr*)ElfImage; 299 #endif 300 301 ASSERT (ElfImage != NULL); 302 ASSERT (EntryPoint != NULL); 303 ASSERT (LoadList != NULL); 304 305 ProgramHdr = (UINT8*)ElfImage + ElfHdr->e_phoff; 306 DEBUG ((EFI_D_INFO, "ELF program header entry : 0x%lx\n", ProgramHdr)); 307 308 ImageSize = 0; 309 310 // Load every loadable ELF segment into memory. 311 for (Index = 0; Index < ElfHdr->e_phnum; ++Index) { 312 313 #ifdef MDE_CPU_ARM 314 ProgramHdrPtr = (Elf32_Phdr*)ProgramHdr; 315 #elif defined(MDE_CPU_AARCH64) 316 ProgramHdrPtr = (Elf64_Phdr*)ProgramHdr; 317 #endif 318 319 // Only consider PT_LOAD type segments, ignore others. 320 if (ProgramHdrPtr->p_type == PT_LOAD) { 321 Status = ElfLoadSegment (ElfImage, (VOID *)ProgramHdrPtr, LoadList); 322 if (EFI_ERROR (Status)) { 323 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFFAILSEG), gRunAxfHiiHandle); 324 return EFI_INVALID_PARAMETER; 325 } 326 ImageSize += ProgramHdrPtr->p_memsz; 327 } 328 ProgramHdr += ElfHdr->e_phentsize; 329 } 330 331 if (ImageSize == 0) { 332 ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOSEG), gRunAxfHiiHandle); 333 return EFI_INVALID_PARAMETER; 334 } 335 336 // Return the entry point specified in the ELF header. 337 *EntryPoint = (void*)ElfHdr->e_entry; 338 339 return EFI_SUCCESS; 340 } 341
