fs/binfmt_elf.c

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