Elf.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef KERNEL_LINKER_ELF_H
#define KERNEL_LINKER_ELF_H
#include <config.h>
 
#ifdef IN_PEDIGREE_KERNEL
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/new"
#endif
 
#include "pedigree/kernel/linker/SymbolTable.h"
#include "pedigree/kernel/utilities/List.h"
 
#ifdef VERBOSE_LINKER
#define DEBUG NOTICE
#else
#define DEBUG(...)
#endif
 
// Object file types
#define ET_NONE 0x0
#define ET_REL 0x1
#define ET_EXEC 0x2
#define ET_DYN 0x3
#define ET_CORE 0x4
 
// Section header types - common to Elf32 and Elf64.
#define SHT_PROGBITS 0x1  // The data is contained in the program file.
#define SHT_SYMTAB 0x2    // Symbol table
#define SHT_STRTAB 0x3    // String table
#define SHT_RELA 0x4
#define SHT_HASH 0x5     // Symbol hash table
#define SHT_DYNAMIC 0x6  // Dynamic linking information
#define SHT_NOTE 0x7
#define SHT_NOBITS 0x8  // The data is not contained in the program file.
#define SHT_REL 0x9
#define SHT_DYNSYM 0xb
#define SHT_INIT_ARRAY 0xe
#define SHT_FINI_ARRAY 0xf
#define SHT_PREINIT_ARRAY 0x10
 
// Section header flags - common to Elf32 and Elf64.
#define SHF_WRITE 0x1
#define SHF_ALLOC 0x2
#define SHF_EXECINSTR 0x4
#define SHF_MASKPROC 0xf0000000
 
// Program header flags - common to Elf32 and Elf64.
#define PF_X 0x1
#define PF_W 0x2
#define PF_R 0x4
 
// Process header flags - common to Elf32 and Elf64.
#define PT_NULL 0    /* Program header table entry unused */
#define PT_LOAD 1    /* Loadable program segment */
#define PT_DYNAMIC 2 /* Dynamic linking information */
#define PT_INTERP 3  /* Program interpreter */
#define PT_NOTE 4    /* Auxiliary information */
#define PT_SHLIB 5   /* Reserved */
#define PT_PHDR 6    /* Entry for header table itself */
#define PT_TLS 7     /* Thread-local storage segment */
#define PT_NUM 8     /* Number of defined types */
 
// Dynamic table flags - common to Elf32 and Elf64.
#define DT_NULL 0             /* Marks end of dynamic section */
#define DT_NEEDED 1           /* Name of needed library */
#define DT_PLTRELSZ 2         /* Size in bytes of PLT relocs */
#define DT_PLTGOT 3           /* Processor defined value */
#define DT_HASH 4             /* Address of symbol hash table */
#define DT_STRTAB 5           /* Address of string table */
#define DT_SYMTAB 6           /* Address of symbol table */
#define DT_RELA 7             /* Address of Rela relocs */
#define DT_RELASZ 8           /* Total size of Rela relocs */
#define DT_RELAENT 9          /* Size of one Rela reloc */
#define DT_STRSZ 10           /* Size of string table */
#define DT_SYMENT 11          /* Size of one symbol table entry */
#define DT_INIT 12            /* Address of init function */
#define DT_FINI 13            /* Address of termination function */
#define DT_SONAME 14          /* Name of shared object */
#define DT_RPATH 15           /* Library search path (deprecated) */
#define DT_SYMBOLIC 16        /* Start symbol search here */
#define DT_REL 17             /* Address of Rel relocs */
#define DT_RELSZ 18           /* Total size of Rel relocs */
#define DT_RELENT 19          /* Size of one Rel reloc */
#define DT_PLTREL 20          /* Type of reloc in PLT */
#define DT_DEBUG 21           /* For debugging; unspecified */
#define DT_TEXTREL 22         /* Reloc might modify .text */
#define DT_JMPREL 23          /* Address of PLT relocs */
#define DT_BIND_NOW 24        /* Process relocations of object */
#define DT_INIT_ARRAY 25      /* Array with addresses of init fct */
#define DT_FINI_ARRAY 26      /* Array with addresses of fini fct */
#define DT_INIT_ARRAYSZ 27    /* Size in bytes of DT_INIT_ARRAY */
#define DT_FINI_ARRAYSZ 28    /* Size in bytes of DT_FINI_ARRAY */
#define DT_RUNPATH 29         /* Library search path */
#define DT_FLAGS 30           /* Flags for the object being loaded */
#define DT_ENCODING 32        /* Start of encoded range */
#define DT_PREINIT_ARRAY 32   /* Array with addresses of preinit fct*/
#define DT_PREINIT_ARRAYSZ 33 /* size in bytes of DT_PREINIT_ARRAY */
 
