UefiPayloadPkg: Add PayloadLoaderPeim which can load ELF payload

[mirror_edk2.git] / UefiPayloadPkg / PayloadLoaderPeim / ElfLib / Elf32Lib.c

/** @file\r
  ELF library\r
\r
  Copyright (c) 2019 - 2021, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "ElfLibInternal.h"\r
\r
/**\r
  Return the section header specified by Index.\r
\r
  @param ImageBase      The image base.\r
  @param Index          The section index.\r
\r
  @return Pointer to the section header.\r
**/\r
Elf32_Shdr *\r
GetElf32SectionByIndex (\r
  IN  UINT8                 *ImageBase,\r
  IN  UINT32                Index\r
  )\r
{\r
  Elf32_Ehdr        *Ehdr;\r
\r
  Ehdr  = (Elf32_Ehdr *)ImageBase;\r
  if (Index >= Ehdr->e_shnum) {\r
    return NULL;\r
  }\r
\r
  return (Elf32_Shdr *)(ImageBase + Ehdr->e_shoff + Index * Ehdr->e_shentsize);\r
}\r
\r
/**\r
  Return the segment header specified by Index.\r
\r
  @param ImageBase      The image base.\r
  @param Index          The segment index.\r
\r
  @return Pointer to the segment header.\r
**/\r
Elf32_Phdr *\r
GetElf32SegmentByIndex (\r
  IN  UINT8                 *ImageBase,\r
  IN  UINT32                Index\r
  )\r
{\r
  Elf32_Ehdr        *Ehdr;\r
\r
  Ehdr  = (Elf32_Ehdr *)ImageBase;\r
  if (Index >= Ehdr->e_phnum) {\r
    return NULL;\r
  }\r
\r
  return (Elf32_Phdr *)(ImageBase + Ehdr->e_phoff + Index * Ehdr->e_phentsize);\r
}\r
\r
/**\r
  Return the section header specified by the range.\r
\r
  @param ImageBase      The image base.\r
  @param Offset         The section offset.\r
  @param Size           The section size.\r
\r
  @return Pointer to the section header.\r
**/\r
Elf32_Shdr *\r
GetElf32SectionByRange (\r
  IN  UINT8                 *ImageBase,\r
  IN  UINT32                Offset,\r
  IN  UINT32                Size\r
  )\r
{\r
  UINT32                    Index;\r
  Elf32_Ehdr                *Ehdr;\r
  Elf32_Shdr                *Shdr;\r
\r
  Ehdr = (Elf32_Ehdr *)ImageBase;\r
\r
  Shdr = (Elf32_Shdr *) (ImageBase + Ehdr->e_shoff);\r
  for (Index = 0; Index < Ehdr->e_shnum; Index++) {\r
    if ((Shdr->sh_offset == Offset) && (Shdr->sh_size == Size)) {\r
      return Shdr;\r
    }\r
    Shdr = ELF_NEXT_ENTRY (Elf32_Shdr, Shdr, Ehdr->e_shentsize);\r
  }\r
  return NULL;\r
}\r
\r
/**\r
  Fix up the image based on the relocation entries.\r
\r
  @param Rela                Relocation entries.\r
  @param RelaSize            Total size of relocation entries.\r
  @param RelaEntrySize       Relocation entry size.\r
  @param RelaType            Type of relocation entry.\r
  @param Delta               The delta between preferred image base and the actual image base.\r
  @param DynamicLinking      TRUE when fixing up according to dynamic relocation.\r
\r
  @retval EFI_SUCCESS   The image fix up is processed successfully.\r
**/\r
EFI_STATUS\r
ProcessRelocation32 (\r
  IN  Elf32_Rela            *Rela,\r
  IN  UINT32                RelaSize,\r
  IN  UINT32                RelaEntrySize,\r
  IN  UINT32                RelaType,\r
  IN  INTN                  Delta,\r
  IN  BOOLEAN               DynamicLinking\r
  )\r
{\r
  UINTN                     Index;\r
  UINT32                    *Ptr;\r
  UINT32                    Type;\r
\r
  for ( Index = 0\r
      ; RelaEntrySize * Index < RelaSize\r
      ; Index++, Rela = ELF_NEXT_ENTRY (Elf32_Rela, Rela, RelaEntrySize)\r
      ) {\r
    //\r
    // r_offset is the virtual address of the storage unit affected by the relocation.\r
    //\r
    Ptr = (UINT32 *)(UINTN)(Rela->r_offset + Delta);\r
    Type  = ELF32_R_TYPE(Rela->r_info);\r
    switch (Type) {\r
      case R_386_NONE:\r
      case R_386_PC32:\r
        //\r
        // No fixup entry required.\r
        //\r
        break;\r
\r
      case R_386_32:\r
        if (DynamicLinking) {\r
          //\r
          // Dynamic section doesn't contain entries of this type.\r
          //\r
          DEBUG ((DEBUG_INFO, "Unsupported relocation type %02X\n", Type));\r
          ASSERT (FALSE);\r
        } else {\r
          *Ptr += (UINT32) Delta;\r
        }\r
        break;\r
\r
      case R_386_RELATIVE:\r
        if (DynamicLinking) {\r
          //\r
          // A: Represents the addend used to compute the value of the relocatable field.\r
          // B: Represents the base address at which a shared object has been loaded into memory during execution.\r
          //    Generally, a shared object is built with a 0 base virtual address, but the execution address will be different.\r
          //\r
          // B (Base Address) in ELF spec is slightly different:\r
          //   An executable or shared object file's base address (on platforms that support the concept) is calculated during\r
          //   execution from three values: the virtual memory load address, the maximum page size, and the lowest virtual address\r
          //   of a program's loadable segment. To compute the base address, one determines the memory address associated with the\r
          //   lowest p_vaddr value for a PT_LOAD segment. This address is truncated to the nearest multiple of the maximum page size.\r
          //   The corresponding p_vaddr value itself is also truncated to the nearest multiple of the maximum page size.\r
          //\r
          //   *** The base address is the difference between the truncated memory address and the truncated p_vaddr value. ***\r
          //\r
          // Delta in this function is B.\r
          //\r
          // Calculation: B + A\r
          //\r
          if (RelaType == SHT_RELA) {\r
            ASSERT (*Ptr == 0);\r
            *Ptr = (UINT32) Delta + Rela->r_addend;\r
          } else {\r
            //\r
            // A is stored in the field of relocation for REL type.\r
            //\r
            *Ptr = (UINT32) Delta + *Ptr;\r
          }\r
        } else {\r
          //\r
          // non-Dynamic section doesn't contain entries of this type.\r
          //\r
          DEBUG ((DEBUG_INFO, "Unsupported relocation type %02X\n", Type));\r
          ASSERT (FALSE);\r
        }\r
        break;\r
\r
      default:\r
        DEBUG ((DEBUG_INFO, "Unsupported relocation type %02X\n", Type));\r
    }\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Relocate the DYN type image.\r
\r
  @param ElfCt                Point to image context.\r
\r
  @retval EFI_SUCCESS      The relocation succeeds.\r
  @retval EFI_UNSUPPORTED  The image doesn't contain a dynamic section.\r
**/\r
EFI_STATUS\r
RelocateElf32Dynamic (\r
  IN    ELF_IMAGE_CONTEXT      *ElfCt\r
  )\r
{\r
  UINT32                       Index;\r
  Elf32_Phdr                   *Phdr;\r
  Elf32_Shdr                   *DynShdr;\r
  Elf32_Shdr                   *RelShdr;\r
  Elf32_Dyn                    *Dyn;\r
  UINT32                       RelaOffset;\r
  UINT32                       RelaCount;\r
  UINT32                       RelaSize;\r
  UINT32                       RelaEntrySize;\r
  UINT32                       RelaType;\r
\r
  //\r
  // 1. Locate the dynamic section.\r
  //\r
  // If an object file participates in dynamic linking, its program header table\r
  // will have an element of type PT_DYNAMIC.\r
  // This ``segment'' contains the .dynamic section. A special symbol, _DYNAMIC,\r
  // labels the section, which contains an array of Elf32_Dyn or Elf64_Dyn.\r
  //\r
  DynShdr = NULL;\r
  for (Index = 0; Index < ElfCt->PhNum; Index++) {\r
    Phdr = GetElf32SegmentByIndex (ElfCt->FileBase, Index);\r
    ASSERT (Phdr != NULL);\r
    if (Phdr->p_type == PT_DYNAMIC) {\r
      //\r
      // Verify the existence of the dynamic section.\r
      //\r
      DynShdr = GetElf32SectionByRange (ElfCt->FileBase, Phdr->p_offset, Phdr->p_filesz);\r
      break;\r
    }\r
  }\r
\r
  //\r
  // It's abnormal a DYN ELF doesn't contain a dynamic section.\r
  //\r
  ASSERT (DynShdr != NULL);\r
  if (DynShdr == NULL) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  ASSERT (DynShdr->sh_type == SHT_DYNAMIC);\r
  ASSERT (DynShdr->sh_entsize >= sizeof (*Dyn));\r
\r
  //\r
  // 2. Locate the relocation section from the dynamic section.\r
  //\r
  RelaOffset    = MAX_UINT32;\r
  RelaSize      = 0;\r
  RelaCount     = 0;\r
  RelaEntrySize = 0;\r
  RelaType      = 0;\r
  for ( Index = 0, Dyn = (Elf32_Dyn *) (ElfCt->FileBase + DynShdr->sh_offset)\r
      ; Index < DynShdr->sh_size / DynShdr->sh_entsize\r
      ; Index++, Dyn = ELF_NEXT_ENTRY (Elf32_Dyn, Dyn, DynShdr->sh_entsize)\r
      ) {\r
    switch (Dyn->d_tag) {\r
      case DT_RELA:\r
      case DT_REL:\r
        //\r
        // DT_REL represent program virtual addresses.\r
        // A file's virtual addresses might not match the memory virtual addresses during execution.\r
        // When interpreting addresses contained in the dynamic structure, the dynamic linker computes actual addresses,\r
        // based on the original file value and the memory base address.\r
        // For consistency, files do not contain relocation entries to ``correct'' addresses in the dynamic structure.\r
        //\r
        RelaOffset = Dyn->d_un.d_ptr - (UINT32) (UINTN) ElfCt->PreferredImageAddress;\r
        RelaType   = (Dyn->d_tag == DT_RELA) ? SHT_RELA: SHT_REL;\r
        break;\r
      case DT_RELACOUNT:\r
      case DT_RELCOUNT:\r
        RelaCount = Dyn->d_un.d_val;\r
        break;\r
      case DT_RELENT:\r
      case DT_RELAENT:\r
        RelaEntrySize = Dyn->d_un.d_val;\r
        break;\r
      case DT_RELSZ:\r
      case DT_RELASZ:\r
        RelaSize = Dyn->d_un.d_val;\r
        break;\r
      default:\r
        break;\r
    }\r
  }\r
\r
  if (RelaOffset == MAX_UINT64) {\r
    ASSERT (RelaCount     == 0);\r
    ASSERT (RelaEntrySize == 0);\r
    ASSERT (RelaSize      == 0);\r
    //\r
    // It's fine that a DYN ELF doesn't contain relocation section.\r
    //\r
    return EFI_SUCCESS;\r
  }\r
\r
  //\r
  // Verify the existence of the relocation section.\r
  //\r
  RelShdr = GetElf32SectionByRange (ElfCt->FileBase, RelaOffset, RelaSize);\r
  ASSERT (RelShdr != NULL);\r
  if (RelShdr == NULL) {\r
    return EFI_UNSUPPORTED;\r
  }\r
  ASSERT (RelShdr->sh_type == RelaType);\r
  ASSERT (RelShdr->sh_entsize == RelaEntrySize);\r
\r
  //\r
  // 3. Process the relocation section.\r
  //\r
  ProcessRelocation32 (\r
    (Elf32_Rela *) (ElfCt->FileBase + RelShdr->sh_offset),\r
    RelShdr->sh_size, RelShdr->sh_entsize, RelShdr->sh_type,\r
    (UINTN) ElfCt->ImageAddress - (UINTN) ElfCt->PreferredImageAddress,\r
    TRUE\r
    );\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Relocate all sections in a ELF image.\r
\r
  @param[in]  ElfCt               ELF image context pointer.\r
\r
  @retval EFI_UNSUPPORTED         Relocation is not supported.\r
  @retval EFI_SUCCESS             ELF image was relocated successfully.\r
**/\r
EFI_STATUS\r
RelocateElf32Sections  (\r
  IN    ELF_IMAGE_CONTEXT      *ElfCt\r
  )\r
{\r
  EFI_STATUS       Status;\r
  Elf32_Ehdr      *Ehdr;\r
  Elf32_Shdr      *RelShdr;\r
  Elf32_Shdr      *Shdr;\r
  UINT32           Index;\r
  UINTN            Delta;\r
\r
  Ehdr  = (Elf32_Ehdr *)ElfCt->FileBase;\r
  if (Ehdr->e_machine != EM_386) {\r
    return EFI_UNSUPPORTED;\r
  }\r
\r
  Delta = (UINTN) ElfCt->ImageAddress - (UINTN) ElfCt->PreferredImageAddress;\r
  ElfCt->EntryPoint = (UINTN)(Ehdr->e_entry + Delta);\r
\r
  //\r
  // 1. Relocate dynamic ELF using the relocation section pointed by dynamic section\r
  //\r
  if (Ehdr->e_type == ET_DYN) {\r
    DEBUG ((DEBUG_INFO, "DYN ELF: Relocate using dynamic sections...\n"));\r
    Status = RelocateElf32Dynamic (ElfCt);\r
    ASSERT_EFI_ERROR (Status);\r
    return Status;\r
  }\r
\r
  //\r
  // 2. Executable ELF: Fix up the delta between actual image address and preferred image address.\r
  //\r
  //  Linker already fixed up EXEC ELF based on the preferred image address.\r
  //  A ELF loader in modern OS only loads it into the preferred image address.\r
  //  The below relocation is unneeded in that case.\r
  //  But the ELF loader in firmware supports to load the image to a different address.\r
  //  The below relocation is needed in this case.\r
  //\r
  DEBUG ((DEBUG_INFO, "EXEC ELF: Fix actual/preferred base address delta ...\n"));\r
  for ( Index = 0, RelShdr = (Elf32_Shdr *) (ElfCt->FileBase + Ehdr->e_shoff)\r
      ; Index < Ehdr->e_shnum\r
      ; Index++,   RelShdr = ELF_NEXT_ENTRY (Elf32_Shdr, RelShdr, Ehdr->e_shentsize)\r
      ) {\r
    if ((RelShdr->sh_type != SHT_REL) && (RelShdr->sh_type != SHT_RELA)) {\r
      continue;\r
    }\r
    Shdr = GetElf32SectionByIndex (ElfCt->FileBase, RelShdr->sh_info);\r
    if ((Shdr->sh_flags & SHF_ALLOC) == SHF_ALLOC) {\r
      //\r
      // Only fix up sections that occupy memory during process execution.\r
      //\r
      ProcessRelocation32 (\r
        (Elf32_Rela *)((UINT8*)Ehdr + RelShdr->sh_offset),\r
        RelShdr->sh_size, RelShdr->sh_entsize, RelShdr->sh_type,\r
        Delta, FALSE\r
        );\r
    }\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
/**\r
  Load ELF image which has 32-bit architecture.\r
\r
  Caller should set Context.ImageAddress to a proper value, either pointing to\r
  a new allocated memory whose size equal to Context.ImageSize, or pointing\r
  to Context.PreferredImageAddress.\r
\r
  @param[in]  ElfCt               ELF image context pointer.\r
\r
  @retval EFI_SUCCESS         ELF binary is loaded successfully.\r
  @retval Others              Loading ELF binary fails.\r
\r
**/\r
EFI_STATUS\r
LoadElf32Image (\r
  IN    ELF_IMAGE_CONTEXT    *ElfCt\r
  )\r
{\r
  Elf32_Ehdr    *Ehdr;\r
  Elf32_Phdr    *Phdr;\r
  UINT16        Index;\r
  UINTN         Delta;\r
\r
  ASSERT (ElfCt != NULL);\r
\r
  //\r
  // Per the sprit of ELF, loading to memory only consumes info from program headers.\r
  //\r
  Ehdr = (Elf32_Ehdr *)ElfCt->FileBase;\r
\r
  for ( Index = 0, Phdr = (Elf32_Phdr *)(ElfCt->FileBase + Ehdr->e_phoff)\r
      ; Index < Ehdr->e_phnum\r
      ; Index++, Phdr = ELF_NEXT_ENTRY (Elf32_Phdr, Phdr, Ehdr->e_phentsize)\r
      ) {\r
    //\r
    // Skip segments that don't require load (type tells, or size is 0)\r
    //\r
    if ((Phdr->p_type != PT_LOAD) ||\r
        (Phdr->p_memsz == 0)) {\r
      continue;\r
    }\r
\r
    //\r
    // The memory offset of segment relative to the image base\r
    // Note: CopyMem() does nothing when the dst equals to src.\r
    //\r
    Delta = Phdr->p_paddr - (UINT32) (UINTN) ElfCt->PreferredImageAddress;\r
    CopyMem (ElfCt->ImageAddress + Delta, ElfCt->FileBase + Phdr->p_offset, Phdr->p_filesz);\r
    ZeroMem (ElfCt->ImageAddress + Delta + Phdr->p_filesz, Phdr->p_memsz - Phdr->p_filesz);\r
  }\r
\r
  //\r
  // Relocate when new new image base is not the preferred image base.\r
  //\r
  if (ElfCt->ImageAddress != ElfCt->PreferredImageAddress) {\r
    RelocateElf32Sections (ElfCt);\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r