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