// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Implementation notes:
//
// We need to remove a piece from the ELF shared library. However, we also
// want to avoid fixing DWARF cfi data and relative relocation addresses.
// So after packing we shift offets and starting address of the RX segment
// while preserving code/data vaddrs location.
// This requires some fixups for symtab/hash/gnu_hash dynamic section addresses.
#include "elf_file.h"
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <algorithm>
#include <string>
#include <vector>
#include "debug.h"
#include "elf_traits.h"
#include "libelf.h"
#include "packer.h"
namespace relocation_packer {
// Out-of-band dynamic tags used to indicate the offset and size of the
// android packed relocations section.
static constexpr int32_t DT_ANDROID_REL = DT_LOOS + 2;
static constexpr int32_t DT_ANDROID_RELSZ = DT_LOOS + 3;
static constexpr int32_t DT_ANDROID_RELA = DT_LOOS + 4;
static constexpr int32_t DT_ANDROID_RELASZ = DT_LOOS + 5;
static constexpr uint32_t SHT_ANDROID_REL = SHT_LOOS + 1;
static constexpr uint32_t SHT_ANDROID_RELA = SHT_LOOS + 2;
static const size_t kPageSize = 4096;
// Alignment to preserve, in bytes. This must be at least as large as the
// largest d_align and sh_addralign values found in the loaded file.
// Out of caution for RELRO page alignment, we preserve to a complete target
// page. See http://www.airs.com/blog/archives/189.
static const size_t kPreserveAlignment = kPageSize;
// Get section data. Checks that the section has exactly one data entry,
// so that the section size and the data size are the same. True in
// practice for all sections we resize when packing or unpacking. Done
// by ensuring that a call to elf_getdata(section, data) returns NULL as
// the next data entry.
static Elf_Data* GetSectionData(Elf_Scn* section) {
Elf_Data* data = elf_getdata(section, NULL);
CHECK(data && elf_getdata(section, data) == NULL);
return data;
}
// Rewrite section data. Allocates new data and makes it the data element's
// buffer. Relies on program exit to free allocated data.
static void RewriteSectionData(Elf_Scn* section,
const void* section_data,
size_t size) {
Elf_Data* data = GetSectionData(section);
CHECK(size == data->d_size);
uint8_t* area = new uint8_t[size];
memcpy(area, section_data, size);
data->d_buf = area;
}
// Verbose ELF header logging.
template <typename Ehdr>
static void VerboseLogElfHeader(const Ehdr* elf_header) {
VLOG(1) << "e_phoff = " << elf_header->e_phoff;
VLOG(1) << "e_shoff = " << elf_header->e_shoff;
VLOG(1) << "e_ehsize = " << elf_header->e_ehsize;
VLOG(1) << "e_phentsize = " << elf_header->e_phentsize;
VLOG(1) << "e_phnum = " << elf_header->e_phnum;
VLOG(1) << "e_shnum = " << elf_header->e_shnum;
VLOG(1) << "e_shstrndx = " << elf_header->e_shstrndx;
}
// Verbose ELF program header logging.
template <typename Phdr>
static void VerboseLogProgramHeader(size_t program_header_index,
const Phdr* program_header) {
std::string type;
switch (program_header->p_type) {
case PT_NULL: type = "NULL"; break;
case PT_LOAD: type = "LOAD"; break;
case PT_DYNAMIC: type = "DYNAMIC"; break;
case PT_INTERP: type = "INTERP"; break;
case PT_PHDR: type = "PHDR"; break;
case PT_GNU_RELRO: type = "GNU_RELRO"; break;
case PT_GNU_STACK: type = "GNU_STACK"; break;
case PT_ARM_EXIDX: type = "EXIDX"; break;
default: type = "(OTHER)"; break;
}
VLOG(1) << "phdr[" << program_header_index << "] : " << type;
VLOG(1) << " p_offset = " << program_header->p_offset;
VLOG(1) << " p_vaddr = " << program_header->p_vaddr;
VLOG(1) << " p_paddr = " << program_header->p_paddr;
VLOG(1) << " p_filesz = " << program_header->p_filesz;
VLOG(1) << " p_memsz = " << program_header->p_memsz;
VLOG(1) << " p_flags = " << program_header->p_flags;
VLOG(1) << " p_align = " << program_header->p_align;
}
// Verbose ELF section header logging.
template <typename Shdr>
static void VerboseLogSectionHeader(const std::string& section_name,
const Shdr* section_header) {
VLOG(1) << "section " << section_name;
VLOG(1) << " sh_addr = " << section_header->sh_addr;
VLOG(1) << " sh_offset = " << section_header->sh_offset;
VLOG(1) << " sh_size = " << section_header->sh_size;
VLOG(1) << " sh_entsize = " << section_header->sh_entsize;
VLOG(1) << " sh_addralign = " << section_header->sh_addralign;
}
// Verbose ELF section data logging.
static void VerboseLogSectionData(const Elf_Data* data) {
VLOG(1) << " data";
VLOG(1) << " d_buf = " << data->d_buf;
VLOG(1) << " d_off = " << data->d_off;
VLOG(1) << " d_size = " << data->d_size;
VLOG(1) << " d_align = " << data->d_align;
}
// Load the complete ELF file into a memory image in libelf, and identify
// the .rel.dyn or .rela.dyn, .dynamic, and .android.rel.dyn or
// .android.rela.dyn sections. No-op if the ELF file has already been loaded.
template <typename ELF>
bool ElfFile<ELF>::Load() {
if (elf_)
return true;
Elf* elf = elf_begin(fd_, ELF_C_RDWR, NULL);
CHECK(elf);
if (elf_kind(elf) != ELF_K_ELF) {
LOG(ERROR) << "File not in ELF format";
return false;
}
auto elf_header = ELF::getehdr(elf);
if (!elf_header) {
LOG(ERROR) << "Failed to load ELF header: " << elf_errmsg(elf_errno());
return false;
}
if (elf_header->e_type != ET_DYN) {
LOG(ERROR) << "ELF file is not a shared object";
return false;
}
// Require that our endianness matches that of the target, and that both
// are little-endian. Safe for all current build/target combinations.
const int endian = elf_header->e_ident[EI_DATA];
CHECK(endian == ELFDATA2LSB);
CHECK(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__);
const int file_class = elf_header->e_ident[EI_CLASS];
VLOG(1) << "endian = " << endian << ", file class = " << file_class;
VerboseLogElfHeader(elf_header);
auto elf_program_header = ELF::getphdr(elf);
CHECK(elf_program_header != nullptr);
const typename ELF::Phdr* dynamic_program_header = NULL;
for (size_t i = 0; i < elf_header->e_phnum; ++i) {
auto program_header = &elf_program_header[i];
VerboseLogProgramHeader(i, program_header);
if (program_header->p_type == PT_DYNAMIC) {
CHECK(dynamic_program_header == NULL);
dynamic_program_header = program_header;
}
}
CHECK(dynamic_program_header != nullptr);
size_t string_index;
elf_getshdrstrndx(elf, &string_index);
// Notes of the dynamic relocations, packed relocations, and .dynamic
// sections. Found while iterating sections, and later stored in class
// attributes.
Elf_Scn* found_relocations_section = nullptr;
Elf_Scn* found_dynamic_section = nullptr;
// Notes of relocation section types seen. We require one or the other of
// these; both is unsupported.
bool has_rel_relocations = false;
bool has_rela_relocations = false;
bool has_android_relocations = false;
Elf_Scn* section = NULL;
while ((section = elf_nextscn(elf, section)) != nullptr) {
auto section_header = ELF::getshdr(section);
std::string name = elf_strptr(elf, string_index, section_header->sh_name);
VerboseLogSectionHeader(name, section_header);
// Note relocation section types.
if (section_header->sh_type == SHT_REL || section_header->sh_type == SHT_ANDROID_REL) {
has_rel_relocations = true;
}
if (section_header->sh_type == SHT_RELA || section_header->sh_type == SHT_ANDROID_RELA) {
has_rela_relocations = true;
}
// Note special sections as we encounter them.
if ((name == ".rel.dyn" || name == ".rela.dyn") &&
section_header->sh_size > 0) {
found_relocations_section = section;
// Note if relocation section is already packed
has_android_relocations =
section_header->sh_type == SHT_ANDROID_REL ||
section_header->sh_type == SHT_ANDROID_RELA;
}
if (section_header->sh_offset == dynamic_program_header->p_offset) {
found_dynamic_section = section;
}
// Ensure we preserve alignment, repeated later for the data block(s).
CHECK(section_header->sh_addralign <= kPreserveAlignment);
Elf_Data* data = NULL;
while ((data = elf_getdata(section, data)) != NULL) {
CHECK(data->d_align <= kPreserveAlignment);
VerboseLogSectionData(data);
}
}
// Loading failed if we did not find the required special sections.
if (!found_dynamic_section) {
LOG(ERROR) << "Missing .dynamic section";
return false;
}
if (found_relocations_section != nullptr) {
// Loading failed if we could not identify the relocations type.
if (!has_rel_relocations && !has_rela_relocations) {
LOG(ERROR) << "No relocations sections found";
return false;
}
if (has_rel_relocations && has_rela_relocations) {
LOG(ERROR) << "Multiple relocations sections with different types found, "
<< "not currently supported";
return false;
}
}
elf_ = elf;
relocations_section_ = found_relocations_section;
dynamic_section_ = found_dynamic_section;
relocations_type_ = has_rel_relocations ? REL : RELA;
has_android_relocations_ = has_android_relocations;
return true;
}
// Helper for ResizeSection(). Adjust the main ELF header for the hole.
template <typename ELF>
static void AdjustElfHeaderForHole(typename ELF::Ehdr* elf_header,
typename ELF::Off hole_start,
ssize_t hole_size) {
if (elf_header->e_phoff > hole_start) {
elf_header->e_phoff += hole_size;
VLOG(1) << "e_phoff adjusted to " << elf_header->e_phoff;
}
if (elf_header->e_shoff > hole_start) {
elf_header->e_shoff += hole_size;
VLOG(1) << "e_shoff adjusted to " << elf_header->e_shoff;
}
}
// Helper for ResizeSection(). Adjust all section headers for the hole.
template <typename ELF>
static void AdjustSectionHeadersForHole(Elf* elf,
typename ELF::Off hole_start,
ssize_t hole_size) {
size_t string_index;
elf_getshdrstrndx(elf, &string_index);
Elf_Scn* section = NULL;
while ((section = elf_nextscn(elf, section)) != NULL) {
auto section_header = ELF::getshdr(section);
std::string name = elf_strptr(elf, string_index, section_header->sh_name);
if (section_header->sh_offset > hole_start) {
section_header->sh_offset += hole_size;
VLOG(1) << "section " << name
<< " sh_offset adjusted to " << section_header->sh_offset;
} else {
section_header->sh_addr -= hole_size;
VLOG(1) << "section " << name
<< " sh_addr adjusted to " << section_header->sh_addr;
}
}
}
// Helpers for ResizeSection(). On packing, reduce p_align for LOAD segments
// to 4kb if larger. On unpacking, restore p_align for LOAD segments if
// packing reduced it to 4kb. Return true if p_align was changed.
template <typename ELF>
static bool ClampLoadSegmentAlignment(typename ELF::Phdr* program_header) {
CHECK(program_header->p_type == PT_LOAD);
// If large, reduce p_align for a LOAD segment to page size on packing.
if (program_header->p_align > kPageSize) {
program_header->p_align = kPageSize;
return true;
}
return false;
}
template <typename ELF>
static bool RestoreLoadSegmentAlignment(typename ELF::Phdr* program_headers,
size_t count,
typename ELF::Phdr* program_header) {
CHECK(program_header->p_type == PT_LOAD);
// If p_align was reduced on packing, restore it to its previous value
// on unpacking. We do this by searching for a different LOAD segment
// and setting p_align to that of the other LOAD segment found.
//
// Relies on the following observations:
// - a packable ELF executable has more than one LOAD segment;
// - before packing all LOAD segments have the same p_align;
// - on packing we reduce only one LOAD segment's p_align.
if (program_header->p_align == kPageSize) {
for (size_t i = 0; i < count; ++i) {
typename ELF::Phdr* other_header = &program_headers[i];
if (other_header->p_type == PT_LOAD && other_header != program_header) {
program_header->p_align = other_header->p_align;
return true;
}
}
LOG(WARNING) << "Cannot find a LOAD segment from which to restore p_align";
}
return false;
}
template <typename ELF>
static bool AdjustLoadSegmentAlignment(typename ELF::Phdr* program_headers,
size_t count,
typename ELF::Phdr* program_header,
ssize_t hole_size) {
CHECK(program_header->p_type == PT_LOAD);
bool status = false;
if (hole_size < 0) {
status = ClampLoadSegmentAlignment<ELF>(program_header);
} else if (hole_size > 0) {
status = RestoreLoadSegmentAlignment<ELF>(program_headers,
count,
program_header);
}
return status;
}
// Helper for ResizeSection(). Adjust the offsets of any program headers
// that have offsets currently beyond the hole start, and adjust the
// virtual and physical addrs (and perhaps alignment) of the others.
template <typename ELF>
static void AdjustProgramHeaderFields(typename ELF::Phdr* program_headers,
size_t count,
typename ELF::Off hole_start,
ssize_t hole_size) {
int alignment_changes = 0;
for (size_t i = 0; i < count; ++i) {
typename ELF::Phdr* program_header = &program_headers[i];
// Do not adjust PT_GNU_STACK - it confuses gdb and results
// in incorrect unwinding if the executable is stripped after
// packing.
if (program_header->p_type == PT_GNU_STACK) {
continue;
}
if (program_header->p_offset > hole_start) {
// The hole start is past this segment, so adjust offset.
program_header->p_offset += hole_size;
VLOG(1) << "phdr[" << i
<< "] p_offset adjusted to "<< program_header->p_offset;
} else {
program_header->p_vaddr -= hole_size;
program_header->p_paddr -= hole_size;
// If packing, clamp LOAD segment alignment to 4kb to prevent strip
// from adjusting it unnecessarily if run on a packed file. If
// unpacking, attempt to restore a reduced alignment to its previous
// value. Ensure that we do this on at most one LOAD segment.
if (program_header->p_type == PT_LOAD) {
alignment_changes += AdjustLoadSegmentAlignment<ELF>(program_headers,
count,
program_header,
hole_size);
LOG_IF(FATAL, alignment_changes > 1)
<< "Changed p_align on more than one LOAD segment";
}
VLOG(1) << "phdr[" << i
<< "] p_vaddr adjusted to "<< program_header->p_vaddr
<< "; p_paddr adjusted to "<< program_header->p_paddr
<< "; p_align adjusted to "<< program_header->p_align;
}
}
}
// Helper for ResizeSection(). Find the first loadable segment in the
// file. We expect it to map from file offset zero.
template <typename ELF>
static typename ELF::Phdr* FindLoadSegmentForHole(typename ELF::Phdr* program_headers,
size_t count,
typename ELF::Off hole_start) {
for (size_t i = 0; i < count; ++i) {
typename ELF::Phdr* program_header = &program_headers[i];
if (program_header->p_type == PT_LOAD &&
program_header->p_offset <= hole_start &&
(program_header->p_offset + program_header->p_filesz) >= hole_start ) {
return program_header;
}
}
LOG(FATAL) << "Cannot locate a LOAD segment with hole_start=0x" << std::hex << hole_start;
NOTREACHED();
return nullptr;
}
// Helper for ResizeSection(). Rewrite program headers.
template <typename ELF>
static void RewriteProgramHeadersForHole(Elf* elf,
typename ELF::Off hole_start,
ssize_t hole_size) {
const typename ELF::Ehdr* elf_header = ELF::getehdr(elf);
CHECK(elf_header);
typename ELF::Phdr* elf_program_header = ELF::getphdr(elf);
CHECK(elf_program_header);
const size_t program_header_count = elf_header->e_phnum;
// Locate the segment that we can overwrite to form the new LOAD entry,
// and the segment that we are going to split into two parts.
typename ELF::Phdr* target_load_header =
FindLoadSegmentForHole<ELF>(elf_program_header, program_header_count, hole_start);
VLOG(1) << "phdr[" << target_load_header - elf_program_header << "] adjust";
// Adjust PT_LOAD program header memsz and filesz
target_load_header->p_filesz += hole_size;
target_load_header->p_memsz += hole_size;
// Adjust the offsets and p_vaddrs
AdjustProgramHeaderFields<ELF>(elf_program_header,
program_header_count,
hole_start,
hole_size);
}
// Helper for ResizeSection(). Locate and return the dynamic section.
template <typename ELF>
static Elf_Scn* GetDynamicSection(Elf* elf) {
const typename ELF::Ehdr* elf_header = ELF::getehdr(elf);
CHECK(elf_header);
const typename ELF::Phdr* elf_program_header = ELF::getphdr(elf);
CHECK(elf_program_header);
// Find the program header that describes the dynamic section.
const typename ELF::Phdr* dynamic_program_header = NULL;
for (size_t i = 0; i < elf_header->e_phnum; ++i) {
const typename ELF::Phdr* program_header = &elf_program_header[i];
if (program_header->p_type == PT_DYNAMIC) {
dynamic_program_header = program_header;
}
}
CHECK(dynamic_program_header);
// Now find the section with the same offset as this program header.
Elf_Scn* dynamic_section = NULL;
Elf_Scn* section = NULL;
while ((section = elf_nextscn(elf, section)) != NULL) {
typename ELF::Shdr* section_header = ELF::getshdr(section);
if (section_header->sh_offset == dynamic_program_header->p_offset) {
dynamic_section = section;
}
}
CHECK(dynamic_section != NULL);
return dynamic_section;
}
// Helper for ResizeSection(). Adjust the .dynamic section for the hole.
template <typename ELF>
void ElfFile<ELF>::AdjustDynamicSectionForHole(Elf_Scn* dynamic_section,
typename ELF::Off hole_start,
ssize_t hole_size,
relocations_type_t relocations_type) {
CHECK(relocations_type != NONE);
Elf_Data* data = GetSectionData(dynamic_section);
auto dynamic_base = reinterpret_cast<typename ELF::Dyn*>(data->d_buf);
std::vector<typename ELF::Dyn> dynamics(
dynamic_base,
dynamic_base + data->d_size / sizeof(dynamics[0]));
if (hole_size > 0) { // expanding
hole_start += hole_size;
}
for (size_t i = 0; i < dynamics.size(); ++i) {
typename ELF::Dyn* dynamic = &dynamics[i];
const typename ELF::Sword tag = dynamic->d_tag;
// Any tags that hold offsets are adjustment candidates.
const bool is_adjustable = (tag == DT_PLTGOT ||
tag == DT_HASH ||
tag == DT_GNU_HASH ||
tag == DT_STRTAB ||
tag == DT_SYMTAB ||
tag == DT_RELA ||
tag == DT_INIT ||
tag == DT_FINI ||
tag == DT_REL ||
tag == DT_JMPREL ||
tag == DT_INIT_ARRAY ||
tag == DT_FINI_ARRAY ||
tag == DT_VERSYM ||
tag == DT_VERNEED ||
tag == DT_VERDEF ||
tag == DT_ANDROID_REL||
tag == DT_ANDROID_RELA);
if (is_adjustable && dynamic->d_un.d_ptr <= hole_start) {
dynamic->d_un.d_ptr -= hole_size;
VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
<< " d_ptr adjusted to " << dynamic->d_un.d_ptr;
}
// DT_RELSZ or DT_RELASZ indicate the overall size of relocations.
// Only one will be present. Adjust by hole size.
if (tag == DT_RELSZ || tag == DT_RELASZ || tag == DT_ANDROID_RELSZ || tag == DT_ANDROID_RELASZ) {
dynamic->d_un.d_val += hole_size;
VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
<< " d_val adjusted to " << dynamic->d_un.d_val;
}
// Special case: DT_MIPS_RLD_MAP_REL stores the difference between dynamic
// entry address and the address of the _r_debug (used by GDB)
// since the dynamic section and target address are on the
// different sides of the hole it needs to be adjusted accordingly
if (tag == DT_MIPS_RLD_MAP_REL) {
dynamic->d_un.d_val += hole_size;
VLOG(1) << "dynamic[" << i << "] " << dynamic->d_tag
<< " d_val adjusted to " << dynamic->d_un.d_val;
}
// Ignore DT_RELCOUNT and DT_RELACOUNT: (1) nobody uses them and
// technically (2) the relative relocation count is not changed.
// DT_RELENT and DT_RELAENT don't change, ignore them as well.
}
void* section_data = &dynamics[0];
size_t bytes = dynamics.size() * sizeof(dynamics[0]);
RewriteSectionData(dynamic_section, section_data, bytes);
}
// Resize a section. If the new size is larger than the current size, open
// up a hole by increasing file offsets that come after the hole. If smaller
// than the current size, remove the hole by decreasing those offsets.
template <typename ELF>
void ElfFile<ELF>::ResizeSection(Elf* elf, Elf_Scn* section, size_t new_size,
typename ELF::Word new_sh_type,
relocations_type_t relocations_type) {
size_t string_index;
elf_getshdrstrndx(elf, &string_index);
auto section_header = ELF::getshdr(section);
std::string name = elf_strptr(elf, string_index, section_header->sh_name);
if (section_header->sh_size == new_size) {
return;
}
// Require that the section size and the data size are the same. True
// in practice for all sections we resize when packing or unpacking.
Elf_Data* data = GetSectionData(section);
CHECK(data->d_off == 0 && data->d_size == section_header->sh_size);
// Require that the section is not zero-length (that is, has allocated
// data that we can validly expand).
CHECK(data->d_size && data->d_buf);
const auto hole_start = section_header->sh_offset;
const ssize_t hole_size = new_size - data->d_size;
VLOG_IF(1, (hole_size > 0)) << "expand section (" << name << ") size: " <<
data->d_size << " -> " << (data->d_size + hole_size);
VLOG_IF(1, (hole_size < 0)) << "shrink section (" << name << ") size: " <<
data->d_size << " -> " << (data->d_size + hole_size);
// libelf overrides sh_entsize for known sh_types, so it does not matter what we set
// for SHT_REL/SHT_RELA.
typename ELF::Xword new_entsize =
(new_sh_type == SHT_ANDROID_REL || new_sh_type == SHT_ANDROID_RELA) ? 1 : 0;
VLOG(1) << "Update section (" << name << ") entry size: " <<
section_header->sh_entsize << " -> " << new_entsize;
// Resize the data and the section header.
data->d_size += hole_size;
section_header->sh_size += hole_size;
section_header->sh_entsize = new_entsize;
section_header->sh_type = new_sh_type;
// Add the hole size to all offsets in the ELF file that are after the
// start of the hole. If the hole size is positive we are expanding the
// section to create a new hole; if negative, we are closing up a hole.
// Start with the main ELF header.
typename ELF::Ehdr* elf_header = ELF::getehdr(elf);
AdjustElfHeaderForHole<ELF>(elf_header, hole_start, hole_size);
// Adjust all section headers.
AdjustSectionHeadersForHole<ELF>(elf, hole_start, hole_size);
// Rewrite the program headers to either split or coalesce segments,
// and adjust dynamic entries to match.
RewriteProgramHeadersForHole<ELF>(elf, hole_start, hole_size);
Elf_Scn* dynamic_section = GetDynamicSection<ELF>(elf);
AdjustDynamicSectionForHole(dynamic_section, hole_start, hole_size, relocations_type);
}
// Find the first slot in a dynamics array with the given tag. The array
// always ends with a free (unused) element, and which we exclude from the
// search. Returns dynamics->size() if not found.
template <typename ELF>
static size_t FindDynamicEntry(typename ELF::Sword tag,
std::vector<typename ELF::Dyn>* dynamics) {
// Loop until the penultimate entry. We exclude the end sentinel.
for (size_t i = 0; i < dynamics->size() - 1; ++i) {
if (dynamics->at(i).d_tag == tag) {
return i;
}
}
// The tag was not found.
return dynamics->size();
}
// Replace dynamic entry.
template <typename ELF>
static void ReplaceDynamicEntry(typename ELF::Sword tag,
const typename ELF::Dyn& dyn,
std::vector<typename ELF::Dyn>* dynamics) {
const size_t slot = FindDynamicEntry<ELF>(tag, dynamics);
if (slot == dynamics->size()) {
LOG(FATAL) << "Dynamic slot is not found for tag=" << tag;
}
// Replace this entry with the one supplied.
dynamics->at(slot) = dyn;
VLOG(1) << "dynamic[" << slot << "] overwritten with " << dyn.d_tag;
}
// Remove relative entries from dynamic relocations and write as packed
// data into android packed relocations.
template <typename ELF>
bool ElfFile<ELF>::PackRelocations() {
// Load the ELF file into libelf.
if (!Load()) {
LOG(ERROR) << "Failed to load as ELF";
return false;
}
if (relocations_section_ == nullptr) {
// There is nothing to do
return true;
}
// Retrieve the current dynamic relocations section data.
Elf_Data* data = GetSectionData(relocations_section_);
// we always pack rela, because packed format is pretty much the same
std::vector<typename ELF::Rela> relocations;
if (relocations_type_ == REL) {
// Convert data to a vector of relocations.
const typename ELF::Rel* relocations_base = reinterpret_cast<typename ELF::Rel*>(data->d_buf);
ConvertRelArrayToRelaVector(relocations_base,
data->d_size / sizeof(typename ELF::Rel), &relocations);
VLOG(1) << "Relocations : REL";
} else if (relocations_type_ == RELA) {
// Convert data to a vector of relocations with addends.
const typename ELF::Rela* relocations_base = reinterpret_cast<typename ELF::Rela*>(data->d_buf);
relocations = std::vector<typename ELF::Rela>(
relocations_base,
relocations_base + data->d_size / sizeof(relocations[0]));
VLOG(1) << "Relocations : RELA";
} else {
NOTREACHED();
}
return PackTypedRelocations(&relocations);
}
// Helper for PackRelocations(). Rel type is one of ELF::Rel or ELF::Rela.
template <typename ELF>
bool ElfFile<ELF>::PackTypedRelocations(std::vector<typename ELF::Rela>* relocations) {
typedef typename ELF::Rela Rela;
if (has_android_relocations_) {
LOG(INFO) << "Relocation table is already packed";
return true;
}
// If no relocations then we have nothing packable. Perhaps
// the shared object has already been packed?
if (relocations->empty()) {
LOG(ERROR) << "No relocations found";
return false;
}
const size_t rel_size =
relocations_type_ == RELA ? sizeof(typename ELF::Rela) : sizeof(typename ELF::Rel);
const size_t initial_bytes = relocations->size() * rel_size;
VLOG(1) << "Unpacked : " << initial_bytes << " bytes";
std::vector<uint8_t> packed;
RelocationPacker<ELF> packer;
// Pack relocations: dry run to estimate memory savings.
packer.PackRelocations(*relocations, &packed);
const size_t packed_bytes_estimate = packed.size() * sizeof(packed[0]);
VLOG(1) << "Packed (no padding): " << packed_bytes_estimate << " bytes";
if (packed.empty()) {
VLOG(1) << "Too few relocations to pack";
return true;
}
// Pre-calculate the size of the hole we will close up when we rewrite
// dynamic relocations. We have to adjust relocation addresses to
// account for this.
typename ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
ssize_t hole_size = initial_bytes - packed_bytes_estimate;
// hole_size needs to be page_aligned.
hole_size -= hole_size % kPreserveAlignment;
VLOG(1) << "Compaction : " << hole_size << " bytes";
// Adjusting for alignment may have removed any packing benefit.
if (hole_size == 0) {
VLOG(1) << "Too few relocations to pack after alignment";
return true;
}
if (hole_size <= 0) {
VLOG(1) << "Packing relocations saves no space";
return true;
}
size_t data_padding_bytes = is_padding_relocations_ ?
initial_bytes - packed_bytes_estimate :
initial_bytes - hole_size - packed_bytes_estimate;
// pad data
std::vector<uint8_t> padding(data_padding_bytes, 0);
packed.insert(packed.end(), padding.begin(), padding.end());
const void* packed_data = &packed[0];
// Run a loopback self-test as a check that packing is lossless.
std::vector<Rela> unpacked;
packer.UnpackRelocations(packed, &unpacked);
CHECK(unpacked.size() == relocations->size());
CHECK(!memcmp(&unpacked[0],
&relocations->at(0),
unpacked.size() * sizeof(unpacked[0])));
// Rewrite the current dynamic relocations section with packed one then shrink it to size.
const size_t bytes = packed.size() * sizeof(packed[0]);
ResizeSection(elf_, relocations_section_, bytes,
relocations_type_ == REL ? SHT_ANDROID_REL : SHT_ANDROID_RELA, relocations_type_);
RewriteSectionData(relocations_section_, packed_data, bytes);
// TODO (dimitry): fix string table and replace .rel.dyn/plt with .android.rel.dyn/plt
// Rewrite .dynamic and rename relocation tags describing the packed android
// relocations.
Elf_Data* data = GetSectionData(dynamic_section_);
const typename ELF::Dyn* dynamic_base = reinterpret_cast<typename ELF::Dyn*>(data->d_buf);
std::vector<typename ELF::Dyn> dynamics(
dynamic_base,
dynamic_base + data->d_size / sizeof(dynamics[0]));
section_header = ELF::getshdr(relocations_section_);
{
typename ELF::Dyn dyn;
dyn.d_tag = relocations_type_ == REL ? DT_ANDROID_REL : DT_ANDROID_RELA;
dyn.d_un.d_ptr = section_header->sh_addr;
ReplaceDynamicEntry<ELF>(relocations_type_ == REL ? DT_REL : DT_RELA, dyn, &dynamics);
}
{
typename ELF::Dyn dyn;
dyn.d_tag = relocations_type_ == REL ? DT_ANDROID_RELSZ : DT_ANDROID_RELASZ;
dyn.d_un.d_val = section_header->sh_size;
ReplaceDynamicEntry<ELF>(relocations_type_ == REL ? DT_RELSZ : DT_RELASZ, dyn, &dynamics);
}
const void* dynamics_data = &dynamics[0];
const size_t dynamics_bytes = dynamics.size() * sizeof(dynamics[0]);
RewriteSectionData(dynamic_section_, dynamics_data, dynamics_bytes);
Flush();
return true;
}
// Find packed relative relocations in the packed android relocations
// section, unpack them, and rewrite the dynamic relocations section to
// contain unpacked data.
template <typename ELF>
bool ElfFile<ELF>::UnpackRelocations() {
// Load the ELF file into libelf.
if (!Load()) {
LOG(ERROR) << "Failed to load as ELF";
return false;
}
if (relocations_section_ == nullptr) {
// There is nothing to do
return true;
}
typename ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
// Retrieve the current packed android relocations section data.
Elf_Data* data = GetSectionData(relocations_section_);
// Convert data to a vector of bytes.
const uint8_t* packed_base = reinterpret_cast<uint8_t*>(data->d_buf);
std::vector<uint8_t> packed(
packed_base,
packed_base + data->d_size / sizeof(packed[0]));
if ((section_header->sh_type == SHT_ANDROID_RELA || section_header->sh_type == SHT_ANDROID_REL) &&
packed.size() > 3 &&
packed[0] == 'A' &&
packed[1] == 'P' &&
packed[2] == 'S' &&
packed[3] == '2') {
LOG(INFO) << "Relocations : " << (relocations_type_ == REL ? "REL" : "RELA");
} else {
LOG(ERROR) << "Packed relocations not found (not packed?)";
return false;
}
return UnpackTypedRelocations(packed);
}
// Helper for UnpackRelocations(). Rel type is one of ELF::Rel or ELF::Rela.
template <typename ELF>
bool ElfFile<ELF>::UnpackTypedRelocations(const std::vector<uint8_t>& packed) {
// Unpack the data to re-materialize the relative relocations.
const size_t packed_bytes = packed.size() * sizeof(packed[0]);
LOG(INFO) << "Packed : " << packed_bytes << " bytes";
std::vector<typename ELF::Rela> unpacked_relocations;
RelocationPacker<ELF> packer;
packer.UnpackRelocations(packed, &unpacked_relocations);
const size_t relocation_entry_size =
relocations_type_ == REL ? sizeof(typename ELF::Rel) : sizeof(typename ELF::Rela);
const size_t unpacked_bytes = unpacked_relocations.size() * relocation_entry_size;
LOG(INFO) << "Unpacked : " << unpacked_bytes << " bytes";
// Retrieve the current dynamic relocations section data.
Elf_Data* data = GetSectionData(relocations_section_);
LOG(INFO) << "Relocations : " << unpacked_relocations.size() << " entries";
// If we found the same number of null relocation entries in the dynamic
// relocations section as we hold as unpacked relative relocations, then
// this is a padded file.
const bool is_padded = packed_bytes == unpacked_bytes;
// Unless padded, pre-apply relative relocations to account for the
// hole, and pre-adjust all relocation offsets accordingly.
typename ELF::Shdr* section_header = ELF::getshdr(relocations_section_);
if (!is_padded) {
LOG(INFO) << "Expansion : " << unpacked_bytes - packed_bytes << " bytes";
}
// Rewrite the current dynamic relocations section with unpacked version of
// relocations.
const void* section_data = nullptr;
std::vector<typename ELF::Rel> unpacked_rel_relocations;
if (relocations_type_ == RELA) {
section_data = &unpacked_relocations[0];
} else if (relocations_type_ == REL) {
ConvertRelaVectorToRelVector(unpacked_relocations, &unpacked_rel_relocations);
section_data = &unpacked_rel_relocations[0];
} else {
NOTREACHED();
}
ResizeSection(elf_, relocations_section_, unpacked_bytes,
relocations_type_ == REL ? SHT_REL : SHT_RELA, relocations_type_);
RewriteSectionData(relocations_section_, section_data, unpacked_bytes);
// Rewrite .dynamic to remove two tags describing packed android relocations.
data = GetSectionData(dynamic_section_);
const typename ELF::Dyn* dynamic_base = reinterpret_cast<typename ELF::Dyn*>(data->d_buf);
std::vector<typename ELF::Dyn> dynamics(
dynamic_base,
dynamic_base + data->d_size / sizeof(dynamics[0]));
{
typename ELF::Dyn dyn;
dyn.d_tag = relocations_type_ == REL ? DT_REL : DT_RELA;
dyn.d_un.d_ptr = section_header->sh_addr;
ReplaceDynamicEntry<ELF>(relocations_type_ == REL ? DT_ANDROID_REL : DT_ANDROID_RELA,
dyn, &dynamics);
}
{
typename ELF::Dyn dyn;
dyn.d_tag = relocations_type_ == REL ? DT_RELSZ : DT_RELASZ;
dyn.d_un.d_val = section_header->sh_size;
ReplaceDynamicEntry<ELF>(relocations_type_ == REL ? DT_ANDROID_RELSZ : DT_ANDROID_RELASZ,
dyn, &dynamics);
}
const void* dynamics_data = &dynamics[0];
const size_t dynamics_bytes = dynamics.size() * sizeof(dynamics[0]);
RewriteSectionData(dynamic_section_, dynamics_data, dynamics_bytes);
Flush();
return true;
}
// Flush rewritten shared object file data.
template <typename ELF>
void ElfFile<ELF>::Flush() {
// Flag all ELF data held in memory as needing to be written back to the
// file, and tell libelf that we have controlled the file layout.
elf_flagelf(elf_, ELF_C_SET, ELF_F_DIRTY);
elf_flagelf(elf_, ELF_C_SET, ELF_F_LAYOUT);
// Write ELF data back to disk.
const off_t file_bytes = elf_update(elf_, ELF_C_WRITE);
if (file_bytes == -1) {
LOG(ERROR) << "elf_update failed: " << elf_errmsg(elf_errno());
}
CHECK(file_bytes > 0);
VLOG(1) << "elf_update returned: " << file_bytes;
// Clean up libelf, and truncate the output file to the number of bytes
// written by elf_update().
elf_end(elf_);
elf_ = NULL;
const int truncate = ftruncate(fd_, file_bytes);
CHECK(truncate == 0);
}
template <typename ELF>
void ElfFile<ELF>::ConvertRelArrayToRelaVector(const typename ELF::Rel* rel_array,
size_t rel_array_size,
std::vector<typename ELF::Rela>* rela_vector) {
for (size_t i = 0; i<rel_array_size; ++i) {
typename ELF::Rela rela;
rela.r_offset = rel_array[i].r_offset;
rela.r_info = rel_array[i].r_info;
rela.r_addend = 0;
rela_vector->push_back(rela);
}
}
template <typename ELF>
void ElfFile<ELF>::ConvertRelaVectorToRelVector(const std::vector<typename ELF::Rela>& rela_vector,
std::vector<typename ELF::Rel>* rel_vector) {
for (auto rela : rela_vector) {
typename ELF::Rel rel;
rel.r_offset = rela.r_offset;
rel.r_info = rela.r_info;
CHECK(rela.r_addend == 0);
rel_vector->push_back(rel);
}
}
template class ElfFile<ELF32_traits>;
template class ElfFile<ELF64_traits>;
} // namespace relocation_packer