662 lines
22 KiB
C++
662 lines
22 KiB
C++
/*
|
|
* Copyright (C) 2012 The Android Open Source Project
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* * Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* * Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in
|
|
* the documentation and/or other materials provided with the
|
|
* distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
|
|
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
|
|
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
|
|
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "linker_phdr.h"
|
|
|
|
#include <errno.h>
|
|
#include <sys/mman.h>
|
|
|
|
#include "linker.h"
|
|
#include "linker_debug.h"
|
|
|
|
/**
|
|
TECHNICAL NOTE ON ELF LOADING.
|
|
|
|
An ELF file's program header table contains one or more PT_LOAD
|
|
segments, which corresponds to portions of the file that need to
|
|
be mapped into the process' address space.
|
|
|
|
Each loadable segment has the following important properties:
|
|
|
|
p_offset -> segment file offset
|
|
p_filesz -> segment file size
|
|
p_memsz -> segment memory size (always >= p_filesz)
|
|
p_vaddr -> segment's virtual address
|
|
p_flags -> segment flags (e.g. readable, writable, executable)
|
|
|
|
We will ignore the p_paddr and p_align fields of Elf32_Phdr for now.
|
|
|
|
The loadable segments can be seen as a list of [p_vaddr ... p_vaddr+p_memsz)
|
|
ranges of virtual addresses. A few rules apply:
|
|
|
|
- the virtual address ranges should not overlap.
|
|
|
|
- if a segment's p_filesz is smaller than its p_memsz, the extra bytes
|
|
between them should always be initialized to 0.
|
|
|
|
- ranges do not necessarily start or end at page boundaries. Two distinct
|
|
segments can have their start and end on the same page. In this case, the
|
|
page inherits the mapping flags of the latter segment.
|
|
|
|
Finally, the real load addrs of each segment is not p_vaddr. Instead the
|
|
loader decides where to load the first segment, then will load all others
|
|
relative to the first one to respect the initial range layout.
|
|
|
|
For example, consider the following list:
|
|
|
|
[ offset:0, filesz:0x4000, memsz:0x4000, vaddr:0x30000 ],
|
|
[ offset:0x4000, filesz:0x2000, memsz:0x8000, vaddr:0x40000 ],
|
|
|
|
This corresponds to two segments that cover these virtual address ranges:
|
|
|
|
0x30000...0x34000
|
|
0x40000...0x48000
|
|
|
|
If the loader decides to load the first segment at address 0xa0000000
|
|
then the segments' load address ranges will be:
|
|
|
|
0xa0030000...0xa0034000
|
|
0xa0040000...0xa0048000
|
|
|
|
In other words, all segments must be loaded at an address that has the same
|
|
constant offset from their p_vaddr value. This offset is computed as the
|
|
difference between the first segment's load address, and its p_vaddr value.
|
|
|
|
However, in practice, segments do _not_ start at page boundaries. Since we
|
|
can only memory-map at page boundaries, this means that the bias is
|
|
computed as:
|
|
|
|
load_bias = phdr0_load_address - PAGE_START(phdr0->p_vaddr)
|
|
|
|
(NOTE: The value must be used as a 32-bit unsigned integer, to deal with
|
|
possible wrap around UINT32_MAX for possible large p_vaddr values).
|
|
|
|
And that the phdr0_load_address must start at a page boundary, with
|
|
the segment's real content starting at:
|
|
|
|
phdr0_load_address + PAGE_OFFSET(phdr0->p_vaddr)
|
|
|
|
Note that ELF requires the following condition to make the mmap()-ing work:
|
|
|
|
PAGE_OFFSET(phdr0->p_vaddr) == PAGE_OFFSET(phdr0->p_offset)
|
|
|
|
The load_bias must be added to any p_vaddr value read from the ELF file to
|
|
determine the corresponding memory address.
|
|
|
|
**/
|
|
|
|
#define MAYBE_MAP_FLAG(x,from,to) (((x) & (from)) ? (to) : 0)
|
|
#define PFLAGS_TO_PROT(x) (MAYBE_MAP_FLAG((x), PF_X, PROT_EXEC) | \
|
|
MAYBE_MAP_FLAG((x), PF_R, PROT_READ) | \
|
|
MAYBE_MAP_FLAG((x), PF_W, PROT_WRITE))
|
|
|
|
ElfReader::ElfReader(const char* name, int fd)
|
|
: name_(name), fd_(fd),
|
|
phdr_num_(0), phdr_mmap_(NULL), phdr_table_(NULL), phdr_size_(0),
|
|
load_start_(NULL), load_size_(0), load_bias_(0),
|
|
loaded_phdr_(NULL) {
|
|
}
|
|
|
|
ElfReader::~ElfReader() {
|
|
if (fd_ != -1) {
|
|
close(fd_);
|
|
}
|
|
if (phdr_mmap_ != NULL) {
|
|
munmap(phdr_mmap_, phdr_size_);
|
|
}
|
|
}
|
|
|
|
bool ElfReader::Load() {
|
|
return ReadElfHeader() &&
|
|
VerifyElfHeader() &&
|
|
ReadProgramHeader() &&
|
|
ReserveAddressSpace() &&
|
|
LoadSegments() &&
|
|
FindPhdr();
|
|
}
|
|
|
|
bool ElfReader::ReadElfHeader() {
|
|
ssize_t rc = TEMP_FAILURE_RETRY(read(fd_, &header_, sizeof(header_)));
|
|
if (rc < 0) {
|
|
DL_ERR("can't read file \"%s\": %s", name_, strerror(errno));
|
|
return false;
|
|
}
|
|
if (rc != sizeof(header_)) {
|
|
DL_ERR("\"%s\" is too small to be an ELF executable. Expected at least %d bytes, only found %d bytes.",
|
|
name_, sizeof(header_), rc);
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool ElfReader::VerifyElfHeader() {
|
|
if (header_.e_ident[EI_MAG0] != ELFMAG0 ||
|
|
header_.e_ident[EI_MAG1] != ELFMAG1 ||
|
|
header_.e_ident[EI_MAG2] != ELFMAG2 ||
|
|
header_.e_ident[EI_MAG3] != ELFMAG3) {
|
|
DL_ERR("\"%s\" has bad ELF magic", name_);
|
|
return false;
|
|
}
|
|
|
|
if (header_.e_ident[EI_CLASS] != ELFCLASS32) {
|
|
DL_ERR("\"%s\" not 32-bit: %d", name_, header_.e_ident[EI_CLASS]);
|
|
return false;
|
|
}
|
|
if (header_.e_ident[EI_DATA] != ELFDATA2LSB) {
|
|
DL_ERR("\"%s\" not little-endian: %d", name_, header_.e_ident[EI_DATA]);
|
|
return false;
|
|
}
|
|
|
|
if (header_.e_type != ET_DYN) {
|
|
DL_ERR("\"%s\" has unexpected e_type: %d", name_, header_.e_type);
|
|
return false;
|
|
}
|
|
|
|
if (header_.e_version != EV_CURRENT) {
|
|
DL_ERR("\"%s\" has unexpected e_version: %d", name_, header_.e_version);
|
|
return false;
|
|
}
|
|
|
|
if (header_.e_machine !=
|
|
#ifdef ANDROID_ARM_LINKER
|
|
EM_ARM
|
|
#elif defined(ANDROID_MIPS_LINKER)
|
|
EM_MIPS
|
|
#elif defined(ANDROID_X86_LINKER)
|
|
EM_386
|
|
#endif
|
|
) {
|
|
DL_ERR("\"%s\" has unexpected e_machine: %d", name_, header_.e_machine);
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Loads the program header table from an ELF file into a read-only private
|
|
// anonymous mmap-ed block.
|
|
bool ElfReader::ReadProgramHeader() {
|
|
phdr_num_ = header_.e_phnum;
|
|
|
|
// Like the kernel, we only accept program header tables that
|
|
// are smaller than 64KiB.
|
|
if (phdr_num_ < 1 || phdr_num_ > 65536/sizeof(Elf32_Phdr)) {
|
|
DL_ERR("\"%s\" has invalid e_phnum: %d", name_, phdr_num_);
|
|
return false;
|
|
}
|
|
|
|
Elf32_Addr page_min = PAGE_START(header_.e_phoff);
|
|
Elf32_Addr page_max = PAGE_END(header_.e_phoff + (phdr_num_ * sizeof(Elf32_Phdr)));
|
|
Elf32_Addr page_offset = PAGE_OFFSET(header_.e_phoff);
|
|
|
|
phdr_size_ = page_max - page_min;
|
|
|
|
void* mmap_result = mmap(NULL, phdr_size_, PROT_READ, MAP_PRIVATE, fd_, page_min);
|
|
if (mmap_result == MAP_FAILED) {
|
|
DL_ERR("\"%s\" phdr mmap failed: %s", name_, strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
phdr_mmap_ = mmap_result;
|
|
phdr_table_ = reinterpret_cast<Elf32_Phdr*>(reinterpret_cast<char*>(mmap_result) + page_offset);
|
|
return true;
|
|
}
|
|
|
|
/* Returns the size of the extent of all the possibly non-contiguous
|
|
* loadable segments in an ELF program header table. This corresponds
|
|
* to the page-aligned size in bytes that needs to be reserved in the
|
|
* process' address space. If there are no loadable segments, 0 is
|
|
* returned.
|
|
*
|
|
* If out_min_vaddr or out_max_vaddr are non-NULL, they will be
|
|
* set to the minimum and maximum addresses of pages to be reserved,
|
|
* or 0 if there is nothing to load.
|
|
*/
|
|
size_t phdr_table_get_load_size(const Elf32_Phdr* phdr_table,
|
|
size_t phdr_count,
|
|
Elf32_Addr* out_min_vaddr,
|
|
Elf32_Addr* out_max_vaddr)
|
|
{
|
|
Elf32_Addr min_vaddr = 0xFFFFFFFFU;
|
|
Elf32_Addr max_vaddr = 0x00000000U;
|
|
|
|
bool found_pt_load = false;
|
|
for (size_t i = 0; i < phdr_count; ++i) {
|
|
const Elf32_Phdr* phdr = &phdr_table[i];
|
|
|
|
if (phdr->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
found_pt_load = true;
|
|
|
|
if (phdr->p_vaddr < min_vaddr) {
|
|
min_vaddr = phdr->p_vaddr;
|
|
}
|
|
|
|
if (phdr->p_vaddr + phdr->p_memsz > max_vaddr) {
|
|
max_vaddr = phdr->p_vaddr + phdr->p_memsz;
|
|
}
|
|
}
|
|
if (!found_pt_load) {
|
|
min_vaddr = 0x00000000U;
|
|
}
|
|
|
|
min_vaddr = PAGE_START(min_vaddr);
|
|
max_vaddr = PAGE_END(max_vaddr);
|
|
|
|
if (out_min_vaddr != NULL) {
|
|
*out_min_vaddr = min_vaddr;
|
|
}
|
|
if (out_max_vaddr != NULL) {
|
|
*out_max_vaddr = max_vaddr;
|
|
}
|
|
return max_vaddr - min_vaddr;
|
|
}
|
|
|
|
// Reserve a virtual address range big enough to hold all loadable
|
|
// segments of a program header table. This is done by creating a
|
|
// private anonymous mmap() with PROT_NONE.
|
|
bool ElfReader::ReserveAddressSpace() {
|
|
Elf32_Addr min_vaddr;
|
|
load_size_ = phdr_table_get_load_size(phdr_table_, phdr_num_, &min_vaddr);
|
|
if (load_size_ == 0) {
|
|
DL_ERR("\"%s\" has no loadable segments", name_);
|
|
return false;
|
|
}
|
|
|
|
uint8_t* addr = reinterpret_cast<uint8_t*>(min_vaddr);
|
|
int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS;
|
|
void* start = mmap(addr, load_size_, PROT_NONE, mmap_flags, -1, 0);
|
|
if (start == MAP_FAILED) {
|
|
DL_ERR("couldn't reserve %d bytes of address space for \"%s\"", load_size_, name_);
|
|
return false;
|
|
}
|
|
|
|
load_start_ = start;
|
|
load_bias_ = reinterpret_cast<uint8_t*>(start) - addr;
|
|
return true;
|
|
}
|
|
|
|
// Map all loadable segments in process' address space.
|
|
// This assumes you already called phdr_table_reserve_memory to
|
|
// reserve the address space range for the library.
|
|
// TODO: assert assumption.
|
|
bool ElfReader::LoadSegments() {
|
|
for (size_t i = 0; i < phdr_num_; ++i) {
|
|
const Elf32_Phdr* phdr = &phdr_table_[i];
|
|
|
|
if (phdr->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
|
|
// Segment addresses in memory.
|
|
Elf32_Addr seg_start = phdr->p_vaddr + load_bias_;
|
|
Elf32_Addr seg_end = seg_start + phdr->p_memsz;
|
|
|
|
Elf32_Addr seg_page_start = PAGE_START(seg_start);
|
|
Elf32_Addr seg_page_end = PAGE_END(seg_end);
|
|
|
|
Elf32_Addr seg_file_end = seg_start + phdr->p_filesz;
|
|
|
|
// File offsets.
|
|
Elf32_Addr file_start = phdr->p_offset;
|
|
Elf32_Addr file_end = file_start + phdr->p_filesz;
|
|
|
|
Elf32_Addr file_page_start = PAGE_START(file_start);
|
|
Elf32_Addr file_length = file_end - file_page_start;
|
|
|
|
if (file_length != 0) {
|
|
void* seg_addr = mmap((void*)seg_page_start,
|
|
file_length,
|
|
PFLAGS_TO_PROT(phdr->p_flags),
|
|
MAP_FIXED|MAP_PRIVATE,
|
|
fd_,
|
|
file_page_start);
|
|
if (seg_addr == MAP_FAILED) {
|
|
DL_ERR("couldn't map \"%s\" segment %d: %s", name_, i, strerror(errno));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// if the segment is writable, and does not end on a page boundary,
|
|
// zero-fill it until the page limit.
|
|
if ((phdr->p_flags & PF_W) != 0 && PAGE_OFFSET(seg_file_end) > 0) {
|
|
memset((void*)seg_file_end, 0, PAGE_SIZE - PAGE_OFFSET(seg_file_end));
|
|
}
|
|
|
|
seg_file_end = PAGE_END(seg_file_end);
|
|
|
|
// seg_file_end is now the first page address after the file
|
|
// content. If seg_end is larger, we need to zero anything
|
|
// between them. This is done by using a private anonymous
|
|
// map for all extra pages.
|
|
if (seg_page_end > seg_file_end) {
|
|
void* zeromap = mmap((void*)seg_file_end,
|
|
seg_page_end - seg_file_end,
|
|
PFLAGS_TO_PROT(phdr->p_flags),
|
|
MAP_FIXED|MAP_ANONYMOUS|MAP_PRIVATE,
|
|
-1,
|
|
0);
|
|
if (zeromap == MAP_FAILED) {
|
|
DL_ERR("couldn't zero fill \"%s\" gap: %s", name_, strerror(errno));
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/* Used internally. Used to set the protection bits of all loaded segments
|
|
* with optional extra flags (i.e. really PROT_WRITE). Used by
|
|
* phdr_table_protect_segments and phdr_table_unprotect_segments.
|
|
*/
|
|
static int
|
|
_phdr_table_set_load_prot(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias,
|
|
int extra_prot_flags)
|
|
{
|
|
const Elf32_Phdr* phdr = phdr_table;
|
|
const Elf32_Phdr* phdr_limit = phdr + phdr_count;
|
|
|
|
for (; phdr < phdr_limit; phdr++) {
|
|
if (phdr->p_type != PT_LOAD || (phdr->p_flags & PF_W) != 0)
|
|
continue;
|
|
|
|
Elf32_Addr seg_page_start = PAGE_START(phdr->p_vaddr) + load_bias;
|
|
Elf32_Addr seg_page_end = PAGE_END(phdr->p_vaddr + phdr->p_memsz) + load_bias;
|
|
|
|
int ret = mprotect((void*)seg_page_start,
|
|
seg_page_end - seg_page_start,
|
|
PFLAGS_TO_PROT(phdr->p_flags) | extra_prot_flags);
|
|
if (ret < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Restore the original protection modes for all loadable segments.
|
|
* You should only call this after phdr_table_unprotect_segments and
|
|
* applying all relocations.
|
|
*
|
|
* Input:
|
|
* phdr_table -> program header table
|
|
* phdr_count -> number of entries in tables
|
|
* load_bias -> load bias
|
|
* Return:
|
|
* 0 on error, -1 on failure (error code in errno).
|
|
*/
|
|
int
|
|
phdr_table_protect_segments(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias)
|
|
{
|
|
return _phdr_table_set_load_prot(phdr_table, phdr_count,
|
|
load_bias, 0);
|
|
}
|
|
|
|
/* Change the protection of all loaded segments in memory to writable.
|
|
* This is useful before performing relocations. Once completed, you
|
|
* will have to call phdr_table_protect_segments to restore the original
|
|
* protection flags on all segments.
|
|
*
|
|
* Note that some writable segments can also have their content turned
|
|
* to read-only by calling phdr_table_protect_gnu_relro. This is no
|
|
* performed here.
|
|
*
|
|
* Input:
|
|
* phdr_table -> program header table
|
|
* phdr_count -> number of entries in tables
|
|
* load_bias -> load bias
|
|
* Return:
|
|
* 0 on error, -1 on failure (error code in errno).
|
|
*/
|
|
int
|
|
phdr_table_unprotect_segments(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias)
|
|
{
|
|
return _phdr_table_set_load_prot(phdr_table, phdr_count,
|
|
load_bias, PROT_WRITE);
|
|
}
|
|
|
|
/* Used internally by phdr_table_protect_gnu_relro and
|
|
* phdr_table_unprotect_gnu_relro.
|
|
*/
|
|
static int
|
|
_phdr_table_set_gnu_relro_prot(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias,
|
|
int prot_flags)
|
|
{
|
|
const Elf32_Phdr* phdr = phdr_table;
|
|
const Elf32_Phdr* phdr_limit = phdr + phdr_count;
|
|
|
|
for (phdr = phdr_table; phdr < phdr_limit; phdr++) {
|
|
if (phdr->p_type != PT_GNU_RELRO)
|
|
continue;
|
|
|
|
/* Tricky: what happens when the relro segment does not start
|
|
* or end at page boundaries?. We're going to be over-protective
|
|
* here and put every page touched by the segment as read-only.
|
|
*
|
|
* This seems to match Ian Lance Taylor's description of the
|
|
* feature at http://www.airs.com/blog/archives/189.
|
|
*
|
|
* Extract:
|
|
* Note that the current dynamic linker code will only work
|
|
* correctly if the PT_GNU_RELRO segment starts on a page
|
|
* boundary. This is because the dynamic linker rounds the
|
|
* p_vaddr field down to the previous page boundary. If
|
|
* there is anything on the page which should not be read-only,
|
|
* the program is likely to fail at runtime. So in effect the
|
|
* linker must only emit a PT_GNU_RELRO segment if it ensures
|
|
* that it starts on a page boundary.
|
|
*/
|
|
Elf32_Addr seg_page_start = PAGE_START(phdr->p_vaddr) + load_bias;
|
|
Elf32_Addr seg_page_end = PAGE_END(phdr->p_vaddr + phdr->p_memsz) + load_bias;
|
|
|
|
int ret = mprotect((void*)seg_page_start,
|
|
seg_page_end - seg_page_start,
|
|
prot_flags);
|
|
if (ret < 0) {
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/* Apply GNU relro protection if specified by the program header. This will
|
|
* turn some of the pages of a writable PT_LOAD segment to read-only, as
|
|
* specified by one or more PT_GNU_RELRO segments. This must be always
|
|
* performed after relocations.
|
|
*
|
|
* The areas typically covered are .got and .data.rel.ro, these are
|
|
* read-only from the program's POV, but contain absolute addresses
|
|
* that need to be relocated before use.
|
|
*
|
|
* Input:
|
|
* phdr_table -> program header table
|
|
* phdr_count -> number of entries in tables
|
|
* load_bias -> load bias
|
|
* Return:
|
|
* 0 on error, -1 on failure (error code in errno).
|
|
*/
|
|
int
|
|
phdr_table_protect_gnu_relro(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias)
|
|
{
|
|
return _phdr_table_set_gnu_relro_prot(phdr_table,
|
|
phdr_count,
|
|
load_bias,
|
|
PROT_READ);
|
|
}
|
|
|
|
#ifdef ANDROID_ARM_LINKER
|
|
|
|
# ifndef PT_ARM_EXIDX
|
|
# define PT_ARM_EXIDX 0x70000001 /* .ARM.exidx segment */
|
|
# endif
|
|
|
|
/* Return the address and size of the .ARM.exidx section in memory,
|
|
* if present.
|
|
*
|
|
* Input:
|
|
* phdr_table -> program header table
|
|
* phdr_count -> number of entries in tables
|
|
* load_bias -> load bias
|
|
* Output:
|
|
* arm_exidx -> address of table in memory (NULL on failure).
|
|
* arm_exidx_count -> number of items in table (0 on failure).
|
|
* Return:
|
|
* 0 on error, -1 on failure (_no_ error code in errno)
|
|
*/
|
|
int
|
|
phdr_table_get_arm_exidx(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias,
|
|
Elf32_Addr** arm_exidx,
|
|
unsigned* arm_exidx_count)
|
|
{
|
|
const Elf32_Phdr* phdr = phdr_table;
|
|
const Elf32_Phdr* phdr_limit = phdr + phdr_count;
|
|
|
|
for (phdr = phdr_table; phdr < phdr_limit; phdr++) {
|
|
if (phdr->p_type != PT_ARM_EXIDX)
|
|
continue;
|
|
|
|
*arm_exidx = (Elf32_Addr*)(load_bias + phdr->p_vaddr);
|
|
*arm_exidx_count = (unsigned)(phdr->p_memsz / 8);
|
|
return 0;
|
|
}
|
|
*arm_exidx = NULL;
|
|
*arm_exidx_count = 0;
|
|
return -1;
|
|
}
|
|
#endif /* ANDROID_ARM_LINKER */
|
|
|
|
/* Return the address and size of the ELF file's .dynamic section in memory,
|
|
* or NULL if missing.
|
|
*
|
|
* Input:
|
|
* phdr_table -> program header table
|
|
* phdr_count -> number of entries in tables
|
|
* load_bias -> load bias
|
|
* Output:
|
|
* dynamic -> address of table in memory (NULL on failure).
|
|
* dynamic_count -> number of items in table (0 on failure).
|
|
* dynamic_flags -> protection flags for section (unset on failure)
|
|
* Return:
|
|
* void
|
|
*/
|
|
void
|
|
phdr_table_get_dynamic_section(const Elf32_Phdr* phdr_table,
|
|
int phdr_count,
|
|
Elf32_Addr load_bias,
|
|
Elf32_Dyn** dynamic,
|
|
size_t* dynamic_count,
|
|
Elf32_Word* dynamic_flags)
|
|
{
|
|
const Elf32_Phdr* phdr = phdr_table;
|
|
const Elf32_Phdr* phdr_limit = phdr + phdr_count;
|
|
|
|
for (phdr = phdr_table; phdr < phdr_limit; phdr++) {
|
|
if (phdr->p_type != PT_DYNAMIC) {
|
|
continue;
|
|
}
|
|
|
|
*dynamic = reinterpret_cast<Elf32_Dyn*>(load_bias + phdr->p_vaddr);
|
|
if (dynamic_count) {
|
|
*dynamic_count = (unsigned)(phdr->p_memsz / 8);
|
|
}
|
|
if (dynamic_flags) {
|
|
*dynamic_flags = phdr->p_flags;
|
|
}
|
|
return;
|
|
}
|
|
*dynamic = NULL;
|
|
if (dynamic_count) {
|
|
*dynamic_count = 0;
|
|
}
|
|
}
|
|
|
|
// Returns the address of the program header table as it appears in the loaded
|
|
// segments in memory. This is in contrast with 'phdr_table_' which
|
|
// is temporary and will be released before the library is relocated.
|
|
bool ElfReader::FindPhdr() {
|
|
const Elf32_Phdr* phdr_limit = phdr_table_ + phdr_num_;
|
|
|
|
// If there is a PT_PHDR, use it directly.
|
|
for (const Elf32_Phdr* phdr = phdr_table_; phdr < phdr_limit; ++phdr) {
|
|
if (phdr->p_type == PT_PHDR) {
|
|
return CheckPhdr(load_bias_ + phdr->p_vaddr);
|
|
}
|
|
}
|
|
|
|
// Otherwise, check the first loadable segment. If its file offset
|
|
// is 0, it starts with the ELF header, and we can trivially find the
|
|
// loaded program header from it.
|
|
for (const Elf32_Phdr* phdr = phdr_table_; phdr < phdr_limit; ++phdr) {
|
|
if (phdr->p_type == PT_LOAD) {
|
|
if (phdr->p_offset == 0) {
|
|
Elf32_Addr elf_addr = load_bias_ + phdr->p_vaddr;
|
|
const Elf32_Ehdr* ehdr = (const Elf32_Ehdr*)(void*)elf_addr;
|
|
Elf32_Addr offset = ehdr->e_phoff;
|
|
return CheckPhdr((Elf32_Addr)ehdr + offset);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
DL_ERR("can't find loaded phdr for \"%s\"", name_);
|
|
return false;
|
|
}
|
|
|
|
// Ensures that our program header is actually within a loadable
|
|
// segment. This should help catch badly-formed ELF files that
|
|
// would cause the linker to crash later when trying to access it.
|
|
bool ElfReader::CheckPhdr(Elf32_Addr loaded) {
|
|
const Elf32_Phdr* phdr_limit = phdr_table_ + phdr_num_;
|
|
Elf32_Addr loaded_end = loaded + (phdr_num_ * sizeof(Elf32_Phdr));
|
|
for (Elf32_Phdr* phdr = phdr_table_; phdr < phdr_limit; ++phdr) {
|
|
if (phdr->p_type != PT_LOAD) {
|
|
continue;
|
|
}
|
|
Elf32_Addr seg_start = phdr->p_vaddr + load_bias_;
|
|
Elf32_Addr seg_end = phdr->p_filesz + seg_start;
|
|
if (seg_start <= loaded && loaded_end <= seg_end) {
|
|
loaded_phdr_ = reinterpret_cast<const Elf32_Phdr*>(loaded);
|
|
return true;
|
|
}
|
|
}
|
|
DL_ERR("\"%s\" loaded phdr %x not in loadable segment", name_, loaded);
|
|
return false;
|
|
}
|