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