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 (BAD_ADDR(k) || 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 (BAD_ADDR(k) || 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                         force_sig(SIGSEGV, current);
1009                         retval = IS_ERR((void *)elf_entry) ?
1010                                         (int)elf_entry : -EINVAL;
1011                         goto out_free_dentry;
1012                 }
1013                 reloc_func_desc = interp_load_addr;
1014
1015                 allow_write_access(interpreter);
1016                 fput(interpreter);
1017                 kfree(elf_interpreter);
1018         } else {
1019                 elf_entry = loc->elf_ex.e_entry;
1020                 if (BAD_ADDR(elf_entry)) {
1021                         force_sig(SIGSEGV, current);
1022                         retval = -EINVAL;
1023                         goto out_free_dentry;
1024                 }
1025         }
1026
1027         if (interpreter_type != INTERPRETER_AOUT)
1028                 sys_close(elf_exec_fileno);
1029
1030         set_binfmt(&elf_format);
1031
1032 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1033         retval = arch_setup_additional_pages(bprm, executable_stack,
1034                         start_code, interp_map_addr);
1035         if (retval < 0) {
1036                 send_sig(SIGKILL, current, 0);
1037                 goto out_free_fh;
1038         }
1039 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1040
1041         kfree(elf_phdata);
1042
1043         compute_creds(bprm);
1044         current->flags &= ~PF_FORKNOEXEC;
1045         create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),
1046                         load_addr, interp_load_addr);
1047         /* N.B. passed_fileno might not be initialized? */
1048         if (interpreter_type == INTERPRETER_AOUT)
1049                 current->mm->arg_start += strlen(passed_fileno) + 1;
1050         current->mm->end_code = end_code;
1051         current->mm->start_code = start_code;
1052         current->mm->start_data = start_data;
1053         current->mm->end_data = end_data;
1054         current->mm->start_stack = bprm->p;
1055
1056 #ifdef __HAVE_ARCH_RANDOMIZE_BRK
1057         if (current->flags & PF_RANDOMIZE)
1058                 randomize_brk(elf_brk);
1059 #endif
1060         if (current->personality & MMAP_PAGE_ZERO) {
1061                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1062                    and some applications "depend" upon this behavior.
1063                    Since we do not have the power to recompile these, we
1064                    emulate the SVr4 behavior.  Sigh.  */
1065                 down_write(&current->mm->mmap_sem);
1066                 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1067                                 MAP_FIXED | MAP_PRIVATE, 0);
1068                 up_write(&current->mm->mmap_sem);
1069         }
1070
1071 #ifdef ELF_PLAT_INIT
1072         /*
1073          * The ABI may specify that certain registers be set up in special
1074          * ways (on i386 %edx is the address of a DT_FINI function, for
1075          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1076          * that the e_entry field is the address of the function descriptor
1077          * for the startup routine, rather than the address of the startup
1078          * routine itself.  This macro performs whatever initialization to
1079          * the regs structure is required as well as any relocations to the
1080          * function descriptor entries when executing dynamically links apps.
1081          */
1082         ELF_PLAT_INIT(regs, reloc_func_desc);
1083 #endif
1084
1085         start_thread(regs, elf_entry, bprm->p);
1086         if (unlikely(current->ptrace & PT_PTRACED)) {
1087                 if (current->ptrace & PT_TRACE_EXEC)
1088                         ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
1089                 else
1090                         send_sig(SIGTRAP, current, 0);
1091         }
1092         retval = 0;
1093 out:
1094         kfree(loc);
1095 out_ret:
1096         return retval;
1097
1098         /* error cleanup */
1099 out_free_dentry:
1100         allow_write_access(interpreter);
1101         if (interpreter)
1102                 fput(interpreter);
1103 out_free_interp:
1104         kfree(elf_interpreter);
1105 out_free_file:
1106         sys_close(elf_exec_fileno);
1107 out_free_fh:
1108         if (files) {
1109                 put_files_struct(current->files);
1110                 current->files = files;
1111         }
1112 out_free_ph:
1113         kfree(elf_phdata);
1114         goto out;
1115 }
1116
1117 /* This is really simpleminded and specialized - we are loading an
1118    a.out library that is given an ELF header. */
1119
1120 static int load_elf_library(struct file *file)
1121 {
1122         struct elf_phdr *elf_phdata;
1123         struct elf_phdr *eppnt;
1124         unsigned long elf_bss, bss, len;
1125         int retval, error, i, j;
1126         struct elfhdr elf_ex;
1127
1128         error = -ENOEXEC;
1129         retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
1130         if (retval != sizeof(elf_ex))
1131                 goto out;
1132
1133         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1134                 goto out;
1135
1136         /* First of all, some simple consistency checks */
1137         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1138            !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1139                 goto out;
1140
1141         /* Now read in all of the header information */
1142
1143         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1144         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1145
1146         error = -ENOMEM;
1147         elf_phdata = kmalloc(j, GFP_KERNEL);
1148         if (!elf_phdata)
1149                 goto out;
1150
1151         eppnt = elf_phdata;
1152         error = -ENOEXEC;
1153         retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1154         if (retval != j)
1155                 goto out_free_ph;
1156
1157         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1158                 if ((eppnt + i)->p_type == PT_LOAD)
1159                         j++;
1160         if (j != 1)
1161                 goto out_free_ph;
1162
1163         while (eppnt->p_type != PT_LOAD)
1164                 eppnt++;
1165
1166         /* Now use mmap to map the library into memory. */
1167         down_write(&current->mm->mmap_sem);
1168         error = do_mmap(file,
1169                         ELF_PAGESTART(eppnt->p_vaddr),
1170                         (eppnt->p_filesz +
1171                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1172                         PROT_READ | PROT_WRITE | PROT_EXEC,
1173                         MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1174                         (eppnt->p_offset -
1175                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1176         up_write(&current->mm->mmap_sem);
1177         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1178                 goto out_free_ph;
1179
1180         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1181         if (padzero(elf_bss)) {
1182                 error = -EFAULT;
1183                 goto out_free_ph;
1184         }
1185
1186         len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);
1187         bss = eppnt->p_memsz + eppnt->p_vaddr;
1188         if (bss > len) {
1189                 down_write(&current->mm->mmap_sem);
1190                 do_brk(len, bss - len);
1191                 up_write(&current->mm->mmap_sem);
1192         }
1193         error = 0;
1194
1195 out_free_ph:
1196         kfree(elf_phdata);
1197 out:
1198         return error;
1199 }
1200
1201 /*
1202  * Note that some platforms still use traditional core dumps and not
1203  * the ELF core dump.  Each platform can select it as appropriate.
1204  */
1205 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1206
1207 /*
1208  * ELF core dumper
1209  *
1210  * Modelled on fs/exec.c:aout_core_dump()
1211  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1212  */
1213 /*
1214  * These are the only things you should do on a core-file: use only these
1215  * functions to write out all the necessary info.
1216  */
1217 static int dump_write(struct file *file, const void *addr, int nr)
1218 {
1219         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1220 }
1221
1222 static int dump_seek(struct file *file, loff_t off)
1223 {
1224         if (file->f_op->llseek) {
1225                 if (file->f_op->llseek(file, off, 0) != off)
1226                         return 0;
1227         } else
1228                 file->f_pos = off;
1229         return 1;
1230 }
1231
1232 /*
1233  * Decide whether a segment is worth dumping; default is yes to be
1234  * sure (missing info is worse than too much; etc).
1235  * Personally I'd include everything, and use the coredump limit...
1236  *
1237  * I think we should skip something. But I am not sure how. H.J.
1238  */
1239 static int maydump(struct vm_area_struct *vma)
1240 {
1241         /* Do not dump I/O mapped devices or special mappings */
1242         if (vma->vm_flags & (VM_IO | VM_RESERVED))
1243                 return 0;
1244
1245         if (vma->vm_flags & VM_DONTEXPAND) /* Kludge for vDSO.  */
1246                 return 1;
1247
1248         /* Dump shared memory only if mapped from an anonymous file.  */
1249         if (vma->vm_flags & VM_SHARED)
1250                 return vma->vm_file->f_dentry->d_inode->i_nlink == 0;
1251
1252         /* If it hasn't been written to, don't write it out */
1253         if (!vma->anon_vma)
1254                 return 0;
1255
1256         return 1;
1257 }
1258
1259 #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
1260
1261 /* An ELF note in memory */
1262 struct memelfnote
1263 {
1264         const char *name;
1265         int type;
1266         unsigned int datasz;
1267         void *data;
1268 };
1269
1270 static int notesize(struct memelfnote *en)
1271 {
1272         int sz;
1273
1274         sz = sizeof(struct elf_note);
1275         sz += roundup(strlen(en->name) + 1, 4);
1276         sz += roundup(en->datasz, 4);
1277
1278         return sz;
1279 }
1280
1281 #define DUMP_WRITE(addr, nr)    \
1282         do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1283 #define DUMP_SEEK(off)  \
1284         do { if (!dump_seek(file, (off))) return 0; } while(0)
1285
1286 static int writenote(struct memelfnote *men, struct file *file)
1287 {
1288         struct elf_note en;
1289
1290         en.n_namesz = strlen(men->name) + 1;
1291         en.n_descsz = men->datasz;
1292         en.n_type = men->type;
1293
1294         DUMP_WRITE(&en, sizeof(en));
1295         DUMP_WRITE(men->name, en.n_namesz);
1296         /* XXX - cast from long long to long to avoid need for libgcc.a */
1297         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1298         DUMP_WRITE(men->data, men->datasz);
1299         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1300
1301         return 1;
1302 }
1303 #undef DUMP_WRITE
1304 #undef DUMP_SEEK
1305
1306 #define DUMP_WRITE(addr, nr)    \
1307         if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1308                 goto end_coredump;
1309 #define DUMP_SEEK(off)  \
1310         if (!dump_seek(file, (off))) \
1311                 goto end_coredump;
1312
1313 static void fill_elf_header(struct elfhdr *elf, int segs)
1314 {
1315         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1316         elf->e_ident[EI_CLASS] = ELF_CLASS;
1317         elf->e_ident[EI_DATA] = ELF_DATA;
1318         elf->e_ident[EI_VERSION] = EV_CURRENT;
1319         elf->e_ident[EI_OSABI] = ELF_OSABI;
1320         memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1321
1322         elf->e_type = ET_CORE;
1323         elf->e_machine = ELF_ARCH;
1324         elf->e_version = EV_CURRENT;
1325         elf->e_entry = 0;
1326         elf->e_phoff = sizeof(struct elfhdr);
1327         elf->e_shoff = 0;
1328         elf->e_flags = ELF_CORE_EFLAGS;
1329         elf->e_ehsize = sizeof(struct elfhdr);
1330         elf->e_phentsize = sizeof(struct elf_phdr);
1331         elf->e_phnum = segs;
1332         elf->e_shentsize = 0;
1333         elf->e_shnum = 0;
1334         elf->e_shstrndx = 0;
1335         return;
1336 }
1337
1338 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
1339 {
1340         phdr->p_type = PT_NOTE;
1341         phdr->p_offset = offset;
1342         phdr->p_vaddr = 0;
1343         phdr->p_paddr = 0;
1344         phdr->p_filesz = sz;
1345         phdr->p_memsz = 0;
1346         phdr->p_flags = 0;
1347         phdr->p_align = 0;
1348         return;
1349 }
1350
1351 static void fill_note(struct memelfnote *note, const char *name, int type,
1352                 unsigned int sz, void *data)
1353 {
1354         note->name = name;
1355         note->type = type;
1356         note->datasz = sz;
1357         note->data = data;
1358         return;
1359 }
1360
1361 /*
1362  * fill up all the fields in prstatus from the given task struct, except registers
1363  * which need to be filled up separately.
1364  */
1365 static void fill_prstatus(struct elf_prstatus *prstatus,
1366                         struct task_struct *p, long signr)
1367 {
1368         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1369         prstatus->pr_sigpend = p->pending.signal.sig[0];
1370         prstatus->pr_sighold = p->blocked.sig[0];
1371         prstatus->pr_pid = p->pid;
1372         prstatus->pr_ppid = p->parent->pid;
1373         prstatus->pr_pgrp = process_group(p);
1374         prstatus->pr_sid = p->signal->session;
1375         if (thread_group_leader(p)) {
1376                 /*
1377                  * This is the record for the group leader.  Add in the
1378                  * cumulative times of previous dead threads.  This total
1379                  * won't include the time of each live thread whose state
1380                  * is included in the core dump.  The final total reported
1381                  * to our parent process when it calls wait4 will include
1382                  * those sums as well as the little bit more time it takes
1383                  * this and each other thread to finish dying after the
1384                  * core dump synchronization phase.
1385                  */
1386                 cputime_to_timeval(cputime_add(p->utime, p->signal->utime),
1387                                    &prstatus->pr_utime);
1388                 cputime_to_timeval(cputime_add(p->stime, p->signal->stime),
1389                                    &prstatus->pr_stime);
1390         } else {
1391                 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1392                 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1393         }
1394         cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1395         cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1396 }
1397
1398 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1399                        struct mm_struct *mm)
1400 {
1401         unsigned int i, len;
1402
1403         /* first copy the parameters from user space */
1404         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1405
1406         len = mm->arg_end - mm->arg_start;
1407         if (len >= ELF_PRARGSZ)
1408                 len = ELF_PRARGSZ-1;
1409         if (copy_from_user(&psinfo->pr_psargs,
1410                            (const char __user *)mm->arg_start, len))
1411                 return -EFAULT;
1412         for(i = 0; i < len; i++)
1413                 if (psinfo->pr_psargs[i] == 0)
1414                         psinfo->pr_psargs[i] = ' ';
1415         psinfo->pr_psargs[len] = 0;
1416
1417         psinfo->pr_pid = p->pid;
1418         psinfo->pr_ppid = p->parent->pid;
1419         psinfo->pr_pgrp = process_group(p);
1420         psinfo->pr_sid = p->signal->session;
1421
1422         i = p->state ? ffz(~p->state) + 1 : 0;
1423         psinfo->pr_state = i;
1424         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1425         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1426         psinfo->pr_nice = task_nice(p);
1427         psinfo->pr_flag = p->flags;
1428         SET_UID(psinfo->pr_uid, p->uid);
1429         SET_GID(psinfo->pr_gid, p->gid);
1430         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1431
1432         return 0;
1433 }
1434
1435 /* Here is the structure in which status of each thread is captured. */
1436 struct elf_thread_status
1437 {
1438         struct list_head list;
1439         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1440         elf_fpregset_t fpu;             /* NT_PRFPREG */
1441         struct task_struct *thread;
1442 #ifdef ELF_CORE_COPY_XFPREGS
1443         elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
1444 #endif
1445         struct memelfnote notes[3];
1446         int num_notes;
1447 };
1448
1449 /*
1450  * In order to add the specific thread information for the elf file format,
1451  * we need to keep a linked list of every threads pr_status and then
1452  * create a single section for them in the final core file.
1453  */
1454 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1455 {
1456         int sz = 0;
1457         struct task_struct *p = t->thread;
1458         t->num_notes = 0;
1459
1460         fill_prstatus(&t->prstatus, p, signr);
1461         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1462
1463         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));
1464         t->num_notes++;
1465         sz += notesize(&t->notes[0]);
1466
1467         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {
1468                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));
1469                 t->num_notes++;
1470                 sz += notesize(&t->notes[1]);
1471         }
1472
1473 #ifdef ELF_CORE_COPY_XFPREGS
1474         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1475                 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);
1476                 t->num_notes++;
1477                 sz += notesize(&t->notes[2]);
1478         }
1479 #endif
1480         return sz;
1481 }
1482
1483 /*
1484  * Actual dumper
1485  *
1486  * This is a two-pass process; first we find the offsets of the bits,
1487  * and then they are actually written out.  If we run out of core limit
1488  * we just truncate.
1489  */
1490 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
1491 {
1492 #define NUM_NOTES       6
1493         int has_dumped = 0;
1494         mm_segment_t fs;
1495         int segs;
1496         size_t size = 0;
1497         int i;
1498         struct vm_area_struct *vma;
1499         struct elfhdr *elf = NULL;
1500         off_t offset = 0, dataoff;
1501         unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
1502         int numnote;
1503         struct memelfnote *notes = NULL;
1504         struct elf_prstatus *prstatus = NULL;   /* NT_PRSTATUS */
1505         struct elf_prpsinfo *psinfo = NULL;     /* NT_PRPSINFO */
1506         struct task_struct *g, *p;
1507         LIST_HEAD(thread_list);
1508         struct list_head *t;
1509         elf_fpregset_t *fpu = NULL;
1510 #ifdef ELF_CORE_COPY_XFPREGS
1511         elf_fpxregset_t *xfpu = NULL;
1512 #endif
1513         int thread_status_size = 0;
1514         elf_addr_t *auxv;
1515
1516         /*
1517          * We no longer stop all VM operations.
1518          *
1519          * This is because those proceses that could possibly change map_count or
1520          * the mmap / vma pages are now blocked in do_exit on current finishing
1521          * this core dump.
1522          *
1523          * Only ptrace can touch these memory addresses, but it doesn't change
1524          * the map_count or the pages allocated.  So no possibility of crashing
1525          * exists while dumping the mm->vm_next areas to the core file.
1526          */
1527
1528         /* alloc memory for large data structures: too large to be on stack */
1529         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1530         if (!elf)
1531                 goto cleanup;
1532         prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1533         if (!prstatus)
1534                 goto cleanup;
1535         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1536         if (!psinfo)
1537                 goto cleanup;
1538         notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1539         if (!notes)
1540                 goto cleanup;
1541         fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1542         if (!fpu)
1543                 goto cleanup;
1544 #ifdef ELF_CORE_COPY_XFPREGS
1545         xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1546         if (!xfpu)
1547                 goto cleanup;
1548 #endif
1549
1550         if (signr) {
1551                 struct elf_thread_status *tmp;
1552                 read_lock(&tasklist_lock);
1553                 do_each_thread(g,p)
1554                         if (current->mm == p->mm && current != p) {
1555                                 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
1556                                 if (!tmp) {
1557                                         read_unlock(&tasklist_lock);
1558                                         goto cleanup;
1559                                 }
1560                                 INIT_LIST_HEAD(&tmp->list);
1561                                 tmp->thread = p;
1562                                 list_add(&tmp->list, &thread_list);
1563                         }
1564                 while_each_thread(g,p);
1565                 read_unlock(&tasklist_lock);
1566                 list_for_each(t, &thread_list) {
1567                         struct elf_thread_status *tmp;
1568                         int sz;
1569
1570                         tmp = list_entry(t, struct elf_thread_status, list);
1571                         sz = elf_dump_thread_status(signr, tmp);
1572                         thread_status_size += sz;
1573                 }
1574         }
1575         /* now collect the dump for the current */
1576         memset(prstatus, 0, sizeof(*prstatus));
1577         fill_prstatus(prstatus, current, signr);
1578         elf_core_copy_regs(&prstatus->pr_reg, regs);
1579
1580         segs = current->mm->map_count;
1581 #ifdef ELF_CORE_EXTRA_PHDRS
1582         segs += ELF_CORE_EXTRA_PHDRS;
1583 #endif
1584
1585         /* Set up header */
1586         fill_elf_header(elf, segs+1);   /* including notes section */
1587
1588         has_dumped = 1;
1589         current->flags |= PF_DUMPCORE;
1590
1591         /*
1592          * Set up the notes in similar form to SVR4 core dumps made
1593          * with info from their /proc.
1594          */
1595
1596         fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1597
1598         fill_psinfo(psinfo, current->group_leader, current->mm);
1599         fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1600
1601         numnote = 2;
1602
1603         auxv = (elf_addr_t *) current->mm->saved_auxv;
1604
1605         i = 0;
1606         do
1607                 i += 2;
1608         while (auxv[i - 2] != AT_NULL);
1609         fill_note(&notes[numnote++], "CORE", NT_AUXV,
1610                   i * sizeof (elf_addr_t), auxv);
1611
1612         /* Try to dump the FPU. */
1613         if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))
1614                 fill_note(notes + numnote++,
1615                           "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1616 #ifdef ELF_CORE_COPY_XFPREGS
1617         if (elf_core_copy_task_xfpregs(current, xfpu))
1618                 fill_note(notes + numnote++,
1619                           "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1620 #endif
1621
1622         fs = get_fs();
1623         set_fs(KERNEL_DS);
1624
1625         DUMP_WRITE(elf, sizeof(*elf));
1626         offset += sizeof(*elf);                         /* Elf header */
1627         offset += (segs+1) * sizeof(struct elf_phdr);   /* Program headers */
1628
1629         /* Write notes phdr entry */
1630         {
1631                 struct elf_phdr phdr;
1632                 int sz = 0;
1633
1634                 for (i = 0; i < numnote; i++)
1635                         sz += notesize(notes + i);
1636
1637                 sz += thread_status_size;
1638
1639                 fill_elf_note_phdr(&phdr, sz, offset);
1640                 offset += sz;
1641                 DUMP_WRITE(&phdr, sizeof(phdr));
1642         }
1643
1644         /* Page-align dumped data */
1645         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1646
1647         /* Write program headers for segments dump */
1648         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1649                 struct elf_phdr phdr;
1650                 size_t sz;
1651
1652                 sz = vma->vm_end - vma->vm_start;
1653
1654                 phdr.p_type = PT_LOAD;
1655                 phdr.p_offset = offset;
1656                 phdr.p_vaddr = vma->vm_start;
1657                 phdr.p_paddr = 0;
1658                 phdr.p_filesz = maydump(vma) ? sz : 0;
1659                 phdr.p_memsz = sz;
1660                 offset += phdr.p_filesz;
1661                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1662                 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
1663                 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
1664                 phdr.p_align = ELF_EXEC_PAGESIZE;
1665
1666                 DUMP_WRITE(&phdr, sizeof(phdr));
1667         }
1668
1669 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1670         ELF_CORE_WRITE_EXTRA_PHDRS;
1671 #endif
1672
1673         /* write out the notes section */
1674         for (i = 0; i < numnote; i++)
1675                 if (!writenote(notes + i, file))
1676                         goto end_coredump;
1677
1678         /* write out the thread status notes section */
1679         list_for_each(t, &thread_list) {
1680                 struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);
1681                 for (i = 0; i < tmp->num_notes; i++)
1682                         if (!writenote(&tmp->notes[i], file))
1683                                 goto end_coredump;
1684         }
1685
1686         DUMP_SEEK(dataoff);
1687
1688         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1689                 unsigned long addr;
1690
1691                 if (!maydump(vma))
1692                         continue;
1693
1694                 for (addr = vma->vm_start;
1695                      addr < vma->vm_end;
1696                      addr += PAGE_SIZE) {
1697                         struct page* page;
1698                         struct vm_area_struct *vma;
1699
1700                         if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1701                                                 &page, &vma) <= 0) {
1702                                 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1703                         } else {
1704                                 if (page == ZERO_PAGE(addr)) {
1705                                         DUMP_SEEK (file->f_pos + PAGE_SIZE);
1706                                 } else {
1707                                         void *kaddr;
1708                                         flush_cache_page(vma, addr, page_to_pfn(page));
1709                                         kaddr = kmap(page);
1710                                         if ((size += PAGE_SIZE) > limit ||
1711                                             !dump_write(file, kaddr,
1712                                             PAGE_SIZE)) {
1713                                                 kunmap(page);
1714                                                 page_cache_release(page);
1715                                                 goto end_coredump;
1716                                         }
1717                                         kunmap(page);
1718                                 }
1719                                 page_cache_release(page);
1720                         }
1721                 }
1722         }
1723
1724 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1725         ELF_CORE_WRITE_EXTRA_DATA;
1726 #endif
1727
1728         if ((off_t)file->f_pos != offset) {
1729                 /* Sanity check */
1730                 printk(KERN_WARNING "elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1731                        (off_t)file->f_pos, offset);
1732         }
1733
1734 end_coredump:
1735         set_fs(fs);
1736
1737 cleanup:
1738         while (!list_empty(&thread_list)) {
1739                 struct list_head *tmp = thread_list.next;
1740                 list_del(tmp);
1741                 kfree(list_entry(tmp, struct elf_thread_status, list));
1742         }
1743
1744         kfree(elf);
1745         kfree(prstatus);
1746         kfree(psinfo);
1747         kfree(notes);
1748         kfree(fpu);
1749 #ifdef ELF_CORE_COPY_XFPREGS
1750         kfree(xfpu);
1751 #endif
1752         return has_dumped;
1753 #undef NUM_NOTES
1754 }
1755
1756 #endif          /* USE_ELF_CORE_DUMP */
1757
1758 static int __init init_elf_binfmt(void)
1759 {
1760         return register_binfmt(&elf_format);
1761 }
1762
1763 static void __exit exit_elf_binfmt(void)
1764 {
1765         /* Remove the COFF and ELF loaders. */
1766         unregister_binfmt(&elf_format);
1767 }
1768
1769 core_initcall(init_elf_binfmt);
1770 module_exit(exit_elf_binfmt);
1771 MODULE_LICENSE("GPL");