ArmPlatformPkg: remove ArmPlatformSysConfigLib library class

[mirror_edk2.git] / ArmPlatformPkg / Library / ArmShellCmdRunAxf / ElfLoader.c

/** @file\r
*\r
*  Copyright (c) 2014, ARM Limited. All rights reserved.\r
*\r
*  This program and the accompanying materials\r
*  are licensed and made available under the terms and conditions of the BSD License\r
*  which accompanies this distribution.  The full text of the license may be found at\r
*  http://opensource.org/licenses/bsd-license.php\r
*\r
*  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
*  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
*\r
**/\r
\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/UefiLib.h>\r
\r
#include "ArmShellCmdRunAxf.h"\r
#include "ElfLoader.h"\r
#include "elf_common.h"\r
#include "elf32.h"\r
#include "elf64.h"\r
\r
\r
// Put the functions the #ifdef. We only use the appropriate one for the platform.\r
// This prevents 'defined but not used' compiler warning.\r
#ifdef MDE_CPU_ARM\r
STATIC\r
BOOLEAN\r
IsArmElf (\r
  IN  CONST VOID *Buf\r
  )\r
{\r
  Elf32_Ehdr *Hdr = (Elf32_Ehdr*)Buf;\r
\r
  if (Hdr->e_ident[EI_CLASS] != ELFCLASS32) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_32), gRunAxfHiiHandle);\r
    return FALSE;\r
  }\r
\r
  if (Hdr->e_machine != EM_ARM) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_32), gRunAxfHiiHandle);\r
    return FALSE;\r
  }\r
\r
  // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA])\r
\r
  return TRUE;\r
}\r
#elif defined(MDE_CPU_AARCH64)\r
STATIC\r
BOOLEAN\r
IsAarch64Elf (\r
  IN  CONST VOID *Buf\r
  )\r
{\r
  Elf64_Ehdr *Hdr = (Elf64_Ehdr*)Buf;\r
\r
  if (Hdr->e_ident[EI_CLASS] != ELFCLASS64) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS_64), gRunAxfHiiHandle);\r
    return FALSE;\r
  }\r
\r
  if (Hdr->e_machine != EM_AARCH64) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGMACH_64), gRunAxfHiiHandle);\r
    return FALSE;\r
  }\r
\r
  // We don't currently check endianness of ELF data (hdr->e_ident[EI_DATA])\r
\r
  return TRUE;\r
}\r
#endif // MDE_CPU_ARM , MDE_CPU_AARCH64\r
\r
\r
/**\r
 Support checking 32 and 64bit as the header could be valid, we might just\r
 not support loading it.\r
**/\r
STATIC\r
EFI_STATUS\r
ElfCheckHeader (\r
  IN  CONST VOID *Buf\r
  )\r
{\r
  Elf32_Ehdr *Hdr32 = (Elf32_Ehdr*)Buf;\r
\r
  if (!IS_ELF (*Hdr32)) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFMAGIC), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Hdr32->e_type != ET_EXEC) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOTEXEC), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Hdr32->e_ident[EI_CLASS] == ELFCLASS32) {\r
    if ((Hdr32->e_phoff == 0) || (Hdr32->e_phentsize == 0) || (Hdr32->e_phnum == 0)) {\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if (Hdr32->e_flags != 0) {\r
      DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n"));\r
    }\r
\r
    DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr32->e_entry));\r
    DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr32->e_phoff));\r
    DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr32->e_phentsize));\r
    DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr32->e_phnum));\r
  } else if (Hdr32->e_ident[EI_CLASS] == ELFCLASS64) {\r
      Elf64_Ehdr *Hdr64 = (Elf64_Ehdr*)Buf;\r
\r
    if ((Hdr64->e_phoff == 0) || (Hdr64->e_phentsize == 0) || (Hdr64->e_phnum == 0)) {\r
      ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOPROG), gRunAxfHiiHandle);\r
      return EFI_INVALID_PARAMETER;\r
    }\r
\r
    if (Hdr64->e_flags != 0) {\r
      DEBUG ((EFI_D_INFO, "Warning: Wrong processor-specific flags, expected 0.\n"));\r
    }\r
