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