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         current->mm->free_area_cache = TASK_UNMAPPED_BASE;
 702         retval = setup_arg_pages(bprm, executable_stack);
 703         if (retval < 0) {
 704                 send_sig(SIGKILL, current, 0);
 705                 goto out_free_dentry;
 706         }
 707
 708         current->mm->start_stack = bprm->p;
 709
 710         /* Now we do a little grungy work by mmaping the ELF image into
 711            the correct location in memory.  At this point, we assume that
 712            the image should be loaded at fixed address, not at a variable
 713            address. */
 714
 715         for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
 716                 int elf_prot = 0, elf_flags;
 717                 unsigned long k, vaddr;
 718
 719                 if (elf_ppnt->p_type != PT_LOAD)
 720                         continue;
 721
 722                 if (unlikely (elf_brk > elf_bss)) {
 723                         unsigned long nbyte;
 724
 725                         /* There was a PT_LOAD segment with p_memsz > p_filesz
 726                            before this one. Map anonymous pages, if needed,
 727                            and clear the area.  */
 728                         retval = set_brk (elf_bss + load_bias,
 729                                           elf_brk + load_bias);
 730                         if (retval) {
 731                                 send_sig(SIGKILL, current, 0);
 732                                 goto out_free_dentry;
 733                         }
 734                         nbyte = ELF_PAGEOFFSET(elf_bss);
 735                         if (nbyte) {
 736                                 nbyte = ELF_MIN_ALIGN - nbyte;
 737                                 if (nbyte > elf_brk - elf_bss)
 738                                         nbyte = elf_brk - elf_bss;
 739                                 clear_user((void __user *) elf_bss + load_bias, nbyte);
 740                         }
 741                 }
 742
 743                 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
 744                 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
 745                 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
 746
 747                 elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
 748
 749                 vaddr = elf_ppnt->p_vaddr;
 750                 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
 751                         elf_flags |= MAP_FIXED;
 752                 } else if (elf_ex.e_type == ET_DYN) {
 753                         /* Try and get dynamic programs out of the way of the default mmap
 754                            base, as well as whatever program they might try to exec.  This
 755                            is because the brk will follow the loader, and is not movable.  */
 756                         load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
 757                 }
 758
 759                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);
 760                 if (BAD_ADDR(error))
 761                         continue;
 762
 763                 if (!load_addr_set) {
 764                         load_addr_set = 1;
 765                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
 766                         if (elf_ex.e_type == ET_DYN) {
 767                                 load_bias += error -
 768                                              ELF_PAGESTART(load_bias + vaddr);
 769                                 load_addr += load_bias;
 770                                 reloc_func_desc = load_bias;
 771                         }
 772                 }
 773                 k = elf_ppnt->p_vaddr;
 774                 if (k < start_code) start_code = k;
 775                 if (start_data < k) start_data = k;
 776
 777                 /*
 778                  * Check to see if the section's size will overflow the
 779                  * allowed task size. Note that p_filesz must always be
 780                  * <= p_memsz so it is only necessary to check p_memsz.
 781                  */
 782                 if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
 783                     elf_ppnt->p_memsz > TASK_SIZE ||
 784                     TASK_SIZE - elf_ppnt->p_memsz < k) {
 785                         /* set_brk can never work.  Avoid overflows.  */
 786                         send_sig(SIGKILL, current, 0);
 787                         goto out_free_dentry;
 788                 }
 789
 790                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
 791
 792                 if (k > elf_bss)
 793                         elf_bss = k;
 794                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
 795                         end_code = k;
 796                 if (end_data < k)
 797                         end_data = k;
 798                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
 799                 if (k > elf_brk)
 800                         elf_brk = k;
 801         }
 802
 803         elf_ex.e_entry += load_bias;
 804         elf_bss += load_bias;
 805         elf_brk += load_bias;
 806         start_code += load_bias;
 807         end_code += load_bias;
 808         start_data += load_bias;
 809         end_data += load_bias;
 810
 811         /* Calling set_brk effectively mmaps the pages that we need
 812          * for the bss and break sections.  We must do this before
 813          * mapping in the interpreter, to make sure it doesn't wind
 814          * up getting placed where the bss needs to go.
 815          */
 816         retval = set_brk(elf_bss, elf_brk);
 817         if (retval) {
 818                 send_sig(SIGKILL, current, 0);
 819                 goto out_free_dentry;
 820         }
 821         padzero(elf_bss);
 822
 823         if (elf_interpreter) {
 824                 if (interpreter_type == INTERPRETER_AOUT)
 825                         elf_entry = load_aout_interp(&interp_ex,
 826                                                      interpreter);
 827                 else
 828                         elf_entry = load_elf_interp(&interp_elf_ex,
 829                                                     interpreter,
 830                                                     &interp_load_addr);
 831                 if (BAD_ADDR(elf_entry)) {
 832                         printk(KERN_ERR "Unable to load interpreter\n");
 833                         send_sig(SIGSEGV, current, 0);
 834                         retval = -ENOEXEC; /* Nobody gets to see this, but.. */
 835                         goto out_free_dentry;
 836                 }
 837                 reloc_func_desc = interp_load_addr;
 838
 839                 allow_write_access(interpreter);
 840                 fput(interpreter);
 841                 kfree(elf_interpreter);
 842         } else {
 843                 elf_entry = elf_ex.e_entry;
 844         }
 845
 846         kfree(elf_phdata);
 847
 848         if (interpreter_type != INTERPRETER_AOUT)
 849                 sys_close(elf_exec_fileno);
 850
 851         set_binfmt(&elf_format);
 852
 853         compute_creds(bprm);
 854         current->flags &= ~PF_FORKNOEXEC;
 855         create_elf_tables(bprm, &elf_ex, (interpreter_type == INTERPRETER_AOUT),
 856                         load_addr, interp_load_addr);
 857         /* N.B. passed_fileno might not be initialized? */
 858         if (interpreter_type == INTERPRETER_AOUT)
 859                 current->mm->arg_start += strlen(passed_fileno) + 1;
 860         current->mm->end_code = end_code;
 861         current->mm->start_code = start_code;
 862         current->mm->start_data = start_data;
 863         current->mm->end_data = end_data;
 864         current->mm->start_stack = bprm->p;
 865
 866         if (current->personality & MMAP_PAGE_ZERO) {
 867                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
 868                    and some applications "depend" upon this behavior.
 869                    Since we do not have the power to recompile these, we
 870                    emulate the SVr4 behavior.  Sigh.  */
 871                 down_write(&current->mm->mmap_sem);
 872                 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
 873                                 MAP_FIXED | MAP_PRIVATE, 0);
 874                 up_write(&current->mm->mmap_sem);
 875         }
 876
 877 #ifdef ELF_PLAT_INIT
 878         /*
 879          * The ABI may specify that certain registers be set up in special
 880          * ways (on i386 %edx is the address of a DT_FINI function, for
 881          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
 882          * that the e_entry field is the address of the function descriptor
 883          * for the startup routine, rather than the address of the startup
 884          * routine itself.  This macro performs whatever initialization to
 885          * the regs structure is required as well as any relocations to the
 886          * function descriptor entries when executing dynamically links apps.
 887          */
 888         ELF_PLAT_INIT(regs, reloc_func_desc);
 889 #endif
 890
 891         start_thread(regs, elf_entry, bprm->p);
 892         if (unlikely(current->ptrace & PT_PTRACED)) {
 893                 if (current->ptrace & PT_TRACE_EXEC)
 894                         ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
 895                 else
 896                         send_sig(SIGTRAP, current, 0);
 897         }
 898         retval = 0;
 899 out:
 900         return retval;
 901
 902         /* error cleanup */
 903 out_free_dentry:
 904         allow_write_access(interpreter);
 905         if (interpreter)
 906                 fput(interpreter);
 907 out_free_interp:
 908         if (elf_interpreter)
 909                 kfree(elf_interpreter);
 910 out_free_file:
 911         sys_close(elf_exec_fileno);
 912 out_free_fh:
 913         if (files) {
 914                 put_files_struct(current->files);
 915                 current->files = files;
 916         }
 917 out_free_ph:
 918         kfree(elf_phdata);
 919         goto out;
 920 }
 921
 922 /* This is really simpleminded and specialized - we are loading an
 923    a.out library that is given an ELF header. */
 924
 925 static int load_elf_library(struct file *file)
 926 {
 927         struct elf_phdr *elf_phdata;
 928         unsigned long elf_bss, bss, len;
 929         int retval, error, i, j;
 930         struct elfhdr elf_ex;
 931
 932         error = -ENOEXEC;
 933         retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
 934         if (retval != sizeof(elf_ex))
 935                 goto out;
 936
 937         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
 938                 goto out;
 939
 940         /* First of all, some simple consistency checks */
 941         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
 942            !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
 943                 goto out;
 944
 945         /* Now read in all of the header information */
 946
 947         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
 948         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
 949
 950         error = -ENOMEM;
 951         elf_phdata = (struct elf_phdr *) kmalloc(j, GFP_KERNEL);
 952         if (!elf_phdata)
 953                 goto out;
 954
 955         error = -ENOEXEC;
 956         retval = kernel_read(file, elf_ex.e_phoff, (char *) elf_phdata, j);
 957         if (retval != j)
 958                 goto out_free_ph;
 959
 960         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
 961                 if ((elf_phdata + i)->p_type == PT_LOAD) j++;
 962         if (j != 1)
 963                 goto out_free_ph;
 964
 965         while (elf_phdata->p_type != PT_LOAD) elf_phdata++;
 966
 967         /* Now use mmap to map the library into memory. */
 968         down_write(&current->mm->mmap_sem);
 969         error = do_mmap(file,
 970                         ELF_PAGESTART(elf_phdata->p_vaddr),
 971                         (elf_phdata->p_filesz +
 972                          ELF_PAGEOFFSET(elf_phdata->p_vaddr)),
 973                         PROT_READ | PROT_WRITE | PROT_EXEC,
 974                         MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
 975                         (elf_phdata->p_offset -
 976                          ELF_PAGEOFFSET(elf_phdata->p_vaddr)));
 977         up_write(&current->mm->mmap_sem);
 978         if (error != ELF_PAGESTART(elf_phdata->p_vaddr))
 979                 goto out_free_ph;
 980
 981         elf_bss = elf_phdata->p_vaddr + elf_phdata->p_filesz;
 982         padzero(elf_bss);
 983
 984         len = ELF_PAGESTART(elf_phdata->p_filesz + elf_phdata->p_vaddr + ELF_MIN_ALIGN - 1);
 985         bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
 986         if (bss > len)
 987                 do_brk(len, bss - len);
 988         error = 0;
 989
 990 out_free_ph:
 991         kfree(elf_phdata);
 992 out:
 993         return error;
 994 }
 995
 996 /*
 997  * Note that some platforms still use traditional core dumps and not
 998  * the ELF core dump.  Each platform can select it as appropriate.
 999  */