// Symbol types
#define STT_NOTYPE 0
#define STT_OBJECT 1
#define STT_FUNC 2
#define STT_SECTION 3
#define STT_FILE 4
#define STT_COMMON 5
#define STT_TLS 6
 
// Symbol bindings
#define STB_LOCAL 0
#define STB_GLOBAL 1
#define STB_WEAK 2
 
// Symbol visibilities
#define STV_DEFAULT 0
#define STV_INTERNAL 1
#define STV_HIDDEN 2
#define STV_PROTECTED 3
 
#if BITS_32
 
#define R_SYM(val) ((val) >> 8)
#define R_TYPE(val) ((val) & 0xff)
 
#define ST_BIND(i) ((i) >> 4)
#define ST_TYPE(i) ((i) & 0xf)
#define ST_INFO(b, t) (((b) << 4) + ((t) & 0xf))
 
typedef uint32_t Elf_Addr;
typedef uint32_t Elf_Off;
typedef uint16_t Elf_Half;
typedef uint32_t Elf_Word;
typedef int32_t Elf_Sword;
 
// We define the Xword and Sxword types for ELF32 even though they don't exist
// in the spec for forwards compatibility with ELF64.
typedef uint32_t Elf_Xword;
typedef int32_t Elf_Sxword;
 
#elif BITS_64
 
#define R_SYM(val) ((val) >> 32)
#define R_TYPE(val) ((val) & 0xffffffffUL)
 
#define ST_BIND(i) ((i) >> 4)
#define ST_TYPE(i) ((i) & 0xf)
#define ST_INFO(b, t) (((b) << 4) + ((t) & 0xf))
 
typedef uint64_t Elf_Addr;
typedef uint64_t Elf_Off;
typedef uint16_t Elf_Half;
typedef uint32_t Elf_Word;
typedef int32_t Elf_Sword;
typedef uint64_t Elf_Xword;
typedef int64_t Elf_Sxword;
 
// Compatibility types for 64-bit kernel, which is actually a 32-bit ELF.
typedef uint32_t Elf32_Addr;
typedef uint32_t Elf32_Off;
typedef uint16_t Elf32_Half;
typedef uint32_t Elf32_Word;
typedef int32_t Elf32_Sword;
typedef uint32_t Elf32_Xword;
typedef int32_t Elf32_Sxword;
 
#endif
 
// Is the symbol type OK to add to the symbol table?
#define ST_TYPEOK(x) (ST_TYPE((x)) <= STT_FUNC)
 
#ifndef _NO_ELF_CLASS
 
class EXPORTED_PUBLIC Elf {
  // PosixSubsystem can use memory mapped files to do its own (very basic)
  // ELF loading, which is an improvement on load()'s copies.
  friend class PosixSubsystem;
  friend class ModuleImage;
 
 protected:
  // Forward declaration of ELF symbol type for lookupSymbol template.
  struct ElfSymbol_t;
 
 public:
  enum class ExecutableValidationResult {
    Valid,
    Malformed,
    WrongArchitecture,
    UnsupportedType,
    UnsupportedLayout,
    MultipleInterpreters,
  };
 
  struct ExecutableMetadata {
    Elf_Half type;
    uintptr_t entryPoint;
    size_t programHeaderOffset;
    size_t programHeaderCount;
    size_t programHeaderSize;
    uintptr_t loadStart;
    uintptr_t loadEnd;
    size_t interpreterOffset;
    size_t interpreterSize;
    bool hasInterpreter;
  };
 
  static constexpr size_t MaximumProgramHeaderTableSize = 65536;
  static constexpr size_t MaximumInterpreterSize = 4096;
 
  Elf();
 
  virtual ~Elf();
 
  Elf(const Elf&);
 
  bool validate(uint8_t* pBuffer, size_t length);
 
  static ExecutableValidationResult validateExecutableHeader(const uint8_t* pBuffer, size_t length,
                                                             size_t fileSize,
                                                             ExecutableMetadata& metadata);
 
  static ExecutableValidationResult validateExecutableProgramHeaders(const uint8_t* pBuffer,
                                                                     size_t length, size_t fileSize,
                                                                     ExecutableMetadata& metadata);
 
  static ExecutableValidationResult validateExecutableInterpreter(
      const uint8_t* pBuffer, size_t length, const ExecutableMetadata& metadata);
 
  bool create(uint8_t* pBuffer, size_t length);
 
  bool createNeededOnly(uint8_t* pBuffer, size_t length);
 
