#include <libelfu/modeltypes.h>
+size_t elfu_mScnIndex(ElfuElf *me, ElfuScn *ms);
size_t elfu_mCountScns(ElfuElf *me);
size_t elfu_mCountPhdrs(ElfuElf *me);
char* elfu_mScnName(ElfuElf *me, ElfuScn *ms);
+ElfuScn* elfu_mScnFirstInSegment(ElfuElf *me, ElfuPhdr *mp);
+ElfuScn* elfu_mScnLastInSegment(ElfuElf *me, ElfuPhdr *mp);
+
+ElfuScn* elfu_mScnByType(ElfuElf *me, Elf32_Word type);
+
int elfu_mCheck(ElfuElf *me);
+ElfuScn* elfu_mCloneScn(ElfuScn *ms);
+
+
ElfuElf* elfu_mFromElf(Elf *e);
void elfu_mToElf(ElfuElf *me, Elf *e);
void elfu_mExpandNobits(ElfuElf *me, GElf_Off off);
-GElf_Xword elfu_mInsertBefore(ElfuElf *me, GElf_Off off, GElf_Xword size);
-GElf_Xword elfu_mInsertAfter(ElfuElf *me, GElf_Off off, GElf_Xword size);
+GElf_Xword elfu_mInsertSpaceBefore(ElfuElf *me, GElf_Off off, GElf_Xword size);
+GElf_Xword elfu_mInsertSpaceAfter(ElfuElf *me, GElf_Off off, GElf_Xword size);
+
+void elfu_mInsertScnInChainBefore(ElfuElf *me, ElfuScn *oldscn, ElfuScn *newscn);
+void elfu_mInsertScnInChainAfter(ElfuElf *me, ElfuScn *oldscn, ElfuScn *newscn);
+
+
+void elfu_mReladd(ElfuElf *me, ElfuElf *mrel);
#endif
unsigned insertAfterOffs;
unsigned insertAfterSz;
unsigned expandNobitsOffs;
+ char *fnReladd;
} CLIOpts;
}
if (opts.insertBeforeSz) {
- elfu_mInsertBefore(me, opts.insertBeforeOffs, opts.insertBeforeSz);
+ elfu_mInsertSpaceBefore(me, opts.insertBeforeOffs, opts.insertBeforeSz);
}
if (opts.insertAfterSz) {
- elfu_mInsertAfter(me, opts.insertAfterOffs, opts.insertAfterSz);
+ elfu_mInsertSpaceAfter(me, opts.insertAfterOffs, opts.insertAfterSz);
+ }
+
+ if (opts.fnReladd) {
+ ELFHandles hRel = { 0 };
+ ElfuElf *mrel = NULL;
+
+ openElf(&hRel, opts.fnReladd, ELF_C_READ);
+ if (!hRel.e) {
+ printf("--reladd: Failed to open file for --reladd, skipping operation.\n");
+ } else {
+ mrel = elfu_mFromElf(hRel.e);
+ closeElf(&hRel);
+ if (!me) {
+ printf("--reladd: Failed to load model for --reladd, skipping operation.\n");
+ } else {
+ printf("--reladd: Model successfully loaded.\n");
+ elfu_mCheck(mrel);
+ printf("--reladd: Input model checked.\n");
+ elfu_mReladd(me, mrel);
+ }
+ }
+
}
elfu_mCheck(me);
--- /dev/null
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+#include <libelfu/libelfu.h>
+
+ElfuScn* elfu_mCloneScn(ElfuScn *ms)
+{
+ ElfuScn *newscn;
+
+ assert(ms);
+
+ newscn = malloc(sizeof(ElfuScn));
+ if (!newscn) {
+ ELFU_WARN("elfu_nCloneScn: Could not allocate memory for new ElfuScn.\n");
+ return NULL;
+ }
+
+
+
+ newscn->shdr = ms->shdr;
+ newscn->data = ms->data;
+ if (ms->data.d_buf) {
+ void *newbuf = malloc(ms->data.d_size);
+ if (!newbuf) {
+ ELFU_WARN("elfu_nCloneScn: Could not allocate memory for new data buffer.\n");
+ free(newscn);
+ return NULL;
+ }
+
+ memcpy(newbuf, ms->data.d_buf, ms->data.d_size);
+ newscn->data.d_buf = newbuf;
+ }
+
+ return newscn;
+}
#include <libelfu/libelfu.h>
+size_t elfu_mScnIndex(ElfuElf *me, ElfuScn *ms)
+{
+ ElfuScn *ms2;
+ size_t i = 1;
+
+ assert(me);
+ assert(ms);
+
+ CIRCLEQ_FOREACH(ms2, &me->scnList, elem) {
+ if (ms2 == ms) {
+ return i;
+ }
+
+ i++;
+ }
+
+ /* Section is not in ELF model. This means the calling code is broken. */
+ assert(0);
+}
+
/* NULL section is not counted! */
size_t elfu_mCountScns(ElfuElf *me)
* the same address in memory, and everything BEFORE it is shifted to
* lower addresses, making space for the new data in-between.
*/
-GElf_Xword elfu_mInsertBefore(ElfuElf *me, GElf_Off off, GElf_Xword size)
+GElf_Xword elfu_mInsertSpaceBefore(ElfuElf *me, GElf_Off off, GElf_Xword size)
{
ElfuScn *ms;
ElfuPhdr *mp;
* use mExpandNobits() first and then inject at the end of
* the expansion site.
*/
-GElf_Xword elfu_mInsertAfter(ElfuElf *me, GElf_Off off, GElf_Xword size)
+GElf_Xword elfu_mInsertSpaceAfter(ElfuElf *me, GElf_Off off, GElf_Xword size)
{
ElfuScn *ms;
ElfuPhdr *mp;
return size;
}
+
+
+
+
+
+/* Update cross-references */
+static void shiftSections(ElfuElf *me, ElfuScn *first)
+{
+ ElfuScn *ms = first;
+ size_t firstIndex = elfu_mScnIndex(me, first);
+
+ do {
+ if (ms == me->shstrtab) {
+ me->ehdr.e_shstrndx++;
+ }
+
+ ms = CIRCLEQ_LOOP_NEXT(&me->scnList, ms, elem);
+ } while (ms != CIRCLEQ_FIRST(&me->scnList));
+
+ CIRCLEQ_FOREACH(ms, &me->scnList, elem) {
+ switch (ms->shdr.sh_type) {
+ case SHT_REL:
+ case SHT_RELA:
+ if (ms->shdr.sh_info >= firstIndex) {
+ ms->shdr.sh_info++;
+ }
+ case SHT_DYNAMIC:
+ case SHT_HASH:
+ case SHT_SYMTAB:
+ case SHT_DYNSYM:
+ case SHT_GNU_versym:
+ case SHT_GNU_verdef:
+ case SHT_GNU_verneed:
+ if (ms->shdr.sh_link >= firstIndex) {
+ ms->shdr.sh_link++;
+ }
+ }
+ }
+}
+
+
+/*
+ * Insert a section into an ELF model, /before/ a given other section
+ */
+void elfu_mInsertScnInChainBefore(ElfuElf *me, ElfuScn *oldscn, ElfuScn *newscn)
+{
+ assert(me);
+ assert(oldscn);
+ assert(newscn);
+
+ shiftSections(me, oldscn);
+
+ CIRCLEQ_INSERT_BEFORE(&me->scnList, oldscn, newscn, elem);
+}
+
+
+/*
+ * Insert a section into an ELF model, /after/ a given other section
+ */
+void elfu_mInsertScnInChainAfter(ElfuElf *me, ElfuScn *oldscn, ElfuScn *newscn)
+{
+ assert(me);
+ assert(oldscn);
+ assert(newscn);
+
+ if (oldscn != CIRCLEQ_LAST(&me->scnList)) {
+ shiftSections(me, CIRCLEQ_NEXT(oldscn, elem));
+ }
+
+ CIRCLEQ_INSERT_AFTER(&me->scnList, oldscn, newscn, elem);
+}
--- /dev/null
+#include <assert.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <libelf/gelf.h>
+#include <libelfu/libelfu.h>
+
+typedef enum Destsegment {
+ DS_UNKNOWN,
+ DS_TEXT,
+ DS_DATA,
+} Destsegment;
+
+
+static Destsegment destsegment(ElfuScn *ms)
+{
+ if (!(ms->shdr.sh_flags & SHF_ALLOC)) {
+ return DS_UNKNOWN;
+ }
+
+ if (!(ms->shdr.sh_flags & SHF_WRITE)
+ && (ms->shdr.sh_flags & SHF_EXECINSTR)) {
+ return DS_TEXT;
+ } else if ((ms->shdr.sh_flags & SHF_WRITE)
+ && !(ms->shdr.sh_flags & SHF_EXECINSTR)) {
+ return DS_DATA;
+ }
+
+ return DS_UNKNOWN;
+}
+
+
+
+static ElfuScn* insertSection(ElfuElf *me, ElfuElf *mrel, ElfuScn *ms)
+{
+ ElfuPhdr *mp;
+ ElfuPhdr *first = NULL;
+ ElfuPhdr *last = NULL;
+ ElfuScn *newscn = NULL;
+ ElfuPhdr *injAnchor;
+ int searchForCode = 0;
+
+ switch (destsegment(ms)) {
+ case DS_TEXT:
+ searchForCode = 1;
+ case DS_DATA:
+ newscn = elfu_mCloneScn(ms);
+ if (!newscn) {
+ return NULL;
+ }
+
+ /* Find first and last LOAD PHDRs. */
+ CIRCLEQ_FOREACH(mp, &me->phdrList, elem) {
+ if (mp->phdr.p_type != PT_LOAD) {
+ continue;
+ }
+
+ if (!first || mp->phdr.p_vaddr < first->phdr.p_vaddr) {
+ first = mp;
+ }
+ if (!last || mp->phdr.p_vaddr > last->phdr.p_vaddr) {
+ /* No need to check p_memsz as segments may not overlap in memory. */
+ last = mp;
+ }
+ }
+
+ if (searchForCode) {
+ if ((first->phdr.p_flags & PF_X) && !(first->phdr.p_flags & PF_W)) {
+ injAnchor = first;
+ } else if ((last->phdr.p_flags & PF_X) && !(last->phdr.p_flags & PF_W)) {
+ injAnchor = last;
+ } else {
+ injAnchor = NULL;
+ }
+ } else {
+ if ((first->phdr.p_flags & PF_W) && !(first->phdr.p_flags & PF_X)) {
+ injAnchor = first;
+ } else if ((last->phdr.p_flags & PF_W) && !(last->phdr.p_flags & PF_X)) {
+ injAnchor = last;
+ } else {
+ injAnchor = NULL;
+ }
+ }
+
+ if (!injAnchor) {
+ ELFU_WARN("insertSection: Could not find injection anchor.\n"
+ " It has to be the first or last segment in the memory image.\n");
+ } else {
+ GElf_Off injOffset;
+
+ /* If the anchor is first or last, insert before or after */
+ if (injAnchor == first) {
+ /* Find first section and inject before it */
+ ElfuScn *firstScn = elfu_mScnFirstInSegment(me, injAnchor);
+ if (!firstScn) {
+ ELFU_WARN("insertSection: mScnFirstInSegment failed.\n");
+
+ // TODO: Error handling
+ } else {
+ injOffset = firstScn->shdr.sh_offset;
+
+ /* Make space */
+ elfu_mInsertSpaceBefore(me, injOffset, ms->shdr.sh_size);
+
+ /* Update memory offset */
+ newscn->shdr.sh_addr = injAnchor->phdr.p_vaddr;
+
+ /* Insert into chain of sections */
+ elfu_mInsertScnInChainBefore(me, firstScn, newscn);
+ }
+ } else {
+ /* Find last section and inject after it */
+ ElfuScn *lastScn = elfu_mScnLastInSegment(me, injAnchor);
+ if (!lastScn) {
+ ELFU_WARN("insertSection: mScnLastInSegment failed.\n");
+
+ // TODO: Error handling
+ } else {
+ injOffset = lastScn->shdr.sh_offset + elfu_gScnSizeFile(&lastScn->shdr);
+
+ /* Expand NOBITS sections at injection site, if any. */
+ elfu_mExpandNobits(me, injOffset);
+
+ /* Recalculate injOffset in case we expanded a NOBITS section */
+ lastScn = elfu_mScnLastInSegment(me, injAnchor);
+ injOffset = lastScn->shdr.sh_offset + elfu_gScnSizeFile(&lastScn->shdr);
+
+ /* Make space */
+ elfu_mInsertSpaceAfter(me, injOffset, ms->shdr.sh_size);
+
+ /* Update memory offset */
+ newscn->shdr.sh_addr = injAnchor->phdr.p_vaddr + (injOffset - injAnchor->phdr.p_offset);
+
+ /* Insert into chain of sections */
+ elfu_mInsertScnInChainAfter(me, lastScn, newscn);
+ }
+ }
+
+ /* Update file offset in new section BEFORE we do anything else */
+ newscn->shdr.sh_offset = injOffset;
+
+ /* Inject name */
+ // TODO
+ newscn->shdr.sh_name = 0;
+
+ // TODO: Relocate
+
+ return newscn;
+ }
+ break;
+
+ case DS_UNKNOWN:
+ ELFU_WARN("insertSection: Don't know where to insert ' %s with flags %jd (type %d).\n",
+ elfu_mScnName(mrel, ms),
+ ms->shdr.sh_flags,
+ ms->shdr.sh_type);
+ default:
+ ELFU_WARN("insertSection: Skipping section %s with flags %jd (type %d).\n",
+ elfu_mScnName(mrel, ms),
+ ms->shdr.sh_flags,
+ ms->shdr.sh_type);
+ return NULL;
+ }
+
+ if (newscn) {
+ // TODO: Destroy newscn
+ }
+ return NULL;
+}
+
+
+
+void elfu_mReladd(ElfuElf *me, ElfuElf *mrel)
+{
+ ElfuScn *ms;
+
+ assert(me);
+ assert(mrel);
+
+
+ /* For each section in object file, guess how to insert it */
+ CIRCLEQ_FOREACH(ms, &mrel->scnList, elem) {
+ ElfuScn *newscn;
+
+ switch(ms->shdr.sh_type) {
+ case SHT_NULL: /* 0 */
+ continue;
+
+ case SHT_PROGBITS: /* 1 */
+ /* Find a place where it belongs and shove it in. */
+ newscn = insertSection(me, mrel, ms);
+ if (!newscn) {
+ ELFU_WARN("mReladd: Could not insert section %s (type %d), skipping.\n",
+ elfu_mScnName(mrel, ms),
+ ms->shdr.sh_type);
+ }
+ break;
+
+ case SHT_SYMTAB: /* 2 */
+ case SHT_DYNSYM: /* 11 */
+ /* Merge with the existing table. Take care of string tables also. */
+
+ case SHT_STRTAB: /* 3 */
+ /* May have to be merged with the existing string table for
+ * the symbol table. */
+
+ case SHT_RELA: /* 4 */
+ case SHT_REL: /* 9 */
+ /* Possibly append this in memory to the section model
+ * that it describes. */
+
+ case SHT_NOBITS: /* 8 */
+ /* Expand this to SHT_PROGBITS, then insert as such. */
+
+ case SHT_HASH: /* 5 */
+ case SHT_DYNAMIC: /* 6 */
+ case SHT_SHLIB: /* 10 */
+ case SHT_SYMTAB_SHNDX: /* 18 */
+
+ /* Don't care about the next ones yet. I've never seen
+ * them and they can be implemented when necessary. */
+ case SHT_NOTE: /* 7 */
+ case SHT_INIT_ARRAY: /* 14 */
+ case SHT_FINI_ARRAY: /* 15 */
+ case SHT_PREINIT_ARRAY: /* 16 */
+ case SHT_GROUP: /* 17 */
+ case SHT_NUM: /* 19 */
+ default:
+ ELFU_WARN("mReladd: Skipping section %s (type %d).\n",
+ elfu_mScnName(mrel, ms),
+ ms->shdr.sh_type);
+ }
+ }
+}
--- /dev/null
+#include <assert.h>
+#include <libelf/gelf.h>
+#include <libelfu/libelfu.h>
+
+
+/*
+ * Returns the first section with the given type.
+ */
+ElfuScn* elfu_mScnByType(ElfuElf *me, Elf32_Word type)
+{
+ ElfuScn *ms;
+
+ assert(me);
+
+ CIRCLEQ_FOREACH(ms, &me->scnList, elem) {
+ if (ms->shdr.sh_type == type) {
+ return ms;
+ }
+ }
+
+ return NULL;
+}
--- /dev/null
+#include <assert.h>
+#include <libelf/gelf.h>
+#include <libelfu/libelfu.h>
+
+
+/*
+ * Returns the first section beginning in the segment.
+ *
+ * Since sections have to be in the file in mapping order to load them
+ * as a continuous segment, we only have to search by start offset.
+ */
+ElfuScn* elfu_mScnFirstInSegment(ElfuElf *me, ElfuPhdr *mp)
+{
+ ElfuScn *ms;
+
+ assert(me);
+ assert(mp);
+
+ CIRCLEQ_FOREACH(ms, &me->scnList, elem) {
+ if ((ms->shdr.sh_offset >= mp->phdr.p_offset)
+ && (ms->shdr.sh_offset < mp->phdr.p_offset + mp->phdr.p_filesz)) {
+ return ms;
+ }
+ }
+
+ return NULL;
+}
+
+
+
+/*
+ * Returns the last section ending in the segment.
+ *
+ * Since sections have to be in the file in mapping order to load them
+ * as a continuous segment, we only have to search by end offset.
+ */
+ElfuScn* elfu_mScnLastInSegment(ElfuElf *me, ElfuPhdr *mp)
+{
+ ElfuScn *last = NULL;
+ ElfuScn *ms;
+
+ assert(me);
+ assert(mp);
+
+ CIRCLEQ_FOREACH(ms, &me->scnList, elem) {
+ /* Get section size on disk - for NOBITS sections that is 0 bytes. */
+ size_t size = elfu_gScnSizeFile(&ms->shdr);
+
+ if (((ms->shdr.sh_offset + size >= mp->phdr.p_offset)
+ && (ms->shdr.sh_offset + size <= mp->phdr.p_offset + mp->phdr.p_filesz))) {
+ last = ms;
+ }
+ }
+
+ return last;
+}
" mapping everything before it to lower mem addresses.\n"
" --insert-after off,sz Insert spacing at given offset,\n"
" mapping everything after it to higher mem addresses.\n"
+ "\n"
+ "High-level insertion:\n"
+ " --reladd obj.o Automatically insert object file contents\n"
"\n");
}
{"insert-before", 1, 0, 10004},
{"insert-after", 1, 0, 10005},
{"expand-nobits", 1, 0, 10006},
+ {"reladd", 1, 0, 10007},
{NULL, 0, NULL, 0}
};
goto USAGE;
}
break;
+ case 10007:
+ opts->fnReladd = optarg;
+ break;
case '?':
default:
goto USAGE;
projects / centaur.git / commitdiff