fs/binfmt_elf.c

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