ldrELFRelocatable.cpp.h revision 744d9da095880c872fc130e158ab664bc6526cfa
/* $Id$ */
/** @file
* IPRT - Binary Image Loader, Template for ELF Relocatable Images.
*/
/*
* Copyright (C) 2006-2007 Sun Microsystems, Inc.
*
* This file is part of VirtualBox Open Source Edition (OSE), as
* available from http://www.virtualbox.org. This file is free software;
* General Public License (GPL) as published by the Free Software
* Foundation, in version 2 as it comes in the "COPYING" file of the
* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
*
* The contents of this file may alternatively be used under the terms
* of the Common Development and Distribution License Version 1.0
* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
* VirtualBox OSE distribution, in which case the provisions of the
* CDDL are applicable instead of those of the GPL.
*
* You may elect to license modified versions of this file under the
* terms and conditions of either the GPL or the CDDL or both.
*
* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
* Clara, CA 95054 USA or visit http://www.sun.com if you need
* additional information or have any questions.
*/
/*******************************************************************************
* Defined Constants And Macros *
*******************************************************************************/
#if ELF_MODE == 32
#define FMT_ELF_ADDR "%08RX32"
#define FMT_ELF_HALF "%04RX16"
#define FMT_ELF_OFF "%08RX32"
#define FMT_ELF_SIZE "%08RX32"
#define FMT_ELF_SWORD "%RI32"
#define FMT_ELF_WORD "%08RX32"
#define FMT_ELF_XWORD "%08RX32"
#define FMT_ELF_SXWORD "%RI32"
#define FMT_ELF_ADDR "%016RX64"
#define FMT_ELF_HALF "%04RX16"
#define FMT_ELF_SHALF "%RI16"
#define FMT_ELF_OFF "%016RX64"
#define FMT_ELF_SIZE "%016RX64"
#define FMT_ELF_SWORD "%RI32"
#define FMT_ELF_WORD "%08RX32"
#define FMT_ELF_XWORD "%016RX64"
#define FMT_ELF_SXWORD "%RI64"
#endif
/*******************************************************************************
* Structures and Typedefs *
*******************************************************************************/
/**
* The ELF loader structure.
*/
typedef struct RTLDRMODELF
{
/** Core module structure. */
/** Pointer to the reader instance. */
/** Pointer to readonly mapping of the image bits.
* This mapping is provided by the pReader. */
const void *pvBits;
/** The ELF header. */
/** Pointer to our copy of the section headers.
* The virtual addresses in this array is the 0 based assignments we've given the image.
* Not valid if the image is DONE. */
/** The size of the loaded image. */
/** The symbol section index. */
unsigned iSymSh;
/** Number of symbols in the table. */
unsigned cSyms;
/** Pointer to symbol table within RTLDRMODELF::pvBits. */
/** The string section index. */
unsigned iStrSh;
/** Size of the string table. */
unsigned cbStr;
/** Pointer to string table within RTLDRMODELF::pvBits. */
const char *pStr;
} RTLDRMODELF, *PRTLDRMODELF;
/**
* Maps the image bits into memory and resolve pointers into it.
*
* @returns iprt status code.
* @param pModElf The ELF loader module instance data.
* @param fNeedsBits Set if we actually need the pvBits member.
* If we don't, we can simply read the string and symbol sections, thus saving memory.
*/
{
return VINF_SUCCESS;
if (RT_SUCCESS(rc))
{
}
return rc;
}
/**
* Get the symbol and symbol value.
*
* @returns iprt status code.
* @param pModElf The ELF loader module instance data.
* @param BaseAddr The base address which the module is being fixedup to.
* @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
* @param pvUser User argument to pass to the callback.
* @param iSym The symbol to get.
* @param ppSym Where to store the symbol pointer on success. (read only)
* @param pSymValue Where to store the symbol value on success.
*/
static int RTLDRELF_NAME(Symbol)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
{
/*
* Validate and find the symbol.
*/
{
return VERR_LDRELF_INVALID_SYMBOL_INDEX;
}
{
}
/*
* Determin the symbol value.
*
* Symbols needs different treatment depending on which section their are in.
* Undefined and absolute symbols goes into special non-existing sections.
*/
{
/*
* Undefined symbol, needs resolving.
*
* Since ELF has no generic concept of importing from specific module (the OS/2 ELF format
* has but that's a OS extension and only applies to programs and dlls), we'll have to ask
* the resolver callback to do a global search.
*/
case SHN_UNDEF:
{
/* Try to resolve the symbol. */
if (RT_FAILURE(rc))
{
return rc;
}
{
return VERR_SYMBOL_VALUE_TOO_BIG;
}
break;
}
/*
* Absolute symbols needs no fixing since they are, well, absolute.
*/
case SHN_ABS:
break;
/*
* All other symbols are adressed relative to their section and need to be fixed up.
*/
default:
{
/* what about common symbols? */
("iSym=%d st_shndx=%d e_shnum=%d pszName=%s\n", iSym, pSym->st_shndx, pModElf->Ehdr.e_shnum, pszName));
return VERR_BAD_EXE_FORMAT;
}
break;
}
return VINF_SUCCESS;
}
/**
* Applies the fixups for a sections.
*
* @returns iprt status code.
* @param pModElf The ELF loader module instance data.
* @param BaseAddr The base address which the module is being fixedup to.
* @param pfnGetImport The callback function to use to resolve imports (aka unresolved externals).
* @param pvUser User argument to pass to the callback.
* @param SecAddr The section address. This is the address the relocations are relative to.
* @param cbSec The section size. The relocations must be inside this.
* @param pu8SecBaseR Where we read section bits from.
* @param pu8SecBaseW Where we write section bits to.
* @param pvRelocs Pointer to where we read the relocations from.
* @param cbRelocs Size of the relocations.
*/
static int RTLDRELF_NAME(RelocateSection)(PRTLDRMODELF pModElf, Elf_Addr BaseAddr, PFNRTLDRIMPORT pfnGetImport, void *pvUser,
{
/*
* Iterate the relocations.
* The relocations are stored in an array of Elf32_Rel records and covers the entire relocation section.
*/
AssertMsgReturn(iRelMax == cbRelocs / sizeof(paRels[0]), (FMT_ELF_SIZE "\n", cbRelocs / sizeof(paRels[0])), VERR_IMAGE_TOO_BIG);
{
/*
* Get the symbol.
*/
int rc = RTLDRELF_NAME(Symbol)(pModElf, BaseAddr, pfnGetImport, pvUser, ELF_R_SYM(paRels[iRel].r_info), &pSym, &SymValue);
if (RT_FAILURE(rc))
return rc;
/*
* Apply the fixup.
*/
AssertMsgReturn(paRels[iRel].r_offset < cbSec, (FMT_ELF_ADDR " " FMT_ELF_SIZE "\n", paRels[iRel].r_offset, cbSec), VERR_LDRELF_INVALID_RELOCATION_OFFSET);
#if ELF_MODE == 32
const Elf_Addr *pAddrR = (const Elf_Addr *)(pu8SecBaseR + paRels[iRel].r_offset); /* Where to read the addend. */
#endif
Elf_Addr *pAddrW = (Elf_Addr *)(pu8SecBaseW + paRels[iRel].r_offset); /* Where to write the fixup. */
{
#if ELF_MODE == 32
/*
* Absolute addressing.
*/
case R_386_32:
{
break;
}
/*
* PC relative addressing.
*/
case R_386_PC32:
{
const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
break;
}
/* ignore */
case R_386_NONE:
break;
/*
* Absolute addressing
*/
case R_X86_64_64:
{
break;
}
/*
* Trunacated 32-bit value (zero-extendedable to the 64-bit value).
*/
case R_X86_64_32:
{
AssertMsgReturn((Elf_Addr)*(uint32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG);
break;
}
/*
* Truncated 32-bit value (sign-extendedable to the 64-bit value).
*/
case R_X86_64_32S:
{
AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
break;
}
/*
* PC relative addressing.
*/
case R_X86_64_PC32:
{
const Elf_Addr SourceAddr = SecAddr + paRels[iRel].r_offset + BaseAddr; /* Where the source really is. */
AssertMsgReturn((Elf_Addr)*(int32_t *)pAddrW == Value, ("Value=" FMT_ELF_ADDR "\n", Value), VERR_SYMBOL_VALUE_TOO_BIG); /** @todo check the sign-extending here. */
break;
}
/* ignore */
case R_X86_64_NONE:
break;
#endif
default:
AssertMsgFailed(("Unknown relocation type: %d (iRel=%d iRelMax=%d)\n",
}
}
return VINF_SUCCESS;
}
/** @copydoc RTLDROPS::pfnClose */
{
{
}
{
}
return VINF_SUCCESS;
}
/** @copydoc RTLDROPS::Done */
{
//PRTLDRMODELF pModElf = (PRTLDRMODELF)pMod;
/** @todo Have to think more about this .... */
return -1;
}
/** @copydoc RTLDROPS::EnumSymbols */
static DECLCALLBACK(int) RTLDRELF_NAME(EnumSymbols)(PRTLDRMODINTERNAL pMod, unsigned fFlags, const void *pvBits, RTUINTPTR BaseAddress,
{
/*
* Validate the input.
*/
AssertMsgReturn((RTUINTPTR)BaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
/*
* Make sure we've got the string and symbol tables. (We don't need the pvBits.)
*/
if (RT_FAILURE(rc))
return rc;
/*
* Enumerate the symbol table.
*/
{
/*
* Skip imports (undefined).
*/
{
/*
* Calc value and get name.
*/
/* absolute symbols are not subject to any relocation. */
/* relative to the section. */
else
{
return VERR_BAD_EXE_FORMAT;
}
&& ( (fFlags & RTLDR_ENUM_SYMBOL_FLAGS_ALL)
)
{
/*
* Call back.
*/
if (rc)
return rc;
}
}
}
return VINF_SUCCESS;
}
/** @copydoc RTLDROPS::GetImageSize */
{
}
/** @copydoc RTLDROPS::GetBits */
static DECLCALLBACK(int) RTLDRELF_NAME(GetBits)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR BaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
{
/*
* Load the bits into pvBits.
*/
{
{
AssertMsgReturn((size_t)paShdrs[iShdr].sh_size == (size_t)paShdrs[iShdr].sh_size, (FMT_ELF_SIZE "\n", paShdrs[iShdr].sh_size), VERR_IMAGE_TOO_BIG);
{
case SHT_NOBITS:
break;
case SHT_PROGBITS:
default:
{
if (RT_FAILURE(rc))
{
return rc;
}
}
}
}
}
/*
* Relocate the image.
*/
return pModElf->Core.pOps->pfnRelocate(pMod, pvBits, BaseAddress, ~(RTUINTPTR)0, pfnGetImport, pvUser);
}
/** @copydoc RTLDROPS::Relocate */
static DECLCALLBACK(int) RTLDRELF_NAME(Relocate)(PRTLDRMODINTERNAL pMod, void *pvBits, RTUINTPTR NewBaseAddress, RTUINTPTR OldBaseAddress, PFNRTLDRIMPORT pfnGetImport, void *pvUser)
{
/*
* Validate the input.
*/
AssertMsgReturn((RTUINTPTR)BaseAddr == NewBaseAddress, ("#RTptr", NewBaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
/*
* Map the image bits if not already done and setup pointer into it.
*/
if (RT_FAILURE(rc))
return rc;
/*
* Iterate the sections looking for interesting SHT_REL[A] sections.
* SHT_REL[A] sections have the section index of the section they contain fixups
* for in the sh_info member.
*/
#ifdef LOG_ENABLED
#endif
{
/*
* Skip sections without interest to us.
*/
#if ELF_MODE == 32
#else
#endif
continue;
continue;
continue;
/*
* Relocate the section.
*/
Log2(("rtldrELF: %s: Relocation records for #%d [%s] (sh_info=%d sh_link=%d) found in #%d [%s] (sh_info=%d sh_link=%d)\n",
pszLogName, (int)pShdrRel->sh_info, ELF_STR(pModElf, pShdr->sh_name), (int)pShdr->sh_info, (int)pShdr->sh_link,
/** @todo Make RelocateSection a function pointer so we can select the one corresponding to the machine when opening the image. */
if (RT_FAILURE(rc))
return rc;
}
return VINF_SUCCESS;
}
/** @copydoc RTLDROPS::pfnGetSymbolEx */
static DECLCALLBACK(int) RTLDRELF_NAME(GetSymbolEx)(PRTLDRMODINTERNAL pMod, const void *pvBits, RTUINTPTR BaseAddress, const char *pszSymbol, RTUINTPTR *pValue)
{
/*
* Validate the input.
*/
AssertMsgReturn((RTUINTPTR)BaseAddr == BaseAddress, ("#RTptr", BaseAddress), VERR_IMAGE_BASE_TOO_HIGH);
/*
* Map the image bits if not already done and setup pointer into it.
*/
if (RT_FAILURE(rc))
return rc;
/*
* Calc all kinds of pointers before we start iterating the symbol table.
*/
{
/* Undefined symbols are not exports, they are imports. */
{
/* Validate the name string and try match with it. */
{
{
/* matched! */
/* absolute symbols are not subject to any relocation. */
/* relative to the section. */
else
{
return VERR_BAD_EXE_FORMAT;
}
return VINF_SUCCESS;
}
}
else
{
AssertMsgFailed(("String outside string table! iSym=%d paSyms[iSym].st_name=%#x\n", iSym, paSyms[iSym].st_name));
}
}
}
return VERR_SYMBOL_NOT_FOUND;
}
/**
* The ELF module operations.
*/
{
#if ELF_MODE == 32
"elf32",
"elf64",
#endif
NULL, /* Get Symbol */
/* ext: */
0
};
/**
* Validates the ELF header.
*
* @returns iprt status code.
* @param pEhdr Pointer to the ELF header.
* @param pszLogName The log name.
* @param cbRawImage The size of the raw image.
*/
static int RTLDRELF_NAME(ValidateElfHeader)(const Elf_Ehdr *pEhdr, const char *pszLogName, uint64_t cbRawImage, PRTLDRARCH penmArch)
{
Log3(("RTLdrELF: e_ident: %.*Rhxs\n"
)
{
Log(("RTLdrELF: %s: Invalid ELF magic (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident));
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: Invalid ELF class (%.*Rhxs)\n", pszLogName, sizeof(pEhdr->e_ident), pEhdr->e_ident));
return VERR_BAD_EXE_FORMAT;
}
{
return VERR_LDRELF_ODD_ENDIAN;
}
{
return VERR_LDRELF_VERSION;
}
{
Log(("RTLdrELF: %s: Elf header e_ehsize is %d expected %d!\n",
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: Elf header e_phentsize is %d expected %d!\n",
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: Elf header e_shentsize is %d expected %d!\n",
return VERR_BAD_EXE_FORMAT;
}
{
case ET_REL:
break;
case ET_EXEC:
return VERR_LDRELF_EXEC;
case ET_DYN:
return VERR_LDRELF_DYN;
default:
return VERR_BAD_EXE_FORMAT;
}
{
#if ELF_MODE == 32
case EM_386:
case EM_486:
break;
case EM_X86_64:
break;
#endif
default:
return VERR_LDRELF_MACHINE;
}
{
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: The program headers extends beyond the file! e_phoff=" FMT_ELF_OFF " e_phnum=" FMT_ELF_HALF "\n",
return VERR_BAD_EXE_FORMAT;
}
{
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: The section headers extends beyond the file! e_shoff=" FMT_ELF_OFF " e_shnum=" FMT_ELF_HALF "\n",
return VERR_BAD_EXE_FORMAT;
}
return VINF_SUCCESS;
}
/**
* Gets the section header name.
*
* @returns pszName.
* @param pReader The loader reader instance.
* @param pEhdr The elf header.
* @param offName The offset of the section header name.
* @param pszName Where to store the name.
* @param cbName The size of the buffer pointed to by pszName.
*/
const char *RTLDRELF_NAME(GetSHdrName)(PRTLDRMODELF pModElf, Elf_Word offName, char *pszName, size_t cbName)
{
if (RT_FAILURE(rc))
{
/* read by for byte. */
{
if (RT_FAILURE(rc))
{
pszName[i] = '\0';
break;
}
}
}
return pszName;
}
/**
* Validates a section header.
*
* @returns iprt status code.
* @param pModElf Pointer to the module structure.
* @param iShdr The index of section header which should be validated.
* The section headers are found in the pModElf->paShdrs array.
* @param pszLogName The log name.
* @param cbRawImage The size of the raw image.
*/
static int RTLDRELF_NAME(ValidateSectionHeader)(PRTLDRMODELF pModElf, unsigned iShdr, const char *pszLogName, RTFOFF cbRawImage)
{
Log3(("RTLdrELF: Section Header #%d:\n"
pShdr->sh_name, RTLDRELF_NAME(GetSHdrName)(pModElf, pShdr->sh_name, szSectionName, sizeof(szSectionName)),
pShdr->sh_entsize));
{
Log(("RTLdrELF: %s: Shdr #%d: sh_link (%d) is beyond the end of the section table (%d)!\n",
return VERR_BAD_EXE_FORMAT;
}
{
/** @todo find specs and check up which sh_info fields indicates section table entries */
case 12301230:
{
Log(("RTLdrELF: %s: Shdr #%d: sh_info (%d) is beyond the end of the section table (%d)!\n",
return VERR_BAD_EXE_FORMAT;
}
break;
case SHT_NULL:
case SHT_PROGBITS:
case SHT_SYMTAB:
case SHT_STRTAB:
case SHT_RELA:
case SHT_HASH:
case SHT_DYNAMIC:
case SHT_NOTE:
case SHT_NOBITS:
case SHT_REL:
case SHT_SHLIB:
case SHT_DYNSYM:
/*
* For these types sh_info doesn't have any special meaning, or anything which
*/
break;
default:
break;
}
{
if ( offEnd > cbRawImage
{
Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD " = %RTfoff) is beyond the end of the file (%RTfoff)!\n",
return VERR_BAD_EXE_FORMAT;
}
{
Log(("RTLdrELF: %s: Shdr #%d: sh_offset (" FMT_ELF_OFF ") + sh_size (" FMT_ELF_XWORD ") is starting in the ELF header!\n",
return VERR_BAD_EXE_FORMAT;
}
}
return VINF_SUCCESS;
}
/**
* Opens an ELF image, fixed bitness.
*
* @returns iprt status code.
* @param pReader The loader reader instance which will provide the raw image bits.
* @param fFlags Reserved, MBZ.
* @param enmArch Architecture specifier.
* @param phLdrMod Where to store the handle.
*/
static int RTLDRELF_NAME(Open)(PRTLDRREADER pReader, uint32_t fFlags, RTLDRARCH enmArch, PRTLDRMOD phLdrMod)
{
/*
* Create the loader module instance.
*/
if (!pModElf)
return VERR_NO_MEMORY;
//pModElf->pvBits = NULL;
//pModElf->Ehdr = {0};
//pModElf->paShdrs = NULL;
//pModElf->paSyms = NULL;
//pModElf->pStr = NULL;
/*
* Read and validate the ELF header and match up the CPU architecture.
*/
if (RT_SUCCESS(rc))
{
if (RT_SUCCESS(rc))
{
if ( enmArch != RTLDRARCH_WHATEVER
&& enmArch != enmArchImage)
}
}
if (RT_SUCCESS(rc))
{
/*
* Read the section headers.
*/
if (paShdrs)
{
if (RT_SUCCESS(rc))
{
/*
* Validate the section headers, allocate memory for the sections (determin the image size),
* and find relevant sections.
*/
{
if (RT_FAILURE(rc))
break;
/* Allocate memory addresses for the section. */
{
Log2(("RTLdrElf: %s: Assigned " FMT_ELF_ADDR " to section #%d\n", pszLogName, paShdrs[i].sh_addr, i));
}
/* We're looking for symbol tables. */
{
{
break;
}
}
} /* for each section header */
Log2(("RTLdrElf: iSymSh=%u cSyms=%u iStrSh=%u cbStr=%u rc=%Rrc cbImage=%#zx\n",
/*
* Are the section headers fine?
* We require there to be symbol & string tables (at least for the time being).
*/
if (RT_SUCCESS(rc))
{
return VINF_SUCCESS;
}
}
}
else
rc = VERR_NO_MEMORY;
}
return rc;
}
/*******************************************************************************
* Cleanup Constants And Macros *
*******************************************************************************/