![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to elfload.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / linux-user|
Return to elfload.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / linux-user |
1.1 root 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: #include "disas.h"
15:
16: /* this flag is uneffective under linux too, should be deleted */
17: #ifndef MAP_DENYWRITE
18: #define MAP_DENYWRITE 0
19: #endif
20:
21: /* should probably go in elf.h */
22: #ifndef ELIBBAD
23: #define ELIBBAD 80
24: #endif
25:
26: #ifdef TARGET_I386
27:
28: #define ELF_START_MMAP 0x80000000
29:
30: /*
31: * This is used to ensure we don't load something for the wrong architecture.
32: */
33: #define elf_check_arch(x) ( ((x) == EM_386) || ((x) == EM_486) )
34:
35: /*
36: * These are used to set parameters in the core dumps.
37: */
38: #define ELF_CLASS ELFCLASS32
39: #define ELF_DATA ELFDATA2LSB
40: #define ELF_ARCH EM_386
41:
42: /* SVR4/i386 ABI (pages 3-31, 3-32) says that when the program
43: starts %edx contains a pointer to a function which might be
44: registered using `atexit'. This provides a mean for the
45: dynamic linker to call DT_FINI functions for shared libraries
46: that have been loaded before the code runs.
47:
48: A value of 0 tells we have no such handler. */
49: #define ELF_PLAT_INIT(_r) _r->edx = 0
50:
51: static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
52: {
53: regs->esp = infop->start_stack;
54: regs->eip = infop->entry;
55: }
56:
57: #define USE_ELF_CORE_DUMP
58: #define ELF_EXEC_PAGESIZE 4096
59:
60: #endif
61:
62: #ifdef TARGET_ARM
63:
64: #define ELF_START_MMAP 0x80000000
65:
66: #define elf_check_arch(x) ( (x) == EM_ARM )
67:
68: #define ELF_CLASS ELFCLASS32
69: #ifdef TARGET_WORDS_BIGENDIAN
70: #define ELF_DATA ELFDATA2MSB
71: #else
72: #define ELF_DATA ELFDATA2LSB
73: #endif
74: #define ELF_ARCH EM_ARM
75:
76: #define ELF_PLAT_INIT(_r) _r->ARM_r0 = 0
77:
78: static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
79: {
80: target_long *stack = (void *)infop->start_stack;
81: memset(regs, 0, sizeof(*regs));
82: regs->ARM_cpsr = 0x10;
83: regs->ARM_pc = infop->entry;
84: regs->ARM_sp = infop->start_stack;
85: regs->ARM_r2 = tswapl(stack[2]); /* envp */
86: regs->ARM_r1 = tswapl(stack[1]); /* argv */
87: /* XXX: it seems that r0 is zeroed after ! */
88: // regs->ARM_r0 = tswapl(stack[0]); /* argc */
89: }
90:
91: #define USE_ELF_CORE_DUMP
92: #define ELF_EXEC_PAGESIZE 4096
93:
94: #endif
95:
96: #ifdef TARGET_SPARC
97: #ifdef TARGET_SPARC64
98:
99: #define ELF_START_MMAP 0x80000000
100:
101: #define elf_check_arch(x) ( (x) == EM_SPARC )
102:
103: #define ELF_CLASS ELFCLASS64
104: #define ELF_DATA ELFDATA2MSB
105: #define ELF_ARCH EM_SPARC
106:
107: /*XXX*/
108: #define ELF_PLAT_INIT(_r)
109:
110: static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
111: {
112: regs->tstate = 0;
113: regs->pc = infop->entry;
114: regs->npc = regs->pc + 4;
115: regs->y = 0;
116: regs->u_regs[14] = infop->start_stack - 16 * 4;
117: }
118:
119: #else
120: #define ELF_START_MMAP 0x80000000
121:
122: #define elf_check_arch(x) ( (x) == EM_SPARC )
123:
124: #define ELF_CLASS ELFCLASS32
125: #define ELF_DATA ELFDATA2MSB
126: #define ELF_ARCH EM_SPARC
127:
128: /*XXX*/
129: #define ELF_PLAT_INIT(_r)
130:
131: static inline void init_thread(struct target_pt_regs *regs, struct image_info *infop)
132: {
133: regs->psr = 0;
134: regs->pc = infop->entry;
135: regs->npc = regs->pc + 4;
136: regs->y = 0;
137: regs->u_regs[14] = infop->start_stack - 16 * 4;
138: }
139:
140: #endif
141: #endif
142:
143: #ifdef TARGET_PPC
144:
145: #define ELF_START_MMAP 0x80000000
146:
147: #define elf_check_arch(x) ( (x) == EM_PPC )
148:
149: #define ELF_CLASS ELFCLASS32
150: #ifdef TARGET_WORDS_BIGENDIAN
151: #define ELF_DATA ELFDATA2MSB
152: #else
153: #define ELF_DATA ELFDATA2LSB
154: #endif
155: #define ELF_ARCH EM_PPC
156:
157: /* Note that isn't exactly what regular kernel does
158: * but this is what the ABI wants and is needed to allow
159: * execution of PPC BSD programs.
160: */
161: #define ELF_PLAT_INIT(_r) \
162: do { \
163: target_ulong *pos = (target_ulong *)bprm->p, tmp = 1; \
164: _r->gpr[3] = bprm->argc; \
165: _r->gpr[4] = (unsigned long)++pos; \
166: for (; tmp != 0; pos++) \
167: tmp = *pos; \
168: _r->gpr[5] = (unsigned long)pos; \
169: } while (0)
170:
171: /*
172: * We need to put in some extra aux table entries to tell glibc what
173: * the cache block size is, so it can use the dcbz instruction safely.
174: */
175: #define AT_DCACHEBSIZE 19
176: #define AT_ICACHEBSIZE 20
177: #define AT_UCACHEBSIZE 21
178: /* A special ignored type value for PPC, for glibc compatibility. */
179: #define AT_IGNOREPPC 22
180: /*
181: * The requirements here are:
182: * - keep the final alignment of sp (sp & 0xf)
183: * - make sure the 32-bit value at the first 16 byte aligned position of
184: * AUXV is greater than 16 for glibc compatibility.
185: * AT_IGNOREPPC is used for that.
186: * - for compatibility with glibc ARCH_DLINFO must always be defined on PPC,
187: * even if DLINFO_ARCH_ITEMS goes to zero or is undefined.
188: */
189: #define DLINFO_ARCH_ITEMS 5
190: #define ARCH_DLINFO \
191: do { \
192: NEW_AUX_ENT(AT_DCACHEBSIZE, 0x20); \
193: NEW_AUX_ENT(AT_ICACHEBSIZE, 0x20); \
194: NEW_AUX_ENT(AT_UCACHEBSIZE, 0); \
195: /* \
196: * Now handle glibc compatibility. \
197: */ \
198: NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
199: NEW_AUX_ENT(AT_IGNOREPPC, AT_IGNOREPPC); \
200: } while (0)
201:
202: static inline void init_thread(struct target_pt_regs *_regs, struct image_info *infop)
203: {
204: _regs->msr = 1 << MSR_PR; /* Set user mode */
205: _regs->gpr[1] = infop->start_stack;
206: _regs->nip = infop->entry;
207: }
208:
209: #define USE_ELF_CORE_DUMP
210: #define ELF_EXEC_PAGESIZE 4096
211:
212: #endif
213:
214: #include "elf.h"
215:
216: /*
217: * MAX_ARG_PAGES defines the number of pages allocated for arguments
218: * and envelope for the new program. 32 should suffice, this gives
219: * a maximum env+arg of 128kB w/4KB pages!
220: */
221: #define MAX_ARG_PAGES 32
222:
223: /*
224: * This structure is used to hold the arguments that are
225: * used when loading binaries.
226: */
227: struct linux_binprm {
228: char buf[128];
229: unsigned long page[MAX_ARG_PAGES];
230: unsigned long p;
231: int sh_bang;
232: int fd;
233: int e_uid, e_gid;
234: int argc, envc;
235: char * filename; /* Name of binary */
236: unsigned long loader, exec;
237: int dont_iput; /* binfmt handler has put inode */
238: };
239:
240: struct exec
241: {
242: unsigned int a_info; /* Use macros N_MAGIC, etc for access */
243: unsigned int a_text; /* length of text, in bytes */
244: unsigned int a_data; /* length of data, in bytes */
245: unsigned int a_bss; /* length of uninitialized data area, in bytes */
246: unsigned int a_syms; /* length of symbol table data in file, in bytes */
247: unsigned int a_entry; /* start address */
248: unsigned int a_trsize; /* length of relocation info for text, in bytes */
249: unsigned int a_drsize; /* length of relocation info for data, in bytes */
250: };
251:
252:
253: #define N_MAGIC(exec) ((exec).a_info & 0xffff)
254: #define OMAGIC 0407
255: #define NMAGIC 0410
256: #define ZMAGIC 0413
257: #define QMAGIC 0314
258:
259: /* max code+data+bss space allocated to elf interpreter */
260: #define INTERP_MAP_SIZE (32 * 1024 * 1024)
261:
262: /* max code+data+bss+brk space allocated to ET_DYN executables */
263: #define ET_DYN_MAP_SIZE (128 * 1024 * 1024)
264:
265: /* from personality.h */
266:
267: /* Flags for bug emulation. These occupy the top three bytes. */
268: #define STICKY_TIMEOUTS 0x4000000
269: #define WHOLE_SECONDS 0x2000000
270:
271: /* Personality types. These go in the low byte. Avoid using the top bit,
272: * it will conflict with error returns.
273: */
274: #define PER_MASK (0x00ff)
275: #define PER_LINUX (0x0000)
276: #define PER_SVR4 (0x0001 | STICKY_TIMEOUTS)
277: #define PER_SVR3 (0x0002 | STICKY_TIMEOUTS)
278: #define PER_SCOSVR3 (0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS)
279: #define PER_WYSEV386 (0x0004 | STICKY_TIMEOUTS)
280: #define PER_ISCR4 (0x0005 | STICKY_TIMEOUTS)
281: #define PER_BSD (0x0006)
282: #define PER_XENIX (0x0007 | STICKY_TIMEOUTS)
283:
284: /* Necessary parameters */
285: #define NGROUPS 32
286:
287: #define TARGET_ELF_EXEC_PAGESIZE TARGET_PAGE_SIZE
288: #define TARGET_ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(TARGET_ELF_EXEC_PAGESIZE-1))
289: #define TARGET_ELF_PAGEOFFSET(_v) ((_v) & (TARGET_ELF_EXEC_PAGESIZE-1))
290:
291: #define INTERPRETER_NONE 0
292: #define INTERPRETER_AOUT 1
293: #define INTERPRETER_ELF 2
294:
295: #define DLINFO_ITEMS 11
296:
297: static inline void memcpy_fromfs(void * to, const void * from, unsigned long n)
298: {
299: memcpy(to, from, n);
300: }
301:
302: extern unsigned long x86_stack_size;
303:
304: static int load_aout_interp(void * exptr, int interp_fd);
305:
306: #ifdef BSWAP_NEEDED
307: static void bswap_ehdr(struct elfhdr *ehdr)
308: {
309: bswap16s(&ehdr->e_type); /* Object file type */
310: bswap16s(&ehdr->e_machine); /* Architecture */
311: bswap32s(&ehdr->e_version); /* Object file version */
312: bswaptls(&ehdr->e_entry); /* Entry point virtual address */
313: bswaptls(&ehdr->e_phoff); /* Program header table file offset */
314: bswaptls(&ehdr->e_shoff); /* Section header table file offset */
315: bswap32s(&ehdr->e_flags); /* Processor-specific flags */
316: bswap16s(&ehdr->e_ehsize); /* ELF header size in bytes */
317: bswap16s(&ehdr->e_phentsize); /* Program header table entry size */
318: bswap16s(&ehdr->e_phnum); /* Program header table entry count */
319: bswap16s(&ehdr->e_shentsize); /* Section header table entry size */
320: bswap16s(&ehdr->e_shnum); /* Section header table entry count */
321: bswap16s(&ehdr->e_shstrndx); /* Section header string table index */
322: }
323:
324: static void bswap_phdr(struct elf_phdr *phdr)
325: {
326: bswap32s(&phdr->p_type); /* Segment type */
327: bswaptls(&phdr->p_offset); /* Segment file offset */
328: bswaptls(&phdr->p_vaddr); /* Segment virtual address */
329: bswaptls(&phdr->p_paddr); /* Segment physical address */
330: bswaptls(&phdr->p_filesz); /* Segment size in file */
331: bswaptls(&phdr->p_memsz); /* Segment size in memory */
332: bswap32s(&phdr->p_flags); /* Segment flags */
333: bswaptls(&phdr->p_align); /* Segment alignment */
334: }
335:
336: static void bswap_shdr(struct elf_shdr *shdr)
337: {
338: bswap32s(&shdr->sh_name);
339: bswap32s(&shdr->sh_type);
340: bswaptls(&shdr->sh_flags);
341: bswaptls(&shdr->sh_addr);
342: bswaptls(&shdr->sh_offset);
343: bswaptls(&shdr->sh_size);
344: bswap32s(&shdr->sh_link);
345: bswap32s(&shdr->sh_info);
346: bswaptls(&shdr->sh_addralign);
347: bswaptls(&shdr->sh_entsize);
348: }
349:
350: static void bswap_sym(Elf32_Sym *sym)
351: {
352: bswap32s(&sym->st_name);
353: bswap32s(&sym->st_value);
354: bswap32s(&sym->st_size);
355: bswap16s(&sym->st_shndx);
356: }
357: #endif
358:
359: static void * get_free_page(void)
360: {
361: void * retval;
362:
363: /* User-space version of kernel get_free_page. Returns a page-aligned
364: * page-sized chunk of memory.
365: */
366: retval = (void *)target_mmap(0, qemu_host_page_size, PROT_READ|PROT_WRITE,
367: MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
368:
369: if((long)retval == -1) {
370: perror("get_free_page");
371: exit(-1);
372: }
373: else {
374: return(retval);
375: }
376: }
377:
378: static void free_page(void * pageaddr)
379: {
380: target_munmap((unsigned long)pageaddr, qemu_host_page_size);
381: }
382:
383: /*
384: * 'copy_string()' copies argument/envelope strings from user
385: * memory to free pages in kernel mem. These are in a format ready
386: * to be put directly into the top of new user memory.
387: *
388: */
389: static unsigned long copy_strings(int argc,char ** argv,unsigned long *page,
390: unsigned long p)
391: {
392: char *tmp, *tmp1, *pag = NULL;
393: int len, offset = 0;
394:
395: if (!p) {
396: return 0; /* bullet-proofing */
397: }
398: while (argc-- > 0) {
399: tmp = argv[argc];
400: if (!tmp) {
401: fprintf(stderr, "VFS: argc is wrong");
402: exit(-1);
403: }
404: tmp1 = tmp;
405: while (*tmp++);
406: len = tmp - tmp1;
407: if (p < len) { /* this shouldn't happen - 128kB */
408: return 0;
409: }
410: while (len) {
411: --p; --tmp; --len;
412: if (--offset < 0) {
413: offset = p % TARGET_PAGE_SIZE;
414: pag = (char *) page[p/TARGET_PAGE_SIZE];
415: if (!pag) {
416: pag = (char *)get_free_page();
417: page[p/TARGET_PAGE_SIZE] = (unsigned long)pag;
418: if (!pag)
419: return 0;
420: }
421: }
422: if (len == 0 || offset == 0) {
423: *(pag + offset) = *tmp;
424: }
425: else {
426: int bytes_to_copy = (len > offset) ? offset : len;
427: tmp -= bytes_to_copy;
428: p -= bytes_to_copy;
429: offset -= bytes_to_copy;
430: len -= bytes_to_copy;
431: memcpy_fromfs(pag + offset, tmp, bytes_to_copy + 1);
432: }
433: }
434: }
435: return p;
436: }
437:
438: static int in_group_p(gid_t g)
439: {
440: /* return TRUE if we're in the specified group, FALSE otherwise */
441: int ngroup;
442: int i;
443: gid_t grouplist[NGROUPS];
444:
445: ngroup = getgroups(NGROUPS, grouplist);
446: for(i = 0; i < ngroup; i++) {
447: if(grouplist[i] == g) {
448: return 1;
449: }
450: }
451: return 0;
452: }
453:
454: static int count(char ** vec)
455: {
456: int i;
457:
458: for(i = 0; *vec; i++) {
459: vec++;
460: }
461:
462: return(i);
463: }
464:
465: static int prepare_binprm(struct linux_binprm *bprm)
466: {
467: struct stat st;
468: int mode;
469: int retval, id_change;
470:
471: if(fstat(bprm->fd, &st) < 0) {
472: return(-errno);
473: }
474:
475: mode = st.st_mode;
476: if(!S_ISREG(mode)) { /* Must be regular file */
477: return(-EACCES);
478: }
479: if(!(mode & 0111)) { /* Must have at least one execute bit set */
480: return(-EACCES);
481: }
482:
483: bprm->e_uid = geteuid();
484: bprm->e_gid = getegid();
485: id_change = 0;
486:
487: /* Set-uid? */
488: if(mode & S_ISUID) {
489: bprm->e_uid = st.st_uid;
490: if(bprm->e_uid != geteuid()) {
491: id_change = 1;
492: }
493: }
494:
495: /* Set-gid? */
496: /*
497: * If setgid is set but no group execute bit then this
498: * is a candidate for mandatory locking, not a setgid
499: * executable.
500: */
501: if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) {
502: bprm->e_gid = st.st_gid;
503: if (!in_group_p(bprm->e_gid)) {
504: id_change = 1;
505: }
506: }
507:
508: memset(bprm->buf, 0, sizeof(bprm->buf));
509: retval = lseek(bprm->fd, 0L, SEEK_SET);
510: if(retval >= 0) {
511: retval = read(bprm->fd, bprm->buf, 128);
512: }
513: if(retval < 0) {
514: perror("prepare_binprm");
515: exit(-1);
516: /* return(-errno); */
517: }
518: else {
519: return(retval);
520: }
521: }
522:
523: unsigned long setup_arg_pages(unsigned long p, struct linux_binprm * bprm,
524: struct image_info * info)
525: {
526: unsigned long stack_base, size, error;
527: int i;
528:
529: /* Create enough stack to hold everything. If we don't use
530: * it for args, we'll use it for something else...
531: */
532: size = x86_stack_size;
533: if (size < MAX_ARG_PAGES*TARGET_PAGE_SIZE)
534: size = MAX_ARG_PAGES*TARGET_PAGE_SIZE;
535: error = target_mmap(0,
536: size + qemu_host_page_size,
537: PROT_READ | PROT_WRITE,
538: MAP_PRIVATE | MAP_ANONYMOUS,
539: -1, 0);
540: if (error == -1) {
541: perror("stk mmap");
542: exit(-1);
543: }
544: /* we reserve one extra page at the top of the stack as guard */
545: target_mprotect(error + size, qemu_host_page_size, PROT_NONE);
546:
547: stack_base = error + size - MAX_ARG_PAGES*TARGET_PAGE_SIZE;
548: p += stack_base;
549:
550: if (bprm->loader) {
551: bprm->loader += stack_base;
552: }
553: bprm->exec += stack_base;
554:
555: for (i = 0 ; i < MAX_ARG_PAGES ; i++) {
556: if (bprm->page[i]) {
557: info->rss++;
558:
559: memcpy((void *)stack_base, (void *)bprm->page[i], TARGET_PAGE_SIZE);
560: free_page((void *)bprm->page[i]);
561: }
562: stack_base += TARGET_PAGE_SIZE;
563: }
564: return p;
565: }
566:
567: static void set_brk(unsigned long start, unsigned long end)
568: {
569: /* page-align the start and end addresses... */
570: start = HOST_PAGE_ALIGN(start);
571: end = HOST_PAGE_ALIGN(end);
572: if (end <= start)
573: return;
574: if(target_mmap(start, end - start,
575: PROT_READ | PROT_WRITE | PROT_EXEC,
576: MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS, -1, 0) == -1) {
577: perror("cannot mmap brk");
578: exit(-1);
579: }
580: }
581:
582:
583: /* We need to explicitly zero any fractional pages after the data
584: section (i.e. bss). This would contain the junk from the file that
585: should not be in memory. */
586: static void padzero(unsigned long elf_bss)
587: {
588: unsigned long nbyte;
589: char * fpnt;
590:
591: /* XXX: this is really a hack : if the real host page size is
592: smaller than the target page size, some pages after the end
593: of the file may not be mapped. A better fix would be to
594: patch target_mmap(), but it is more complicated as the file
595: size must be known */
596: if (qemu_real_host_page_size < qemu_host_page_size) {
597: unsigned long end_addr, end_addr1;
598: end_addr1 = (elf_bss + qemu_real_host_page_size - 1) &
599: ~(qemu_real_host_page_size - 1);
600: end_addr = HOST_PAGE_ALIGN(elf_bss);
601: if (end_addr1 < end_addr) {
602: mmap((void *)end_addr1, end_addr - end_addr1,
603: PROT_READ|PROT_WRITE|PROT_EXEC,
604: MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
605: }
606: }
607:
608: nbyte = elf_bss & (qemu_host_page_size-1);
609: if (nbyte) {
610: nbyte = qemu_host_page_size - nbyte;
611: fpnt = (char *) elf_bss;
612: do {
613: *fpnt++ = 0;
614: } while (--nbyte);
615: }
616: }
617:
618: static unsigned int * create_elf_tables(char *p, int argc, int envc,
619: struct elfhdr * exec,
620: unsigned long load_addr,
621: unsigned long load_bias,
622: unsigned long interp_load_addr, int ibcs,
623: struct image_info *info)
624: {
625: target_ulong *argv, *envp;
626: target_ulong *sp, *csp;
627: int v;
628:
629: /*
630: * Force 16 byte _final_ alignment here for generality.
631: */
632: sp = (unsigned int *) (~15UL & (unsigned long) p);
633: csp = sp;
634: csp -= (DLINFO_ITEMS + 1) * 2;
635: #ifdef DLINFO_ARCH_ITEMS
636: csp -= DLINFO_ARCH_ITEMS*2;
637: #endif
638: csp -= envc+1;
639: csp -= argc+1;
640: csp -= (!ibcs ? 3 : 1); /* argc itself */
641: if ((unsigned long)csp & 15UL)
642: sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
643:
644: #define NEW_AUX_ENT(id, val) \
645: sp -= 2; \
646: put_user (id, sp); \
647: put_user (val, sp + 1)
648: NEW_AUX_ENT (AT_NULL, 0);
649:
650: /* There must be exactly DLINFO_ITEMS entries here. */
651: NEW_AUX_ENT(AT_PHDR, (target_ulong)(load_addr + exec->e_phoff));
652: NEW_AUX_ENT(AT_PHENT, (target_ulong)(sizeof (struct elf_phdr)));
653: NEW_AUX_ENT(AT_PHNUM, (target_ulong)(exec->e_phnum));
654: NEW_AUX_ENT(AT_PAGESZ, (target_ulong)(TARGET_PAGE_SIZE));
655: NEW_AUX_ENT(AT_BASE, (target_ulong)(interp_load_addr));
656: NEW_AUX_ENT(AT_FLAGS, (target_ulong)0);
657: NEW_AUX_ENT(AT_ENTRY, load_bias + exec->e_entry);
658: NEW_AUX_ENT(AT_UID, (target_ulong) getuid());
659: NEW_AUX_ENT(AT_EUID, (target_ulong) geteuid());
660: NEW_AUX_ENT(AT_GID, (target_ulong) getgid());
661: NEW_AUX_ENT(AT_EGID, (target_ulong) getegid());
662: #ifdef ARCH_DLINFO
663: /*
664: * ARCH_DLINFO must come last so platform specific code can enforce
665: * special alignment requirements on the AUXV if necessary (eg. PPC).
666: */
667: ARCH_DLINFO;
668: #endif
669: #undef NEW_AUX_ENT
670:
671: sp -= envc+1;
672: envp = sp;
673: sp -= argc+1;
674: argv = sp;
675: if (!ibcs) {
676: put_user((target_ulong)envp,--sp);
677: put_user((target_ulong)argv,--sp);
678: }
679: put_user(argc,--sp);
680: info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
681: while (argc-->0) {
682: put_user((target_ulong)p,argv++);
683: do {
684: get_user(v, p);
685: p++;
686: } while (v != 0);
687: }
688: put_user(0,argv);
689: info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
690: while (envc-->0) {
691: put_user((target_ulong)p,envp++);
692: do {
693: get_user(v, p);
694: p++;
695: } while (v != 0);
696: }
697: put_user(0,envp);
698: info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
699: return sp;
700: }
701:
702:
703:
704: static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
705: int interpreter_fd,
706: unsigned long *interp_load_addr)
707: {
708: struct elf_phdr *elf_phdata = NULL;
709: struct elf_phdr *eppnt;
710: unsigned long load_addr = 0;
711: int load_addr_set = 0;
712: int retval;
713: unsigned long last_bss, elf_bss;
714: unsigned long error;
715: int i;
716:
717: elf_bss = 0;
718: last_bss = 0;
719: error = 0;
720:
721: #ifdef BSWAP_NEEDED
722: bswap_ehdr(interp_elf_ex);
723: #endif
724: /* First of all, some simple consistency checks */
725: if ((interp_elf_ex->e_type != ET_EXEC &&
726: interp_elf_ex->e_type != ET_DYN) ||
727: !elf_check_arch(interp_elf_ex->e_machine)) {
728: return ~0UL;
729: }
730:
731:
732: /* Now read in all of the header information */
733:
734: if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > TARGET_PAGE_SIZE)
735: return ~0UL;
736:
737: elf_phdata = (struct elf_phdr *)
738: malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
739:
740: if (!elf_phdata)
741: return ~0UL;
742:
743: /*
744: * If the size of this structure has changed, then punt, since
745: * we will be doing the wrong thing.
746: */
747: if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr)) {
748: free(elf_phdata);
749: return ~0UL;
750: }
751:
752: retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
753: if(retval >= 0) {
754: retval = read(interpreter_fd,
755: (char *) elf_phdata,
756: sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
757: }
758: if (retval < 0) {
759: perror("load_elf_interp");
760: exit(-1);
761: free (elf_phdata);
762: return retval;
763: }
764: #ifdef BSWAP_NEEDED
765: eppnt = elf_phdata;
766: for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
767: bswap_phdr(eppnt);
768: }
769: #endif
770:
771: if (interp_elf_ex->e_type == ET_DYN) {
772: /* in order to avoid harcoding the interpreter load
773: address in qemu, we allocate a big enough memory zone */
774: error = target_mmap(0, INTERP_MAP_SIZE,
775: PROT_NONE, MAP_PRIVATE | MAP_ANON,
776: -1, 0);
777: if (error == -1) {
778: perror("mmap");
779: exit(-1);
780: }
781: load_addr = error;
782: load_addr_set = 1;
783: }
784:
785: eppnt = elf_phdata;
786: for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++)
787: if (eppnt->p_type == PT_LOAD) {
788: int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
789: int elf_prot = 0;
790: unsigned long vaddr = 0;
791: unsigned long k;
792:
793: if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
794: if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
795: if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
796: if (interp_elf_ex->e_type == ET_EXEC || load_addr_set) {
797: elf_type |= MAP_FIXED;
798: vaddr = eppnt->p_vaddr;
799: }
800: error = target_mmap(load_addr+TARGET_ELF_PAGESTART(vaddr),
801: eppnt->p_filesz + TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr),
802: elf_prot,
803: elf_type,
804: interpreter_fd,
805: eppnt->p_offset - TARGET_ELF_PAGEOFFSET(eppnt->p_vaddr));
806:
807: if (error > -1024UL) {
808: /* Real error */
809: close(interpreter_fd);
810: free(elf_phdata);
811: return ~0UL;
812: }
813:
814: if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
815: load_addr = error;
816: load_addr_set = 1;
817: }
818:
819: /*
820: * Find the end of the file mapping for this phdr, and keep
821: * track of the largest address we see for this.
822: */
823: k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
824: if (k > elf_bss) elf_bss = k;
825:
826: /*
827: * Do the same thing for the memory mapping - between
828: * elf_bss and last_bss is the bss section.
829: */
830: k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
831: if (k > last_bss) last_bss = k;
832: }
833:
834: /* Now use mmap to map the library into memory. */
835:
836: close(interpreter_fd);
837:
838: /*
839: * Now fill out the bss section. First pad the last page up
840: * to the page boundary, and then perform a mmap to make sure
841: * that there are zeromapped pages up to and including the last
842: * bss page.
843: */
844: padzero(elf_bss);
845: elf_bss = TARGET_ELF_PAGESTART(elf_bss + qemu_host_page_size - 1); /* What we have mapped so far */
846:
847: /* Map the last of the bss segment */
848: if (last_bss > elf_bss) {
849: target_mmap(elf_bss, last_bss-elf_bss,
850: PROT_READ|PROT_WRITE|PROT_EXEC,
851: MAP_FIXED|MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
852: }
853: free(elf_phdata);
854:
855: *interp_load_addr = load_addr;
856: return ((unsigned long) interp_elf_ex->e_entry) + load_addr;
857: }
858:
859: /* Best attempt to load symbols from this ELF object. */
860: static void load_symbols(struct elfhdr *hdr, int fd)
861: {
862: unsigned int i;
863: struct elf_shdr sechdr, symtab, strtab;
864: char *strings;
865: struct syminfo *s;
866:
867: lseek(fd, hdr->e_shoff, SEEK_SET);
868: for (i = 0; i < hdr->e_shnum; i++) {
869: if (read(fd, &sechdr, sizeof(sechdr)) != sizeof(sechdr))
870: return;
871: #ifdef BSWAP_NEEDED
872: bswap_shdr(&sechdr);
873: #endif
874: if (sechdr.sh_type == SHT_SYMTAB) {
875: symtab = sechdr;
876: lseek(fd, hdr->e_shoff
877: + sizeof(sechdr) * sechdr.sh_link, SEEK_SET);
878: if (read(fd, &strtab, sizeof(strtab))
879: != sizeof(strtab))
880: return;
881: #ifdef BSWAP_NEEDED
882: bswap_shdr(&strtab);
883: #endif
884: goto found;
885: }
886: }
887: return; /* Shouldn't happen... */
888:
889: found:
890: /* Now know where the strtab and symtab are. Snarf them. */
891: s = malloc(sizeof(*s));
892: s->disas_symtab = malloc(symtab.sh_size);
893: s->disas_strtab = strings = malloc(strtab.sh_size);
894: if (!s->disas_symtab || !s->disas_strtab)
895: return;
896:
897: lseek(fd, symtab.sh_offset, SEEK_SET);
898: if (read(fd, s->disas_symtab, symtab.sh_size) != symtab.sh_size)
899: return;
900:
901: #ifdef BSWAP_NEEDED
902: for (i = 0; i < symtab.sh_size / sizeof(struct elf_sym); i++)
903: bswap_sym(s->disas_symtab + sizeof(struct elf_sym)*i);
904: #endif
905:
906: lseek(fd, strtab.sh_offset, SEEK_SET);
907: if (read(fd, strings, strtab.sh_size) != strtab.sh_size)
908: return;
909: s->disas_num_syms = symtab.sh_size / sizeof(struct elf_sym);
910: s->next = syminfos;
911: syminfos = s;
912: }
913:
914: static int load_elf_binary(struct linux_binprm * bprm, struct target_pt_regs * regs,
915: struct image_info * info)
916: {
917: struct elfhdr elf_ex;
918: struct elfhdr interp_elf_ex;
919: struct exec interp_ex;
920: int interpreter_fd = -1; /* avoid warning */
921: unsigned long load_addr, load_bias;
922: int load_addr_set = 0;
923: unsigned int interpreter_type = INTERPRETER_NONE;
924: unsigned char ibcs2_interpreter;
925: int i;
926: unsigned long mapped_addr;
927: struct elf_phdr * elf_ppnt;
928: struct elf_phdr *elf_phdata;
929: unsigned long elf_bss, k, elf_brk;
930: int retval;
931: char * elf_interpreter;
932: unsigned long elf_entry, interp_load_addr = 0;
933: int status;
934: unsigned long start_code, end_code, end_data;
935: unsigned long elf_stack;
936: char passed_fileno[6];
937:
938: ibcs2_interpreter = 0;
939: status = 0;
940: load_addr = 0;
941: load_bias = 0;
942: elf_ex = *((struct elfhdr *) bprm->buf); /* exec-header */
943: #ifdef BSWAP_NEEDED
944: bswap_ehdr(&elf_ex);
945: #endif
946:
947: if (elf_ex.e_ident[0] != 0x7f ||
948: strncmp(&elf_ex.e_ident[1], "ELF",3) != 0) {
949: return -ENOEXEC;
950: }
951:
952: /* First of all, some simple consistency checks */
953: if ((elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN) ||
954: (! elf_check_arch(elf_ex.e_machine))) {
955: return -ENOEXEC;
956: }
957:
958: /* Now read in all of the header information */
959: elf_phdata = (struct elf_phdr *)malloc(elf_ex.e_phentsize*elf_ex.e_phnum);
960: if (elf_phdata == NULL) {
961: return -ENOMEM;
962: }
963:
964: retval = lseek(bprm->fd, elf_ex.e_phoff, SEEK_SET);
965: if(retval > 0) {
966: retval = read(bprm->fd, (char *) elf_phdata,
967: elf_ex.e_phentsize * elf_ex.e_phnum);
968: }
969:
970: if (retval < 0) {
971: perror("load_elf_binary");
972: exit(-1);
973: free (elf_phdata);
974: return -errno;
975: }
976:
977: #ifdef BSWAP_NEEDED
978: elf_ppnt = elf_phdata;
979: for (i=0; i<elf_ex.e_phnum; i++, elf_ppnt++) {
980: bswap_phdr(elf_ppnt);
981: }
982: #endif
983: elf_ppnt = elf_phdata;
984:
985: elf_bss = 0;
986: elf_brk = 0;
987:
988:
989: elf_stack = ~0UL;
990: elf_interpreter = NULL;
991: start_code = ~0UL;
992: end_code = 0;
993: end_data = 0;
994:
995: for(i=0;i < elf_ex.e_phnum; i++) {
996: if (elf_ppnt->p_type == PT_INTERP) {
997: if ( elf_interpreter != NULL )
998: {
999: free (elf_phdata);
1000: free(elf_interpreter);
1001: close(bprm->fd);
1002: return -EINVAL;
1003: }
1004:
1005: /* This is the program interpreter used for
1006: * shared libraries - for now assume that this
1007: * is an a.out format binary
1008: */
1009:
1010: elf_interpreter = (char *)malloc(elf_ppnt->p_filesz);
1011:
1012: if (elf_interpreter == NULL) {
1013: free (elf_phdata);
1014: close(bprm->fd);
1015: return -ENOMEM;
1016: }
1017:
1018: retval = lseek(bprm->fd, elf_ppnt->p_offset, SEEK_SET);
1019: if(retval >= 0) {
1020: retval = read(bprm->fd, elf_interpreter, elf_ppnt->p_filesz);
1021: }
1022: if(retval < 0) {
1023: perror("load_elf_binary2");
1024: exit(-1);
1025: }
1026:
1027: /* If the program interpreter is one of these two,
1028: then assume an iBCS2 image. Otherwise assume
1029: a native linux image. */
1030:
1031: /* JRP - Need to add X86 lib dir stuff here... */
1032:
1033: if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
1034: strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0) {
1035: ibcs2_interpreter = 1;
1036: }
1037:
1038: #if 0
1039: printf("Using ELF interpreter %s\n", elf_interpreter);
1040: #endif
1041: if (retval >= 0) {
1042: retval = open(path(elf_interpreter), O_RDONLY);
1043: if(retval >= 0) {
1044: interpreter_fd = retval;
1045: }
1046: else {
1047: perror(elf_interpreter);
1048: exit(-1);
1049: /* retval = -errno; */
1050: }
1051: }
1052:
1053: if (retval >= 0) {
1054: retval = lseek(interpreter_fd, 0, SEEK_SET);
1055: if(retval >= 0) {
1056: retval = read(interpreter_fd,bprm->buf,128);
1057: }
1058: }
1059: if (retval >= 0) {
1060: interp_ex = *((struct exec *) bprm->buf); /* aout exec-header */
1061: interp_elf_ex=*((struct elfhdr *) bprm->buf); /* elf exec-header */
1062: }
1063: if (retval < 0) {
1064: perror("load_elf_binary3");
1065: exit(-1);
1066: free (elf_phdata);
1067: free(elf_interpreter);
1068: close(bprm->fd);
1069: return retval;
1070: }
1071: }
1072: elf_ppnt++;
1073: }
1074:
1075: /* Some simple consistency checks for the interpreter */
1076: if (elf_interpreter){
1077: interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
1078:
1079: /* Now figure out which format our binary is */
1080: if ((N_MAGIC(interp_ex) != OMAGIC) && (N_MAGIC(interp_ex) != ZMAGIC) &&
1081: (N_MAGIC(interp_ex) != QMAGIC)) {
1082: interpreter_type = INTERPRETER_ELF;
1083: }
1084:
1085: if (interp_elf_ex.e_ident[0] != 0x7f ||
1086: strncmp(&interp_elf_ex.e_ident[1], "ELF",3) != 0) {
1087: interpreter_type &= ~INTERPRETER_ELF;
1088: }
1089:
1090: if (!interpreter_type) {
1091: free(elf_interpreter);
1092: free(elf_phdata);
1093: close(bprm->fd);
1094: return -ELIBBAD;
1095: }
1096: }
1097:
1098: /* OK, we are done with that, now set up the arg stuff,
1099: and then start this sucker up */
1100:
1101: if (!bprm->sh_bang) {
1102: char * passed_p;
1103:
1104: if (interpreter_type == INTERPRETER_AOUT) {
1105: snprintf(passed_fileno, sizeof(passed_fileno), "%d", bprm->fd);
1106: passed_p = passed_fileno;
1107:
1108: if (elf_interpreter) {
1109: bprm->p = copy_strings(1,&passed_p,bprm->page,bprm->p);
1110: bprm->argc++;
1111: }
1112: }
1113: if (!bprm->p) {
1114: if (elf_interpreter) {
1115: free(elf_interpreter);
1116: }
1117: free (elf_phdata);
1118: close(bprm->fd);
1119: return -E2BIG;
1120: }
1121: }
1122:
1123: /* OK, This is the point of no return */
1124: info->end_data = 0;
1125: info->end_code = 0;
1126: info->start_mmap = (unsigned long)ELF_START_MMAP;
1127: info->mmap = 0;
1128: elf_entry = (unsigned long) elf_ex.e_entry;
1129:
1130: /* Do this so that we can load the interpreter, if need be. We will
1131: change some of these later */
1132: info->rss = 0;
1133: bprm->p = setup_arg_pages(bprm->p, bprm, info);
1134: info->start_stack = bprm->p;
1135:
1136: /* Now we do a little grungy work by mmaping the ELF image into
1137: * the correct location in memory. At this point, we assume that
1138: * the image should be loaded at fixed address, not at a variable
1139: * address.
1140: */
1141:
1142: for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
1143: int elf_prot = 0;
1144: int elf_flags = 0;
1145: unsigned long error;
1146:
1147: if (elf_ppnt->p_type != PT_LOAD)
1148: continue;
1149:
1150: if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
1151: if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
1152: if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
1153: elf_flags = MAP_PRIVATE | MAP_DENYWRITE;
1154: if (elf_ex.e_type == ET_EXEC || load_addr_set) {
1155: elf_flags |= MAP_FIXED;
1156: } else if (elf_ex.e_type == ET_DYN) {
1157: /* Try and get dynamic programs out of the way of the default mmap
1158: base, as well as whatever program they might try to exec. This
1159: is because the brk will follow the loader, and is not movable. */
1160: /* NOTE: for qemu, we do a big mmap to get enough space
1161: without harcoding any address */
1162: error = target_mmap(0, ET_DYN_MAP_SIZE,
1163: PROT_NONE, MAP_PRIVATE | MAP_ANON,
1164: -1, 0);
1165: if (error == -1) {
1166: perror("mmap");
1167: exit(-1);
1168: }
1169: load_bias = TARGET_ELF_PAGESTART(error - elf_ppnt->p_vaddr);
1170: }
1171:
1172: error = target_mmap(TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr),
1173: (elf_ppnt->p_filesz +
1174: TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
1175: elf_prot,
1176: (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE),
1177: bprm->fd,
1178: (elf_ppnt->p_offset -
1179: TARGET_ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
1180: if (error == -1) {
1181: perror("mmap");
1182: exit(-1);
1183: }
1184:
1185: #ifdef LOW_ELF_STACK
1186: if (TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr) < elf_stack)
1187: elf_stack = TARGET_ELF_PAGESTART(elf_ppnt->p_vaddr);
1188: #endif
1189:
1190: if (!load_addr_set) {
1191: load_addr_set = 1;
1192: load_addr = elf_ppnt->p_vaddr - elf_ppnt->p_offset;
1193: if (elf_ex.e_type == ET_DYN) {
1194: load_bias += error -
1195: TARGET_ELF_PAGESTART(load_bias + elf_ppnt->p_vaddr);
1196: load_addr += load_bias;
1197: }
1198: }
1199: k = elf_ppnt->p_vaddr;
1200: if (k < start_code)
1201: start_code = k;
1202: k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1203: if (k > elf_bss)
1204: elf_bss = k;
1205: if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1206: end_code = k;
1207: if (end_data < k)
1208: end_data = k;
1209: k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1210: if (k > elf_brk) elf_brk = k;
1211: }
1212:
1213: elf_entry += load_bias;
1214: elf_bss += load_bias;
1215: elf_brk += load_bias;
1216: start_code += load_bias;
1217: end_code += load_bias;
1218: // start_data += load_bias;
1219: end_data += load_bias;
1220:
1221: if (elf_interpreter) {
1222: if (interpreter_type & 1) {
1223: elf_entry = load_aout_interp(&interp_ex, interpreter_fd);
1224: }
1225: else if (interpreter_type & 2) {
1226: elf_entry = load_elf_interp(&interp_elf_ex, interpreter_fd,
1227: &interp_load_addr);
1228: }
1229:
1230: close(interpreter_fd);
1231: free(elf_interpreter);
1232:
1233: if (elf_entry == ~0UL) {
1234: printf("Unable to load interpreter\n");
1235: free(elf_phdata);
1236: exit(-1);
1237: return 0;
1238: }
1239: }
1240:
1241: free(elf_phdata);
1242:
1243: if (loglevel)
1244: load_symbols(&elf_ex, bprm->fd);
1245:
1246: if (interpreter_type != INTERPRETER_AOUT) close(bprm->fd);
1247: info->personality = (ibcs2_interpreter ? PER_SVR4 : PER_LINUX);
1248:
1249: #ifdef LOW_ELF_STACK
1250: info->start_stack = bprm->p = elf_stack - 4;
1251: #endif
1252: bprm->p = (unsigned long)
1253: create_elf_tables((char *)bprm->p,
1254: bprm->argc,
1255: bprm->envc,
1256: &elf_ex,
1257: load_addr, load_bias,
1258: interp_load_addr,
1259: (interpreter_type == INTERPRETER_AOUT ? 0 : 1),
1260: info);
1261: if (interpreter_type == INTERPRETER_AOUT)
1262: info->arg_start += strlen(passed_fileno) + 1;
1263: info->start_brk = info->brk = elf_brk;
1264: info->end_code = end_code;
1265: info->start_code = start_code;
1266: info->end_data = end_data;
1267: info->start_stack = bprm->p;
1268:
1269: /* Calling set_brk effectively mmaps the pages that we need for the bss and break
1270: sections */
1271: set_brk(elf_bss, elf_brk);
1272:
1273: padzero(elf_bss);
1274:
1275: #if 0
1276: printf("(start_brk) %x\n" , info->start_brk);
1277: printf("(end_code) %x\n" , info->end_code);
1278: printf("(start_code) %x\n" , info->start_code);
1279: printf("(end_data) %x\n" , info->end_data);
1280: printf("(start_stack) %x\n" , info->start_stack);
1281: printf("(brk) %x\n" , info->brk);
1282: #endif
1283:
1284: if ( info->personality == PER_SVR4 )
1285: {
1286: /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1287: and some applications "depend" upon this behavior.
1288: Since we do not have the power to recompile these, we
1289: emulate the SVr4 behavior. Sigh. */
1290: mapped_addr = target_mmap(0, qemu_host_page_size, PROT_READ | PROT_EXEC,
1291: MAP_FIXED | MAP_PRIVATE, -1, 0);
1292: }
1293:
1294: #ifdef ELF_PLAT_INIT
1295: /*
1296: * The ABI may specify that certain registers be set up in special
1297: * ways (on i386 %edx is the address of a DT_FINI function, for
1298: * example. This macro performs whatever initialization to
1299: * the regs structure is required.
1300: */
1301: ELF_PLAT_INIT(regs);
1302: #endif
1303:
1304:
1305: info->entry = elf_entry;
1306:
1307: return 0;
1308: }
1309:
1310:
1311:
1312: int elf_exec(const char * filename, char ** argv, char ** envp,
1313: struct target_pt_regs * regs, struct image_info *infop)
1314: {
1315: struct linux_binprm bprm;
1316: int retval;
1317: int i;
1318:
1319: bprm.p = TARGET_PAGE_SIZE*MAX_ARG_PAGES-sizeof(unsigned int);
1320: for (i=0 ; i<MAX_ARG_PAGES ; i++) /* clear page-table */
1321: bprm.page[i] = 0;
1322: retval = open(filename, O_RDONLY);
1323: if (retval < 0)
1324: return retval;
1325: bprm.fd = retval;
1326: bprm.filename = (char *)filename;
1327: bprm.sh_bang = 0;
1328: bprm.loader = 0;
1329: bprm.exec = 0;
1330: bprm.dont_iput = 0;
1331: bprm.argc = count(argv);
1332: bprm.envc = count(envp);
1333:
1334: retval = prepare_binprm(&bprm);
1335:
1336: if(retval>=0) {
1337: bprm.p = copy_strings(1, &bprm.filename, bprm.page, bprm.p);
1338: bprm.exec = bprm.p;
1339: bprm.p = copy_strings(bprm.envc,envp,bprm.page,bprm.p);
1340: bprm.p = copy_strings(bprm.argc,argv,bprm.page,bprm.p);
1341: if (!bprm.p) {
1342: retval = -E2BIG;
1343: }
1344: }
1345:
1346: if(retval>=0) {
1347: retval = load_elf_binary(&bprm,regs,infop);
1348: }
1349: if(retval>=0) {
1350: /* success. Initialize important registers */
1351: init_thread(regs, infop);
1352: return retval;
1353: }
1354:
1355: /* Something went wrong, return the inode and free the argument pages*/
1356: for (i=0 ; i<MAX_ARG_PAGES ; i++) {
1357: free_page((void *)bprm.page[i]);
1358: }
1359: return(retval);
1360: }
1361:
1362:
1363: static int load_aout_interp(void * exptr, int interp_fd)
1364: {
1365: printf("a.out interpreter not yet supported\n");
1366: return(0);
1367: }
1368:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.