1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
|
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <libelfu/libelfu.h>
static GElf_Word shiftStuffAtAfterOffset(ElfuElf *me,
GElf_Off offset,
GElf_Word size)
{
ElfuPhdr *mp;
ElfuScn *ms;
/* Force a minimum alignment, just to be sure. */
GElf_Word align = 64;
/* Find maximum alignment size by which we have to shift.
* Assumes alignment sizes are always 2^x. */
CIRCLEQ_FOREACH(mp, &me->phdrList, elem) {
if (mp->phdr.p_offset >= offset) {
if (mp->phdr.p_align > align) {
align = mp->phdr.p_align;
}
}
}
CIRCLEQ_FOREACH(ms, &me->orphanScnList, elemChildScn) {
if (ms->shdr.sh_offset >= offset) {
if (ms->shdr.sh_addralign > align) {
align = ms->shdr.sh_addralign;
}
}
}
size = ROUNDUP(size, align);
/* Shift stuff */
CIRCLEQ_FOREACH(mp, &me->phdrList, elem) {
if (mp->phdr.p_type != PT_LOAD) {
continue;
}
if (mp->phdr.p_offset >= offset) {
mp->phdr.p_offset += size;
elfu_mPhdrUpdateChildOffsets(mp);
}
}
CIRCLEQ_FOREACH(ms, &me->orphanScnList, elemChildScn) {
if (ms->shdr.sh_offset >= offset) {
ms->shdr.sh_offset += size;
}
}
if (me->ehdr.e_phoff >= offset) {
me->ehdr.e_phoff += size;
}
if (me->ehdr.e_shoff >= offset) {
me->ehdr.e_shoff += size;
}
return size;
}
/* Finds a suitable PHDR to insert a hole into and expands it
* if necessary.
* Returns memory address the hole will be mapped to, or 0 if
* the operation failed. */
GElf_Addr elfu_mLayoutGetSpaceInPhdr(ElfuElf *me, GElf_Word size,
GElf_Word align, int w, int x,
ElfuPhdr **injPhdr)
{
ElfuPhdr *first = NULL;
ElfuPhdr *last = NULL;
ElfuPhdr *mp;
assert(!(w && x));
/* Find first and last LOAD PHDRs.
* Don't compare p_memsz - segments don't overlap in memory. */
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) {
last = mp;
}
}
if ((w && (last->phdr.p_flags & PF_W))
|| (x && (last->phdr.p_flags & PF_X))) {
/* Need to append. */
GElf_Off injOffset = OFFS_END(last->phdr.p_offset, last->phdr.p_filesz);
GElf_Word injSpace = 0;
GElf_Word nobitsize = last->phdr.p_memsz - last->phdr.p_filesz;
/* Expand NOBITS if any */
if (nobitsize > 0) {
GElf_Off endOff = OFFS_END(last->phdr.p_offset, last->phdr.p_filesz);
GElf_Off endAddr = OFFS_END(last->phdr.p_vaddr, last->phdr.p_filesz);
ElfuScn *ms;
ELFU_INFO("Expanding NOBITS at address 0x%jx...\n", endAddr);
CIRCLEQ_FOREACH(ms, &last->childScnList, elemChildScn) {
if (ms->shdr.sh_offset == endOff) {
assert(ms->shdr.sh_type == SHT_NOBITS);
assert(ms->shdr.sh_size == nobitsize);
ms->data.d_buf = malloc(ms->shdr.sh_size);
memset(ms->data.d_buf, '\0', ms->shdr.sh_size);
if (!ms->data.d_buf) {
ELFU_WARN("mExpandNobits: Could not allocate %jd bytes for NOBITS expansion. Data may be inconsistent.\n", ms->shdr.sh_size);
assert(0);
goto ERROR;
}
ms->data.d_align = 1;
ms->data.d_off = 0;
ms->data.d_type = ELF_T_BYTE;
ms->data.d_size = ms->shdr.sh_size;
ms->data.d_version = elf_version(EV_NONE);
ms->shdr.sh_type = SHT_PROGBITS;
ms->shdr.sh_addr = endAddr;
}
}
injSpace += shiftStuffAtAfterOffset(me, endOff, nobitsize);
injSpace -= nobitsize;
injOffset += nobitsize;
last->phdr.p_filesz += nobitsize;
assert(last->phdr.p_filesz == last->phdr.p_memsz);
}
/* Calculate how much space we need, taking alignment into account */
size += ROUNDUP(injOffset, align) - injOffset;
/* If there is not enough space left, create even more. */
if (injSpace < size) {
injSpace += shiftStuffAtAfterOffset(me, injOffset, size - injSpace);
}
assert(injSpace >= size);
/* Remap ourselves */
last->phdr.p_filesz += size;
last->phdr.p_memsz += size;
injOffset = ROUNDUP(injOffset, align);
if (injPhdr) {
*injPhdr = last;
}
return last->phdr.p_vaddr + (injOffset - last->phdr.p_offset);
} else if ((w && (first->phdr.p_flags & PF_W))
|| (x && (first->phdr.p_flags & PF_X))) {
/* Need to prepend or split up the PHDR. */
GElf_Off injOffset = OFFS_END(first->phdr.p_offset, first->phdr.p_filesz);
ElfuScn *ms;
/* Round up size to take PHDR alignment into account.
* We assume that this is a multiple of the alignment asked for. */
assert(first->phdr.p_align >= align);
size = ROUNDUP(size, first->phdr.p_align);
/* Find first section. We assume there is at least one. */
assert(!CIRCLEQ_EMPTY(&first->childScnList));
injOffset = CIRCLEQ_FIRST(&first->childScnList)->shdr.sh_offset;
/* Move our sections */
CIRCLEQ_FOREACH(ms, &first->childScnList, elemChildScn) {
if (ms->shdr.sh_offset >= injOffset) {
ms->shdr.sh_offset += size;
}
}
/* Move our PHDRs */
CIRCLEQ_FOREACH(mp, &first->childPhdrList, elemChildPhdr) {
if (mp->phdr.p_offset >= injOffset) {
mp->phdr.p_offset += size;
} else {
mp->phdr.p_vaddr -= size;
mp->phdr.p_paddr -= size;
}
}
/* Move other PHDRs and sections */
assert(size <= shiftStuffAtAfterOffset(me, injOffset, size));
/* Remap ourselves */
first->phdr.p_vaddr -= size;
first->phdr.p_paddr -= size;
first->phdr.p_filesz += size;
first->phdr.p_memsz += size;
injOffset = ROUNDUP(injOffset, align);
if (injPhdr) {
*injPhdr = first;
}
return first->phdr.p_vaddr + (injOffset - first->phdr.p_offset);
}
ERROR:
if (injPhdr) {
*injPhdr = NULL;
}
return 0;
}
|
