vcs.maemo.org Git - qemu/blob - linux-user/elfload.c

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