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