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