fs/binfmt_elf.c

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