\r
    DEBUG ((EFI_D_INFO, "Entry point addr: 0x%lx\n", Hdr64->e_entry));\r
    DEBUG ((EFI_D_INFO, "Start of program headers: 0x%lx\n", Hdr64->e_phoff));\r
    DEBUG ((EFI_D_INFO, "Size of 1 program header: %d\n", Hdr64->e_phentsize));\r
    DEBUG ((EFI_D_INFO, "Number of program headers: %d\n", Hdr64->e_phnum));\r
  } else {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFWRONGCLASS), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
 Load an ELF segment into memory.\r
\r
 This function assumes the ELF file is valid.\r
 This function is meant to be called for PT_LOAD type segments only.\r
**/\r
STATIC\r
EFI_STATUS\r
ElfLoadSegment (\r
  IN  CONST VOID  *ElfImage,\r
  IN  CONST VOID  *PHdr,\r
  IN  LIST_ENTRY  *LoadList\r
  )\r
{\r
  VOID             *FileSegment;\r
  VOID             *MemSegment;\r
  UINTN             ExtraZeroes;\r
  UINTN             ExtraZeroesCount;\r
  RUNAXF_LOAD_LIST *LoadNode;\r
\r
#ifdef MDE_CPU_ARM\r
  Elf32_Phdr  *ProgramHdr;\r
  ProgramHdr = (Elf32_Phdr *)PHdr;\r
#elif defined(MDE_CPU_AARCH64)\r
  Elf64_Phdr  *ProgramHdr;\r
  ProgramHdr = (Elf64_Phdr *)PHdr;\r
#endif\r
\r
  ASSERT (ElfImage != NULL);\r
  ASSERT (ProgramHdr != NULL);\r
\r
  FileSegment = (VOID *)((UINTN)ElfImage + ProgramHdr->p_offset);\r
  MemSegment = (VOID *)ProgramHdr->p_vaddr;\r
\r
  // If the segment's memory size p_memsz is larger than the file size p_filesz,\r
  // the "extra" bytes are defined to hold the value 0 and to follow the\r
  // segment's initialised area.\r
  // This is typically the case for the .bss segment.\r
  // The file size may not be larger than the memory size.\r
  if (ProgramHdr->p_filesz > ProgramHdr->p_memsz) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADFORMAT), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Load the segment in memory.\r
  if (ProgramHdr->p_filesz != 0) {\r
    DEBUG ((EFI_D_INFO, "Loading segment from 0x%lx to 0x%lx (size = %ld)\n",\r
                 FileSegment, MemSegment, ProgramHdr->p_filesz));\r
\r
    LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST));\r
    if (LoadNode == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    LoadNode->MemOffset  = (UINTN)MemSegment;\r
    LoadNode->FileOffset = (UINTN)FileSegment;\r
    LoadNode->Length     = (UINTN)ProgramHdr->p_filesz;\r
    InsertTailList (LoadList, &LoadNode->Link);\r
  }\r
