fs/binfmt_elf.c

   1 /*
   2  * linux/fs/binfmt_elf.c
   3  *
   4  * These are the functions used to load ELF format executables as used
   5  * on SVr4 machines.  Information on the format may be found in the book
   6  * "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support
   7  * Tools".
   8  *
   9  * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/fs.h>
  15 #include <linux/stat.h>
  16 #include <linux/time.h>
  17 #include <linux/mm.h>
  18 #include <linux/mman.h>
  19 #include <linux/a.out.h>
  20 #include <linux/errno.h>
  21 #include <linux/signal.h>
  22 #include <linux/binfmts.h>
  23 #include <linux/string.h>
  24 #include <linux/file.h>
  25 #include <linux/fcntl.h>
  26 #include <linux/ptrace.h>
  27 #include <linux/slab.h>
  28 #include <linux/shm.h>
  29 #include <linux/personality.h>
  30 #include <linux/elfcore.h>
  31 #include <linux/init.h>
  32 #include <linux/highuid.h>
  33 #include <linux/smp.h>
  34 #include <linux/smp_lock.h>
  35 #include <linux/compiler.h>
  36 #include <linux/highmem.h>
  37 #include <linux/pagemap.h>
  38 #include <linux/security.h>
  39 #include <linux/syscalls.h>
  40 #include <linux/random.h>
  41 #include <linux/vs_memory.h>
  42 #include <linux/vs_cvirt.h>
  43
  44 #include <asm/uaccess.h>
  45 #include <asm/param.h>
  46 #include <asm/page.h>
  47
  48 #include <linux/elf.h>
  49
  50 static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs);
  51 static int load_elf_library(struct file*);
  52 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int, unsigned long);
  53 extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
  54
  55 #ifndef elf_addr_t
  56 #define elf_addr_t unsigned long
  57 #endif
  58
  59 /*
  60  * If we don't support core dumping, then supply a NULL so we
  61  * don't even try.
  62  */
  63 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
  64 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file);
  65 #else
  66 #define elf_core_dump   NULL
  67 #endif
  68
  69 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
  70 # define ELF_MIN_ALIGN  ELF_EXEC_PAGESIZE
  71 #else
  72 # define ELF_MIN_ALIGN  PAGE_SIZE
  73 #endif
  74
  75 #ifndef ELF_CORE_EFLAGS
  76 #define ELF_CORE_EFLAGS 0
  77 #endif
  78
  79 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
  80 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
  81 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
  82
  83 static struct linux_binfmt elf_format = {
  84                 .module         = THIS_MODULE,
  85                 .load_binary    = load_elf_binary,
  86                 .load_shlib     = load_elf_library,
  87                 .core_dump      = elf_core_dump,
  88                 .min_coredump   = ELF_EXEC_PAGESIZE
  89 };
  90
  91 #define BAD_ADDR(x)     ((unsigned long)(x) > PAGE_MASK)
  92
  93 static int set_brk(unsigned long start, unsigned long end)
  94 {
  95         start = ELF_PAGEALIGN(start);
  96         end = ELF_PAGEALIGN(end);
  97         if (end > start) {
  98                 unsigned long addr;
  99                 down_write(&current->mm->mmap_sem);
 100                 addr = do_brk(start, end - start);
 101                 up_write(&current->mm->mmap_sem);
 102                 if (BAD_ADDR(addr))
 103                         return addr;
 104         }
 105         current->mm->start_brk = current->mm->brk = end;
 106         return 0;
 107 }
 108
 109
 110 /* We need to explicitly zero any fractional pages
 111    after the data section (i.e. bss).  This would
 112    contain the junk from the file that should not
 113    be in memory */
 114
 115
 116 static int padzero(unsigned long elf_bss)
 117 {
 118         unsigned long nbyte;
 119
 120         nbyte = ELF_PAGEOFFSET(elf_bss);
 121         if (nbyte) {
 122                 nbyte = ELF_MIN_ALIGN - nbyte;
 123                 if (clear_user((void __user *) elf_bss, nbyte))
 124                         return -EFAULT;
 125         }
 126         return 0;
 127 }
 128
 129 /* Let's use some macros to make this stack manipulation a litle clearer */
 130 #ifdef CONFIG_STACK_GROWSUP
 131 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
 132 #define STACK_ROUND(sp, items) \
 133         ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
 134 #define STACK_ALLOC(sp, len) ({ elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; old_sp; })
 135 #else
 136 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
 137 #define STACK_ROUND(sp, items) \
 138         (((unsigned long) (sp - items)) &~ 15UL)
 139 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
 140 #endif
 141
 142 static int
 143 create_elf_tables(struct linux_binprm *bprm, struct elfhdr * exec,
 144                 int interp_aout, unsigned long load_addr,
 145                 unsigned long interp_load_addr)
 146 {
 147         unsigned long p = bprm->p;
 148         int argc = bprm->argc;
 149         int envc = bprm->envc;
 150         elf_addr_t __user *argv;
 151         elf_addr_t __user *envp;
 152         elf_addr_t __user *sp;
 153         elf_addr_t __user *u_platform;
 154         const char *k_platform = ELF_PLATFORM;
 155         int items;
 156         elf_addr_t *elf_info;
 157         int ei_index = 0;
 158         struct task_struct *tsk = current;
 159
 160         /*
 161          * If this architecture has a platform capability string, copy it
 162          * to userspace.  In some cases (Sparc), this info is impossible
 163          * for userspace to get any other way, in others (i386) it is
 164          * merely difficult.
 165          */
 166
 167         u_platform = NULL;
 168         if (k_platform) {
 169                 size_t len = strlen(k_platform) + 1;
 170
 171                 /*
 172                  * In some cases (e.g. Hyper-Threading), we want to avoid L1
 173                  * evictions by the processes running on the same package. One
 174                  * thing we can do is to shuffle the initial stack for them.
 175                  */
 176
 177                 p = arch_align_stack(p);
 178
 179                 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
 180                 if (__copy_to_user(u_platform, k_platform, len))
 181                         return -EFAULT;
 182         }
 183
 184         /* Create the ELF interpreter info */
 185         elf_info = (elf_addr_t *) current->mm->saved_auxv;
 186 #define NEW_AUX_ENT(id, val) \
 187         do { elf_info[ei_index++] = id; elf_info[ei_index++] = val; } while (0)
 188
 189 #ifdef ARCH_DLINFO
 190         /*
 191          * ARCH_DLINFO must come first so PPC can do its special alignment of
 192          * AUXV.
 193          */
 194         ARCH_DLINFO;
 195 #endif
 196         NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
 197         NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
 198         NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
 199         NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
 200         NEW_AUX_ENT(AT_PHENT, sizeof (struct elf_phdr));
 201         NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
 202         NEW_AUX_ENT(AT_BASE, interp_load_addr);
 203         NEW_AUX_ENT(AT_FLAGS, 0);
 204         NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
 205         NEW_AUX_ENT(AT_UID, (elf_addr_t) tsk->uid);
 206         NEW_AUX_ENT(AT_EUID, (elf_addr_t) tsk->euid);
 207         NEW_AUX_ENT(AT_GID, (elf_addr_t) tsk->gid);
 208         NEW_AUX_ENT(AT_EGID, (elf_addr_t) tsk->egid);
 209         NEW_AUX_ENT(AT_SECURE, (elf_addr_t) security_bprm_secureexec(bprm));
 210         if (k_platform) {
 211                 NEW_AUX_ENT(AT_PLATFORM, (elf_addr_t)(unsigned long)u_platform);
 212         }
 213         if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
 214                 NEW_AUX_ENT(AT_EXECFD, (elf_addr_t) bprm->interp_data);
 215         }
 216 #undef NEW_AUX_ENT
 217         /* AT_NULL is zero; clear the rest too */
 218         memset(&elf_info[ei_index], 0,
 219                sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
 220
 221         /* And advance past the AT_NULL entry.  */
 222         ei_index += 2;
 223
 224         sp = STACK_ADD(p, ei_index);
 225
 226         items = (argc + 1) + (envc + 1);
 227         if (interp_aout) {
 228                 items += 3; /* a.out interpreters require argv & envp too */
 229         } else {
 230                 items += 1; /* ELF interpreters only put argc on the stack */
 231         }
 232         bprm->p = STACK_ROUND(sp, items);
 233
 234         /* Point sp at the lowest address on the stack */
 235 #ifdef CONFIG_STACK_GROWSUP
 236         sp = (elf_addr_t __user *)bprm->p - items - ei_index;
 237         bprm->exec = (unsigned long) sp; /* XXX: PARISC HACK */
 238 #else
 239         sp = (elf_addr_t __user *)bprm->p;
 240 #endif
 241
 242         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
 243         if (__put_user(argc, sp++))
 244                 return -EFAULT;
 245         if (interp_aout) {
 246                 argv = sp + 2;
 247                 envp = argv + argc + 1;
 248                 __put_user((elf_addr_t)(unsigned long)argv, sp++);
 249                 __put_user((elf_addr_t)(unsigned long)envp, sp++);
 250         } else {
 251                 argv = sp;
 252                 envp = argv + argc + 1;
 253         }
 254
 255         /* Populate argv and envp */
 256         p = current->mm->arg_end = current->mm->arg_start;
 257         while (argc-- > 0) {
 258                 size_t len;
 259                 __put_user((elf_addr_t)p, argv++);
 260                 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
 261                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
 262                         return 0;
 263                 p += len;
 264         }
 265         if (__put_user(0, argv))
 266                 return -EFAULT;
 267         current->mm->arg_end = current->mm->env_start = p;
 268         while (envc-- > 0) {
 269                 size_t len;
 270                 __put_user((elf_addr_t)p, envp++);
 271                 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
 272                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
 273                         return 0;
 274                 p += len;
 275         }
 276         if (__put_user(0, envp))
 277                 return -EFAULT;
 278         current->mm->env_end = p;
 279
 280         /* Put the elf_info on the stack in the right place.  */
 281         sp = (elf_addr_t __user *)envp + 1;
 282         if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
 283                 return -EFAULT;
 284         return 0;
 285 }
 286
 287 #ifndef elf_map
 288
 289 static unsigned long elf_map(struct file *filep, unsigned long addr,
 290                              struct elf_phdr *eppnt, int prot, int type,
 291                              unsigned long total_size)
 292 {
 293         unsigned long map_addr;
 294         unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
 295         unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
 296
 297         addr = ELF_PAGESTART(addr);
 298         size = ELF_PAGEALIGN(size);
 299
 300         /* mmap() will return -EINVAL if given a zero size, but a
 301          * segment with zero filesize is perfectly valid */
 302         if (!size)
 303                 return addr;
 304
 305         down_write(&current->mm->mmap_sem);
 306
 307         /*
 308          * total_size is the size of the ELF (interpreter) image.
 309          * The _first_ mmap needs to know the full size, otherwise
 310          * randomization might put this image into an overlapping
 311          * position with the ELF binary image. (since size < total_size)
 312          * So we first map the 'big' image - and unmap the remainder at
 313          * the end. (which unmap is needed for ELF images with holes.)
 314          */
 315         if (total_size) {
 316                 total_size = ELF_PAGEALIGN(total_size);
 317                 map_addr = do_mmap(filep, addr, total_size, prot, type, off);
 318                 if (!BAD_ADDR(map_addr))
 319                         do_munmap(current->mm, map_addr+size, total_size-size);
 320         } else
 321                 map_addr = do_mmap(filep, addr, size, prot, type, off);
 322
 323         up_write(&current->mm->mmap_sem);
 324
 325         return map_addr;
 326 }
 327
 328 #endif /* !elf_map */
 329
 330 static inline unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
 331 {
 332         int i, first_idx = -1, last_idx = -1;
 333
 334         for (i = 0; i < nr; i++)
 335                 if (cmds[i].p_type == PT_LOAD) {
 336                         last_idx = i;
 337                         if (first_idx == -1)
 338                                 first_idx = i;
 339                 }
 340
 341         if (first_idx == -1)
 342                 return 0;
 343
 344         return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
 345                                 ELF_PAGESTART(cmds[first_idx].p_vaddr);
 346 }
 347
 348
 349 /* This is much more generalized than the library routine read function,
 350    so we keep this separate.  Technically the library read function
 351    is only provided so that we can read a.out libraries that have
 352    an ELF header */
 353
 354 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
 355                                      struct file * interpreter,
 356                                      unsigned long *interp_map_addr,
 357                                      unsigned long no_base)
 358 {
 359         struct elf_phdr *elf_phdata;
 360         struct elf_phdr *eppnt;
 361         unsigned long load_addr = 0;
 362         int load_addr_set = 0;
 363         unsigned long last_bss = 0, elf_bss = 0;
 364         unsigned long error = ~0UL;
 365         unsigned long total_size;
 366         int retval, i, size;
 367
 368         /* First of all, some simple consistency checks */
 369         if (interp_elf_ex->e_type != ET_EXEC &&
 370             interp_elf_ex->e_type != ET_DYN)
 371                 goto out;
 372         if (!elf_check_arch(interp_elf_ex))
 373                 goto out;
 374         if (!interpreter->f_op || !interpreter->f_op->mmap)
 375                 goto out;
 376
 377         /*
 378          * If the size of this structure has changed, then punt, since
 379          * we will be doing the wrong thing.
 380          */
 381         if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
 382                 goto out;
 383         if (interp_elf_ex->e_phnum < 1 ||
 384                 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
 385                 goto out;
 386
 387         /* Now read in all of the header information */
 388
 389         size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
 390         if (size > ELF_MIN_ALIGN)
 391                 goto out;
 392         elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
 393         if (!elf_phdata)
 394                 goto out;
 395
 396         retval = kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);
 397         error = -EIO;
 398         if (retval != size) {
 399                 if (retval < 0)
 400                         error = retval;
 401                 goto out_close;
 402         }
 403
 404         total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
 405         if (!total_size)
 406                 goto out_close;
 407
 408         eppnt = elf_phdata;
 409         for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
 410           if (eppnt->p_type == PT_LOAD) {
 411             int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
 412             int elf_prot = 0;
 413             unsigned long vaddr = 0;
 414             unsigned long k, map_addr;
 415
 416             if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
 417             if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
 418             if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
 419             vaddr = eppnt->p_vaddr;
 420             if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
 421                 elf_type |= MAP_FIXED;
 422             else if (no_base && interp_elf_ex->e_type == ET_DYN)
 423                 load_addr = -vaddr;
 424
 425             map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type, total_size);
 426             total_size = 0;
 427             if (!*interp_map_addr)
 428                 *interp_map_addr = map_addr;
 429             error = map_addr;
 430             if (BAD_ADDR(map_addr))
 431                 goto out_close;
 432
 433             if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
 434                 load_addr = map_addr - ELF_PAGESTART(vaddr);
 435                 load_addr_set = 1;
 436             }
 437
 438             /*
 439              * Check to see if the section's size will overflow the
 440              * allowed task size. Note that p_filesz must always be
 441              * <= p_memsize so it is only necessary to check p_memsz.
 442              */
 443             k = load_addr + eppnt->p_vaddr;
 444             if (k > TASK_SIZE || eppnt->p_filesz > eppnt->p_memsz ||
 445                 eppnt->p_memsz > TASK_SIZE || TASK_SIZE - eppnt->p_memsz < k) {
 446                 error = -ENOMEM;
 447                 goto out_close;
 448             }
 449
 450             /*
 451              * Find the end of the file mapping for this phdr, and keep
 452              * track of the largest address we see for this.
 453              */
 454             k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
 455             if (k > elf_bss)
 456                 elf_bss = k;
 457
 458             /*
 459              * Do the same thing for the memory mapping - between
 460              * elf_bss and last_bss is the bss section.
 461              */
 462             k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
 463             if (k > last_bss)
 464                 last_bss = k;
 465           }
 466         }
 467
 468         /*
 469          * Now fill out the bss section.  First pad the last page up
 470          * to the page boundary, and then perform a mmap to make sure
 471          * that there are zero-mapped pages up to and including the
 472          * last bss page.
 473          */
 474         if (padzero(elf_bss)) {
 475                 error = -EFAULT;
 476                 goto out_close;
 477         }
 478
 479         elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);   /* What we have mapped so far */
 480
 481         /* Map the last of the bss segment */
 482         if (last_bss > elf_bss) {
 483                 down_write(&current->mm->mmap_sem);
 484                 error = do_brk(elf_bss, last_bss - elf_bss);
 485                 up_write(&current->mm->mmap_sem);
 486                 if (BAD_ADDR(error))
 487                         goto out_close;
 488         }
 489
 490         error = load_addr;
 491
 492 out_close:
 493         kfree(elf_phdata);
 494 out:
 495         return error;
 496 }
 497
 498 static unsigned long load_aout_interp(struct exec * interp_ex,
 499                              struct file * interpreter)
 500 {
 501         unsigned long text_data, elf_entry = ~0UL;
 502         char __user * addr;
 503         loff_t offset;
 504
 505         current->mm->end_code = interp_ex->a_text;
 506         text_data = interp_ex->a_text + interp_ex->a_data;
 507         current->mm->end_data = text_data;
 508         current->mm->brk = interp_ex->a_bss + text_data;
 509
 510         switch (N_MAGIC(*interp_ex)) {
 511         case OMAGIC:
 512                 offset = 32;
 513                 addr = (char __user *)0;
 514                 break;
 515         case ZMAGIC:
 516         case QMAGIC:
 517                 offset = N_TXTOFF(*interp_ex);
 518                 addr = (char __user *) N_TXTADDR(*interp_ex);
 519                 break;
 520         default:
 521                 goto out;
 522         }
 523
 524         down_write(&current->mm->mmap_sem);
 525         do_brk(0, text_data);
 526         up_write(&current->mm->mmap_sem);
 527         if (!interpreter->f_op || !interpreter->f_op->read)
 528                 goto out;
 529         if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
 530                 goto out;
 531         flush_icache_range((unsigned long)addr,
 532                            (unsigned long)addr + text_data);
 533
 534
 535         down_write(&current->mm->mmap_sem);
 536         do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
 537                 interp_ex->a_bss);
 538         up_write(&current->mm->mmap_sem);
 539         elf_entry = interp_ex->a_entry;
 540
 541 out:
 542         return elf_entry;
 543 }
 544
 545 /*
 546  * These are the functions used to load ELF style executables and shared
 547  * libraries.  There is no binary dependent code anywhere else.
 548  */
 549
 550 #define INTERPRETER_NONE 0
 551 #define INTERPRETER_AOUT 1
 552 #define INTERPRETER_ELF 2
 553
 554 #ifndef STACK_RND_MASK
 555 #define STACK_RND_MASK 0x7ff            /* with 4K pages 8MB of VA */
 556 #endif
 557
 558 static unsigned long randomize_stack_top(unsigned long stack_top)
 559 {
 560         unsigned int random_variable = 0;
 561
 562         if (current->flags & PF_RANDOMIZE) {
 563                 random_variable = get_random_int() & STACK_RND_MASK;
 564                 random_variable <<= PAGE_SHIFT;
 565         }
 566 #ifdef CONFIG_STACK_GROWSUP
 567         return PAGE_ALIGN(stack_top) + random_variable;
 568 #else
 569         return PAGE_ALIGN(stack_top) - random_variable;
 570 #endif
 571 }
 572
 573 static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
 574 {
 575         struct file *interpreter = NULL; /* to shut gcc up */
 576         unsigned long load_addr = 0, load_bias = 0;
 577         int load_addr_set = 0;
 578         char * elf_interpreter = NULL;
 579         unsigned int interpreter_type = INTERPRETER_NONE;
 580         unsigned char ibcs2_interpreter = 0;
 581         unsigned long error;
 582         struct elf_phdr * elf_ppnt, *elf_phdata;
 583         unsigned long elf_bss, elf_brk;
 584         int elf_exec_fileno;
 585         int retval, i;
 586         unsigned int size;
 587         unsigned long elf_entry, interp_load_addr = 0, interp_map_addr = 0;
 588         unsigned long start_code, end_code, start_data, end_data;
 589         unsigned long reloc_func_desc = 0;
 590         char passed_fileno[6];
 591         struct files_struct *files;
 592         int have_pt_gnu_stack, executable_stack;
 593         unsigned long def_flags = 0;
 594         struct {
 595                 struct elfhdr elf_ex;
 596                 struct elfhdr interp_elf_ex;
 597                 struct exec interp_ex;
 598         } *loc;
 599
 600         loc = kmalloc(sizeof(*loc), GFP_KERNEL);
 601         if (!loc) {
 602                 retval = -ENOMEM;
 603                 goto out_ret;
 604         }
 605
 606         /* Get the exec-header */
 607         loc->elf_ex = *((struct elfhdr *) bprm->buf);
 608
 609         retval = -ENOEXEC;
 610         /* First of all, some simple consistency checks */
 611         if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
 612                 goto out;
 613
 614         if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
 615                 goto out;
 616         if (!elf_check_arch(&loc->elf_ex))
 617                 goto out;
 618         if (!bprm->file->f_op||!bprm->file->f_op->mmap)
 619                 goto out;
 620
 621         /* Now read in all of the header information */
 622
 623         if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
 624                 goto out;
 625         if (loc->elf_ex.e_phnum < 1 ||
 626                 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
 627                 goto out;
 628         size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
 629         retval = -ENOMEM;
 630         elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
 631         if (!elf_phdata)
 632                 goto out;
 633
 634         retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);
 635         if (retval != size) {
 636                 if (retval >= 0)
 637                         retval = -EIO;
 638                 goto out_free_ph;
 639         }
 640
 641         files = current->files;         /* Refcounted so ok */
 642         retval = unshare_files();
 643         if (retval < 0)
 644                 goto out_free_ph;
 645         if (files == current->files) {
 646                 put_files_struct(files);
 647                 files = NULL;
 648         }
 649
 650         /* exec will make our files private anyway, but for the a.out
 651            loader stuff we need to do it earlier */
 652
 653         retval = get_unused_fd();
 654         if (retval < 0)
 655                 goto out_free_fh;
 656         get_file(bprm->file);
 657         fd_install(elf_exec_fileno = retval, bprm->file);
 658
 659         elf_ppnt = elf_phdata;
 660         elf_bss = 0;
 661         elf_brk = 0;
 662
 663         start_code = ~0UL;
 664         end_code = 0;
 665         start_data = 0;
 666         end_data = 0;
 667
 668         for (i = 0; i < loc->elf_ex.e_phnum; i++) {
 669                 if (elf_ppnt->p_type == PT_INTERP) {
 670                         /* This is the program interpreter used for
 671                          * shared libraries - for now assume that this
 672                          * is an a.out format binary
 673                          */
 674
 675                         retval = -ENOEXEC;
 676                         if (elf_ppnt->p_filesz > PATH_MAX ||
 677                             elf_ppnt->p_filesz < 2)
 678                                 goto out_free_file;
 679
 680                         retval = -ENOMEM;
 681                         elf_interpreter = kmalloc(elf_ppnt->p_filesz,
 682                                                            GFP_KERNEL);
 683                         if (!elf_interpreter)
 684                                 goto out_free_file;
 685
 686                         retval = kernel_read(bprm->file, elf_ppnt->p_offset,
 687                                            elf_interpreter,
 688                                            elf_ppnt->p_filesz);
 689                         if (retval != elf_ppnt->p_filesz) {
 690                                 if (retval >= 0)
 691                                         retval = -EIO;
 692                                 goto out_free_interp;
 693                         }
 694                         /* make sure path is NULL terminated */
 695                         retval = -ENOEXEC;
 696                         if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
 697                                 goto out_free_interp;
 698
 699                         /* If the program interpreter is one of these two,
 700                          * then assume an iBCS2 image. Otherwise assume
 701                          * a native linux image.
 702                          */
 703                         if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
 704                             strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
 705                                 ibcs2_interpreter = 1;
 706
 707                         /*
 708                          * The early SET_PERSONALITY here is so that the lookup
 709                          * for the interpreter happens in the namespace of the
 710                          * to-be-execed image.  SET_PERSONALITY can select an
 711                          * alternate root.
 712                          *
 713                          * However, SET_PERSONALITY is NOT allowed to switch
 714                          * this task into the new images's memory mapping
 715                          * policy - that is, TASK_SIZE must still evaluate to
 716                          * that which is appropriate to the execing application.
 717                          * This is because exit_mmap() needs to have TASK_SIZE
 718                          * evaluate to the size of the old image.
 719                          *
 720                          * So if (say) a 64-bit application is execing a 32-bit
 721                          * application it is the architecture's responsibility
 722                          * to defer changing the value of TASK_SIZE until the
 723                          * switch really is going to happen - do this in
 724                          * flush_thread().      - akpm
 725                          */
 726                         SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
 727
 728                         interpreter = open_exec(elf_interpreter);
 729                         retval = PTR_ERR(interpreter);
 730                         if (IS_ERR(interpreter))
 731                                 goto out_free_interp;
 732                         retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);
 733                         if (retval != BINPRM_BUF_SIZE) {
 734                                 if (retval >= 0)
 735                                         retval = -EIO;
 736                                 goto out_free_dentry;
 737                         }
 738
 739                         /* Get the exec headers */
 740                         loc->interp_ex = *((struct exec *) bprm->buf);
 741                         loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);
 742                         break;
 743                 }
 744                 elf_ppnt++;
 745         }
 746
 747         elf_ppnt = elf_phdata;
 748         executable_stack = EXSTACK_DEFAULT;
 749
 750         for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
 751                 if (elf_ppnt->p_type == PT_GNU_STACK) {
 752                         if (elf_ppnt->p_flags & PF_X)
 753                                 executable_stack = EXSTACK_ENABLE_X;
 754                         else
 755                                 executable_stack = EXSTACK_DISABLE_X;
 756                         break;
 757                 }
 758         have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);
 759
 760         if (current->personality == PER_LINUX && (exec_shield & 2)) {
 761                 executable_stack = EXSTACK_DISABLE_X;
 762                 current->flags |= PF_RANDOMIZE;
 763         }
 764
 765         /* Some simple consistency checks for the interpreter */
 766         if (elf_interpreter) {
 767                 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
 768
 769                 /* Now figure out which format our binary is */
 770                 if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
 771                     (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
 772                     (N_MAGIC(loc->interp_ex) != QMAGIC))
 773                         interpreter_type = INTERPRETER_ELF;
 774
 775                 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
 776                         interpreter_type &= ~INTERPRETER_ELF;
 777
 778                 retval = -ELIBBAD;
 779                 if (!interpreter_type)
 780                         goto out_free_dentry;
 781
 782                 /* Make sure only one type was selected */
 783                 if ((interpreter_type & INTERPRETER_ELF) &&
 784                      interpreter_type != INTERPRETER_ELF) {
 785                         // FIXME - ratelimit this before re-enabling
 786                         // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
 787                         interpreter_type = INTERPRETER_ELF;
 788                 }
 789                 /* Verify the interpreter has a valid arch */
 790                 if ((interpreter_type == INTERPRETER_ELF) &&
 791                     !elf_check_arch(&loc->interp_elf_ex))
 792                         goto out_free_dentry;
 793         } else {
 794                 /* Executables without an interpreter also need a personality  */
 795                 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
 796         }
 797
 798         /* OK, we are done with that, now set up the arg stuff,
 799            and then start this sucker up */
 800
 801         if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
 802                 char *passed_p = passed_fileno;
 803                 sprintf(passed_fileno, "%d", elf_exec_fileno);
 804
 805                 if (elf_interpreter) {
 806                         retval = copy_strings_kernel(1, &passed_p, bprm);
 807                         if (retval)
 808                                 goto out_free_dentry;
 809                         bprm->argc++;
 810                 }
 811         }
 812
 813         /* Flush all traces of the currently running executable */
 814         retval = flush_old_exec(bprm);
 815         if (retval)
 816                 goto out_free_dentry;
 817
 818 #ifdef __i386__
 819         /*
 820          * Turn off the CS limit completely if exec-shield disabled or
 821          * NX active:
 822          */
 823         if (!exec_shield || executable_stack != EXSTACK_DISABLE_X || nx_enabled)
 824                 arch_add_exec_range(current->mm, -1);
 825 #endif
 826
 827         /* Discard our unneeded old files struct */
 828         if (files) {
 829                 steal_locks(files);
 830                 put_files_struct(files);
 831                 files = NULL;
 832         }
 833
 834         /* OK, This is the point of no return */
 835         current->mm->start_data = 0;
 836         current->mm->end_data = 0;
 837         current->mm->end_code = 0;
 838         current->mm->mmap = NULL;
 839         current->flags &= ~PF_FORKNOEXEC;
 840         current->mm->def_flags = def_flags;
 841
 842         /* Do this immediately, since STACK_TOP as used in setup_arg_pages
 843            may depend on the personality.  */
 844         SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
 845         if (!(exec_shield & 2) &&
 846                         elf_read_implies_exec(loc->elf_ex, executable_stack))
 847                 current->personality |= READ_IMPLIES_EXEC;
 848
 849         if ( !(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 850                 current->flags |= PF_RANDOMIZE;
 851         arch_pick_mmap_layout(current->mm);
 852
 853         /* Do this so that we can load the interpreter, if need be.  We will
 854            change some of these later */
 855         current->mm->free_area_cache = current->mm->mmap_base;
 856         current->mm->cached_hole_size = 0;
 857         retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
 858                                  executable_stack);
 859         if (retval < 0) {
 860                 send_sig(SIGKILL, current, 0);
 861                 goto out_free_dentry;
 862         }
 863
 864         current->mm->start_stack = bprm->p;
 865
 866
 867         /* Now we do a little grungy work by mmaping the ELF image into
 868            the correct location in memory.
 869          */
 870
 871         for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
 872                 int elf_prot = 0, elf_flags;
 873                 unsigned long k, vaddr;
 874
 875                 if (elf_ppnt->p_type != PT_LOAD)
 876                         continue;
 877
 878                 if (unlikely (elf_brk > elf_bss)) {
 879                         unsigned long nbyte;
 880
 881                         /* There was a PT_LOAD segment with p_memsz > p_filesz
 882                            before this one. Map anonymous pages, if needed,
 883                            and clear the area.  */
 884                         retval = set_brk (elf_bss + load_bias,
 885                                           elf_brk + load_bias);
 886                         if (retval) {
 887                                 send_sig(SIGKILL, current, 0);
 888                                 goto out_free_dentry;
 889                         }
 890                         nbyte = ELF_PAGEOFFSET(elf_bss);
 891                         if (nbyte) {
 892                                 nbyte = ELF_MIN_ALIGN - nbyte;
 893                                 if (nbyte > elf_brk - elf_bss)
 894                                         nbyte = elf_brk - elf_bss;
 895                                 if (clear_user((void __user *)elf_bss +
 896                                                         load_bias, nbyte)) {
 897                                         /*
 898                                          * This bss-zeroing can fail if the ELF
 899                                          * file specifies odd protections.  So
 900                                          * we don't check the return value
 901                                          */
 902                                 }
 903                         }
 904                 }
 905
 906                 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
 907                 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
 908                 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
 909
 910                 elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
 911
 912                 vaddr = elf_ppnt->p_vaddr;
 913                 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set)
 914                         elf_flags |= MAP_FIXED;
 915                 else if (loc->elf_ex.e_type == ET_DYN)
 916 #ifdef __i386__
 917                         load_bias = 0;
 918 #else
 919                         load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
 920 #endif
 921
 922                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags, 0);
 923                 if (BAD_ADDR(error)) {
 924                         send_sig(SIGKILL, current, 0);
 925                         goto out_free_dentry;
 926                 }
 927
 928                 if (!load_addr_set) {
 929                         load_addr_set = 1;
 930                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
 931                         if (loc->elf_ex.e_type == ET_DYN) {
 932                                 load_bias += error -
 933                                              ELF_PAGESTART(load_bias + vaddr);
 934                                 load_addr += load_bias;
 935                                 reloc_func_desc = load_bias;
 936                         }
 937                 }
 938                 k = elf_ppnt->p_vaddr;
 939                 if (k < start_code) start_code = k;
 940                 if (start_data < k) start_data = k;
 941
 942                 /*
 943                  * Check to see if the section's size will overflow the
 944                  * allowed task size. Note that p_filesz must always be
 945                  * <= p_memsz so it is only necessary to check p_memsz.
 946                  */
 947                 if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
 948                     elf_ppnt->p_memsz > TASK_SIZE ||
 949                     TASK_SIZE - elf_ppnt->p_memsz < k) {
 950                         /* set_brk can never work.  Avoid overflows.  */
 951                         send_sig(SIGKILL, current, 0);
 952                         goto out_free_dentry;
 953                 }
 954
 955                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
 956
 957                 if (k > elf_bss)
 958                         elf_bss = k;
 959                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
 960                         end_code = k;
 961                 if (end_data < k)
 962                         end_data = k;
 963                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
 964                 if (k > elf_brk)
 965                         elf_brk = k;
 966         }
 967
 968         loc->elf_ex.e_entry += load_bias;
 969         elf_bss += load_bias;
 970         elf_brk += load_bias;
 971         start_code += load_bias;
 972         end_code += load_bias;
 973         start_data += load_bias;
 974         end_data += load_bias;
 975
 976         /* Calling set_brk effectively mmaps the pages that we need
 977          * for the bss and break sections.  We must do this before
 978          * mapping in the interpreter, to make sure it doesn't wind
 979          * up getting placed where the bss needs to go.
 980          */
 981         retval = set_brk(elf_bss, elf_brk);
 982         if (retval) {
 983                 send_sig(SIGKILL, current, 0);
 984                 goto out_free_dentry;
 985         }
 986         if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
 987                 send_sig(SIGSEGV, current, 0);
 988                 retval = -EFAULT; /* Nobody gets to see this, but.. */
 989                 goto out_free_dentry;
 990         }
 991
 992         if (elf_interpreter) {
 993                 if (interpreter_type == INTERPRETER_AOUT)
 994                         elf_entry = load_aout_interp(&loc->interp_ex,
 995                                                      interpreter);
 996                 else {
 997                         elf_entry = load_elf_interp(&loc->interp_elf_ex,
 998                                                     interpreter,
 999                                                     &interp_map_addr,
1000                                                     load_bias);
1001                         if (!BAD_ADDR(elf_entry)) {
1002                                 /* load_elf_interp() returns relocation adjustment */
1003                                 interp_load_addr = elf_entry;
1004                                 elf_entry += loc->interp_elf_ex.e_entry;
1005                         }
1006                 }
1007                 if (BAD_ADDR(elf_entry)) {
1008                         printk(KERN_ERR "Unable to load interpreter %.128s\n",
1009                                 elf_interpreter);
1010                         force_sig(SIGSEGV, current);
1011                         retval = -ENOEXEC; /* Nobody gets to see this, but.. */
1012                         goto out_free_dentry;
1013                 }
1014                 reloc_func_desc = interp_load_addr;
1015
1016                 allow_write_access(interpreter);
1017                 fput(interpreter);
1018                 kfree(elf_interpreter);
1019         } else {
1020                 elf_entry = loc->elf_ex.e_entry;
1021                 if (BAD_ADDR(elf_entry)) {
1022                         send_sig(SIGSEGV, current, 0);
1023                         retval = -ENOEXEC; /* Nobody gets to see this, but.. */
1024                         goto out_free_dentry;
1025                 }
1026         }
1027
1028         if (interpreter_type != INTERPRETER_AOUT)
1029                 sys_close(elf_exec_fileno);
1030
1031         set_binfmt(&elf_format);
1032
1033 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1034         retval = arch_setup_additional_pages(bprm, executable_stack,
1035                         start_code, interp_map_addr);
1036         if (retval < 0) {
1037                 send_sig(SIGKILL, current, 0);
1038                 goto out_free_fh;
1039         }
1040 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1041
1042         kfree(elf_phdata);
1043
1044         compute_creds(bprm);
1045         current->flags &= ~PF_FORKNOEXEC;
1046         create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),
1047                         load_addr, interp_load_addr);
1048         /* N.B. passed_fileno might not be initialized? */
1049         if (interpreter_type == INTERPRETER_AOUT)
1050                 current->mm->arg_start += strlen(passed_fileno) + 1;
1051         current->mm->end_code = end_code;
1052         current->mm->start_code = start_code;
1053         current->mm->start_data = start_data;
1054         current->mm->end_data = end_data;
1055         current->mm->start_stack = bprm->p;
1056
1057 #ifdef __HAVE_ARCH_RANDOMIZE_BRK
1058         if (current->flags & PF_RANDOMIZE)
1059                 randomize_brk(elf_brk);
1060 #endif
1061         if (current->personality & MMAP_PAGE_ZERO) {
1062                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1063                    and some applications "depend" upon this behavior.
1064                    Since we do not have the power to recompile these, we
1065                    emulate the SVr4 behavior.  Sigh.  */
1066                 down_write(&current->mm->mmap_sem);
1067                 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1068                                 MAP_FIXED | MAP_PRIVATE, 0);
1069                 up_write(&current->mm->mmap_sem);
1070         }
1071
1072 #ifdef ELF_PLAT_INIT
1073         /*
1074          * The ABI may specify that certain registers be set up in special
1075          * ways (on i386 %edx is the address of a DT_FINI function, for
1076          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1077          * that the e_entry field is the address of the function descriptor
1078          * for the startup routine, rather than the address of the startup
1079          * routine itself.  This macro performs whatever initialization to
1080          * the regs structure is required as well as any relocations to the
1081          * function descriptor entries when executing dynamically links apps.
1082          */
1083         ELF_PLAT_INIT(regs, reloc_func_desc);
1084 #endif
1085
1086         start_thread(regs, elf_entry, bprm->p);
1087         if (unlikely(current->ptrace & PT_PTRACED)) {
1088                 if (current->ptrace & PT_TRACE_EXEC)
1089                         ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
1090                 else
1091                         send_sig(SIGTRAP, current, 0);
1092         }
1093         retval = 0;
1094 out:
1095         kfree(loc);
1096 out_ret:
1097         return retval;
1098
1099         /* error cleanup */
1100 out_free_dentry:
1101         allow_write_access(interpreter);
1102         if (interpreter)
1103                 fput(interpreter);
1104 out_free_interp:
1105         kfree(elf_interpreter);
1106 out_free_file:
1107         sys_close(elf_exec_fileno);
1108 out_free_fh:
1109         if (files) {
1110                 put_files_struct(current->files);
1111                 current->files = files;
1112         }
1113 out_free_ph:
1114         kfree(elf_phdata);
1115         goto out;
1116 }
1117
1118 /* This is really simpleminded and specialized - we are loading an
1119    a.out library that is given an ELF header. */
1120
1121 static int load_elf_library(struct file *file)
1122 {
1123         struct elf_phdr *elf_phdata;
1124         struct elf_phdr *eppnt;
1125         unsigned long elf_bss, bss, len;
1126         int retval, error, i, j;
1127         struct elfhdr elf_ex;
1128
1129         error = -ENOEXEC;
1130         retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
1131         if (retval != sizeof(elf_ex))
1132                 goto out;
1133
1134         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1135                 goto out;
1136
1137         /* First of all, some simple consistency checks */
1138         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1139            !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1140                 goto out;
1141
1142         /* Now read in all of the header information */
1143
1144         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1145         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1146
1147         error = -ENOMEM;
1148         elf_phdata = kmalloc(j, GFP_KERNEL);
1149         if (!elf_phdata)
1150                 goto out;
1151
1152         eppnt = elf_phdata;
1153         error = -ENOEXEC;
1154         retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1155         if (retval != j)
1156                 goto out_free_ph;
1157
1158         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1159                 if ((eppnt + i)->p_type == PT_LOAD)
1160                         j++;
1161         if (j != 1)
1162                 goto out_free_ph;
1163
1164         while (eppnt->p_type != PT_LOAD)
1165                 eppnt++;
1166
1167         /* Now use mmap to map the library into memory. */
1168         down_write(&current->mm->mmap_sem);
1169         error = do_mmap(file,
1170                         ELF_PAGESTART(eppnt->p_vaddr),
1171                         (eppnt->p_filesz +
1172                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1173                         PROT_READ | PROT_WRITE | PROT_EXEC,
1174                         MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1175                         (eppnt->p_offset -
1176                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1177         up_write(&current->mm->mmap_sem);
1178         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1179                 goto out_free_ph;
1180
1181         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1182         if (padzero(elf_bss)) {
1183                 error = -EFAULT;
1184                 goto out_free_ph;
1185         }
1186
1187         len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);
1188         bss = eppnt->p_memsz + eppnt->p_vaddr;
1189         if (bss > len) {
1190                 down_write(&current->mm->mmap_sem);
1191                 do_brk(len, bss - len);
1192                 up_write(&current->mm->mmap_sem);
1193         }
1194         error = 0;
1195
1196 out_free_ph:
1197         kfree(elf_phdata);
1198 out:
1199         return error;
1200 }
1201
1202 /*
1203  * Note that some platforms still use traditional core dumps and not
1204  * the ELF core dump.  Each platform can select it as appropriate.
1205  */
1206 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1207
1208 /*
1209  * ELF core dumper
1210  *
1211  * Modelled on fs/exec.c:aout_core_dump()
1212  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1213  */
1214 /*
1215  * These are the only things you should do on a core-file: use only these
1216  * functions to write out all the necessary info.
1217  */
1218 static int dump_write(struct file *file, const void *addr, int nr)
1219 {
1220         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1221 }
1222
1223 static int dump_seek(struct file *file, loff_t off)
1224 {
1225         if (file->f_op->llseek) {
1226                 if (file->f_op->llseek(file, off, 0) != off)
1227                         return 0;
1228         } else
1229                 file->f_pos = off;
1230         return 1;
1231 }
1232
1233 /*
1234  * Decide whether a segment is worth dumping; default is yes to be
1235  * sure (missing info is worse than too much; etc).
1236  * Personally I'd include everything, and use the coredump limit...
1237  *
1238  * I think we should skip something. But I am not sure how. H.J.
1239  */
1240 static int maydump(struct vm_area_struct *vma)
1241 {
1242         /* Do not dump I/O mapped devices or special mappings */
1243         if (vma->vm_flags & (VM_IO | VM_RESERVED))
1244                 return 0;
1245
1246         if (vma->vm_flags & VM_DONTEXPAND) /* Kludge for vDSO.  */
1247                 return 1;
1248
1249         /* Dump shared memory only if mapped from an anonymous file.  */
1250         if (vma->vm_flags & VM_SHARED)
1251                 return vma->vm_file->f_dentry->d_inode->i_nlink == 0;
1252
1253         /* If it hasn't been written to, don't write it out */
1254         if (!vma->anon_vma)
1255                 return 0;
1256
1257         return 1;
1258 }
1259
1260 #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
1261
1262 /* An ELF note in memory */
1263 struct memelfnote
1264 {
1265         const char *name;
1266         int type;
1267         unsigned int datasz;
1268         void *data;
1269 };
1270
1271 static int notesize(struct memelfnote *en)
1272 {
1273         int sz;
1274
1275         sz = sizeof(struct elf_note);
1276         sz += roundup(strlen(en->name) + 1, 4);
1277         sz += roundup(en->datasz, 4);
1278
1279         return sz;
1280 }
1281
1282 #define DUMP_WRITE(addr, nr)    \
1283         do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1284 #define DUMP_SEEK(off)  \
1285         do { if (!dump_seek(file, (off))) return 0; } while(0)
1286
1287 static int writenote(struct memelfnote *men, struct file *file)
1288 {
1289         struct elf_note en;
1290
1291         en.n_namesz = strlen(men->name) + 1;
1292         en.n_descsz = men->datasz;
1293         en.n_type = men->type;
1294
1295         DUMP_WRITE(&en, sizeof(en));
1296         DUMP_WRITE(men->name, en.n_namesz);
1297         /* XXX - cast from long long to long to avoid need for libgcc.a */
1298         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1299         DUMP_WRITE(men->data, men->datasz);
1300         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1301
1302         return 1;
1303 }
1304 #undef DUMP_WRITE
1305 #undef DUMP_SEEK
1306
1307 #define DUMP_WRITE(addr, nr)    \
1308         if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1309                 goto end_coredump;
1310 #define DUMP_SEEK(off)  \
1311         if (!dump_seek(file, (off))) \
1312                 goto end_coredump;
1313
1314 static void fill_elf_header(struct elfhdr *elf, int segs)
1315 {
1316         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1317         elf->e_ident[EI_CLASS] = ELF_CLASS;
1318         elf->e_ident[EI_DATA] = ELF_DATA;
1319         elf->e_ident[EI_VERSION] = EV_CURRENT;
1320         elf->e_ident[EI_OSABI] = ELF_OSABI;
1321         memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1322
1323         elf->e_type = ET_CORE;
1324         elf->e_machine = ELF_ARCH;
1325         elf->e_version = EV_CURRENT;
1326         elf->e_entry = 0;
1327         elf->e_phoff = sizeof(struct elfhdr);
1328         elf->e_shoff = 0;
1329         elf->e_flags = ELF_CORE_EFLAGS;
1330         elf->e_ehsize = sizeof(struct elfhdr);
1331         elf->e_phentsize = sizeof(struct elf_phdr);
1332         elf->e_phnum = segs;
1333         elf->e_shentsize = 0;
1334         elf->e_shnum = 0;
1335         elf->e_shstrndx = 0;
1336         return;
1337 }
1338
1339 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
1340 {
1341         phdr->p_type = PT_NOTE;
1342         phdr->p_offset = offset;
1343         phdr->p_vaddr = 0;
1344         phdr->p_paddr = 0;
1345         phdr->p_filesz = sz;
1346         phdr->p_memsz = 0;
1347         phdr->p_flags = 0;
1348         phdr->p_align = 0;
1349         return;
1350 }
1351
1352 static void fill_note(struct memelfnote *note, const char *name, int type,
1353                 unsigned int sz, void *data)
1354 {
1355         note->name = name;
1356         note->type = type;
1357         note->datasz = sz;
1358         note->data = data;
1359         return;
1360 }
1361
1362 /*
1363  * fill up all the fields in prstatus from the given task struct, except registers
1364  * which need to be filled up separately.
1365  */
1366 static void fill_prstatus(struct elf_prstatus *prstatus,
1367                         struct task_struct *p, long signr)
1368 {
1369         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1370         prstatus->pr_sigpend = p->pending.signal.sig[0];
1371         prstatus->pr_sighold = p->blocked.sig[0];
1372         prstatus->pr_pid = p->pid;
1373         prstatus->pr_ppid = p->parent->pid;
1374         prstatus->pr_pgrp = process_group(p);
1375         prstatus->pr_sid = p->signal->session;
1376         if (thread_group_leader(p)) {
1377                 /*
1378                  * This is the record for the group leader.  Add in the
1379                  * cumulative times of previous dead threads.  This total
1380                  * won't include the time of each live thread whose state
1381                  * is included in the core dump.  The final total reported
1382                  * to our parent process when it calls wait4 will include
1383                  * those sums as well as the little bit more time it takes
1384                  * this and each other thread to finish dying after the
1385                  * core dump synchronization phase.
1386                  */
1387                 cputime_to_timeval(cputime_add(p->utime, p->signal->utime),
1388                                    &prstatus->pr_utime);
1389                 cputime_to_timeval(cputime_add(p->stime, p->signal->stime),
1390                                    &prstatus->pr_stime);
1391         } else {
1392                 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1393                 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1394         }
1395         cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1396         cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1397 }
1398
1399 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1400                        struct mm_struct *mm)
1401 {
1402         unsigned int i, len;
1403
1404         /* first copy the parameters from user space */
1405         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1406
1407         len = mm->arg_end - mm->arg_start;
1408         if (len >= ELF_PRARGSZ)
1409                 len = ELF_PRARGSZ-1;
1410         if (copy_from_user(&psinfo->pr_psargs,
1411                            (const char __user *)mm->arg_start, len))
1412                 return -EFAULT;
1413         for(i = 0; i < len; i++)
1414                 if (psinfo->pr_psargs[i] == 0)
1415                         psinfo->pr_psargs[i] = ' ';
1416         psinfo->pr_psargs[len] = 0;
1417
1418         psinfo->pr_pid = p->pid;
1419         psinfo->pr_ppid = p->parent->pid;
1420         psinfo->pr_pgrp = process_group(p);
1421         psinfo->pr_sid = p->signal->session;
1422
1423         i = p->state ? ffz(~p->state) + 1 : 0;
1424         psinfo->pr_state = i;
1425         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1426         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1427         psinfo->pr_nice = task_nice(p);
1428         psinfo->pr_flag = p->flags;
1429         SET_UID(psinfo->pr_uid, p->uid);
1430         SET_GID(psinfo->pr_gid, p->gid);
1431         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1432
1433         return 0;
1434 }
1435
1436 /* Here is the structure in which status of each thread is captured. */
1437 struct elf_thread_status
1438 {
1439         struct list_head list;
1440         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1441         elf_fpregset_t fpu;             /* NT_PRFPREG */
1442         struct task_struct *thread;
1443 #ifdef ELF_CORE_COPY_XFPREGS
1444         elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
1445 #endif
1446         struct memelfnote notes[3];
1447         int num_notes;
1448 };
1449
1450 /*
1451  * In order to add the specific thread information for the elf file format,
1452  * we need to keep a linked list of every threads pr_status and then
1453  * create a single section for them in the final core file.
1454  */
1455 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1456 {
1457         int sz = 0;
1458         struct task_struct *p = t->thread;
1459         t->num_notes = 0;
1460
1461         fill_prstatus(&t->prstatus, p, signr);
1462         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1463
1464         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));
1465         t->num_notes++;
1466         sz += notesize(&t->notes[0]);
1467
1468         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {
1469                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));
1470                 t->num_notes++;
1471                 sz += notesize(&t->notes[1]);
1472         }
1473
1474 #ifdef ELF_CORE_COPY_XFPREGS
1475         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1476                 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);
1477                 t->num_notes++;
1478                 sz += notesize(&t->notes[2]);
1479         }
1480 #endif
1481         return sz;
1482 }
1483
1484 /*
1485  * Actual dumper
1486  *
1487  * This is a two-pass process; first we find the offsets of the bits,
1488  * and then they are actually written out.  If we run out of core limit
1489  * we just truncate.
1490  */
1491 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
1492 {
1493 #define NUM_NOTES       6
1494         int has_dumped = 0;
1495         mm_segment_t fs;
1496         int segs;
1497         size_t size = 0;
1498         int i;
1499         struct vm_area_struct *vma;
1500         struct elfhdr *elf = NULL;
1501         off_t offset = 0, dataoff;
1502         unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
1503         int numnote;
1504         struct memelfnote *notes = NULL;
1505         struct elf_prstatus *prstatus = NULL;   /* NT_PRSTATUS */
1506         struct elf_prpsinfo *psinfo = NULL;     /* NT_PRPSINFO */
1507         struct task_struct *g, *p;
1508         LIST_HEAD(thread_list);
1509         struct list_head *t;
1510         elf_fpregset_t *fpu = NULL;
1511 #ifdef ELF_CORE_COPY_XFPREGS
1512         elf_fpxregset_t *xfpu = NULL;
1513 #endif
1514         int thread_status_size = 0;
1515         elf_addr_t *auxv;
1516
1517         /*
1518          * We no longer stop all VM operations.
1519          *
1520          * This is because those proceses that could possibly change map_count or
1521          * the mmap / vma pages are now blocked in do_exit on current finishing
1522          * this core dump.
1523          *
1524          * Only ptrace can touch these memory addresses, but it doesn't change
1525          * the map_count or the pages allocated.  So no possibility of crashing
1526          * exists while dumping the mm->vm_next areas to the core file.
1527          */
1528
1529         /* alloc memory for large data structures: too large to be on stack */
1530         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1531         if (!elf)
1532                 goto cleanup;
1533         prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1534         if (!prstatus)
1535                 goto cleanup;
1536         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1537         if (!psinfo)
1538                 goto cleanup;
1539         notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1540         if (!notes)
1541                 goto cleanup;
1542         fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1543         if (!fpu)
1544                 goto cleanup;
1545 #ifdef ELF_CORE_COPY_XFPREGS
1546         xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1547         if (!xfpu)
1548                 goto cleanup;
1549 #endif
1550
1551         if (signr) {
1552                 struct elf_thread_status *tmp;
1553                 read_lock(&tasklist_lock);
1554                 do_each_thread(g,p)
1555                         if (current->mm == p->mm && current != p) {
1556                                 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
1557                                 if (!tmp) {
1558                                         read_unlock(&tasklist_lock);
1559                                         goto cleanup;
1560                                 }
1561                                 INIT_LIST_HEAD(&tmp->list);
1562                                 tmp->thread = p;
1563                                 list_add(&tmp->list, &thread_list);
1564                         }
1565                 while_each_thread(g,p);
1566                 read_unlock(&tasklist_lock);
1567                 list_for_each(t, &thread_list) {
1568                         struct elf_thread_status *tmp;
1569                         int sz;
1570
1571                         tmp = list_entry(t, struct elf_thread_status, list);
1572                         sz = elf_dump_thread_status(signr, tmp);
1573                         thread_status_size += sz;
1574                 }
1575         }
1576         /* now collect the dump for the current */
1577         memset(prstatus, 0, sizeof(*prstatus));
1578         fill_prstatus(prstatus, current, signr);
1579         elf_core_copy_regs(&prstatus->pr_reg, regs);
1580
1581         segs = current->mm->map_count;
1582 #ifdef ELF_CORE_EXTRA_PHDRS
1583         segs += ELF_CORE_EXTRA_PHDRS;
1584 #endif
1585
1586         /* Set up header */
1587         fill_elf_header(elf, segs+1);   /* including notes section */
1588
1589         has_dumped = 1;
1590         current->flags |= PF_DUMPCORE;
1591
1592         /*
1593          * Set up the notes in similar form to SVR4 core dumps made
1594          * with info from their /proc.
1595          */
1596
1597         fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1598
1599         fill_psinfo(psinfo, current->group_leader, current->mm);
1600         fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1601
1602         numnote = 2;
1603
1604         auxv = (elf_addr_t *) current->mm->saved_auxv;
1605
1606         i = 0;
1607         do
1608                 i += 2;
1609         while (auxv[i - 2] != AT_NULL);
1610         fill_note(&notes[numnote++], "CORE", NT_AUXV,
1611                   i * sizeof (elf_addr_t), auxv);
1612
1613         /* Try to dump the FPU. */
1614         if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))
1615                 fill_note(notes + numnote++,
1616                           "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1617 #ifdef ELF_CORE_COPY_XFPREGS
1618         if (elf_core_copy_task_xfpregs(current, xfpu))
1619                 fill_note(notes + numnote++,
1620                           "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1621 #endif
1622
1623         fs = get_fs();
1624         set_fs(KERNEL_DS);
1625
1626         DUMP_WRITE(elf, sizeof(*elf));
1627         offset += sizeof(*elf);                         /* Elf header */
1628         offset += (segs+1) * sizeof(struct elf_phdr);   /* Program headers */
1629
1630         /* Write notes phdr entry */
1631         {
1632                 struct elf_phdr phdr;
1633                 int sz = 0;
1634
1635                 for (i = 0; i < numnote; i++)
1636                         sz += notesize(notes + i);
1637
1638                 sz += thread_status_size;
1639
1640                 fill_elf_note_phdr(&phdr, sz, offset);
1641                 offset += sz;
1642                 DUMP_WRITE(&phdr, sizeof(phdr));
1643         }
1644
1645         /* Page-align dumped data */
1646         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1647
1648         /* Write program headers for segments dump */
1649         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1650                 struct elf_phdr phdr;
1651                 size_t sz;
1652
1653                 sz = vma->vm_end - vma->vm_start;
1654
1655                 phdr.p_type = PT_LOAD;
1656                 phdr.p_offset = offset;
1657                 phdr.p_vaddr = vma->vm_start;
1658                 phdr.p_paddr = 0;
1659                 phdr.p_filesz = maydump(vma) ? sz : 0;
1660                 phdr.p_memsz = sz;
1661                 offset += phdr.p_filesz;
1662                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1663                 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
1664                 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
1665                 phdr.p_align = ELF_EXEC_PAGESIZE;
1666
1667                 DUMP_WRITE(&phdr, sizeof(phdr));
1668         }
1669
1670 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1671         ELF_CORE_WRITE_EXTRA_PHDRS;
1672 #endif
1673
1674         /* write out the notes section */
1675         for (i = 0; i < numnote; i++)
1676                 if (!writenote(notes + i, file))
1677                         goto end_coredump;
1678
1679         /* write out the thread status notes section */
1680         list_for_each(t, &thread_list) {
1681                 struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);
1682                 for (i = 0; i < tmp->num_notes; i++)
1683                         if (!writenote(&tmp->notes[i], file))
1684                                 goto end_coredump;
1685         }
1686
1687         DUMP_SEEK(dataoff);
1688
1689         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1690                 unsigned long addr;
1691
1692                 if (!maydump(vma))
1693                         continue;
1694
1695                 for (addr = vma->vm_start;
1696                      addr < vma->vm_end;
1697                      addr += PAGE_SIZE) {
1698                         struct page* page;
1699                         struct vm_area_struct *vma;
1700
1701                         if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1702                                                 &page, &vma) <= 0) {
1703                                 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1704                         } else {
1705                                 if (page == ZERO_PAGE(addr)) {
1706                                         DUMP_SEEK (file->f_pos + PAGE_SIZE);
1707                                 } else {
1708                                         void *kaddr;
1709                                         flush_cache_page(vma, addr, page_to_pfn(page));
1710                                         kaddr = kmap(page);
1711                                         if ((size += PAGE_SIZE) > limit ||
1712                                             !dump_write(file, kaddr,
1713                                             PAGE_SIZE)) {
1714                                                 kunmap(page);
1715                                                 page_cache_release(page);
1716                                                 goto end_coredump;
1717                                         }
1718                                         kunmap(page);
1719                                 }
1720                                 page_cache_release(page);
1721                         }
1722                 }
1723         }
1724
1725 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1726         ELF_CORE_WRITE_EXTRA_DATA;
1727 #endif
1728
1729         if ((off_t)file->f_pos != offset) {
1730                 /* Sanity check */
1731                 printk(KERN_WARNING "elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1732                        (off_t)file->f_pos, offset);
1733         }
1734
1735 end_coredump:
1736         set_fs(fs);
1737
1738 cleanup:
1739         while (!list_empty(&thread_list)) {
1740                 struct list_head *tmp = thread_list.next;
1741                 list_del(tmp);
1742                 kfree(list_entry(tmp, struct elf_thread_status, list));
1743         }
1744
1745         kfree(elf);
1746         kfree(prstatus);
1747         kfree(psinfo);
1748         kfree(notes);
1749         kfree(fpu);
1750 #ifdef ELF_CORE_COPY_XFPREGS
1751         kfree(xfpu);
1752 #endif
1753         return has_dumped;
1754 #undef NUM_NOTES
1755 }
1756
1757 #endif          /* USE_ELF_CORE_DUMP */
1758
1759 static int __init init_elf_binfmt(void)
1760 {
1761         return register_binfmt(&elf_format);
1762 }
1763
1764 static void __exit exit_elf_binfmt(void)
1765 {
1766         /* Remove the COFF and ELF loaders. */
1767         unregister_binfmt(&elf_format);
1768 }
1769
1770 core_initcall(init_elf_binfmt);
1771 module_exit(exit_elf_binfmt);
1772 MODULE_LICENSE("GPL");