474 lines
19 KiB
Diff
474 lines
19 KiB
Diff
Rework the growing algorithm in patchelf to support ARM systems.
|
||
See <https://github.com/NixOS/patchelf/issues/8>.
|
||
This patch copied from:
|
||
<https://github.com/sriemer/patchelf/commit/0a96239cea6b97b9a0fff80da576e58ca2dfb2a2>
|
||
|
||
From 0a96239cea6b97b9a0fff80da576e58ca2dfb2a2 Mon Sep 17 00:00:00 2001
|
||
From: Sebastian Parschauer <s.parschauer@gmx.de>
|
||
Date: Sat, 28 Jun 2014 01:24:57 +0200
|
||
Subject: [PATCH] Rework the growing algorithm
|
||
|
||
On ARM systems there is no space in virtual memory for another LOAD
|
||
area in front of the code LOAD area. So insert data to its end
|
||
instead. At this location there should be enough space in virtual
|
||
memory due to alignment. We can extend it until the end of the
|
||
alignment but the file shift may be greater as it must be aligned
|
||
to the page size. Do the same for the data LOAD area.
|
||
---
|
||
src/patchelf.cc | 357 ++++++++++++++++++++++----------------------------------
|
||
1 file changed, 142 insertions(+), 215 deletions(-)
|
||
|
||
diff --git a/src/patchelf.cc b/src/patchelf.cc
|
||
index dcbfd38..4fce9e6 100644
|
||
--- a/src/patchelf.cc
|
||
+++ b/src/patchelf.cc
|
||
@@ -116,7 +116,11 @@ private:
|
||
|
||
void sortShdrs();
|
||
|
||
- void shiftFile(unsigned int extraPages, Elf_Addr startPage);
|
||
+ void shiftFileSingle(size_t fileShift, Elf_Off insertOff);
|
||
+
|
||
+ void shiftFile(size_t neededCode, size_t neededData,
|
||
+ Elf_Off codeOff[], Elf_Off dataOff[],
|
||
+ Elf_Addr *codePage, Elf_Addr *dataPage);
|
||
|
||
string getSectionName(const Elf_Shdr & shdr);
|
||
|
||
@@ -130,13 +134,11 @@ private:
|
||
unsigned int size);
|
||
|
||
void writeReplacedSections(Elf_Off & curOff,
|
||
- Elf_Addr startAddr, Elf_Off startOffset);
|
||
+ Elf_Addr startAddr, Elf_Off startOffset, bool isData);
|
||
|
||
void rewriteHeaders(Elf_Addr phdrAddress);
|
||
|
||
- void rewriteSectionsLibrary();
|
||
-
|
||
- void rewriteSectionsExecutable();
|
||
+ void rewriteSectionsBinary();
|
||
|
||
public:
|
||
|
||
@@ -391,46 +393,119 @@ static unsigned int roundUp(unsigned int n, unsigned int m)
|
||
|
||
|
||
template<ElfFileParams>
|
||
-void ElfFile<ElfFileParamNames>::shiftFile(unsigned int extraPages, Elf_Addr startPage)
|
||
+void ElfFile<ElfFileParamNames>::shiftFileSingle(size_t fileShift,
|
||
+ Elf_Off insertOff)
|
||
{
|
||
- /* Move the entire contents of the file `extraPages' pages
|
||
- further. */
|
||
unsigned int oldSize = fileSize;
|
||
- unsigned int shift = extraPages * pageSize;
|
||
- growFile(fileSize + extraPages * pageSize);
|
||
- memmove(contents + extraPages * pageSize, contents, oldSize);
|
||
- memset(contents + sizeof(Elf_Ehdr), 0, shift - sizeof(Elf_Ehdr));
|
||
+
|
||
+ /* Grow at the end */
|
||
+ growFile(fileSize + fileShift);
|
||
+
|
||
+ /* move the data from the insertion point
|
||
+ to the end and zero inserted space */
|
||
+ memmove(contents + insertOff + fileShift,
|
||
+ contents + insertOff, oldSize - insertOff);
|
||
+ memset(contents + insertOff, 0, fileShift);
|
||
|
||
/* Adjust the ELF header. */
|
||
wri(hdr->e_phoff, sizeof(Elf_Ehdr));
|
||
- wri(hdr->e_shoff, rdi(hdr->e_shoff) + shift);
|
||
+ if (rdi(hdr->e_shoff) >= insertOff)
|
||
+ wri(hdr->e_shoff, rdi(hdr->e_shoff) + fileShift);
|
||
|
||
/* Update the offsets in the section headers. */
|
||
- for (int i = 1; i < rdi(hdr->e_shnum); ++i)
|
||
- wri(shdrs[i].sh_offset, rdi(shdrs[i].sh_offset) + shift);
|
||
+ for (int i = 1; i < rdi(hdr->e_shnum); ++i) {
|
||
+ if (rdi(shdrs[i].sh_offset) >= insertOff)
|
||
+ wri(shdrs[i].sh_offset, rdi(shdrs[i].sh_offset) + fileShift);
|
||
+ }
|
||
|
||
/* Update the offsets in the program headers. */
|
||
for (int i = 0; i < rdi(hdr->e_phnum); ++i) {
|
||
- wri(phdrs[i].p_offset, rdi(phdrs[i].p_offset) + shift);
|
||
- if (rdi(phdrs[i].p_align) != 0 &&
|
||
- (rdi(phdrs[i].p_vaddr) - rdi(phdrs[i].p_offset)) % rdi(phdrs[i].p_align) != 0) {
|
||
- debug("changing alignment of program header %d from %d to %d\n", i,
|
||
- rdi(phdrs[i].p_align), pageSize);
|
||
- wri(phdrs[i].p_align, pageSize);
|
||
+ if (rdi(phdrs[i].p_offset) >= insertOff)
|
||
+ wri(phdrs[i].p_offset, rdi(phdrs[i].p_offset) + fileShift);
|
||
+ /* Check for ELF load command alignment issue the same
|
||
+ way as glibc/elf/dl-load.c does. This gives us the
|
||
+ chance to run an interpreter explicitly. */
|
||
+ if (rdi(phdrs[i].p_type) == PT_LOAD && ((rdi(phdrs[i].p_vaddr) -
|
||
+ rdi(phdrs[i].p_offset)) & (rdi(phdrs[i].p_align) - 1)) != 0) {
|
||
+ debug("changing alignment of program header %d from %d to %d\n",
|
||
+ i, rdi(phdrs[i].p_align), pageSize);
|
||
+ wri(phdrs[i].p_align, pageSize);
|
||
}
|
||
}
|
||
+}
|
||
+
|
||
+template<ElfFileParams>
|
||
+void ElfFile<ElfFileParamNames>::shiftFile(size_t neededCode,
|
||
+ size_t neededData, Elf_Off codeOff[], Elf_Off dataOff[],
|
||
+ Elf_Addr *codePage, Elf_Addr *dataPage)
|
||
+{
|
||
+ /* Move some contents of the file further. The binary has one LOAD area
|
||
+ * for code and one for data. There is virtual memory space between
|
||
+ * these which we can use due to alignment.
|
||
+ */
|
||
+ unsigned int memShift = neededCode;
|
||
+ unsigned int fileShift = roundUp(neededCode, pageSize);
|
||
+ unsigned int maxMemShift = 0;
|
||
+
|
||
+ if (neededCode > 0) {
|
||
+ /* find the LOAD program header for code and extend it */
|
||
+ for (int i = 0; i < rdi(hdr->e_phnum); ++i) {
|
||
+ if (rdi(phdrs[i].p_type) == PT_LOAD &&
|
||
+ rdi(phdrs[i].p_flags) & PF_X) {
|
||
+ codeOff[1] = rdi(phdrs[i].p_filesz);
|
||
+ codeOff[0] = codeOff[1] + rdi(phdrs[i].p_offset);
|
||
+ maxMemShift = rdi(phdrs[i].p_memsz) % rdi(phdrs[i].p_align);
|
||
+ if (maxMemShift == 0)
|
||
+ continue;
|
||
+ maxMemShift = rdi(phdrs[i].p_align) - maxMemShift;
|
||
+ if (maxMemShift == 0 || memShift > maxMemShift)
|
||
+ continue;
|
||
+ *codePage = rdi(phdrs[i].p_vaddr);
|
||
+ wri(phdrs[i].p_filesz, rdi(phdrs[i].p_filesz) + memShift);
|
||
+ wri(phdrs[i].p_memsz, rdi(phdrs[i].p_memsz) + memShift);
|
||
+ break;
|
||
+ }
|
||
+ }
|
||
+ debug("codeOff: %#lx, memShift: %d, maxMemShift: %d, fileShift: %d\n",
|
||
+ codeOff[1], memShift, maxMemShift, fileShift);
|
||
+ if (codeOff[1] == 0 || maxMemShift == 0)
|
||
+ goto out;
|
||
+
|
||
+ shiftFileSingle(fileShift, codeOff[0]);
|
||
+ }
|
||
+
|
||
+ /* +++ Do the same for the data LOAD area +++ */
|
||
+ memShift = neededData;
|
||
+ fileShift = roundUp(neededData, pageSize);
|
||
+ maxMemShift = 0;
|
||
+ if (neededData > 0) {
|
||
+ /* find the LOAD program header for data and extend it */
|
||
+ for (int i = 0; i < rdi(hdr->e_phnum); ++i) {
|
||
+ if (rdi(phdrs[i].p_type) == PT_LOAD &&
|
||
+ rdi(phdrs[i].p_flags) & PF_W) {
|
||
+ dataOff[1] = rdi(phdrs[i].p_filesz);
|
||
+ dataOff[0] = dataOff[1] + rdi(phdrs[i].p_offset);
|
||
+ maxMemShift = rdi(phdrs[i].p_memsz) % rdi(phdrs[i].p_align);
|
||
+ if (maxMemShift == 0)
|
||
+ continue;
|
||
+ maxMemShift = rdi(phdrs[i].p_align) - maxMemShift;
|
||
+ if (maxMemShift == 0 || memShift > maxMemShift)
|
||
+ continue;
|
||
+ *dataPage = rdi(phdrs[i].p_vaddr);
|
||
+ wri(phdrs[i].p_filesz, rdi(phdrs[i].p_filesz) + memShift);
|
||
+ wri(phdrs[i].p_memsz, rdi(phdrs[i].p_memsz) + memShift);
|
||
+ break;
|
||
+ }
|
||
+ }
|
||
+ debug("dataOff: %#lx, memShift: %d, maxMemShift: %d, fileShift: %d\n",
|
||
+ dataOff[1], memShift, maxMemShift, fileShift);
|
||
+ if (dataOff[1] == 0 || maxMemShift == 0)
|
||
+ goto out;
|
||
|
||
- /* Add a segment that maps the new program/section headers and
|
||
- PT_INTERP segment into memory. Otherwise glibc will choke. */
|
||
- phdrs.resize(rdi(hdr->e_phnum) + 1);
|
||
- wri(hdr->e_phnum, rdi(hdr->e_phnum) + 1);
|
||
- Elf_Phdr & phdr = phdrs[rdi(hdr->e_phnum) - 1];
|
||
- wri(phdr.p_type, PT_LOAD);
|
||
- wri(phdr.p_offset, 0);
|
||
- wri(phdr.p_vaddr, wri(phdr.p_paddr, startPage));
|
||
- wri(phdr.p_filesz, wri(phdr.p_memsz, shift));
|
||
- wri(phdr.p_flags, PF_R | PF_W);
|
||
- wri(phdr.p_align, pageSize);
|
||
+ shiftFileSingle(fileShift, dataOff[0]);
|
||
+ }
|
||
+out:
|
||
+ return;
|
||
}
|
||
|
||
|
||
@@ -491,7 +566,7 @@ string & ElfFile<ElfFileParamNames>::replaceSection(const SectionName & sectionN
|
||
|
||
template<ElfFileParams>
|
||
void ElfFile<ElfFileParamNames>::writeReplacedSections(Elf_Off & curOff,
|
||
- Elf_Addr startAddr, Elf_Off startOffset)
|
||
+ Elf_Addr startAddr, Elf_Off startOffset, bool isData = false)
|
||
{
|
||
/* Overwrite the old section contents with 'X's. Do this
|
||
*before* writing the new section contents (below) to prevent
|
||
@@ -501,6 +576,9 @@ void ElfFile<ElfFileParamNames>::writeReplacedSections(Elf_Off & curOff,
|
||
{
|
||
string sectionName = i->first;
|
||
Elf_Shdr & shdr = findSection(sectionName);
|
||
+ if ((!isData && rdi(shdr.sh_flags) & SHF_WRITE) ||
|
||
+ (isData && ~(rdi(shdr.sh_flags)) & SHF_WRITE))
|
||
+ continue;
|
||
memset(contents + rdi(shdr.sh_offset), 'X', rdi(shdr.sh_size));
|
||
}
|
||
|
||
@@ -509,6 +587,9 @@ void ElfFile<ElfFileParamNames>::writeReplacedSections(Elf_Off & curOff,
|
||
{
|
||
string sectionName = i->first;
|
||
Elf_Shdr & shdr = findSection(sectionName);
|
||
+ if ((!isData && rdi(shdr.sh_flags) & SHF_WRITE) ||
|
||
+ (isData && ~(rdi(shdr.sh_flags)) & SHF_WRITE))
|
||
+ continue;
|
||
debug("rewriting section `%s' from offset 0x%x (size %d) to offset 0x%x (size %d)\n",
|
||
sectionName.c_str(), rdi(shdr.sh_offset), rdi(shdr.sh_size), curOff, i->second.size());
|
||
|
||
@@ -546,201 +627,47 @@ void ElfFile<ElfFileParamNames>::writeReplacedSections(Elf_Off & curOff,
|
||
curOff += roundUp(i->second.size(), sectionAlignment);
|
||
}
|
||
|
||
- replacedSections.clear();
|
||
+ if (isData)
|
||
+ replacedSections.clear();
|
||
}
|
||
|
||
|
||
template<ElfFileParams>
|
||
-void ElfFile<ElfFileParamNames>::rewriteSectionsLibrary()
|
||
+void ElfFile<ElfFileParamNames>::rewriteSectionsBinary()
|
||
{
|
||
- /* For dynamic libraries, we just place the replacement sections
|
||
- at the end of the file. They're mapped into memory by a
|
||
- PT_LOAD segment located directly after the last virtual address
|
||
- page of other segments. */
|
||
- Elf_Addr startPage = 0;
|
||
- for (unsigned int i = 0; i < phdrs.size(); ++i) {
|
||
- Elf_Addr thisPage = roundUp(rdi(phdrs[i].p_vaddr) + rdi(phdrs[i].p_memsz), pageSize);
|
||
- if (thisPage > startPage) startPage = thisPage;
|
||
- }
|
||
-
|
||
- debug("last page is 0x%llx\n", (unsigned long long) startPage);
|
||
+ Elf_Off codeOff[2] = {0}, dataOff[2] = {0};
|
||
+ Elf_Addr codePage = 0, dataPage = 0;
|
||
+ size_t neededCode = 0, neededData = 0, oldCode = 0, oldData = 0;
|
||
+ Elf_Shdr shdr = findSection(".text");
|
||
+ Elf_Addr firstPage = rdi(shdr.sh_addr) - rdi(shdr.sh_offset);
|
||
|
||
+ debug("first page is 0x%llx\n", (unsigned long long) firstPage);
|
||
|
||
- /* Compute the total space needed for the replaced sections and
|
||
- the program headers. */
|
||
- off_t neededSpace = (phdrs.size() + 1) * sizeof(Elf_Phdr);
|
||
+ /* Compute the total space needed for the replaced sections */
|
||
for (ReplacedSections::iterator i = replacedSections.begin();
|
||
- i != replacedSections.end(); ++i)
|
||
- neededSpace += roundUp(i->second.size(), sectionAlignment);
|
||
- debug("needed space is %d\n", neededSpace);
|
||
-
|
||
-
|
||
- size_t startOffset = roundUp(fileSize, pageSize);
|
||
-
|
||
- growFile(startOffset + neededSpace);
|
||
-
|
||
-
|
||
- /* Even though this file is of type ET_DYN, it could actually be
|
||
- an executable. For instance, Gold produces executables marked
|
||
- ET_DYN. In that case we can still hit the kernel bug that
|
||
- necessitated rewriteSectionsExecutable(). However, such
|
||
- executables also tend to start at virtual address 0, so
|
||
- rewriteSectionsExecutable() won't work because it doesn't have
|
||
- any virtual address space to grow downwards into. As a
|
||
- workaround, make sure that the virtual address of our new
|
||
- PT_LOAD segment relative to the first PT_LOAD segment is equal
|
||
- to its offset; otherwise we hit the kernel bug. This may
|
||
- require creating a hole in the executable. The bigger the size
|
||
- of the uninitialised data segment, the bigger the hole. */
|
||
- if (isExecutable) {
|
||
- if (startOffset >= startPage) {
|
||
- debug("shifting new PT_LOAD segment by %d bytes to work around a Linux kernel bug\n", startOffset - startPage);
|
||
- } else {
|
||
- size_t hole = startPage - startOffset;
|
||
- /* Print a warning, because the hole could be very big. */
|
||
- fprintf(stderr, "warning: working around a Linux kernel bug by creating a hole of %zu bytes in ‘%s’\n", hole, fileName.c_str());
|
||
- assert(hole % pageSize == 0);
|
||
- /* !!! We could create an actual hole in the file here,
|
||
- but it's probably not worth the effort. */
|
||
- growFile(fileSize + hole);
|
||
- startOffset += hole;
|
||
- }
|
||
- startPage = startOffset;
|
||
- }
|
||
-
|
||
-
|
||
- /* Add a segment that maps the replaced sections and program
|
||
- headers into memory. */
|
||
- phdrs.resize(rdi(hdr->e_phnum) + 1);
|
||
- wri(hdr->e_phnum, rdi(hdr->e_phnum) + 1);
|
||
- Elf_Phdr & phdr = phdrs[rdi(hdr->e_phnum) - 1];
|
||
- wri(phdr.p_type, PT_LOAD);
|
||
- wri(phdr.p_offset, startOffset);
|
||
- wri(phdr.p_vaddr, wri(phdr.p_paddr, startPage));
|
||
- wri(phdr.p_filesz, wri(phdr.p_memsz, neededSpace));
|
||
- wri(phdr.p_flags, PF_R | PF_W);
|
||
- wri(phdr.p_align, pageSize);
|
||
-
|
||
-
|
||
- /* Write out the replaced sections. */
|
||
- Elf_Off curOff = startOffset + phdrs.size() * sizeof(Elf_Phdr);
|
||
- writeReplacedSections(curOff, startPage, startOffset);
|
||
- assert((off_t) curOff == startOffset + neededSpace);
|
||
-
|
||
-
|
||
- /* Move the program header to the start of the new area. */
|
||
- wri(hdr->e_phoff, startOffset);
|
||
-
|
||
- rewriteHeaders(startPage);
|
||
-}
|
||
-
|
||
-
|
||
-template<ElfFileParams>
|
||
-void ElfFile<ElfFileParamNames>::rewriteSectionsExecutable()
|
||
-{
|
||
- /* Sort the sections by offset, otherwise we won't correctly find
|
||
- all the sections before the last replaced section. */
|
||
- sortShdrs();
|
||
-
|
||
-
|
||
- /* What is the index of the last replaced section? */
|
||
- unsigned int lastReplaced = 0;
|
||
- for (unsigned int i = 1; i < rdi(hdr->e_shnum); ++i) {
|
||
- string sectionName = getSectionName(shdrs[i]);
|
||
- if (replacedSections.find(sectionName) != replacedSections.end()) {
|
||
- debug("using replaced section `%s'\n", sectionName.c_str());
|
||
- lastReplaced = i;
|
||
- }
|
||
- }
|
||
-
|
||
- assert(lastReplaced != 0);
|
||
-
|
||
- debug("last replaced is %d\n", lastReplaced);
|
||
-
|
||
- /* Try to replace all sections before that, as far as possible.
|
||
- Stop when we reach an irreplacable section (such as one of type
|
||
- SHT_PROGBITS). These cannot be moved in virtual address space
|
||
- since that would invalidate absolute references to them. */
|
||
- assert(lastReplaced + 1 < shdrs.size()); /* !!! I'm lazy. */
|
||
- size_t startOffset = rdi(shdrs[lastReplaced + 1].sh_offset);
|
||
- Elf_Addr startAddr = rdi(shdrs[lastReplaced + 1].sh_addr);
|
||
- string prevSection;
|
||
- for (unsigned int i = 1; i <= lastReplaced; ++i) {
|
||
- Elf_Shdr & shdr(shdrs[i]);
|
||
- string sectionName = getSectionName(shdr);
|
||
- debug("looking at section `%s'\n", sectionName.c_str());
|
||
- /* !!! Why do we stop after a .dynstr section? I can't
|
||
- remember! */
|
||
- if ((rdi(shdr.sh_type) == SHT_PROGBITS && sectionName != ".interp")
|
||
- || prevSection == ".dynstr")
|
||
- {
|
||
- startOffset = rdi(shdr.sh_offset);
|
||
- startAddr = rdi(shdr.sh_addr);
|
||
- lastReplaced = i - 1;
|
||
- break;
|
||
+ i != replacedSections.end(); ++i) {
|
||
+ shdr = findSection(i->first);
|
||
+ if (rdi(shdr.sh_flags) & SHF_WRITE) {
|
||
+ oldData += rdi(shdr.sh_size);
|
||
+ neededData += roundUp(i->second.size(), sectionAlignment);
|
||
} else {
|
||
- if (replacedSections.find(sectionName) == replacedSections.end()) {
|
||
- debug("replacing section `%s' which is in the way\n", sectionName.c_str());
|
||
- replaceSection(sectionName, rdi(shdr.sh_size));
|
||
- }
|
||
+ oldCode += rdi(shdr.sh_size);
|
||
+ neededCode += roundUp(i->second.size(), sectionAlignment);
|
||
}
|
||
- prevSection = sectionName;
|
||
}
|
||
|
||
- debug("first reserved offset/addr is 0x%x/0x%llx\n",
|
||
- startOffset, (unsigned long long) startAddr);
|
||
-
|
||
- assert(startAddr % pageSize == startOffset % pageSize);
|
||
- Elf_Addr firstPage = startAddr - startOffset;
|
||
- debug("first page is 0x%llx\n", (unsigned long long) firstPage);
|
||
-
|
||
- /* Right now we assume that the section headers are somewhere near
|
||
- the end, which appears to be the case most of the time.
|
||
- Therefore they're not accidentally overwritten by the replaced
|
||
- sections. !!! Fix this. */
|
||
- assert((off_t) rdi(hdr->e_shoff) >= startOffset);
|
||
-
|
||
-
|
||
- /* Compute the total space needed for the replaced sections, the
|
||
- ELF header, and the program headers. */
|
||
- size_t neededSpace = sizeof(Elf_Ehdr) + phdrs.size() * sizeof(Elf_Phdr);
|
||
- for (ReplacedSections::iterator i = replacedSections.begin();
|
||
- i != replacedSections.end(); ++i)
|
||
- neededSpace += roundUp(i->second.size(), sectionAlignment);
|
||
-
|
||
- debug("needed space is %d\n", neededSpace);
|
||
-
|
||
- /* If we need more space at the start of the file, then grow the
|
||
- file by the minimum number of pages and adjust internal
|
||
- offsets. */
|
||
- if (neededSpace > startOffset) {
|
||
-
|
||
- /* We also need an additional program header, so adjust for that. */
|
||
- neededSpace += sizeof(Elf_Phdr);
|
||
- debug("needed space is %d\n", neededSpace);
|
||
-
|
||
- unsigned int neededPages = roundUp(neededSpace - startOffset, pageSize) / pageSize;
|
||
- debug("needed pages is %d\n", neededPages);
|
||
- if (neededPages * pageSize > firstPage)
|
||
- error("virtual address space underrun!");
|
||
-
|
||
- firstPage -= neededPages * pageSize;
|
||
- startOffset += neededPages * pageSize;
|
||
-
|
||
- shiftFile(neededPages, firstPage);
|
||
- }
|
||
-
|
||
-
|
||
- /* Clear out the free space. */
|
||
- Elf_Off curOff = sizeof(Elf_Ehdr) + phdrs.size() * sizeof(Elf_Phdr);
|
||
- debug("clearing first %d bytes\n", startOffset - curOff);
|
||
- memset(contents + curOff, 0, startOffset - curOff);
|
||
+ debug("needed space is C: %d, D: %d\n", neededCode, neededData);
|
||
|
||
+ /* If we need more space within the file, then grow the
|
||
+ file and adjust internal offsets. */
|
||
+ shiftFile(neededCode, neededData, codeOff, dataOff, &codePage,
|
||
+ &dataPage);
|
||
+ assert(codeOff[0] > 0);
|
||
|
||
/* Write out the replaced sections. */
|
||
- writeReplacedSections(curOff, firstPage, 0);
|
||
- assert((off_t) curOff == neededSpace);
|
||
-
|
||
+ debug("codePage: %#lx, dataPage: %#lx\n", codePage, dataPage);
|
||
+ writeReplacedSections(codeOff[0], codePage + codeOff[1], codeOff[0]);
|
||
+ writeReplacedSections(dataOff[0], dataPage + dataOff[1], dataOff[0], true);
|
||
|
||
rewriteHeaders(firstPage + rdi(hdr->e_phoff));
|
||
}
|
||
@@ -758,10 +685,10 @@ void ElfFile<ElfFileParamNames>::rewriteSections()
|
||
|
||
if (rdi(hdr->e_type) == ET_DYN) {
|
||
debug("this is a dynamic library\n");
|
||
- rewriteSectionsLibrary();
|
||
+ rewriteSectionsBinary();
|
||
} else if (rdi(hdr->e_type) == ET_EXEC) {
|
||
debug("this is an executable\n");
|
||
- rewriteSectionsExecutable();
|
||
+ rewriteSectionsBinary();
|
||
} else error("unknown ELF type");
|
||
}
|
||
|
||
--
|
||
2.1.2
|
||
|