fs/binfmt_elf.c

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