1000 #ifdef USE_ELF_CORE_DUMP
1001
1002 /*
1003  * ELF core dumper
1004  *
1005  * Modelled on fs/exec.c:aout_core_dump()
1006  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1007  */
1008 /*
1009  * These are the only things you should do on a core-file: use only these
1010  * functions to write out all the necessary info.
1011  */
1012 static int dump_write(struct file *file, const void *addr, int nr)
1013 {
1014         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1015 }
1016
1017 static int dump_seek(struct file *file, off_t off)
1018 {
1019         if (file->f_op->llseek) {
1020                 if (file->f_op->llseek(file, off, 0) != off)
1021                         return 0;
1022         } else
1023                 file->f_pos = off;
1024         return 1;
1025 }
1026
1027 /*
1028  * Decide whether a segment is worth dumping; default is yes to be
1029  * sure (missing info is worse than too much; etc).
1030  * Personally I'd include everything, and use the coredump limit...
1031  *
1032  * I think we should skip something. But I am not sure how. H.J.
1033  */
1034 static int maydump(struct vm_area_struct *vma)
1035 {
1036         /*
1037          * If we may not read the contents, don't allow us to dump
1038          * them either. "dump_write()" can't handle it anyway.
1039          */
1040         if (!(vma->vm_flags & VM_READ))
1041                 return 0;
1042
1043         /* Do not dump I/O mapped devices! -DaveM */
1044         if (vma->vm_flags & VM_IO)
1045                 return 0;
1046 #if 1
1047         if (vma->vm_flags & (VM_WRITE|VM_GROWSUP|VM_GROWSDOWN))
1048                 return 1;
1049         if (vma->vm_flags & (VM_READ|VM_EXEC|VM_EXECUTABLE|VM_SHARED))
1050                 return 0;
1051 #endif
1052         return 1;
1053 }
1054
1055 #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
1056
1057 /* An ELF note in memory */
1058 struct memelfnote
1059 {
1060         const char *name;
1061         int type;
1062         unsigned int datasz;
1063         void *data;
1064 };
1065
1066 static int notesize(struct memelfnote *en)
1067 {
1068         int sz;
1069
1070         sz = sizeof(struct elf_note);
1071         sz += roundup(strlen(en->name) + 1, 4);
1072         sz += roundup(en->datasz, 4);
1073
1074         return sz;
1075 }
1076
1077 #define DUMP_WRITE(addr, nr)    \
1078         do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1079 #define DUMP_SEEK(off)  \
1080         do { if (!dump_seek(file, (off))) return 0; } while(0)
1081
1082 static int writenote(struct memelfnote *men, struct file *file)
1083 {
1084         struct elf_note en;
1085
1086         en.n_namesz = strlen(men->name) + 1;
1087         en.n_descsz = men->datasz;
1088         en.n_type = men->type;
1089
1090         DUMP_WRITE(&en, sizeof(en));
1091         DUMP_WRITE(men->name, en.n_namesz);
1092         /* XXX - cast from long long to long to avoid need for libgcc.a */
1093         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1094         DUMP_WRITE(men->data, men->datasz);
1095         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1096
1097         return 1;
1098 }
1099 #undef DUMP_WRITE
1100 #undef DUMP_SEEK
1101
1102 #define DUMP_WRITE(addr, nr)    \
1103         if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1104                 goto end_coredump;
1105 #define DUMP_SEEK(off)  \
1106         if (!dump_seek(file, (off))) \
1107                 goto end_coredump;
1108
1109 static inline void fill_elf_header(struct elfhdr *elf, int segs)
1110 {
1111         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1112         elf->e_ident[EI_CLASS] = ELF_CLASS;
1113         elf->e_ident[EI_DATA] = ELF_DATA;
1114         elf->e_ident[EI_VERSION] = EV_CURRENT;
1115         elf->e_ident[EI_OSABI] = ELF_OSABI;
1116         memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1117
1118         elf->e_type = ET_CORE;
1119         elf->e_machine = ELF_ARCH;
1120         elf->e_version = EV_CURRENT;
1121         elf->e_entry = 0;
1122         elf->e_phoff = sizeof(struct elfhdr);
1123         elf->e_shoff = 0;
1124         elf->e_flags = 0;
1125         elf->e_ehsize = sizeof(struct elfhdr);
1126         elf->e_phentsize = sizeof(struct elf_phdr);
1127         elf->e_phnum = segs;
1128         elf->e_shentsize = 0;
1129         elf->e_shnum = 0;
1130         elf->e_shstrndx = 0;
1131         return;
1132 }
1133
1134 static inline void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
1135 {
1136         phdr->p_type = PT_NOTE;
1137         phdr->p_offset = offset;
1138         phdr->p_vaddr = 0;
1139         phdr->p_paddr = 0;
1140         phdr->p_filesz = sz;
1141         phdr->p_memsz = 0;
1142         phdr->p_flags = 0;
1143         phdr->p_align = 0;
1144         return;
1145 }
1146
1147 static void fill_note(struct memelfnote *note, const char *name, int type,
1148                 unsigned int sz, void *data)
1149 {
1150         note->name = name;
1151         note->type = type;
1152         note->datasz = sz;
1153         note->data = data;
1154         return;
1155 }
1156
1157 /*
1158  * fill up all the fields in prstatus from the given task struct, except registers
1159  * which need to be filled up separately.
1160  */
1161 static void fill_prstatus(struct elf_prstatus *prstatus,
1162                         struct task_struct *p, long signr)
1163 {
1164         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1165         prstatus->pr_sigpend = p->pending.signal.sig[0];
1166         prstatus->pr_sighold = p->blocked.sig[0];
1167         prstatus->pr_pid = p->pid;
1168         prstatus->pr_ppid = p->parent->pid;
1169         prstatus->pr_pgrp = process_group(p);
1170         prstatus->pr_sid = p->signal->session;
1171         jiffies_to_timeval(p->utime, &prstatus->pr_utime);
1172         jiffies_to_timeval(p->stime, &prstatus->pr_stime);
1173         jiffies_to_timeval(p->cutime, &prstatus->pr_cutime);
1174         jiffies_to_timeval(p->cstime, &prstatus->pr_cstime);
1175 }
1176
1177 static void fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1178                         struct mm_struct *mm)
1179 {
1180         int i, len;
1181
1182         /* first copy the parameters from user space */
1183         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1184
1185         len = mm->arg_end - mm->arg_start;
1186         if (len >= ELF_PRARGSZ)
1187                 len = ELF_PRARGSZ-1;
1188         copy_from_user(&psinfo->pr_psargs,
1189                        (const char __user *)mm->arg_start, len);
1190         for(i = 0; i < len; i++)
1191                 if (psinfo->pr_psargs[i] == 0)
1192                         psinfo->pr_psargs[i] = ' ';
1193         psinfo->pr_psargs[len] = 0;
1194
1195         psinfo->pr_pid = p->pid;
1196         psinfo->pr_ppid = p->parent->pid;
1197         psinfo->pr_pgrp = process_group(p);
1198         psinfo->pr_sid = p->signal->session;
1199
1200         i = p->state ? ffz(~p->state) + 1 : 0;
1201         psinfo->pr_state = i;
1202         psinfo->pr_sname = (i < 0 || i > 5) ? '.' : "RSDTZW"[i];
1203         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1204         psinfo->pr_nice = task_nice(p);
1205         psinfo->pr_flag = p->flags;
1206         SET_UID(psinfo->pr_uid, p->uid);
1207         SET_GID(psinfo->pr_gid, p->gid);
1208         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1209
1210         return;
1211 }
1212
1213 /* Here is the structure in which status of each thread is captured. */
1214 struct elf_thread_status
1215 {
1216         struct list_head list;
1217         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1218         elf_fpregset_t fpu;             /* NT_PRFPREG */
1219 #ifdef ELF_CORE_COPY_XFPREGS
1220         elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
1221 #endif
1222         struct memelfnote notes[3];
1223         int num_notes;
1224 };
1225
1226 /*
1227  * In order to add the specific thread information for the elf file format,
1228  * we need to keep a linked list of every threads pr_status and then
1229  * create a single section for them in the final core file.
1230  */
1231 static int elf_dump_thread_status(long signr, struct task_struct * p, struct list_head * thread_list)
1232 {
1233
1234         struct elf_thread_status *t;
1235         int sz = 0;
1236
1237         t = kmalloc(sizeof(*t), GFP_ATOMIC);
1238         if (!t)
1239                 return 0;
1240         memset(t, 0, sizeof(*t));
1241
1242         INIT_LIST_HEAD(&t->list);
1243         t->num_notes = 0;
1244
1245         fill_prstatus(&t->prstatus, p, signr);
1246         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1247
1248         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));
1249         t->num_notes++;
1250         sz += notesize(&t->notes[0]);
1251
1252         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {
1253                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));
1254                 t->num_notes++;
1255                 sz += notesize(&t->notes[1]);
1256         }
1257
1258 #ifdef ELF_CORE_COPY_XFPREGS
1259         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1260                 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);
1261                 t->num_notes++;
1262                 sz += notesize(&t->notes[2]);
1263         }
1264 #endif
1265         list_add(&t->list, thread_list);
1266         return sz;
1267 }
1268
1269 /*
1270  * Actual dumper
1271  *
1272  * This is a two-pass process; first we find the offsets of the bits,
1273  * and then they are actually written out.  If we run out of core limit
1274  * we just truncate.
1275  */
1276 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
1277 {
1278 #define NUM_NOTES       6
1279         int has_dumped = 0;
1280         mm_segment_t fs;
1281         int segs;
1282         size_t size = 0;
1283         int i;
1284         struct vm_area_struct *vma;
1285         struct elfhdr *elf = NULL;
1286         off_t offset = 0, dataoff;
1287         unsigned long limit = current->rlim[RLIMIT_CORE].rlim_cur;
1288         int numnote;
1289         struct memelfnote *notes = NULL;
1290         struct elf_prstatus *prstatus = NULL;   /* NT_PRSTATUS */
1291         struct elf_prpsinfo *psinfo = NULL;     /* NT_PRPSINFO */
1292         struct task_struct *g, *p;
1293         LIST_HEAD(thread_list);
1294         struct list_head *t;
1295         elf_fpregset_t *fpu = NULL;
1296 #ifdef ELF_CORE_COPY_XFPREGS
1297         elf_fpxregset_t *xfpu = NULL;
1298 #endif
1299         int thread_status_size = 0;
1300         elf_addr_t *auxv;
1301
1302         /*
1303          * We no longer stop all VM operations.
1304          *
1305          * This is because those proceses that could possibly change map_count or
1306          * the mmap / vma pages are now blocked in do_exit on current finishing
1307          * this core dump.
1308          *
1309          * Only ptrace can touch these memory addresses, but it doesn't change
1310          * the map_count or the pages allocated.  So no possibility of crashing
1311          * exists while dumping the mm->vm_next areas to the core file.
1312          */
1313
1314         /* alloc memory for large data structures: too large to be on stack */
1315         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1316         if (!elf)
1317                 goto cleanup;
1318         prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1319         if (!prstatus)
1320                 goto cleanup;
1321         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1322         if (!psinfo)
1323                 goto cleanup;
1324         notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1325         if (!notes)
1326                 goto cleanup;
1327         fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1328         if (!fpu)
1329                 goto cleanup;
1330 #ifdef ELF_CORE_COPY_XFPREGS
1331         xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1332         if (!xfpu)
1333                 goto cleanup;
1334 #endif
1335
1336         /* capture the status of all other threads */
1337         if (signr) {
1338                 read_lock(&tasklist_lock);
1339                 do_each_thread(g,p)
1340                         if (current->mm == p->mm && current != p) {
1341                                 int sz = elf_dump_thread_status(signr, p, &thread_list);
1342                                 if (!sz) {
1343                                         read_unlock(&tasklist_lock);
1344                                         goto cleanup;
1345                                 } else
1346                                         thread_status_size += sz;
1347                         }
1348                 while_each_thread(g,p);
1349                 read_unlock(&tasklist_lock);
1350         }
1351
1352         /* now collect the dump for the current */
1353         memset(prstatus, 0, sizeof(*prstatus));
1354         fill_prstatus(prstatus, current, signr);
1355         elf_core_copy_regs(&prstatus->pr_reg, regs);
1356
1357         segs = current->mm->map_count;
1358 #ifdef ELF_CORE_EXTRA_PHDRS
1359         segs += ELF_CORE_EXTRA_PHDRS;
1360 #endif
1361
1362         /* Set up header */
1363         fill_elf_header(elf, segs+1);   /* including notes section */
1364
1365         has_dumped = 1;
1366         current->flags |= PF_DUMPCORE;
1367
1368         /*
1369          * Set up the notes in similar form to SVR4 core dumps made
1370          * with info from their /proc.
1371          */
1372
1373         fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1374
1375         fill_psinfo(psinfo, current->group_leader, current->mm);
1376         fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1377
1378         fill_note(notes +2, "CORE", NT_TASKSTRUCT, sizeof(*current), current);
1379
1380         numnote = 3;
1381
1382         auxv = (elf_addr_t *) current->mm->saved_auxv;
1383
1384         i = 0;
1385         do
1386                 i += 2;
1387         while (auxv[i - 2] != AT_NULL);
1388         fill_note(&notes[numnote++], "CORE", NT_AUXV,
1389                   i * sizeof (elf_addr_t), auxv);
1390
1391         /* Try to dump the FPU. */
1392         if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))
1393                 fill_note(notes + numnote++,
1394                           "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1395 #ifdef ELF_CORE_COPY_XFPREGS
1396         if (elf_core_copy_task_xfpregs(current, xfpu))
1397                 fill_note(notes + numnote++,
1398                           "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1399 #endif
1400
1401         fs = get_fs();
1402         set_fs(KERNEL_DS);
1403
1404         DUMP_WRITE(elf, sizeof(*elf));
1405         offset += sizeof(*elf);                         /* Elf header */
1406         offset += (segs+1) * sizeof(struct elf_phdr);   /* Program headers */
1407
1408         /* Write notes phdr entry */
1409         {
1410                 struct elf_phdr phdr;
1411                 int sz = 0;
1412
1413                 for (i = 0; i < numnote; i++)
1414                         sz += notesize(notes + i);
1415
1416                 sz += thread_status_size;
1417
1418                 fill_elf_note_phdr(&phdr, sz, offset);
1419                 offset += sz;
1420                 DUMP_WRITE(&phdr, sizeof(phdr));
1421         }
1422
1423         /* Page-align dumped data */
1424         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1425
1426         /* Write program headers for segments dump */
1427         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1428                 struct elf_phdr phdr;
1429                 size_t sz;
1430
1431                 sz = vma->vm_end - vma->vm_start;
1432
1433                 phdr.p_type = PT_LOAD;
1434                 phdr.p_offset = offset;
1435                 phdr.p_vaddr = vma->vm_start;
1436                 phdr.p_paddr = 0;
1437                 phdr.p_filesz = maydump(vma) ? sz : 0;
1438                 phdr.p_memsz = sz;
1439                 offset += phdr.p_filesz;
1440                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1441                 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
1442                 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
1443                 phdr.p_align = ELF_EXEC_PAGESIZE;
1444
1445                 DUMP_WRITE(&phdr, sizeof(phdr));
1446         }
1447
1448 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1449         ELF_CORE_WRITE_EXTRA_PHDRS;
1450 #endif
1451
1452         /* write out the notes section */
1453         for (i = 0; i < numnote; i++)
1454                 if (!writenote(notes + i, file))
1455                         goto end_coredump;
1456
1457         /* write out the thread status notes section */
1458         list_for_each(t, &thread_list) {
1459                 struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);
1460                 for (i = 0; i < tmp->num_notes; i++)
1461                         if (!writenote(&tmp->notes[i], file))
1462                                 goto end_coredump;
1463         }
1464
1465         DUMP_SEEK(dataoff);
1466
1467         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1468                 unsigned long addr;
1469
1470                 if (!maydump(vma))
1471                         continue;
1472
1473                 for (addr = vma->vm_start;
1474                      addr < vma->vm_end;
1475                      addr += PAGE_SIZE) {
1476                         struct page* page;
1477                         struct vm_area_struct *vma;
1478
1479                         if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1480                                                 &page, &vma) <= 0) {
1481                                 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1482                         } else {
1483                                 if (page == ZERO_PAGE(addr)) {
1484                                         DUMP_SEEK (file->f_pos + PAGE_SIZE);
1485                                 } else {
1486                                         void *kaddr;
1487                                         flush_cache_page(vma, addr);
1488                                         kaddr = kmap(page);
1489                                         if ((size += PAGE_SIZE) > limit ||
1490                                             !dump_write(file, kaddr,
1491                                             PAGE_SIZE)) {
1492                                                 kunmap(page);
1493                                                 page_cache_release(page);
1494                                                 goto end_coredump;
1495                                         }
1496                                         kunmap(page);
1497                                 }
1498                                 page_cache_release(page);
1499                         }
1500                 }
1501         }
1502
1503 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1504         ELF_CORE_WRITE_EXTRA_DATA;
1505 #endif
1506
1507         if ((off_t) file->f_pos != offset) {
1508                 /* Sanity check */
1509                 printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1510                        (off_t) file->f_pos, offset);
1511         }
1512
1513 end_coredump:
1514         set_fs(fs);
1515
1516 cleanup:
1517         while(!list_empty(&thread_list)) {
1518                 struct list_head *tmp = thread_list.next;
1519                 list_del(tmp);
1520                 kfree(list_entry(tmp, struct elf_thread_status, list));
1521         }
1522
1523         kfree(elf);
1524         kfree(prstatus);
1525         kfree(psinfo);
1526         kfree(notes);
1527         kfree(fpu);
1528 #ifdef ELF_CORE_COPY_XFPREGS
1529         kfree(xfpu);
1530 #endif
1531         return has_dumped;
1532 #undef NUM_NOTES
1533 }
1534
1535 #endif          /* USE_ELF_CORE_DUMP */
1536
1537 static int __init init_elf_binfmt(void)
1538 {
1539         return register_binfmt(&elf_format);
1540 }
1541
1542 static void __exit exit_elf_binfmt(void)
1543 {
1544         /* Remove the COFF and ELF loaders. */
1545         unregister_binfmt(&elf_format);
1546 }
1547
1548 core_initcall(init_elf_binfmt);
1549 module_exit(exit_elf_binfmt);
1550 MODULE_LICENSE("GPL");