\r
  ExtraZeroes = ((UINTN)MemSegment + ProgramHdr->p_filesz);\r
  ExtraZeroesCount = ProgramHdr->p_memsz - ProgramHdr->p_filesz;\r
  DEBUG ((EFI_D_INFO, "Completing segment with %d zero bytes.\n", ExtraZeroesCount));\r
  if (ExtraZeroesCount > 0) {\r
    // Extra Node to add the Zeroes.\r
    LoadNode = AllocateRuntimeZeroPool (sizeof (RUNAXF_LOAD_LIST));\r
    if (LoadNode == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    LoadNode->MemOffset  = (UINTN)ExtraZeroes;\r
    LoadNode->Zeroes     = TRUE;\r
    LoadNode->Length     = ExtraZeroesCount;\r
    InsertTailList (LoadList, &LoadNode->Link);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
 Check that the ELF File Header is valid and Machine type supported.\r
\r
 Not all information is checked in the ELF header, only the stuff that\r
 matters to us in our simplified ELF loader.\r
\r
 @param[in] ElfImage  Address of the ELF file to check.\r
\r
 @retval EFI_SUCCESS on success.\r
 @retval EFI_INVALID_PARAMETER if the header is invalid.\r
 @retval EFI_UNSUPPORTED if the file type/platform is not supported.\r
**/\r
EFI_STATUS\r
ElfCheckFile (\r
  IN  CONST VOID *ElfImage\r
  )\r
{\r
  EFI_STATUS Status;\r
\r
  ASSERT (ElfImage != NULL);\r
\r
  // Check that the ELF header is valid.\r
  Status = ElfCheckHeader (ElfImage);\r
  if (EFI_ERROR(Status)) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFBADHEADER), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
#ifdef MDE_CPU_ARM\r
  if (IsArmElf (ElfImage)) {\r
    return EFI_SUCCESS;\r
  }\r
#elif defined(MDE_CPU_AARCH64)\r
  if (IsAarch64Elf (ElfImage)) {\r
    return EFI_SUCCESS;\r
  }\r
#endif\r
\r
  ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_BAD_ARCH), gRunAxfHiiHandle);\r
  return EFI_UNSUPPORTED;\r
}\r
\r
\r
/**\r
  Load a ELF file.\r
\r
  @param[in] ElfImage       Address of the ELF file in memory.\r
\r
  @param[out] EntryPoint    Will be filled with the ELF entry point address.\r
\r
  @param[out] ImageSize     Will be filled with the ELF size in memory. This will\r
                            effectively be equal to the sum of the segments sizes.\r
\r
  This functon assumes the header is valid and supported as checked with\r
  ElfCheckFile().\r
\r
  @retval EFI_SUCCESS on success.\r
  @retval EFI_INVALID_PARAMETER if the ELF file is invalid.\r
**/\r
EFI_STATUS\r
ElfLoadFile (\r
  IN  CONST VOID   *ElfImage,\r
  OUT VOID        **EntryPoint,\r
  OUT LIST_ENTRY   *LoadList\r
  )\r
{\r
  EFI_STATUS    Status;\r
  UINT8        *ProgramHdr;\r
  UINTN         Index;\r
  UINTN         ImageSize;\r
\r
#ifdef MDE_CPU_ARM\r
  Elf32_Ehdr   *ElfHdr;\r
  Elf32_Phdr   *ProgramHdrPtr;\r
\r
  ElfHdr = (Elf32_Ehdr*)ElfImage;\r
#elif defined(MDE_CPU_AARCH64)\r
  Elf64_Ehdr   *ElfHdr;\r
  Elf64_Phdr   *ProgramHdrPtr;\r
\r
  ElfHdr = (Elf64_Ehdr*)ElfImage;\r
#endif\r
\r
  ASSERT (ElfImage   != NULL);\r
  ASSERT (EntryPoint != NULL);\r
  ASSERT (LoadList   != NULL);\r
\r
  ProgramHdr = (UINT8*)ElfImage + ElfHdr->e_phoff;\r
  DEBUG ((EFI_D_INFO, "ELF program header entry : 0x%lx\n", ProgramHdr));\r
\r
  ImageSize = 0;\r
\r
  // Load every loadable ELF segment into memory.\r
  for (Index = 0; Index < ElfHdr->e_phnum; ++Index) {\r
\r
#ifdef MDE_CPU_ARM\r
    ProgramHdrPtr = (Elf32_Phdr*)ProgramHdr;\r
#elif defined(MDE_CPU_AARCH64)\r
    ProgramHdrPtr = (Elf64_Phdr*)ProgramHdr;\r
#endif\r
\r
    // Only consider PT_LOAD type segments, ignore others.\r
    if (ProgramHdrPtr->p_type == PT_LOAD) {\r
      Status = ElfLoadSegment (ElfImage, (VOID *)ProgramHdrPtr, LoadList);\r
      if (EFI_ERROR (Status)) {\r
        ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFFAILSEG), gRunAxfHiiHandle);\r
        return EFI_INVALID_PARAMETER;\r
      }\r
      ImageSize += ProgramHdrPtr->p_memsz;\r
    }\r
    ProgramHdr += ElfHdr->e_phentsize;\r
  }\r
\r
  if (ImageSize == 0) {\r
    ShellPrintHiiEx (-1, -1, NULL, STRING_TOKEN (STR_RUNAXF_ELFNOSEG), gRunAxfHiiHandle);\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  // Return the entry point specified in the ELF header.\r
  *EntryPoint = (void*)ElfHdr->e_entry;\r
\r
  return EFI_SUCCESS;\r
}\r