git.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
  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           NEW_AUX_ENT (AT_PHDR, (unsigned int)(load_addr + exec->e_phoff));
 364           NEW_AUX_ENT (AT_PHENT, (unsigned int)(sizeof (struct elf_phdr)));
 365           NEW_AUX_ENT (AT_PHNUM, (unsigned int)(exec->e_phnum));
 366           NEW_AUX_ENT (AT_PAGESZ, (unsigned int)(ALPHA_PAGE_SIZE));
 367           NEW_AUX_ENT (AT_BASE, (unsigned int)(interp_load_addr));
 368           NEW_AUX_ENT (AT_FLAGS, (unsigned int)0);
 369           NEW_AUX_ENT (AT_ENTRY, (unsigned int) exec->e_entry);
 370           NEW_AUX_ENT (AT_UID, (unsigned int) getuid());
 371           NEW_AUX_ENT (AT_EUID, (unsigned int) geteuid());
 372           NEW_AUX_ENT (AT_GID, (unsigned int) getgid());
 373           NEW_AUX_ENT (AT_EGID, (unsigned int) getegid());
 374         }
 375         NEW_AUX_ENT (AT_NULL, 0);
 376 #undef NEW_AUX_ENT
 377         put_user(tswapl(argc),--sp);
 378         info->arg_start = (unsigned int)((unsigned long)p & 0xffffffff);
 379         while (argc-->0) {
 380                 put_user(tswapl((target_ulong)p),argv++);
 381                 while (get_user(p++)) /* nothing */ ;
 382         }
 383         put_user(0,argv);
 384         info->arg_end = info->env_start = (unsigned int)((unsigned long)p & 0xffffffff);
 385         while (envc-->0) {
 386                 put_user(tswapl((target_ulong)p),envp++);
 387                 while (get_user(p++)) /* nothing */ ;
 388         }
 389         put_user(0,envp);
 390         info->env_end = (unsigned int)((unsigned long)p & 0xffffffff);
 391         return sp;
 392 }
 393
 394
 395
 396 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
 397                                      int interpreter_fd,
 398                                      unsigned long *interp_load_addr)
 399 {
 400         struct elf_phdr *elf_phdata  =  NULL;
 401         struct elf_phdr *eppnt;
 402         unsigned long load_addr;
 403         int load_addr_set = 0;
 404         int retval;
 405         unsigned long last_bss, elf_bss;
 406         unsigned long error;
 407         int i;
 408
 409         elf_bss = 0;
 410         last_bss = 0;
 411         error = 0;
 412
 413         /* We put this here so that mmap will search for the *first*
 414          * available memory...
 415          */
 416         load_addr = INTERP_LOADADDR;
 417
 418 #ifdef BSWAP_NEEDED
 419         bswap_ehdr(interp_elf_ex);
 420 #endif
 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
 429         /* Now read in all of the header information */
 430
 431         if (sizeof(struct elf_phdr) * interp_elf_ex->e_phnum > X86_PAGE_SIZE)
 432             return ~0UL;
 433
 434         elf_phdata =  (struct elf_phdr *)
 435                 malloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
 436
 437         if (!elf_phdata)
 438           return ~0UL;
 439
 440         /*
 441          * If the size of this structure has changed, then punt, since
 442          * we will be doing the wrong thing.
 443          */
 444         if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
 445           {
 446             free(elf_phdata);
 447             return ~0UL;
 448           }
 449
 450         retval = lseek(interpreter_fd, interp_elf_ex->e_phoff, SEEK_SET);
 451         if(retval >= 0) {
 452             retval = read(interpreter_fd,
 453                            (char *) elf_phdata,
 454                            sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
 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