  bool loadModule(uint8_t* pBuffer, size_t length, uintptr_t& loadBase, size_t& loadSize,
                  SymbolTable* pSymbolTableCopy = 0);
 
  bool finaliseModule(uint8_t* pBuffer, size_t length);
 
  bool allocate(uint8_t* pBuffer, size_t length, uintptr_t& loadBase, SymbolTable* pSymtab = 0,
                bool bAllocate = true, size_t* pSize = 0);
 
  bool load(uint8_t* pBuffer, size_t length, uintptr_t loadBase, SymbolTable* pSymtab = 0,
            uintptr_t nStart = 0, uintptr_t nEnd = ~0, bool relocate = true,
            uintptr_t destinationBase = 0);
 
  static bool extractEntryPoint(uint8_t* pBuffer, size_t length, uintptr_t& entry);
 
  static bool extractInformation(uint8_t* pBuffer, size_t length, size_t& phdrCount,
                                 size_t& phdrEntrySize, uintptr_t& phdrAddress);
 
  List<char*>& neededLibraries();
 
  String& getInterpreter();
 
  uintptr_t getLastAddress();
 
  uintptr_t getInitFunc() {
    return m_InitFunc;
  }
  uintptr_t getFiniFunc() {
    return m_FiniFunc;
  }
 
  template <class T = ElfSymbol_t>
  const char* lookupSymbol(uintptr_t addr, uintptr_t* startAddr, T* symbolTable);
 
  const char* lookupSymbol(uintptr_t addr, uintptr_t* startAddr);
 
  uintptr_t lookupSymbol(const char* pName);
 
  uintptr_t lookupDynamicSymbolAddress(const char* str, uintptr_t loadBase);
 
  uintptr_t applySpecificRelocation(uintptr_t off, SymbolTable* pSymtab, uintptr_t loadBase,
                                    SymbolTable::Policy policy = SymbolTable::LocalFirst);
 
  uintptr_t getGlobalOffsetTable();
 
  size_t getPltSize();
 
  void populateSymbolTable(SymbolTable* pSymtab, uintptr_t loadBase);
 
  void preallocateSymbols(SymbolTable* pSymtabOverride = nullptr,
                          SymbolTable* pAdditionalSymtab = nullptr);
 
  SymbolTable* getSymbolTable() {
    return &m_SymbolTable;
  }
 
  uintptr_t getEntryPoint();
 
  uintptr_t debugFrameTable();
  uintptr_t debugFrameTableLength();
 
  void setName(const String& s) {
    m_Name.assign(s);
  }
 
  const String& getName() const {
    return m_Name;
  }
 
 protected:
#endif
  struct ElfHeader_t {
    uint8_t ident[16];
    Elf_Half type;
    Elf_Half machine;
    Elf_Word version;
    Elf_Addr entry;
    Elf_Off phoff;
    Elf_Off shoff;
    Elf_Word flags;
    Elf_Half ehsize;
    Elf_Half phentsize;
    Elf_Half phnum;
    Elf_Half shentsize;
    Elf_Half shnum;
    Elf_Half shstrndx;
  } PACKED;
 
  struct ElfProgramHeader_t {
    Elf_Word type;
#if BITS_64
    Elf_Word flags;
#endif
    Elf_Off offset;
    Elf_Addr vaddr;
    Elf_Addr paddr;
    Elf_Xword filesz;
    Elf_Xword memsz;
#if !BITS_64
    Elf_Word flags;
#endif
    Elf_Xword align;
  } PACKED;
 
  struct ElfSectionHeader_t {
    Elf_Word name;
    Elf_Word type;
    Elf_Xword flags;
    Elf_Addr addr;
    Elf_Off offset;
    Elf_Xword size;
    Elf_Word link;
    Elf_Word info;
    Elf_Xword addralign;
    Elf_Xword entsize;
  } PACKED;
 
#if BITS_64
  struct Elf32SectionHeader_t {
    Elf32_Word name;
    Elf32_Word type;
    Elf32_Xword flags;
    Elf32_Addr addr;
    Elf32_Off offset;
    Elf32_Xword size;
    Elf32_Word link;
    Elf32_Word info;
    Elf32_Xword addralign;
    Elf32_Xword entsize;
  } PACKED;
#else
typedef ElfSectionHeader_t Elf32SectionHeader_t;
#endif
 
