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