root / linux-user / elfload.c @ d691f669
History | View | Annotate | Download (25.9 kB)
1 |
/* This is the Linux kernel elf-loading code, ported into user space */
|
---|---|
2 |
|
3 |
#include <stdio.h> |
4 |
#include <sys/types.h> |
5 |
#include <fcntl.h> |
6 |
#include <sys/stat.h> |
7 |
#include <errno.h> |
8 |
#include <unistd.h> |
9 |
#include <sys/mman.h> |
10 |
#include <stdlib.h> |
11 |
#include <string.h> |
12 |
|
13 |
#include "qemu.h" |
14 |
|
15 |
#include "linux_bin.h" |
16 |
#include "elf.h" |
17 |
#include "segment.h" |
18 |
|
19 |
/* Necessary parameters */
|
20 |
#define ALPHA_PAGE_SIZE 4096 |
21 |
#define X86_PAGE_SIZE 4096 |
22 |
|
23 |
#define ALPHA_PAGE_MASK (~(ALPHA_PAGE_SIZE-1)) |
24 |
#define X86_PAGE_MASK (~(X86_PAGE_SIZE-1)) |
25 |
|
26 |
#define ALPHA_PAGE_ALIGN(addr) ((((addr)+ALPHA_PAGE_SIZE)-1)&ALPHA_PAGE_MASK) |
27 |
#define X86_PAGE_ALIGN(addr) ((((addr)+X86_PAGE_SIZE)-1)&X86_PAGE_MASK) |
28 |
|
29 |
#define NGROUPS 32 |
30 |
|
31 |
#define X86_ELF_EXEC_PAGESIZE X86_PAGE_SIZE
|
32 |
#define X86_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(X86_ELF_EXEC_PAGESIZE-1)) |
33 |
#define X86_ELF_PAGEOFFSET(_v) ((_v) & (X86_ELF_EXEC_PAGESIZE-1)) |
34 |
|
35 |
#define ALPHA_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ALPHA_PAGE_SIZE-1)) |
36 |
#define ALPHA_ELF_PAGEOFFSET(_v) ((_v) & (ALPHA_PAGE_SIZE-1)) |
37 |
|
38 |
#define INTERPRETER_NONE 0 |
39 |
#define INTERPRETER_AOUT 1 |
40 |
#define INTERPRETER_ELF 2 |
41 |
|
42 |
#define DLINFO_ITEMS 12 |
43 |
|
44 |
/* Where we find X86 libraries... */
|
45 |
|
46 |
|
47 |
//extern void * mmap4k();
|
48 |
#define mmap4k(a, b, c, d, e, f) mmap((void *)(a), b, c, d, e, f) |
49 |
|
50 |
extern unsigned long x86_stack_size; |
51 |
|
52 |
static int load_aout_interp(void * exptr, int interp_fd); |
53 |
|
54 |
#ifdef BSWAP_NEEDED
|
55 |
static void bswap_ehdr(Elf32_Ehdr *ehdr) |
56 |
{ |
57 |
bswap16s(&ehdr->e_type); /* Object file type */
|
58 |
bswap16s(&ehdr->e_machine); /* Architecture */
|
59 |
bswap32s(&ehdr->e_version); /* Object file version */
|
60 |
bswap32s(&ehdr->e_entry); /* Entry point virtual address */
|
61 |
bswap32s(&ehdr->e_phoff); /* Program header table file offset */
|
62 |
bswap32s(&ehdr->e_shoff); /* Section header table file offset */
|
63 |
bswap32s(&ehdr->e_flags); /* Processor-specific flags */
|
64 |
bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
|
65 |
bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
|
66 |
bswap16s(&ehdr->e_phnum); /* Program header table entry count */
|
67 |
bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
|
68 |
bswap16s(&ehdr->e_shnum); /* Section header table entry count */
|
69 |
bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
|
70 |
} |
71 |
|
72 |
static void bswap_phdr(Elf32_Phdr *phdr) |
73 |
{ |
74 |
bswap32s(&phdr->p_type); /* Segment type */
|
75 |
bswap32s(&phdr->p_offset); /* Segment file offset */
|
76 |
bswap32s(&phdr->p_vaddr); /* Segment virtual address */
|
77 |
bswap32s(&phdr->p_paddr); /* Segment physical address */
|
78 |
bswap32s(&phdr->p_filesz); /* Segment size in file */
|
79 |
bswap32s(&phdr->p_memsz); /* Segment size in memory */
|
80 |
bswap32s(&phdr->p_flags); /* Segment flags */
|
81 |
bswap32s(&phdr->p_align); /* Segment alignment */
|
82 |
} |
83 |
#endif
|
84 |
|
85 |
static void * get_free_page(void) |
86 |
{ |
87 |
void * retval;
|
88 |
|
89 |
/* User-space version of kernel get_free_page. Returns a page-aligned
|
90 |
* page-sized chunk of memory.
|
91 |
*/
|
92 |
retval = mmap4k(0, ALPHA_PAGE_SIZE, PROT_READ|PROT_WRITE,
|
93 |
MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
94 |
|
95 |
if((long)retval == -1) { |
96 |
perror("get_free_page");
|
97 |
exit(-1);
|
98 |
} |
99 |
else {
|
100 |
return(retval);
|
101 |
} |
102 |
} |
103 |
|
104 |
static void free_page(void * pageaddr) |
105 |
{ |
106 |
(void)munmap(pageaddr, ALPHA_PAGE_SIZE);
|
107 |
} |
108 |
|
109 |
/*
|
110 |
* 'copy_string()' copies argument/envelope strings from user
|
111 |
* memory to free pages in kernel mem. These are in a format ready
|
112 |
* to be put directly into the top of new user memory.
|
113 |
*
|
114 |
*/
|
115 |
static unsigned long copy_strings(int argc,char ** argv,unsigned long *page, |
116 |
unsigned long p) |
117 |
{ |
118 |
char *tmp, *tmp1, *pag = NULL; |
119 |
int len, offset = 0; |
120 |
|
121 |
if (!p) {
|
122 |
return 0; /* bullet-proofing */ |
123 |
} |
124 |
while (argc-- > 0) { |
125 |
if (!(tmp1 = tmp = get_user(argv+argc))) {
|
126 |
fprintf(stderr, "VFS: argc is wrong");
|
127 |
exit(-1);
|
128 |
} |
129 |
while (get_user(tmp++));
|
130 |
len = tmp - tmp1; |
131 |
if (p < len) { /* this shouldn't happen - 128kB */ |
132 |
return 0; |
133 |
} |
134 |
while (len) {
|
135 |
--p; --tmp; --len; |
136 |
if (--offset < 0) { |
137 |
offset = p % X86_PAGE_SIZE; |
138 |
if (!(pag = (char *) page[p/X86_PAGE_SIZE]) && |
139 |
!(pag = (char *) page[p/X86_PAGE_SIZE] =
|
140 |
(unsigned long *) get_free_page())) { |
141 |
return 0; |
142 |
} |
143 |
} |
144 |
if (len == 0 || offset == 0) { |
145 |
*(pag + offset) = get_user(tmp); |
146 |
} |
147 |
else {
|
148 |
int bytes_to_copy = (len > offset) ? offset : len;
|
149 |
tmp -= bytes_to_copy; |
150 |
p -= bytes_to_copy; |
151 |
offset -= bytes_to_copy; |
152 |
len -= bytes_to_copy; |
153 |
memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
|
154 |
} |
155 |
} |
156 |
} |
157 |
return p;
|
158 |
} |
159 |
|
160 |
static int in_group_p(gid_t g) |
161 |
{ |
162 |
/* return TRUE if we're in the specified group, FALSE otherwise */
|
163 |
int ngroup;
|
164 |
int i;
|
165 |
gid_t grouplist[NGROUPS]; |
166 |
|
167 |
ngroup = getgroups(NGROUPS, grouplist); |
168 |
for(i = 0; i < ngroup; i++) { |
169 |
if(grouplist[i] == g) {
|
170 |
return 1; |
171 |
} |
172 |
} |
173 |
return 0; |
174 |
} |
175 |
|
176 |
static int count(char ** vec) |
177 |
{ |
178 |
int i;
|
179 |
|
180 |
for(i = 0; *vec; i++) { |
181 |
vec++; |
182 |
} |
183 |
|
184 |
return(i);
|
185 |
} |
186 |
|
187 |
static int prepare_binprm(struct linux_binprm *bprm) |
188 |
{ |
189 |
struct stat st;
|
190 |
int mode;
|
191 |
int retval, id_change;
|
192 |
|
193 |
if(fstat(bprm->fd, &st) < 0) { |
194 |
return(-errno);
|
195 |
} |
196 |
|
197 |
mode = st.st_mode; |
198 |
if(!S_ISREG(mode)) { /* Must be regular file */ |
199 |
return(-EACCES);
|
200 |
} |
201 |
if(!(mode & 0111)) { /* Must have at least one execute bit set */ |
202 |
return(-EACCES);
|
203 |
} |
204 |
|
205 |
bprm->e_uid = geteuid(); |
206 |
bprm->e_gid = getegid(); |
207 |
id_change = 0;
|
208 |
|
209 |
/* Set-uid? */
|
210 |
if(mode & S_ISUID) {
|
211 |
bprm->e_uid = st.st_uid; |
212 |
if(bprm->e_uid != geteuid()) {
|
213 |
id_change = 1;
|
214 |
} |
215 |
} |
216 |
|
217 |
/* Set-gid? */
|
218 |
/*
|
219 |
* If setgid is set but no group execute bit then this
|
220 |
* is a candidate for mandatory locking, not a setgid
|
221 |
* executable.
|
222 |
*/
|
223 |
if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
|
224 |
bprm->e_gid = st.st_gid; |
225 |
if (!in_group_p(bprm->e_gid)) {
|
226 |
id_change = 1;
|
227 |
} |
228 |
} |
229 |
|
230 |
memset(bprm->buf, 0, sizeof(bprm->buf)); |
231 |
retval = lseek(bprm->fd, 0L, SEEK_SET);
|
232 |
if(retval >= 0) { |
233 |
retval = read(bprm->fd, bprm->buf, 128);
|
234 |
} |
235 |
if(retval < 0) { |
236 |
perror("prepare_binprm");
|
237 |
exit(-1);
|
238 |
/* return(-errno); */
|
239 |
} |
240 |
else {
|
241 |
return(retval);
|
242 |
} |
243 |
} |
244 |
|
245 |
unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm, |
246 |
struct image_info * info)
|
247 |
{ |
248 |
unsigned long stack_base; |
249 |
int i;
|
250 |
extern unsigned long stktop; |
251 |
|
252 |
stack_base = X86_STACK_TOP - MAX_ARG_PAGES*X86_PAGE_SIZE; |
253 |
|
254 |
p += stack_base; |
255 |
if (bprm->loader) {
|
256 |
bprm->loader += stack_base; |
257 |
} |
258 |
bprm->exec += stack_base; |
259 |
|
260 |
/* Create enough stack to hold everything. If we don't use
|
261 |
* it for args, we'll use it for something else...
|
262 |
*/
|
263 |
/* XXX: on x86 MAP_GROWSDOWN only works if ESP <= address + 32, so
|
264 |
we allocate a bigger stack. Need a better solution, for example
|
265 |
by remapping the process stack directly at the right place */
|
266 |
if(x86_stack_size > MAX_ARG_PAGES*X86_PAGE_SIZE) {
|
267 |
if((long)mmap4k((void *)(X86_STACK_TOP-x86_stack_size), x86_stack_size + X86_PAGE_SIZE, |
268 |
PROT_READ | PROT_WRITE, |
269 |
MAP_GROWSDOWN | MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) { |
270 |
perror("stk mmap");
|
271 |
exit(-1);
|
272 |
} |
273 |
} |
274 |
else {
|
275 |
if((long)mmap4k((void *)stack_base, (MAX_ARG_PAGES+1)*X86_PAGE_SIZE, |
276 |
PROT_READ | PROT_WRITE, |
277 |
MAP_GROWSDOWN | MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) { |
278 |
perror("stk mmap");
|
279 |
exit(-1);
|
280 |
} |
281 |
} |
282 |
|
283 |
stktop = stack_base; |
284 |
|
285 |
for (i = 0 ; i < MAX_ARG_PAGES ; i++) { |
286 |
if (bprm->page[i]) {
|
287 |
info->rss++; |
288 |
|
289 |
memcpy((void *)stack_base, (void *)bprm->page[i], X86_PAGE_SIZE); |
290 |
free_page((void *)bprm->page[i]);
|
291 |
} |
292 |
stack_base += X86_PAGE_SIZE; |
293 |
} |
294 |
return p;
|
295 |
} |
296 |
|
297 |
static void set_brk(unsigned long start, unsigned long end) |
298 |
{ |
299 |
/* page-align the start and end addresses... */
|
300 |
start = ALPHA_PAGE_ALIGN(start); |
301 |
end = ALPHA_PAGE_ALIGN(end); |
302 |
if (end <= start)
|
303 |
return;
|
304 |
if((long)mmap4k(start, end - start, |
305 |
PROT_READ | PROT_WRITE | PROT_EXEC, |
306 |
MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) { |
307 |
perror("cannot mmap brk");
|
308 |
exit(-1);
|
309 |
} |
310 |
} |
311 |
|
312 |
|
313 |
/* We need to explicitly zero any fractional pages
|
314 |
after the data section (i.e. bss). This would
|
315 |
contain the junk from the file that should not
|
316 |
be in memory */
|
317 |
|
318 |
|
319 |
static void padzero(unsigned long elf_bss) |
320 |
{ |
321 |
unsigned long nbyte; |
322 |
char * fpnt;
|
323 |
|
324 |
nbyte = elf_bss & (ALPHA_PAGE_SIZE-1); /* was X86_PAGE_SIZE - JRP */ |
325 |
if (nbyte) {
|
326 |
nbyte = ALPHA_PAGE_SIZE - nbyte; |
327 |
fpnt = (char *) elf_bss;
|
328 |
do {
|
329 |
*fpnt++ = 0;
|
330 |
} while (--nbyte);
|
331 |
} |
332 |
} |
333 |
|
334 |
static unsigned int * create_elf_tables(char *p, int argc, int envc, |
335 |
struct elfhdr * exec,
|
336 |
unsigned long load_addr, |
337 |
unsigned long interp_load_addr, int ibcs, |
338 |
struct image_info *info)
|
339 |
{ |
340 |
target_ulong *argv, *envp, *dlinfo; |
341 |
target_ulong *sp; |
342 |
|
343 |
/*
|
344 |
* Force 16 byte alignment here for generality.
|
345 |
*/
|
346 |
sp = (unsigned int *) (~15UL & (unsigned long) p); |
347 |
sp -= exec ? DLINFO_ITEMS*2 : 2; |
348 |
dlinfo = sp; |
349 |
sp -= envc+1;
|
350 |
envp = sp; |
351 |
sp -= argc+1;
|
352 |
argv = sp; |
353 |
if (!ibcs) {
|
354 |
put_user(tswapl((target_ulong)envp),--sp); |
355 |
put_user(tswapl((target_ulong)argv),--sp); |
356 |
} |
357 |
|
358 |
#define NEW_AUX_ENT(id, val) \
|
359 |
put_user (tswapl(id), dlinfo++); \ |
360 |
put_user (tswapl(val), dlinfo++) |
361 |
|
362 |
if (exec) { /* Put this here for an ELF program interpreter */ |
363 |
struct elf_phdr * eppnt;
|
364 |
eppnt = (struct elf_phdr *)((unsigned long)exec->e_phoff); |
365 |
|
366 |
NEW_AUX_ENT (AT_PHDR, (unsigned int)(load_addr + exec->e_phoff)); |
367 |
NEW_AUX_ENT (AT_PHENT, (unsigned int)(sizeof (struct elf_phdr))); |
368 |
NEW_AUX_ENT (AT_PHNUM, (unsigned int)(exec->e_phnum)); |
369 |
NEW_AUX_ENT (AT_PAGESZ, (unsigned int)(ALPHA_PAGE_SIZE)); |
370 |
NEW_AUX_ENT (AT_BASE, (unsigned int)(interp_load_addr)); |
371 |
NEW_AUX_ENT (AT_FLAGS, (unsigned int)0); |
372 |
NEW_AUX_ENT (AT_ENTRY, (unsigned int) exec->e_entry); |
373 |
NEW_AUX_ENT (AT_UID, (unsigned int) getuid()); |
374 |
NEW_AUX_ENT (AT_EUID, (unsigned int) geteuid()); |
375 |
NEW_AUX_ENT (AT_GID, (unsigned int) getgid()); |
376 |
NEW_AUX_ENT (AT_EGID, (unsigned int) getegid()); |
377 |
} |
378 |
NEW_AUX_ENT (AT_NULL, 0);
|
379 |
#undef NEW_AUX_ENT
|
380 |
put_user(tswapl(argc),--sp); |
381 |
info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff); |
382 |
while (argc-->0) { |
383 |
put_user(tswapl((target_ulong)p),argv++); |
384 |
while (get_user(p++)) /* nothing */ ; |
385 |
} |
386 |
put_user(0,argv);
|
387 |
info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff); |
388 |
while (envc-->0) { |
389 |
put_user(tswapl((target_ulong)p),envp++); |
390 |
while (get_user(p++)) /* nothing */ ; |
391 |
} |
392 |
put_user(0,envp);
|
393 |
info->env_end = (unsigned int)((unsigned long)p & 0xffffffff); |
394 |
return sp;
|
395 |
} |
396 |
|
397 |
|
398 |
|
399 |
static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex, |
400 |
int interpreter_fd,
|
401 |
unsigned long *interp_load_addr) |
402 |
{ |
403 |
struct elf_phdr *elf_phdata = NULL; |
404 |
struct elf_phdr *eppnt;
|
405 |
unsigned long load_addr; |
406 |
int load_addr_set = 0; |
407 |
int retval;
|
408 |
unsigned long last_bss, elf_bss; |
409 |
unsigned long error; |
410 |
int i;
|
411 |
|
412 |
elf_bss = 0;
|
413 |
last_bss = 0;
|
414 |
error = 0;
|
415 |
|
416 |
/* We put this here so that mmap will search for the *first*
|
417 |
* available memory...
|
418 |
*/
|
419 |
load_addr = INTERP_LOADADDR; |
420 |
|
421 |
/* First of all, some simple consistency checks */
|
422 |
if ((interp_elf_ex->e_type != ET_EXEC &&
|
423 |
interp_elf_ex->e_type != ET_DYN) || |
424 |
!elf_check_arch(interp_elf_ex->e_machine)) { |
425 |
return ~0UL; |
426 |
} |
427 |
|
428 |
/* Now read in all of the header information */
|
429 |
|
430 |
if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > X86_PAGE_SIZE) |
431 |
return ~0UL; |
432 |
|
433 |
elf_phdata = (struct elf_phdr *)
|
434 |
malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); |
435 |
|
436 |
if (!elf_phdata)
|
437 |
return ~0UL; |
438 |
|
439 |
/*
|
440 |
* If the size of this structure has changed, then punt, since
|
441 |
* we will be doing the wrong thing.
|
442 |
*/
|
443 |
if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) |
444 |
{ |
445 |
free(elf_phdata); |
446 |
return ~0UL; |
447 |
} |
448 |
|
449 |
retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET); |
450 |
if(retval >= 0) { |
451 |
retval = read(interpreter_fd, |
452 |
(char *) elf_phdata,
|
453 |
sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); |
454 |
} |
455 |
|
456 |
if (retval < 0) { |
457 |
perror("load_elf_interp");
|
458 |
exit(-1);
|
459 |
free (elf_phdata); |
460 |
return retval;
|
461 |
} |
462 |
#ifdef BSWAP_NEEDED
|
463 |
eppnt = elf_phdata; |
464 |
for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) { |
465 |
bswap_phdr(eppnt); |
466 |
} |
467 |
#endif
|
468 |
eppnt = elf_phdata; |
469 |
for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) |
470 |
if (eppnt->p_type == PT_LOAD) {
|
471 |
int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
|
472 |
int elf_prot = 0; |
473 |
unsigned long vaddr = 0; |
474 |
unsigned long k; |
475 |
|
476 |
if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
|
477 |
if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
|
478 |
if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
|
479 |
if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
|
480 |
elf_type |= MAP_FIXED; |
481 |
vaddr = eppnt->p_vaddr; |
482 |
} |
483 |
error = (unsigned long)mmap4k(load_addr+X86_ELF_PAGESTART(vaddr), |
484 |
eppnt->p_filesz + X86_ELF_PAGEOFFSET(eppnt->p_vaddr), |
485 |
elf_prot, |
486 |
elf_type, |
487 |
interpreter_fd, |
488 |
eppnt->p_offset - X86_ELF_PAGEOFFSET(eppnt->p_vaddr)); |
489 |
|
490 |
if (error > -1024UL) { |
491 |
/* Real error */
|
492 |
close(interpreter_fd); |
493 |
free(elf_phdata); |
494 |
return ~0UL; |
495 |
} |
496 |
|
497 |
if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
|
498 |
load_addr = error; |
499 |
load_addr_set = 1;
|
500 |
} |
501 |
|
502 |
/*
|
503 |
* Find the end of the file mapping for this phdr, and keep
|
504 |
* track of the largest address we see for this.
|
505 |
*/
|
506 |
k = load_addr + eppnt->p_vaddr + eppnt->p_filesz; |
507 |
if (k > elf_bss) elf_bss = k;
|
508 |
|
509 |
/*
|
510 |
* Do the same thing for the memory mapping - between
|
511 |
* elf_bss and last_bss is the bss section.
|
512 |
*/
|
513 |
k = load_addr + eppnt->p_memsz + eppnt->p_vaddr; |
514 |
if (k > last_bss) last_bss = k;
|
515 |
} |
516 |
|
517 |
/* Now use mmap to map the library into memory. */
|
518 |
|
519 |
close(interpreter_fd); |
520 |
|
521 |
/*
|
522 |
* Now fill out the bss section. First pad the last page up
|
523 |
* to the page boundary, and then perform a mmap to make sure
|
524 |
* that there are zeromapped pages up to and including the last
|
525 |
* bss page.
|
526 |
*/
|
527 |
padzero(elf_bss); |
528 |
elf_bss = X86_ELF_PAGESTART(elf_bss + ALPHA_PAGE_SIZE - 1); /* What we have mapped so far */ |
529 |
|
530 |
/* Map the last of the bss segment */
|
531 |
if (last_bss > elf_bss) {
|
532 |
mmap4k(elf_bss, last_bss-elf_bss, |
533 |
PROT_READ|PROT_WRITE|PROT_EXEC, |
534 |
MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0); |
535 |
} |
536 |
free(elf_phdata); |
537 |
|
538 |
*interp_load_addr = load_addr; |
539 |
return ((unsigned long) interp_elf_ex->e_entry) + load_addr; |
540 |
} |
541 |
|
542 |
|
543 |
|
544 |
static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs, |
545 |
struct image_info * info)
|
546 |
{ |
547 |
struct elfhdr elf_ex;
|
548 |
struct elfhdr interp_elf_ex;
|
549 |
struct exec interp_ex;
|
550 |
int interpreter_fd = -1; /* avoid warning */ |
551 |
unsigned long load_addr; |
552 |
int load_addr_set = 0; |
553 |
unsigned int interpreter_type = INTERPRETER_NONE; |
554 |
unsigned char ibcs2_interpreter; |
555 |
int i;
|
556 |
void * mapped_addr;
|
557 |
struct elf_phdr * elf_ppnt;
|
558 |
struct elf_phdr *elf_phdata;
|
559 |
unsigned long elf_bss, k, elf_brk; |
560 |
int retval;
|
561 |
char * elf_interpreter;
|
562 |
unsigned long elf_entry, interp_load_addr = 0; |
563 |
int status;
|
564 |
unsigned long start_code, end_code, end_data; |
565 |
unsigned long elf_stack; |
566 |
char passed_fileno[6]; |
567 |
|
568 |
ibcs2_interpreter = 0;
|
569 |
status = 0;
|
570 |
load_addr = 0;
|
571 |
elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */ |
572 |
#ifdef BSWAP_NEEDED
|
573 |
bswap_ehdr(&elf_ex); |
574 |
#endif
|
575 |
|
576 |
if (elf_ex.e_ident[0] != 0x7f || |
577 |
strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) { |
578 |
return -ENOEXEC;
|
579 |
} |
580 |
|
581 |
/* First of all, some simple consistency checks */
|
582 |
if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
|
583 |
(! elf_check_arch(elf_ex.e_machine))) { |
584 |
return -ENOEXEC;
|
585 |
} |
586 |
|
587 |
/* Now read in all of the header information */
|
588 |
|
589 |
elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
|
590 |
if (elf_phdata == NULL) { |
591 |
return -ENOMEM;
|
592 |
} |
593 |
|
594 |
retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET); |
595 |
if(retval > 0) { |
596 |
retval = read(bprm->fd, (char *) elf_phdata,
|
597 |
elf_ex.e_phentsize * elf_ex.e_phnum); |
598 |
} |
599 |
|
600 |
if (retval < 0) { |
601 |
perror("load_elf_binary");
|
602 |
exit(-1);
|
603 |
free (elf_phdata); |
604 |
return -errno;
|
605 |
} |
606 |
|
607 |
#ifdef BSWAP_NEEDED
|
608 |
elf_ppnt = elf_phdata; |
609 |
for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) { |
610 |
bswap_phdr(elf_ppnt); |
611 |
} |
612 |
#endif
|
613 |
elf_ppnt = elf_phdata; |
614 |
|
615 |
elf_bss = 0;
|
616 |
elf_brk = 0;
|
617 |
|
618 |
|
619 |
elf_stack = ~0UL;
|
620 |
elf_interpreter = NULL;
|
621 |
start_code = ~0UL;
|
622 |
end_code = 0;
|
623 |
end_data = 0;
|
624 |
|
625 |
for(i=0;i < elf_ex.e_phnum; i++) { |
626 |
if (elf_ppnt->p_type == PT_INTERP) {
|
627 |
if ( elf_interpreter != NULL ) |
628 |
{ |
629 |
free (elf_phdata); |
630 |
free(elf_interpreter); |
631 |
close(bprm->fd); |
632 |
return -EINVAL;
|
633 |
} |
634 |
|
635 |
/* This is the program interpreter used for
|
636 |
* shared libraries - for now assume that this
|
637 |
* is an a.out format binary
|
638 |
*/
|
639 |
|
640 |
elf_interpreter = (char *)malloc(elf_ppnt->p_filesz+
|
641 |
strlen(bprm->interp_prefix)); |
642 |
|
643 |
if (elf_interpreter == NULL) { |
644 |
free (elf_phdata); |
645 |
close(bprm->fd); |
646 |
return -ENOMEM;
|
647 |
} |
648 |
|
649 |
strcpy(elf_interpreter, bprm->interp_prefix); |
650 |
retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET); |
651 |
if(retval >= 0) { |
652 |
retval = read(bprm->fd, |
653 |
elf_interpreter+strlen(bprm->interp_prefix), |
654 |
elf_ppnt->p_filesz); |
655 |
} |
656 |
if(retval < 0) { |
657 |
perror("load_elf_binary2");
|
658 |
exit(-1);
|
659 |
} |
660 |
|
661 |
/* If the program interpreter is one of these two,
|
662 |
then assume an iBCS2 image. Otherwise assume
|
663 |
a native linux image. */
|
664 |
|
665 |
/* JRP - Need to add X86 lib dir stuff here... */
|
666 |
|
667 |
if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 || |
668 |
strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) { |
669 |
ibcs2_interpreter = 1;
|
670 |
} |
671 |
|
672 |
#if 0
|
673 |
printf("Using ELF interpreter %s\n", elf_interpreter);
|
674 |
#endif
|
675 |
if (retval >= 0) { |
676 |
retval = open(elf_interpreter, O_RDONLY); |
677 |
if(retval >= 0) { |
678 |
interpreter_fd = retval; |
679 |
} |
680 |
else {
|
681 |
perror(elf_interpreter); |
682 |
exit(-1);
|
683 |
/* retval = -errno; */
|
684 |
} |
685 |
} |
686 |
|
687 |
if (retval >= 0) { |
688 |
retval = lseek(interpreter_fd, 0, SEEK_SET);
|
689 |
if(retval >= 0) { |
690 |
retval = read(interpreter_fd,bprm->buf,128);
|
691 |
} |
692 |
} |
693 |
if (retval >= 0) { |
694 |
interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */ |
695 |
interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */ |
696 |
} |
697 |
if (retval < 0) { |
698 |
perror("load_elf_binary3");
|
699 |
exit(-1);
|
700 |
free (elf_phdata); |
701 |
free(elf_interpreter); |
702 |
close(bprm->fd); |
703 |
return retval;
|
704 |
} |
705 |
} |
706 |
elf_ppnt++; |
707 |
} |
708 |
|
709 |
/* Some simple consistency checks for the interpreter */
|
710 |
if (elf_interpreter){
|
711 |
interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT; |
712 |
|
713 |
/* Now figure out which format our binary is */
|
714 |
if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
|
715 |
(N_MAGIC(interp_ex) != QMAGIC)) { |
716 |
interpreter_type = INTERPRETER_ELF; |
717 |
} |
718 |
|
719 |
if (interp_elf_ex.e_ident[0] != 0x7f || |
720 |
strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) { |
721 |
interpreter_type &= ~INTERPRETER_ELF; |
722 |
} |
723 |
|
724 |
if (!interpreter_type) {
|
725 |
free(elf_interpreter); |
726 |
free(elf_phdata); |
727 |
close(bprm->fd); |
728 |
return -ELIBBAD;
|
729 |
} |
730 |
} |
731 |
|
732 |
/* OK, we are done with that, now set up the arg stuff,
|
733 |
and then start this sucker up */
|
734 |
|
735 |
if (!bprm->sh_bang) {
|
736 |
char * passed_p;
|
737 |
|
738 |
if (interpreter_type == INTERPRETER_AOUT) {
|
739 |
sprintf(passed_fileno, "%d", bprm->fd);
|
740 |
passed_p = passed_fileno; |
741 |
|
742 |
if (elf_interpreter) {
|
743 |
bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
|
744 |
bprm->argc++; |
745 |
} |
746 |
} |
747 |
if (!bprm->p) {
|
748 |
if (elf_interpreter) {
|
749 |
free(elf_interpreter); |
750 |
} |
751 |
free (elf_phdata); |
752 |
close(bprm->fd); |
753 |
return -E2BIG;
|
754 |
} |
755 |
} |
756 |
|
757 |
/* OK, This is the point of no return */
|
758 |
info->end_data = 0;
|
759 |
info->end_code = 0;
|
760 |
info->start_mmap = (unsigned long)ELF_START_MMAP; |
761 |
info->mmap = 0;
|
762 |
elf_entry = (unsigned long) elf_ex.e_entry; |
763 |
|
764 |
/* Do this so that we can load the interpreter, if need be. We will
|
765 |
change some of these later */
|
766 |
info->rss = 0;
|
767 |
bprm->p = setup_arg_pages(bprm->p, bprm, info); |
768 |
info->start_stack = bprm->p; |
769 |
|
770 |
/* Now we do a little grungy work by mmaping the ELF image into
|
771 |
* the correct location in memory. At this point, we assume that
|
772 |
* the image should be loaded at fixed address, not at a variable
|
773 |
* address.
|
774 |
*/
|
775 |
|
776 |
|
777 |
|
778 |
for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) { |
779 |
if (elf_ppnt->p_type == PT_LOAD) {
|
780 |
int elf_prot = 0; |
781 |
if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
|
782 |
if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
|
783 |
if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
|
784 |
|
785 |
mapped_addr = mmap4k(X86_ELF_PAGESTART(elf_ppnt->p_vaddr), |
786 |
(elf_ppnt->p_filesz + |
787 |
X86_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)), |
788 |
elf_prot, |
789 |
(MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE), |
790 |
bprm->fd, |
791 |
(elf_ppnt->p_offset - |
792 |
X86_ELF_PAGEOFFSET(elf_ppnt->p_vaddr))); |
793 |
|
794 |
if((unsigned long)mapped_addr == 0xffffffffffffffff) { |
795 |
perror("mmap");
|
796 |
exit(-1);
|
797 |
} |
798 |
|
799 |
|
800 |
|
801 |
#ifdef LOW_ELF_STACK
|
802 |
if (X86_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
|
803 |
elf_stack = X86_ELF_PAGESTART(elf_ppnt->p_vaddr); |
804 |
#endif
|
805 |
|
806 |
if (!load_addr_set) {
|
807 |
load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset; |
808 |
load_addr_set = 1;
|
809 |
} |
810 |
k = elf_ppnt->p_vaddr; |
811 |
if (k < start_code) start_code = k;
|
812 |
k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz; |
813 |
if (k > elf_bss) elf_bss = k;
|
814 |
#if 1 |
815 |
if ((elf_ppnt->p_flags & PF_X) && end_code < k)
|
816 |
#else
|
817 |
if ( !(elf_ppnt->p_flags & PF_W) && end_code < k)
|
818 |
#endif
|
819 |
end_code = k; |
820 |
if (end_data < k) end_data = k;
|
821 |
k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz; |
822 |
if (k > elf_brk) elf_brk = k;
|
823 |
} |
824 |
} |
825 |
|
826 |
if (elf_interpreter) {
|
827 |
if (interpreter_type & 1) { |
828 |
elf_entry = load_aout_interp(&interp_ex, interpreter_fd); |
829 |
} |
830 |
else if (interpreter_type & 2) { |
831 |
elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd, |
832 |
&interp_load_addr); |
833 |
} |
834 |
|
835 |
close(interpreter_fd); |
836 |
free(elf_interpreter); |
837 |
|
838 |
if (elf_entry == ~0UL) { |
839 |
printf("Unable to load interpreter\n");
|
840 |
free(elf_phdata); |
841 |
exit(-1);
|
842 |
return 0; |
843 |
} |
844 |
} |
845 |
|
846 |
free(elf_phdata); |
847 |
|
848 |
if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
|
849 |
info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX); |
850 |
|
851 |
#ifdef LOW_ELF_STACK
|
852 |
info->start_stack = bprm->p = elf_stack - 4;
|
853 |
#endif
|
854 |
bprm->p = (unsigned long) |
855 |
create_elf_tables((char *)bprm->p,
|
856 |
bprm->argc, |
857 |
bprm->envc, |
858 |
(interpreter_type == INTERPRETER_ELF ? &elf_ex : NULL),
|
859 |
load_addr, |
860 |
interp_load_addr, |
861 |
(interpreter_type == INTERPRETER_AOUT ? 0 : 1), |
862 |
info); |
863 |
if (interpreter_type == INTERPRETER_AOUT)
|
864 |
info->arg_start += strlen(passed_fileno) + 1;
|
865 |
info->start_brk = info->brk = elf_brk; |
866 |
info->end_code = end_code; |
867 |
info->start_code = start_code; |
868 |
info->end_data = end_data; |
869 |
info->start_stack = bprm->p; |
870 |
|
871 |
/* Calling set_brk effectively mmaps the pages that we need for the bss and break
|
872 |
sections */
|
873 |
set_brk(elf_bss, elf_brk); |
874 |
|
875 |
padzero(elf_bss); |
876 |
|
877 |
#if 0
|
878 |
printf("(start_brk) %x\n" , info->start_brk);
|
879 |
printf("(end_code) %x\n" , info->end_code);
|
880 |
printf("(start_code) %x\n" , info->start_code);
|
881 |
printf("(end_data) %x\n" , info->end_data);
|
882 |
printf("(start_stack) %x\n" , info->start_stack);
|
883 |
printf("(brk) %x\n" , info->brk);
|
884 |
#endif
|
885 |
|
886 |
if ( info->personality == PER_SVR4 )
|
887 |
{ |
888 |
/* Why this, you ask??? Well SVr4 maps page 0 as read-only,
|
889 |
and some applications "depend" upon this behavior.
|
890 |
Since we do not have the power to recompile these, we
|
891 |
emulate the SVr4 behavior. Sigh. */
|
892 |
mapped_addr = mmap4k(NULL, ALPHA_PAGE_SIZE, PROT_READ | PROT_EXEC,
|
893 |
MAP_FIXED | MAP_PRIVATE, -1, 0); |
894 |
} |
895 |
|
896 |
#ifdef ELF_PLAT_INIT
|
897 |
/*
|
898 |
* The ABI may specify that certain registers be set up in special
|
899 |
* ways (on i386 %edx is the address of a DT_FINI function, for
|
900 |
* example. This macro performs whatever initialization to
|
901 |
* the regs structure is required.
|
902 |
*/
|
903 |
ELF_PLAT_INIT(regs); |
904 |
#endif
|
905 |
|
906 |
|
907 |
info->entry = elf_entry; |
908 |
|
909 |
return 0; |
910 |
} |
911 |
|
912 |
|
913 |
|
914 |
int elf_exec(const char *interp_prefix, |
915 |
const char * filename, char ** argv, char ** envp, |
916 |
struct target_pt_regs * regs, struct image_info *infop) |
917 |
{ |
918 |
struct linux_binprm bprm;
|
919 |
int retval;
|
920 |
int i;
|
921 |
|
922 |
bprm.p = X86_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int); |
923 |
for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */ |
924 |
bprm.page[i] = 0;
|
925 |
retval = open(filename, O_RDONLY); |
926 |
if (retval == -1) { |
927 |
perror(filename); |
928 |
exit(-1);
|
929 |
/* return retval; */
|
930 |
} |
931 |
else {
|
932 |
bprm.fd = retval; |
933 |
} |
934 |
bprm.interp_prefix = (char *)interp_prefix;
|
935 |
bprm.filename = (char *)filename;
|
936 |
bprm.sh_bang = 0;
|
937 |
bprm.loader = 0;
|
938 |
bprm.exec = 0;
|
939 |
bprm.dont_iput = 0;
|
940 |
bprm.argc = count(argv); |
941 |
bprm.envc = count(envp); |
942 |
|
943 |
retval = prepare_binprm(&bprm); |
944 |
|
945 |
if(retval>=0) { |
946 |
bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p);
|
947 |
bprm.exec = bprm.p; |
948 |
bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p); |
949 |
bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p); |
950 |
if (!bprm.p) {
|
951 |
retval = -E2BIG; |
952 |
} |
953 |
} |
954 |
|
955 |
if(retval>=0) { |
956 |
retval = load_elf_binary(&bprm,regs,infop); |
957 |
} |
958 |
if(retval>=0) { |
959 |
/* success. Initialize important registers */
|
960 |
regs->esp = infop->start_stack; |
961 |
regs->eip = infop->entry; |
962 |
return retval;
|
963 |
} |
964 |
|
965 |
/* Something went wrong, return the inode and free the argument pages*/
|
966 |
for (i=0 ; i<MAX_ARG_PAGES ; i++) { |
967 |
free_page((void *)bprm.page[i]);
|
968 |
} |
969 |
return(retval);
|
970 |
} |
971 |
|
972 |
|
973 |
static int load_aout_interp(void * exptr, int interp_fd) |
974 |
{ |
975 |
printf("a.out interpreter not yet supported\n");
|
976 |
return(0); |
977 |
} |
978 |
|