  struct ElfSymbol_t {
    Elf_Word name;
#if BITS_64
    uint8_t info;
    uint8_t other;
    Elf_Half shndx;
#endif
    Elf_Addr value;
    Elf_Xword size;
#if !BITS_64
    uint8_t info;
    uint8_t other;
    Elf_Half shndx;
#endif
  } PACKED;
 
#if BITS_64
  struct Elf32Symbol_t {
    Elf32_Word name;
    Elf32_Addr value;
    Elf32_Xword size;
    uint8_t info;
    uint8_t other;
    Elf32_Half shndx;
  } PACKED;
#else
typedef ElfSymbol_t Elf32Symbol_t;
#endif
 
  struct ElfHash_t {
    Elf_Word nbucket;
    Elf_Word nchain;
    // buckets follow
    // chains follow
  };
 
  struct ElfDyn_t {
    Elf_Sxword tag;
    union {
      Elf_Xword val;
      Elf_Addr ptr;
    } un;
  } PACKED;
 
  struct ElfRel_t {
    Elf_Addr offset;
    Elf_Xword info;
  } PACKED;
 
  struct ElfRela_t {
    Elf_Addr offset;
    Elf_Xword info;
    Elf_Sxword addend;
  } PACKED;
 
#ifndef _NO_ELF_CLASS
 private:
  template <typename T>
  static T* elfCopy(uint8_t*, ElfProgramHeader_t*, size_t, T*, size_t);
 
  bool relocate(uint8_t* pBuffer, uintptr_t length);
  bool relocateModinfo(uint8_t* pBuffer, uintptr_t length);
 
  bool applyRelocation(ElfRel_t rel, ElfSectionHeader_t* pSh, SymbolTable* pSymtab = 0,
                       uintptr_t loadBase = 0, SymbolTable::Policy policy = SymbolTable::LocalFirst,
                       uintptr_t destinationAddress = 0, uintptr_t destinationEnd = 0);
 
  bool applyRelocation(ElfRela_t rela, ElfSectionHeader_t* pSh, SymbolTable* pSymtab = 0,
                       uintptr_t loadBase = 0, SymbolTable::Policy policy = SymbolTable::LocalFirst,
                       uintptr_t destinationAddress = 0, uintptr_t destinationEnd = 0);
 
#if ARMV7
  bool applyArmRelocation(Elf_Word type, Elf_Word symbolIndex, uintptr_t offset, intptr_t addend,
                          ElfSectionHeader_t* section, SymbolTable* symbols, uintptr_t loadBase,
                          SymbolTable::Policy policy, uintptr_t destinationAddress,
                          uintptr_t destinationEnd);
#endif
 
  void rebaseDynamic();
 
 protected:
  ElfSymbol_t* m_pSymbolTable;
  size_t m_nSymbolTableSize;
  char* m_pStringTable;
  size_t m_nStringTableSize;
  char* m_pShstrtab;
  size_t m_nShstrtabSize;
  uintptr_t* m_pGotTable;   // Global offset table.
  ElfRel_t* m_pRelTable;    // Dynamic REL relocations.
  ElfRela_t* m_pRelaTable;  // Dynamic RELA relocations.
  size_t m_nRelTableSize;
  size_t m_nRelaTableSize;
  ElfRel_t* m_pPltRelTable;
  ElfRela_t* m_pPltRelaTable;
  bool m_bUsesRela;  // If PltRelaTable is valid, else PltRelTable is.
  uint32_t* m_pDebugTable;
  size_t m_nDebugTableSize;
  ElfSymbol_t* m_pDynamicSymbolTable;
  size_t m_nDynamicSymbolTableSize;
  char* m_pDynamicStringTable;
  size_t m_nDynamicStringTableSize;
  ElfSectionHeader_t* m_pSectionHeaders;
  size_t m_nSectionHeaders;
  ElfProgramHeader_t* m_pProgramHeaders;
  size_t m_nProgramHeaders;
  size_t m_nPltSize;
  uintptr_t m_nEntry;
  List<char*> m_NeededLibraries;
  SymbolTable m_SymbolTable;
  uintptr_t m_InitFunc;
  uintptr_t m_FiniFunc;
  String m_sInterpreter;
 
  String m_Name;
  uintptr_t m_LoadBase;
 
 private:
  Elf& operator=(const Elf&);
};
 
extern template const char* Elf::lookupSymbol<Elf::ElfSymbol_t>(uintptr_t addr,
                                                                uintptr_t* startAddr = 0,
                                                                ElfSymbol_t* symbolTable = 0);
#if BITS_64
extern template const char* Elf::lookupSymbol<Elf::Elf32Symbol_t>(uintptr_t addr,
                                                                  uintptr_t* startAddr = 0,
                                                                  Elf32Symbol_t* symbolTable = 0);
#endif
 
#endif
 
#endif