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 ([email protected]).
  10  */
  11
  12 #include <linux/module.h>
  13 #include <linux/kernel.h>
  14 #include <linux/fs.h>
  15 #include <linux/mm.h>
  16 #include <linux/mman.h>
  17 #include <linux/errno.h>
  18 #include <linux/signal.h>
  19 #include <linux/binfmts.h>
  20 #include <linux/string.h>
  21 #include <linux/file.h>
  22 #include <linux/slab.h>
  23 #include <linux/personality.h>
  24 #include <linux/elfcore.h>
  25 #include <linux/init.h>
  26 #include <linux/highuid.h>
  27 #include <linux/compiler.h>
  28 #include <linux/highmem.h>
  29 #include <linux/pagemap.h>
  30 #include <linux/vmalloc.h>
  31 #include <linux/security.h>
  32 #include <linux/random.h>
  33 #include <linux/elf.h>
  34 #include <linux/elf-randomize.h>
  35 #include <linux/utsname.h>
  36 #include <linux/coredump.h>
  37 #include <linux/sched.h>
  38 #include <linux/sched/coredump.h>
  39 #include <linux/sched/task_stack.h>
  40 #include <linux/sched/cputime.h>
  41 #include <linux/cred.h>
  42 #include <linux/dax.h>
  43 #include <linux/uaccess.h>
  44 #include <asm/param.h>
  45 #include <asm/page.h>
  46
  47 #ifndef user_long_t
  48 #define user_long_t long
  49 #endif
  50 #ifndef user_siginfo_t
  51 #define user_siginfo_t siginfo_t
  52 #endif
  53
  54 /* That's for binfmt_elf_fdpic to deal with */
  55 #ifndef elf_check_fdpic
  56 #define elf_check_fdpic(ex) false
  57 #endif
  58
  59 static int load_elf_binary(struct linux_binprm *bprm);
  60 static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
  61                                 int, int, unsigned long);
  62
  63 #ifdef CONFIG_USELIB
  64 static int load_elf_library(struct file *);
  65 #else
  66 #define load_elf_library NULL
  67 #endif
  68
  69 /*
  70  * If we don't support core dumping, then supply a NULL so we
  71  * don't even try.
  72  */
  73 #ifdef CONFIG_ELF_CORE
  74 static int elf_core_dump(struct coredump_params *cprm);
  75 #else
  76 #define elf_core_dump   NULL
  77 #endif
  78
  79 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
  80 #define ELF_MIN_ALIGN   ELF_EXEC_PAGESIZE
  81 #else
  82 #define ELF_MIN_ALIGN   PAGE_SIZE
  83 #endif
  84
  85 #ifndef ELF_CORE_EFLAGS
  86 #define ELF_CORE_EFLAGS 0
  87 #endif
  88
  89 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
  90 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
  91 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
  92
  93 static struct linux_binfmt elf_format = {
  94         .module         = THIS_MODULE,
  95         .load_binary    = load_elf_binary,
  96         .load_shlib     = load_elf_library,
  97         .core_dump      = elf_core_dump,
  98         .min_coredump   = ELF_EXEC_PAGESIZE,
  99 };
 100
 101 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
 102
 103 static int set_brk(unsigned long start, unsigned long end, int prot)
 104 {
 105         start = ELF_PAGEALIGN(start);
 106         end = ELF_PAGEALIGN(end);
 107         if (end > start) {
 108                 /*
 109                  * Map the last of the bss segment.
 110                  * If the header is requesting these pages to be
 111                  * executable, honour that (ppc32 needs this).
 112                  */
 113                 int error = vm_brk_flags(start, end - start,
 114                                 prot & PROT_EXEC ? VM_EXEC : 0);
 115                 if (error)
 116                         return error;
 117         }
 118         current->mm->start_brk = current->mm->brk = end;
 119         return 0;
 120 }
 121
 122 /* We need to explicitly zero any fractional pages
 123    after the data section (i.e. bss).  This would
 124    contain the junk from the file that should not
 125    be in memory
 126  */
 127 static int padzero(unsigned long elf_bss)
 128 {
 129         unsigned long nbyte;
 130
 131         nbyte = ELF_PAGEOFFSET(elf_bss);
 132         if (nbyte) {
 133                 nbyte = ELF_MIN_ALIGN - nbyte;
 134                 if (clear_user((void __user *) elf_bss, nbyte))
 135                         return -EFAULT;
 136         }
 137         return 0;
 138 }
 139
 140 /* Let's use some macros to make this stack manipulation a little clearer */
 141 #ifdef CONFIG_STACK_GROWSUP
 142 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
 143 #define STACK_ROUND(sp, items) \
 144         ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
 145 #define STACK_ALLOC(sp, len) ({ \
 146         elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
 147         old_sp; })
 148 #else
 149 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
 150 #define STACK_ROUND(sp, items) \
 151         (((unsigned long) (sp - items)) &~ 15UL)
 152 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
 153 #endif
 154
 155 #ifndef ELF_BASE_PLATFORM
 156 /*
 157  * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
 158  * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
 159  * will be copied to the user stack in the same manner as AT_PLATFORM.
 160  */
 161 #define ELF_BASE_PLATFORM NULL
 162 #endif
 163
 164 static int
 165 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
 166                 unsigned long load_addr, unsigned long interp_load_addr)
 167 {
 168         unsigned long p = bprm->p;
 169         int argc = bprm->argc;
 170         int envc = bprm->envc;
 171         elf_addr_t __user *sp;
 172         elf_addr_t __user *u_platform;
 173         elf_addr_t __user *u_base_platform;
 174         elf_addr_t __user *u_rand_bytes;
 175         const char *k_platform = ELF_PLATFORM;
 176         const char *k_base_platform = ELF_BASE_PLATFORM;
 177         unsigned char k_rand_bytes[16];
 178         int items;
 179         elf_addr_t *elf_info;
 180         int ei_index = 0;
 181         const struct cred *cred = current_cred();
 182         struct vm_area_struct *vma;
 183
 184         /*
 185          * In some cases (e.g. Hyper-Threading), we want to avoid L1
 186          * evictions by the processes running on the same package. One
 187          * thing we can do is to shuffle the initial stack for them.
 188          */
 189
 190         p = arch_align_stack(p);
 191
 192         /*
 193          * If this architecture has a platform capability string, copy it
 194          * to userspace.  In some cases (Sparc), this info is impossible
 195          * for userspace to get any other way, in others (i386) it is
 196          * merely difficult.
 197          */
 198         u_platform = NULL;
 199         if (k_platform) {
 200                 size_t len = strlen(k_platform) + 1;
 201
 202                 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
 203                 if (__copy_to_user(u_platform, k_platform, len))
 204                         return -EFAULT;
 205         }
 206
 207         /*
 208          * If this architecture has a "base" platform capability
 209          * string, copy it to userspace.
 210          */
 211         u_base_platform = NULL;
 212         if (k_base_platform) {
 213                 size_t len = strlen(k_base_platform) + 1;
 214
 215                 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
 216                 if (__copy_to_user(u_base_platform, k_base_platform, len))
 217                         return -EFAULT;
 218         }
 219
 220         /*
 221          * Generate 16 random bytes for userspace PRNG seeding.
 222          */
 223         get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
 224         u_rand_bytes = (elf_addr_t __user *)
 225                        STACK_ALLOC(p, sizeof(k_rand_bytes));
 226         if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
 227                 return -EFAULT;
 228
 229         /* Create the ELF interpreter info */
 230         elf_info = (elf_addr_t *)current->mm->saved_auxv;
 231         /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
 232 #define NEW_AUX_ENT(id, val) \
 233         do { \
 234                 elf_info[ei_index++] = id; \
 235                 elf_info[ei_index++] = val; \
 236         } while (0)
 237
 238 #ifdef ARCH_DLINFO
 239         /*
 240          * ARCH_DLINFO must come first so PPC can do its special alignment of
 241          * AUXV.
 242          * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
 243          * ARCH_DLINFO changes
 244          */
 245         ARCH_DLINFO;
 246 #endif
 247         NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
 248         NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
 249         NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
 250         NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
 251         NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
 252         NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
 253         NEW_AUX_ENT(AT_BASE, interp_load_addr);
 254         NEW_AUX_ENT(AT_FLAGS, 0);
 255         NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
 256         NEW_AUX_ENT(AT_UID, from_kuid_munged(cred->user_ns, cred->uid));
 257         NEW_AUX_ENT(AT_EUID, from_kuid_munged(cred->user_ns, cred->euid));
 258         NEW_AUX_ENT(AT_GID, from_kgid_munged(cred->user_ns, cred->gid));
 259         NEW_AUX_ENT(AT_EGID, from_kgid_munged(cred->user_ns, cred->egid));
 260         NEW_AUX_ENT(AT_SECURE, bprm->secureexec);
 261         NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
 262 #ifdef ELF_HWCAP2
 263         NEW_AUX_ENT(AT_HWCAP2, ELF_HWCAP2);
 264 #endif
 265         NEW_AUX_ENT(AT_EXECFN, bprm->exec);
 266         if (k_platform) {
 267                 NEW_AUX_ENT(AT_PLATFORM,
 268                             (elf_addr_t)(unsigned long)u_platform);
 269         }
 270         if (k_base_platform) {
 271                 NEW_AUX_ENT(AT_BASE_PLATFORM,
 272                             (elf_addr_t)(unsigned long)u_base_platform);
 273         }
 274         if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
 275                 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
 276         }
 277 #undef NEW_AUX_ENT
 278         /* AT_NULL is zero; clear the rest too */
 279         memset(&elf_info[ei_index], 0,
 280                sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
 281
 282         /* And advance past the AT_NULL entry.  */
 283         ei_index += 2;
 284
 285         sp = STACK_ADD(p, ei_index);
 286
 287         items = (argc + 1) + (envc + 1) + 1;
 288         bprm->p = STACK_ROUND(sp, items);
 289
 290         /* Point sp at the lowest address on the stack */
 291 #ifdef CONFIG_STACK_GROWSUP
 292         sp = (elf_addr_t __user *)bprm->p - items - ei_index;
 293         bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
 294 #else
 295         sp = (elf_addr_t __user *)bprm->p;
 296 #endif
 297
 298
 299         /*
 300          * Grow the stack manually; some architectures have a limit on how
 301          * far ahead a user-space access may be in order to grow the stack.
 302          */
 303         vma = find_extend_vma(current->mm, bprm->p);
 304         if (!vma)
 305                 return -EFAULT;
 306
 307         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
 308         if (__put_user(argc, sp++))
 309                 return -EFAULT;
 310
 311         /* Populate list of argv pointers back to argv strings. */
 312         p = current->mm->arg_end = current->mm->arg_start;
 313         while (argc-- > 0) {
 314                 size_t len;
 315                 if (__put_user((elf_addr_t)p, sp++))
 316                         return -EFAULT;
 317                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
 318                 if (!len || len > MAX_ARG_STRLEN)
 319                         return -EINVAL;
 320                 p += len;
 321         }
 322         if (__put_user(0, sp++))
 323                 return -EFAULT;
 324         current->mm->arg_end = p;
 325
 326         /* Populate list of envp pointers back to envp strings. */
 327         current->mm->env_end = current->mm->env_start = p;
 328         while (envc-- > 0) {
 329                 size_t len;
 330                 if (__put_user((elf_addr_t)p, sp++))
 331                         return -EFAULT;
 332                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
 333                 if (!len || len > MAX_ARG_STRLEN)
 334                         return -EINVAL;
 335                 p += len;
 336         }
 337         if (__put_user(0, sp++))
 338                 return -EFAULT;
 339         current->mm->env_end = p;
 340
 341         /* Put the elf_info on the stack in the right place.  */
 342         if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
 343                 return -EFAULT;
 344         return 0;
 345 }
 346
 347 #ifndef elf_map
 348
 349 static unsigned long elf_map(struct file *filep, unsigned long addr,
 350                 struct elf_phdr *eppnt, int prot, int type,
 351                 unsigned long total_size)
 352 {
 353         unsigned long map_addr;
 354         unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
 355         unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
 356         addr = ELF_PAGESTART(addr);
 357         size = ELF_PAGEALIGN(size);
 358
 359         /* mmap() will return -EINVAL if given a zero size, but a
 360          * segment with zero filesize is perfectly valid */
 361         if (!size)
 362                 return addr;
 363
 364         /*
 365         * total_size is the size of the ELF (interpreter) image.
 366         * The _first_ mmap needs to know the full size, otherwise
 367         * randomization might put this image into an overlapping
 368         * position with the ELF binary image. (since size < total_size)
 369         * So we first map the 'big' image - and unmap the remainder at
 370         * the end. (which unmap is needed for ELF images with holes.)
 371         */
 372         if (total_size) {
 373                 total_size = ELF_PAGEALIGN(total_size);
 374                 map_addr = vm_mmap(filep, addr, total_size, prot, type, off);
 375                 if (!BAD_ADDR(map_addr))
 376                         vm_munmap(map_addr+size, total_size-size);
 377         } else
 378                 map_addr = vm_mmap(filep, addr, size, prot, type, off);
 379
 380         if ((type & MAP_FIXED_NOREPLACE) &&
 381             PTR_ERR((void *)map_addr) == -EEXIST)
 382                 pr_info("%d (%s): Uhuuh, elf segment at %px requested but the memory is mapped already\n",
 383                         task_pid_nr(current), current->comm, (void *)addr);
 384
 385         return(map_addr);
 386 }
 387
 388 #endif /* !elf_map */
 389
 390 static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
 391 {
 392         int i, first_idx = -1, last_idx = -1;
 393
 394         for (i = 0; i < nr; i++) {
 395                 if (cmds[i].p_type == PT_LOAD) {
 396                         last_idx = i;
 397                         if (first_idx == -1)
 398                                 first_idx = i;
 399                 }
 400         }
 401         if (first_idx == -1)
 402                 return 0;
 403
 404         return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
 405                                 ELF_PAGESTART(cmds[first_idx].p_vaddr);
 406 }
 407
 408 /**
 409  * load_elf_phdrs() - load ELF program headers
 410  * @elf_ex:   ELF header of the binary whose program headers should be loaded
 411  * @elf_file: the opened ELF binary file
 412  *
 413  * Loads ELF program headers from the binary file elf_file, which has the ELF
 414  * header pointed to by elf_ex, into a newly allocated array. The caller is
 415  * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
 416  */
 417 static struct elf_phdr *load_elf_phdrs(struct elfhdr *elf_ex,
 418                                        struct file *elf_file)
 419 {
 420         struct elf_phdr *elf_phdata = NULL;
 421         int retval, err = -1;
 422         loff_t pos = elf_ex->e_phoff;
 423         unsigned int size;
 424
 425         /*
 426          * If the size of this structure has changed, then punt, since
 427          * we will be doing the wrong thing.
 428          */
 429         if (elf_ex->e_phentsize != sizeof(struct elf_phdr))
 430                 goto out;
 431
 432         /* Sanity check the number of program headers... */
 433         /* ...and their total size. */
 434         size = sizeof(struct elf_phdr) * elf_ex->e_phnum;
 435         if (size == 0 || size > 65536 || size > ELF_MIN_ALIGN)
 436                 goto out;
 437
 438         elf_phdata = kmalloc(size, GFP_KERNEL);
 439         if (!elf_phdata)
 440                 goto out;
 441
 442         /* Read in the program headers */
 443         retval = kernel_read(elf_file, elf_phdata, size, &pos);
 444         if (retval != size) {
 445                 err = (retval < 0) ? retval : -EIO;
 446                 goto out;
 447         }
 448
 449         /* Success! */
 450         err = 0;
 451 out:
 452         if (err) {
 453                 kfree(elf_phdata);
 454                 elf_phdata = NULL;
 455         }
 456         return elf_phdata;
 457 }
 458
 459 #ifndef CONFIG_ARCH_BINFMT_ELF_STATE
 460
 461 /**
 462  * struct arch_elf_state - arch-specific ELF loading state
 463  *
 464  * This structure is used to preserve architecture specific data during
 465  * the loading of an ELF file, throughout the checking of architecture
 466  * specific ELF headers & through to the point where the ELF load is
 467  * known to be proceeding (ie. SET_PERSONALITY).
 468  *
 469  * This implementation is a dummy for architectures which require no
 470  * specific state.
 471  */
 472 struct arch_elf_state {
 473 };
 474
 475 #define INIT_ARCH_ELF_STATE {}
 476
 477 /**
 478  * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
 479  * @ehdr:       The main ELF header
 480  * @phdr:       The program header to check
 481  * @elf:        The open ELF file
 482  * @is_interp:  True if the phdr is from the interpreter of the ELF being
 483  *              loaded, else false.
 484  * @state:      Architecture-specific state preserved throughout the process
 485  *              of loading the ELF.
 486  *
 487  * Inspects the program header phdr to validate its correctness and/or
 488  * suitability for the system. Called once per ELF program header in the
 489  * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
 490  * interpreter.
 491  *
 492  * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
 493  *         with that return code.
 494  */
 495 static inline int arch_elf_pt_proc(struct elfhdr *ehdr,
 496                                    struct elf_phdr *phdr,
 497                                    struct file *elf, bool is_interp,
 498                                    struct arch_elf_state *state)
 499 {
 500         /* Dummy implementation, always proceed */
 501         return 0;
 502 }
 503
 504 /**
 505  * arch_check_elf() - check an ELF executable
 506  * @ehdr:       The main ELF header
 507  * @has_interp: True if the ELF has an interpreter, else false.
 508  * @interp_ehdr: The interpreter's ELF header
 509  * @state:      Architecture-specific state preserved throughout the process
 510  *              of loading the ELF.
 511  *
 512  * Provides a final opportunity for architecture code to reject the loading
 513  * of the ELF & cause an exec syscall to return an error. This is called after
 514  * all program headers to be checked by arch_elf_pt_proc have been.
 515  *
 516  * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
 517  *         with that return code.
 518  */
 519 static inline int arch_check_elf(struct elfhdr *ehdr, bool has_interp,
 520                                  struct elfhdr *interp_ehdr,
 521                                  struct arch_elf_state *state)
 522 {
 523         /* Dummy implementation, always proceed */
 524         return 0;
 525 }
 526
 527 #endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
 528
 529 /* This is much more generalized than the library routine read function,
 530    so we keep this separate.  Technically the library read function
 531    is only provided so that we can read a.out libraries that have
 532    an ELF header */
 533
 534 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
 535                 struct file *interpreter, unsigned long *interp_map_addr,
 536                 unsigned long no_base, struct elf_phdr *interp_elf_phdata)
 537 {
 538         struct elf_phdr *eppnt;
 539         unsigned long load_addr = 0;
 540         int load_addr_set = 0;
 541         unsigned long last_bss = 0, elf_bss = 0;
 542         int bss_prot = 0;
 543         unsigned long error = ~0UL;
 544         unsigned long total_size;
 545         int i;
 546
 547         /* First of all, some simple consistency checks */
 548         if (interp_elf_ex->e_type != ET_EXEC &&
 549             interp_elf_ex->e_type != ET_DYN)
 550                 goto out;
 551         if (!elf_check_arch(interp_elf_ex) ||
 552             elf_check_fdpic(interp_elf_ex))
 553                 goto out;
 554         if (!interpreter->f_op->mmap)
 555                 goto out;
 556
 557         total_size = total_mapping_size(interp_elf_phdata,
 558                                         interp_elf_ex->e_phnum);
 559         if (!total_size) {
 560                 error = -EINVAL;
 561                 goto out;
 562         }
 563
 564         eppnt = interp_elf_phdata;
 565         for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
 566                 if (eppnt->p_type == PT_LOAD) {
 567                         int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
 568                         int elf_prot = 0;
 569                         unsigned long vaddr = 0;
 570                         unsigned long k, map_addr;
 571
 572                         if (eppnt->p_flags & PF_R)
 573                                 elf_prot = PROT_READ;
 574                         if (eppnt->p_flags & PF_W)
 575                                 elf_prot |= PROT_WRITE;
 576                         if (eppnt->p_flags & PF_X)
 577                                 elf_prot |= PROT_EXEC;
 578                         vaddr = eppnt->p_vaddr;
 579                         if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
 580                                 elf_type |= MAP_FIXED_NOREPLACE;
 581                         else if (no_base && interp_elf_ex->e_type == ET_DYN)
 582                                 load_addr = -vaddr;
 583
 584                         map_addr = elf_map(interpreter, load_addr + vaddr,
 585                                         eppnt, elf_prot, elf_type, total_size);
 586                         total_size = 0;
 587                         if (!*interp_map_addr)
 588                                 *interp_map_addr = map_addr;
 589                         error = map_addr;
 590                         if (BAD_ADDR(map_addr))
 591                                 goto out;
 592
 593                         if (!load_addr_set &&
 594                             interp_elf_ex->e_type == ET_DYN) {
 595                                 load_addr = map_addr - ELF_PAGESTART(vaddr);
 596                                 load_addr_set = 1;
 597                         }
 598
 599                         /*
 600                          * Check to see if the section's size will overflow the
 601                          * allowed task size. Note that p_filesz must always be
 602                          * <= p_memsize so it's only necessary to check p_memsz.
 603                          */
 604                         k = load_addr + eppnt->p_vaddr;
 605                         if (BAD_ADDR(k) ||
 606                             eppnt->p_filesz > eppnt->p_memsz ||
 607                             eppnt->p_memsz > TASK_SIZE ||
 608                             TASK_SIZE - eppnt->p_memsz < k) {
 609                                 error = -ENOMEM;
 610                                 goto out;
 611                         }
 612
 613                         /*
 614                          * Find the end of the file mapping for this phdr, and
 615                          * keep track of the largest address we see for this.
 616                          */
 617                         k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
 618                         if (k > elf_bss)
 619                                 elf_bss = k;
 620
 621                         /*
 622                          * Do the same thing for the memory mapping - between
 623                          * elf_bss and last_bss is the bss section.
 624                          */
 625                         k = load_addr + eppnt->p_vaddr + eppnt->p_memsz;
 626                         if (k > last_bss) {
 627                                 last_bss = k;
 628                                 bss_prot = elf_prot;
 629                         }
 630                 }
 631         }
 632
 633         /*
 634          * Now fill out the bss section: first pad the last page from
 635          * the file up to the page boundary, and zero it from elf_bss
 636          * up to the end of the page.
 637          */
 638         if (padzero(elf_bss)) {
 639                 error = -EFAULT;
 640                 goto out;
 641         }
 642         /*
 643          * Next, align both the file and mem bss up to the page size,
 644          * since this is where elf_bss was just zeroed up to, and where
 645          * last_bss will end after the vm_brk_flags() below.
 646          */
 647         elf_bss = ELF_PAGEALIGN(elf_bss);
 648         last_bss = ELF_PAGEALIGN(last_bss);
 649         /* Finally, if there is still more bss to allocate, do it. */
 650         if (last_bss > elf_bss) {
 651                 error = vm_brk_flags(elf_bss, last_bss - elf_bss,
 652                                 bss_prot & PROT_EXEC ? VM_EXEC : 0);
 653                 if (error)
 654                         goto out;
 655         }
 656
 657         error = load_addr;
 658 out:
 659         return error;
 660 }
 661
 662 /*
 663  * These are the functions used to load ELF style executables and shared
 664  * libraries.  There is no binary dependent code anywhere else.
 665  */
 666
 667 #ifndef STACK_RND_MASK
 668 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12))     /* 8MB of VA */
 669 #endif
 670
 671 static unsigned long randomize_stack_top(unsigned long stack_top)
 672 {
 673         unsigned long random_variable = 0;
 674
 675         if (current->flags & PF_RANDOMIZE) {
 676                 random_variable = get_random_long();
 677                 random_variable &= STACK_RND_MASK;
 678                 random_variable <<= PAGE_SHIFT;
 679         }
 680 #ifdef CONFIG_STACK_GROWSUP
 681         return PAGE_ALIGN(stack_top) + random_variable;
 682 #else
 683         return PAGE_ALIGN(stack_top) - random_variable;
 684 #endif
 685 }
 686
 687 static int load_elf_binary(struct linux_binprm *bprm)
 688 {
 689         struct file *interpreter = NULL; /* to shut gcc up */
 690         unsigned long load_addr = 0, load_bias = 0;
 691         int load_addr_set = 0;
 692         char * elf_interpreter = NULL;
 693         unsigned long error;
 694         struct elf_phdr *elf_ppnt, *elf_phdata, *interp_elf_phdata = NULL;
 695         unsigned long elf_bss, elf_brk;
 696         int bss_prot = 0;
 697         int retval, i;
 698         unsigned long elf_entry;
 699         unsigned long interp_load_addr = 0;
 700         unsigned long start_code, end_code, start_data, end_data;
 701         unsigned long reloc_func_desc __maybe_unused = 0;
 702         int executable_stack = EXSTACK_DEFAULT;
 703         struct pt_regs *regs = current_pt_regs();
 704         struct {
 705                 struct elfhdr elf_ex;
 706                 struct elfhdr interp_elf_ex;
 707         } *loc;
 708         struct arch_elf_state arch_state = INIT_ARCH_ELF_STATE;
 709         loff_t pos;
 710
 711         loc = kmalloc(sizeof(*loc), GFP_KERNEL);
 712         if (!loc) {
 713                 retval = -ENOMEM;
 714                 goto out_ret;
 715         }
 716
 717         /* Get the exec-header */
 718         loc->elf_ex = *((struct elfhdr *)bprm->buf);
 719
 720         retval = -ENOEXEC;
 721         /* First of all, some simple consistency checks */
 722         if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
 723                 goto out;
 724
 725         if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
 726                 goto out;
 727         if (!elf_check_arch(&loc->elf_ex))
 728                 goto out;
 729         if (elf_check_fdpic(&loc->elf_ex))
 730                 goto out;
 731         if (!bprm->file->f_op->mmap)
 732                 goto out;
 733
 734         elf_phdata = load_elf_phdrs(&loc->elf_ex, bprm->file);
 735         if (!elf_phdata)
 736                 goto out;
 737
 738         elf_ppnt = elf_phdata;
 739         elf_bss = 0;
 740         elf_brk = 0;
 741
 742         start_code = ~0UL;
 743         end_code = 0;
 744         start_data = 0;
 745         end_data = 0;
 746
 747         for (i = 0; i < loc->elf_ex.e_phnum; i++) {
 748                 if (elf_ppnt->p_type == PT_INTERP) {
 749                         /* This is the program interpreter used for
 750                          * shared libraries - for now assume that this
 751                          * is an a.out format binary
 752                          */
 753                         retval = -ENOEXEC;
 754                         if (elf_ppnt->p_filesz > PATH_MAX ||
 755                             elf_ppnt->p_filesz < 2)
 756                                 goto out_free_ph;
 757
 758                         retval = -ENOMEM;
 759                         elf_interpreter = kmalloc(elf_ppnt->p_filesz,
 760                                                   GFP_KERNEL);
 761                         if (!elf_interpreter)
 762                                 goto out_free_ph;
 763
 764                         pos = elf_ppnt->p_offset;
 765                         retval = kernel_read(bprm->file, elf_interpreter,
 766                                              elf_ppnt->p_filesz, &pos);
 767                         if (retval != elf_ppnt->p_filesz) {
 768                                 if (retval >= 0)
 769                                         retval = -EIO;
 770                                 goto out_free_interp;
 771                         }
 772                         /* make sure path is NULL terminated */
 773                         retval = -ENOEXEC;
 774                         if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
 775                                 goto out_free_interp;
 776
 777                         interpreter = open_exec(elf_interpreter);
 778                         retval = PTR_ERR(interpreter);
 779                         if (IS_ERR(interpreter))
 780                                 goto out_free_interp;
 781
 782                         /*
 783                          * If the binary is not readable then enforce
 784                          * mm->dumpable = 0 regardless of the interpreter's
 785                          * permissions.
 786                          */
 787                         would_dump(bprm, interpreter);
 788
 789                         /* Get the exec headers */
 790                         pos = 0;
 791                         retval = kernel_read(interpreter, &loc->interp_elf_ex,
 792                                              sizeof(loc->interp_elf_ex), &pos);
 793                         if (retval != sizeof(loc->interp_elf_ex)) {
 794                                 if (retval >= 0)
 795                                         retval = -EIO;
 796                                 goto out_free_dentry;
 797                         }
 798
 799                         break;
 800                 }
 801                 elf_ppnt++;
 802         }
 803
 804         elf_ppnt = elf_phdata;
 805         for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
 806                 switch (elf_ppnt->p_type) {
 807                 case PT_GNU_STACK:
 808                         if (elf_ppnt->p_flags & PF_X)
 809                                 executable_stack = EXSTACK_ENABLE_X;
 810                         else
 811                                 executable_stack = EXSTACK_DISABLE_X;
 812                         break;
 813
 814                 case PT_LOPROC ... PT_HIPROC:
 815                         retval = arch_elf_pt_proc(&loc->elf_ex, elf_ppnt,
 816                                                   bprm->file, false,
 817                                                   &arch_state);
 818                         if (retval)
 819                                 goto out_free_dentry;
 820                         break;
 821                 }
 822
 823         /* Some simple consistency checks for the interpreter */
 824         if (elf_interpreter) {
 825                 retval = -ELIBBAD;
 826                 /* Not an ELF interpreter */
 827                 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
 828                         goto out_free_dentry;
 829                 /* Verify the interpreter has a valid arch */
 830                 if (!elf_check_arch(&loc->interp_elf_ex) ||
 831                     elf_check_fdpic(&loc->interp_elf_ex))
 832                         goto out_free_dentry;
 833
 834                 /* Load the interpreter program headers */
 835                 interp_elf_phdata = load_elf_phdrs(&loc->interp_elf_ex,
 836                                                    interpreter);
 837                 if (!interp_elf_phdata)
 838                         goto out_free_dentry;
 839
 840                 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
 841                 elf_ppnt = interp_elf_phdata;
 842                 for (i = 0; i < loc->interp_elf_ex.e_phnum; i++, elf_ppnt++)
 843                         switch (elf_ppnt->p_type) {
 844                         case PT_LOPROC ... PT_HIPROC:
 845                                 retval = arch_elf_pt_proc(&loc->interp_elf_ex,
 846                                                           elf_ppnt, interpreter,
 847                                                           true, &arch_state);
 848                                 if (retval)
 849                                         goto out_free_dentry;
 850                                 break;
 851                         }
 852         }
 853
 854         /*
 855          * Allow arch code to reject the ELF at this point, whilst it's
 856          * still possible to return an error to the code that invoked
 857          * the exec syscall.
 858          */
 859         retval = arch_check_elf(&loc->elf_ex,
 860                                 !!interpreter, &loc->interp_elf_ex,
 861                                 &arch_state);
 862         if (retval)
 863                 goto out_free_dentry;
 864
 865         /* Flush all traces of the currently running executable */
 866         retval = flush_old_exec(bprm);
 867         if (retval)
 868                 goto out_free_dentry;
 869
 870         /* Do this immediately, since STACK_TOP as used in setup_arg_pages
 871            may depend on the personality.  */
 872         SET_PERSONALITY2(loc->elf_ex, &arch_state);
 873         if (elf_read_implies_exec(loc->elf_ex, executable_stack))
 874                 current->personality |= READ_IMPLIES_EXEC;
 875
 876         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
 877                 current->flags |= PF_RANDOMIZE;
 878
 879         setup_new_exec(bprm);
 880         install_exec_creds(bprm);
 881
 882         /* Do this so that we can load the interpreter, if need be.  We will
 883            change some of these later */
 884         retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
 885                                  executable_stack);
 886         if (retval < 0)
 887                 goto out_free_dentry;
 888
 889         current->mm->start_stack = bprm->p;
 890
 891         /* Now we do a little grungy work by mmapping the ELF image into
 892            the correct location in memory. */
 893         for(i = 0, elf_ppnt = elf_phdata;
 894             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
 895                 int elf_prot = 0, elf_flags, elf_fixed = MAP_FIXED_NOREPLACE;
 896                 unsigned long k, vaddr;
 897                 unsigned long total_size = 0;
 898
 899                 if (elf_ppnt->p_type != PT_LOAD)
 900                         continue;
 901
 902                 if (unlikely (elf_brk > elf_bss)) {
 903                         unsigned long nbyte;
 904
 905                         /* There was a PT_LOAD segment with p_memsz > p_filesz
 906                            before this one. Map anonymous pages, if needed,
 907                            and clear the area.  */
 908                         retval = set_brk(elf_bss + load_bias,
 909                                          elf_brk + load_bias,
 910                                          bss_prot);
 911                         if (retval)
 912                                 goto out_free_dentry;
 913                         nbyte = ELF_PAGEOFFSET(elf_bss);
 914                         if (nbyte) {
 915                                 nbyte = ELF_MIN_ALIGN - nbyte;
 916                                 if (nbyte > elf_brk - elf_bss)
 917                                         nbyte = elf_brk - elf_bss;
 918                                 if (clear_user((void __user *)elf_bss +
 919                                                         load_bias, nbyte)) {
 920                                         /*
 921                                          * This bss-zeroing can fail if the ELF
 922                                          * file specifies odd protections. So
 923                                          * we don't check the return value
 924                                          */
 925                                 }
 926                         }
 927
 928                         /*
 929                          * Some binaries have overlapping elf segments and then
 930                          * we have to forcefully map over an existing mapping
 931                          * e.g. over this newly established brk mapping.
 932                          */
 933                         elf_fixed = MAP_FIXED;
 934                 }
 935
 936                 if (elf_ppnt->p_flags & PF_R)
 937                         elf_prot |= PROT_READ;
 938                 if (elf_ppnt->p_flags & PF_W)
 939                         elf_prot |= PROT_WRITE;
 940                 if (elf_ppnt->p_flags & PF_X)
 941                         elf_prot |= PROT_EXEC;
 942
 943                 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
 944
 945                 vaddr = elf_ppnt->p_vaddr;
 946                 /*
 947                  * If we are loading ET_EXEC or we have already performed
 948                  * the ET_DYN load_addr calculations, proceed normally.
 949                  */
 950                 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
 951                         elf_flags |= elf_fixed;
 952                 } else if (loc->elf_ex.e_type == ET_DYN) {
 953                         /*
 954                          * This logic is run once for the first LOAD Program
 955                          * Header for ET_DYN binaries to calculate the
 956                          * randomization (load_bias) for all the LOAD
 957                          * Program Headers, and to calculate the entire
 958                          * size of the ELF mapping (total_size). (Note that
 959                          * load_addr_set is set to true later once the
 960                          * initial mapping is performed.)
 961                          *
 962                          * There are effectively two types of ET_DYN
 963                          * binaries: programs (i.e. PIE: ET_DYN with INTERP)
 964                          * and loaders (ET_DYN without INTERP, since they
 965                          * _are_ the ELF interpreter). The loaders must
 966                          * be loaded away from programs since the program
 967                          * may otherwise collide with the loader (especially
 968                          * for ET_EXEC which does not have a randomized
 969                          * position). For example to handle invocations of
 970                          * "./ld.so someprog" to test out a new version of
 971                          * the loader, the subsequent program that the
 972                          * loader loads must avoid the loader itself, so
 973                          * they cannot share the same load range. Sufficient
 974                          * room for the brk must be allocated with the
 975                          * loader as well, since brk must be available with
 976                          * the loader.
 977                          *
 978                          * Therefore, programs are loaded offset from
 979                          * ELF_ET_DYN_BASE and loaders are loaded into the
 980                          * independently randomized mmap region (0 load_bias
 981                          * without MAP_FIXED).
 982                          */
 983                         if (elf_interpreter) {
 984                                 load_bias = ELF_ET_DYN_BASE;
 985                                 if (current->flags & PF_RANDOMIZE)
 986                                         load_bias += arch_mmap_rnd();
 987                                 elf_flags |= elf_fixed;
 988                         } else
 989                                 load_bias = 0;
 990
 991                         /*
 992                          * Since load_bias is used for all subsequent loading
 993                          * calculations, we must lower it by the first vaddr
 994                          * so that the remaining calculations based on the
 995                          * ELF vaddrs will be correctly offset. The result
 996                          * is then page aligned.
 997                          */
 998                         load_bias = ELF_PAGESTART(load_bias - vaddr);
 999
1000                         total_size = total_mapping_size(elf_phdata,
1001                                                         loc->elf_ex.e_phnum);
1002                         if (!total_size) {
1003                                 retval = -EINVAL;
1004                                 goto out_free_dentry;
1005                         }
1006                 }
1007
1008                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
1009                                 elf_prot, elf_flags, total_size);
1010                 if (BAD_ADDR(error)) {
1011                         retval = IS_ERR((void *)error) ?
1012                                 PTR_ERR((void*)error) : -EINVAL;
1013                         goto out_free_dentry;
1014                 }
1015
1016                 if (!load_addr_set) {
1017                         load_addr_set = 1;
1018                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
1019                         if (loc->elf_ex.e_type == ET_DYN) {
1020                                 load_bias += error -
1021                                              ELF_PAGESTART(load_bias + vaddr);
1022                                 load_addr += load_bias;
1023                                 reloc_func_desc = load_bias;
1024                         }
1025                 }
1026                 k = elf_ppnt->p_vaddr;
1027                 if (k < start_code)
1028                         start_code = k;
1029                 if (start_data < k)
1030                         start_data = k;
1031
1032                 /*
1033                  * Check to see if the section's size will overflow the
1034                  * allowed task size. Note that p_filesz must always be
1035                  * <= p_memsz so it is only necessary to check p_memsz.
1036                  */
1037                 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
1038                     elf_ppnt->p_memsz > TASK_SIZE ||
1039                     TASK_SIZE - elf_ppnt->p_memsz < k) {
1040                         /* set_brk can never work. Avoid overflows. */
1041                         retval = -EINVAL;
1042                         goto out_free_dentry;
1043                 }
1044
1045                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1046
1047                 if (k > elf_bss)
1048                         elf_bss = k;
1049                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1050                         end_code = k;
1051                 if (end_data < k)
1052                         end_data = k;
1053                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1054                 if (k > elf_brk) {
1055                         bss_prot = elf_prot;
1056                         elf_brk = k;
1057                 }
1058         }
1059
1060         loc->elf_ex.e_entry += load_bias;
1061         elf_bss += load_bias;
1062         elf_brk += load_bias;
1063         start_code += load_bias;
1064         end_code += load_bias;
1065         start_data += load_bias;
1066         end_data += load_bias;
1067
1068         /* Calling set_brk effectively mmaps the pages that we need
1069          * for the bss and break sections.  We must do this before
1070          * mapping in the interpreter, to make sure it doesn't wind
1071          * up getting placed where the bss needs to go.
1072          */
1073         retval = set_brk(elf_bss, elf_brk, bss_prot);
1074         if (retval)
1075                 goto out_free_dentry;
1076         if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
1077                 retval = -EFAULT; /* Nobody gets to see this, but.. */
1078                 goto out_free_dentry;
1079         }
1080
1081         if (elf_interpreter) {
1082                 unsigned long interp_map_addr = 0;
1083
1084                 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1085                                             interpreter,
1086                                             &interp_map_addr,
1087                                             load_bias, interp_elf_phdata);
1088                 if (!IS_ERR((void *)elf_entry)) {
1089                         /*
1090                          * load_elf_interp() returns relocation
1091                          * adjustment
1092                          */
1093                         interp_load_addr = elf_entry;
1094                         elf_entry += loc->interp_elf_ex.e_entry;
1095                 }
1096                 if (BAD_ADDR(elf_entry)) {
1097                         retval = IS_ERR((void *)elf_entry) ?
1098                                         (int)elf_entry : -EINVAL;
1099                         goto out_free_dentry;
1100                 }
1101                 reloc_func_desc = interp_load_addr;
1102
1103                 allow_write_access(interpreter);
1104                 fput(interpreter);
1105                 kfree(elf_interpreter);
1106         } else {
1107                 elf_entry = loc->elf_ex.e_entry;
1108                 if (BAD_ADDR(elf_entry)) {
1109                         retval = -EINVAL;
1110                         goto out_free_dentry;
1111                 }
1112         }
1113
1114         kfree(interp_elf_phdata);
1115         kfree(elf_phdata);
1116
1117         set_binfmt(&elf_format);
1118
1119 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1120         retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
1121         if (retval < 0)
1122                 goto out;
1123 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1124
1125         retval = create_elf_tables(bprm, &loc->elf_ex,
1126                           load_addr, interp_load_addr);
1127         if (retval < 0)
1128                 goto out;
1129         /* N.B. passed_fileno might not be initialized? */
1130         current->mm->end_code = end_code;
1131         current->mm->start_code = start_code;
1132         current->mm->start_data = start_data;
1133         current->mm->end_data = end_data;
1134         current->mm->start_stack = bprm->p;
1135
1136         if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1137                 current->mm->brk = current->mm->start_brk =
1138                         arch_randomize_brk(current->mm);
1139 #ifdef compat_brk_randomized
1140                 current->brk_randomized = 1;
1141 #endif
1142         }
1143
1144         if (current->personality & MMAP_PAGE_ZERO) {
1145                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1146                    and some applications "depend" upon this behavior.
1147                    Since we do not have the power to recompile these, we
1148                    emulate the SVr4 behavior. Sigh. */
1149                 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1150                                 MAP_FIXED | MAP_PRIVATE, 0);
1151         }
1152
1153 #ifdef ELF_PLAT_INIT
1154         /*
1155          * The ABI may specify that certain registers be set up in special
1156          * ways (on i386 %edx is the address of a DT_FINI function, for
1157          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1158          * that the e_entry field is the address of the function descriptor
1159          * for the startup routine, rather than the address of the startup
1160          * routine itself.  This macro performs whatever initialization to
1161          * the regs structure is required as well as any relocations to the
1162          * function descriptor entries when executing dynamically links apps.
1163          */
1164         ELF_PLAT_INIT(regs, reloc_func_desc);
1165 #endif
1166
1167         finalize_exec(bprm);
1168         start_thread(regs, elf_entry, bprm->p);
1169         retval = 0;
1170 out:
1171         kfree(loc);
1172 out_ret:
1173         return retval;
1174
1175         /* error cleanup */
1176 out_free_dentry:
1177         kfree(interp_elf_phdata);
1178         allow_write_access(interpreter);
1179         if (interpreter)
1180                 fput(interpreter);
1181 out_free_interp:
1182         kfree(elf_interpreter);
1183 out_free_ph:
1184         kfree(elf_phdata);
1185         goto out;
1186 }
1187
1188 #ifdef CONFIG_USELIB
1189 /* This is really simpleminded and specialized - we are loading an
1190    a.out library that is given an ELF header. */
1191 static int load_elf_library(struct file *file)
1192 {
1193         struct elf_phdr *elf_phdata;
1194         struct elf_phdr *eppnt;
1195         unsigned long elf_bss, bss, len;
1196         int retval, error, i, j;
1197         struct elfhdr elf_ex;
1198         loff_t pos = 0;
1199
1200         error = -ENOEXEC;
1201         retval = kernel_read(file, &elf_ex, sizeof(elf_ex), &pos);
1202         if (retval != sizeof(elf_ex))
1203                 goto out;
1204
1205         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1206                 goto out;
1207
1208         /* First of all, some simple consistency checks */
1209         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1210             !elf_check_arch(&elf_ex) || !file->f_op->mmap)
1211                 goto out;
1212         if (elf_check_fdpic(&elf_ex))
1213                 goto out;
1214
1215         /* Now read in all of the header information */
1216
1217         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1218         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1219
1220         error = -ENOMEM;
1221         elf_phdata = kmalloc(j, GFP_KERNEL);
1222         if (!elf_phdata)
1223                 goto out;
1224
1225         eppnt = elf_phdata;
1226         error = -ENOEXEC;
1227         pos =  elf_ex.e_phoff;
1228         retval = kernel_read(file, eppnt, j, &pos);
1229         if (retval != j)
1230                 goto out_free_ph;
1231
1232         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1233                 if ((eppnt + i)->p_type == PT_LOAD)
1234                         j++;
1235         if (j != 1)
1236                 goto out_free_ph;
1237
1238         while (eppnt->p_type != PT_LOAD)
1239                 eppnt++;
1240
1241         /* Now use mmap to map the library into memory. */
1242         error = vm_mmap(file,
1243                         ELF_PAGESTART(eppnt->p_vaddr),
1244                         (eppnt->p_filesz +
1245                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1246                         PROT_READ | PROT_WRITE | PROT_EXEC,
1247                         MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_DENYWRITE,
1248                         (eppnt->p_offset -
1249                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1250         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1251                 goto out_free_ph;
1252
1253         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1254         if (padzero(elf_bss)) {
1255                 error = -EFAULT;
1256                 goto out_free_ph;
1257         }
1258
1259         len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1260         bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
1261         if (bss > len) {
1262                 error = vm_brk(len, bss - len);
1263                 if (error)
1264                         goto out_free_ph;
1265         }
1266         error = 0;
1267
1268 out_free_ph:
1269         kfree(elf_phdata);
1270 out:
1271         return error;
1272 }
1273 #endif /* #ifdef CONFIG_USELIB */
1274
1275 #ifdef CONFIG_ELF_CORE
1276 /*
1277  * ELF core dumper
1278  *
1279  * Modelled on fs/exec.c:aout_core_dump()
1280  * Jeremy Fitzhardinge <[email protected]>
1281  */
1282
1283 /*
1284  * The purpose of always_dump_vma() is to make sure that special kernel mappings
1285  * that are useful for post-mortem analysis are included in every core dump.
1286  * In that way we ensure that the core dump is fully interpretable later
1287  * without matching up the same kernel and hardware config to see what PC values
1288  * meant. These special mappings include - vDSO, vsyscall, and other
1289  * architecture specific mappings
1290  */
1291 static bool always_dump_vma(struct vm_area_struct *vma)
1292 {
1293         /* Any vsyscall mappings? */
1294         if (vma == get_gate_vma(vma->vm_mm))
1295                 return true;
1296
1297         /*
1298          * Assume that all vmas with a .name op should always be dumped.
1299          * If this changes, a new vm_ops field can easily be added.
1300          */
1301         if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1302                 return true;
1303
1304         /*
1305          * arch_vma_name() returns non-NULL for special architecture mappings,
1306          * such as vDSO sections.
1307          */
1308         if (arch_vma_name(vma))
1309                 return true;
1310
1311         return false;
1312 }
1313
1314 /*
1315  * Decide what to dump of a segment, part, all or none.
1316  */
1317 static unsigned long vma_dump_size(struct vm_area_struct *vma,
1318                                    unsigned long mm_flags)
1319 {
1320 #define FILTER(type)    (mm_flags & (1UL << MMF_DUMP_##type))
1321
1322         /* always dump the vdso and vsyscall sections */
1323         if (always_dump_vma(vma))
1324                 goto whole;
1325
1326         if (vma->vm_flags & VM_DONTDUMP)
1327                 return 0;
1328
1329         /* support for DAX */
1330         if (vma_is_dax(vma)) {
1331                 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1332                         goto whole;
1333                 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1334                         goto whole;
1335                 return 0;
1336         }
1337
1338         /* Hugetlb memory check */
1339         if (vma->vm_flags & VM_HUGETLB) {
1340                 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1341                         goto whole;
1342                 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1343                         goto whole;
1344                 return 0;
1345         }
1346
1347         /* Do not dump I/O mapped devices or special mappings */
1348         if (vma->vm_flags & VM_IO)
1349                 return 0;
1350
1351         /* By default, dump shared memory if mapped from an anonymous file. */
1352         if (vma->vm_flags & VM_SHARED) {
1353                 if (file_inode(vma->vm_file)->i_nlink == 0 ?
1354                     FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1355                         goto whole;
1356                 return 0;
1357         }
1358
1359         /* Dump segments that have been written to.  */
1360         if (vma->anon_vma && FILTER(ANON_PRIVATE))
1361                 goto whole;
1362         if (vma->vm_file == NULL)
1363                 return 0;
1364
1365         if (FILTER(MAPPED_PRIVATE))
1366                 goto whole;
1367
1368         /*
1369          * If this looks like the beginning of a DSO or executable mapping,
1370          * check for an ELF header.  If we find one, dump the first page to
1371          * aid in determining what was mapped here.
1372          */
1373         if (FILTER(ELF_HEADERS) &&
1374             vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1375                 u32 __user *header = (u32 __user *) vma->vm_start;
1376                 u32 word;
1377                 mm_segment_t fs = get_fs();
1378                 /*
1379                  * Doing it this way gets the constant folded by GCC.
1380                  */
1381                 union {
1382                         u32 cmp;
1383                         char elfmag[SELFMAG];
1384                 } magic;
1385                 BUILD_BUG_ON(SELFMAG != sizeof word);
1386                 magic.elfmag[EI_MAG0] = ELFMAG0;
1387                 magic.elfmag[EI_MAG1] = ELFMAG1;
1388                 magic.elfmag[EI_MAG2] = ELFMAG2;
1389                 magic.elfmag[EI_MAG3] = ELFMAG3;
1390                 /*
1391                  * Switch to the user "segment" for get_user(),
1392                  * then put back what elf_core_dump() had in place.
1393                  */
1394                 set_fs(USER_DS);
1395                 if (unlikely(get_user(word, header)))
1396                         word = 0;
1397                 set_fs(fs);
1398                 if (word == magic.cmp)
1399                         return PAGE_SIZE;
1400         }
1401
1402 #undef  FILTER
1403
1404         return 0;
1405
1406 whole:
1407         return vma->vm_end - vma->vm_start;
1408 }
1409
1410 /* An ELF note in memory */
1411 struct memelfnote
1412 {
1413         const char *name;
1414         int type;
1415         unsigned int datasz;
1416         void *data;
1417 };
1418
1419 static int notesize(struct memelfnote *en)
1420 {
1421         int sz;
1422
1423         sz = sizeof(struct elf_note);
1424         sz += roundup(strlen(en->name) + 1, 4);
1425         sz += roundup(en->datasz, 4);
1426
1427         return sz;
1428 }
1429
1430 static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1431 {
1432         struct elf_note en;
1433         en.n_namesz = strlen(men->name) + 1;
1434         en.n_descsz = men->datasz;
1435         en.n_type = men->type;
1436
1437         return dump_emit(cprm, &en, sizeof(en)) &&
1438             dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1439             dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1440 }
1441
1442 static void fill_elf_header(struct elfhdr *elf, int segs,
1443                             u16 machine, u32 flags)
1444 {
1445         memset(elf, 0, sizeof(*elf));
1446
1447         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1448         elf->e_ident[EI_CLASS] = ELF_CLASS;
1449         elf->e_ident[EI_DATA] = ELF_DATA;
1450         elf->e_ident[EI_VERSION] = EV_CURRENT;
1451         elf->e_ident[EI_OSABI] = ELF_OSABI;
1452
1453         elf->e_type = ET_CORE;
1454         elf->e_machine = machine;
1455         elf->e_version = EV_CURRENT;
1456         elf->e_phoff = sizeof(struct elfhdr);
1457         elf->e_flags = flags;
1458         elf->e_ehsize = sizeof(struct elfhdr);
1459         elf->e_phentsize = sizeof(struct elf_phdr);
1460         elf->e_phnum = segs;
1461
1462         return;
1463 }
1464
1465 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1466 {
1467         phdr->p_type = PT_NOTE;
1468         phdr->p_offset = offset;
1469         phdr->p_vaddr = 0;
1470         phdr->p_paddr = 0;
1471         phdr->p_filesz = sz;
1472         phdr->p_memsz = 0;
1473         phdr->p_flags = 0;
1474         phdr->p_align = 0;
1475         return;
1476 }
1477
1478 static void fill_note(struct memelfnote *note, const char *name, int type,
1479                 unsigned int sz, void *data)
1480 {
1481         note->name = name;
1482         note->type = type;
1483         note->datasz = sz;
1484         note->data = data;
1485         return;
1486 }
1487
1488 /*
1489  * fill up all the fields in prstatus from the given task struct, except
1490  * registers which need to be filled up separately.
1491  */
1492 static void fill_prstatus(struct elf_prstatus *prstatus,
1493                 struct task_struct *p, long signr)
1494 {
1495         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1496         prstatus->pr_sigpend = p->pending.signal.sig[0];
1497         prstatus->pr_sighold = p->blocked.sig[0];
1498         rcu_read_lock();
1499         prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1500         rcu_read_unlock();
1501         prstatus->pr_pid = task_pid_vnr(p);
1502         prstatus->pr_pgrp = task_pgrp_vnr(p);
1503         prstatus->pr_sid = task_session_vnr(p);
1504         if (thread_group_leader(p)) {
1505                 struct task_cputime cputime;
1506
1507                 /*
1508                  * This is the record for the group leader.  It shows the
1509                  * group-wide total, not its individual thread total.
1510                  */
1511                 thread_group_cputime(p, &cputime);
1512                 prstatus->pr_utime = ns_to_timeval(cputime.utime);
1513                 prstatus->pr_stime = ns_to_timeval(cputime.stime);
1514         } else {
1515                 u64 utime, stime;
1516
1517                 task_cputime(p, &utime, &stime);
1518                 prstatus->pr_utime = ns_to_timeval(utime);
1519                 prstatus->pr_stime = ns_to_timeval(stime);
1520         }
1521
1522         prstatus->pr_cutime = ns_to_timeval(p->signal->cutime);
1523         prstatus->pr_cstime = ns_to_timeval(p->signal->cstime);
1524 }
1525
1526 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1527                        struct mm_struct *mm)
1528 {
1529         const struct cred *cred;
1530         unsigned int i, len;
1531
1532         /* first copy the parameters from user space */
1533         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1534
1535         len = mm->arg_end - mm->arg_start;
1536         if (len >= ELF_PRARGSZ)
1537                 len = ELF_PRARGSZ-1;
1538         if (copy_from_user(&psinfo->pr_psargs,
1539                            (const char __user *)mm->arg_start, len))
1540                 return -EFAULT;
1541         for(i = 0; i < len; i++)
1542                 if (psinfo->pr_psargs[i] == 0)
1543                         psinfo->pr_psargs[i] = ' ';
1544         psinfo->pr_psargs[len] = 0;
1545
1546         rcu_read_lock();
1547         psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1548         rcu_read_unlock();
1549         psinfo->pr_pid = task_pid_vnr(p);
1550         psinfo->pr_pgrp = task_pgrp_vnr(p);
1551         psinfo->pr_sid = task_session_vnr(p);
1552
1553         i = p->state ? ffz(~p->state) + 1 : 0;
1554         psinfo->pr_state = i;
1555         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1556         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1557         psinfo->pr_nice = task_nice(p);
1558         psinfo->pr_flag = p->flags;
1559         rcu_read_lock();
1560         cred = __task_cred(p);
1561         SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1562         SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1563         rcu_read_unlock();
1564         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1565
1566         return 0;
1567 }
1568
1569 static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1570 {
1571         elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1572         int i = 0;
1573         do
1574                 i += 2;
1575         while (auxv[i - 2] != AT_NULL);
1576         fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1577 }
1578
1579 static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1580                 const kernel_siginfo_t *siginfo)
1581 {
1582         mm_segment_t old_fs = get_fs();
1583         set_fs(KERNEL_DS);
1584         copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1585         set_fs(old_fs);
1586         fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1587 }
1588
1589 #define MAX_FILE_NOTE_SIZE (4*1024*1024)
1590 /*
1591  * Format of NT_FILE note:
1592  *
1593  * long count     -- how many files are mapped
1594  * long page_size -- units for file_ofs
1595  * array of [COUNT] elements of
1596  *   long start
1597  *   long end
1598  *   long file_ofs
1599  * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1600  */
1601 static int fill_files_note(struct memelfnote *note)
1602 {
1603         struct vm_area_struct *vma;
1604         unsigned count, size, names_ofs, remaining, n;
1605         user_long_t *data;
1606         user_long_t *start_end_ofs;
1607         char *name_base, *name_curpos;
1608
1609         /* *Estimated* file count and total data size needed */
1610         count = current->mm->map_count;
1611         if (count > UINT_MAX / 64)
1612                 return -EINVAL;
1613         size = count * 64;
1614
1615         names_ofs = (2 + 3 * count) * sizeof(data[0]);
1616  alloc:
1617         if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
1618                 return -EINVAL;
1619         size = round_up(size, PAGE_SIZE);
1620         data = kvmalloc(size, GFP_KERNEL);
1621         if (ZERO_OR_NULL_PTR(data))
1622                 return -ENOMEM;
1623
1624         start_end_ofs = data + 2;
1625         name_base = name_curpos = ((char *)data) + names_ofs;
1626         remaining = size - names_ofs;
1627         count = 0;
1628         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1629                 struct file *file;
1630                 const char *filename;
1631
1632                 file = vma->vm_file;
1633                 if (!file)
1634                         continue;
1635                 filename = file_path(file, name_curpos, remaining);
1636                 if (IS_ERR(filename)) {
1637                         if (PTR_ERR(filename) == -ENAMETOOLONG) {
1638                                 kvfree(data);
1639                                 size = size * 5 / 4;
1640                                 goto alloc;
1641                         }
1642                         continue;
1643                 }
1644
1645                 /* file_path() fills at the end, move name down */
1646                 /* n = strlen(filename) + 1: */
1647                 n = (name_curpos + remaining) - filename;
1648                 remaining = filename - name_curpos;
1649                 memmove(name_curpos, filename, n);
1650                 name_curpos += n;
1651
1652                 *start_end_ofs++ = vma->vm_start;
1653                 *start_end_ofs++ = vma->vm_end;
1654                 *start_end_ofs++ = vma->vm_pgoff;
1655                 count++;
1656         }
1657
1658         /* Now we know exact count of files, can store it */
1659         data[0] = count;
1660         data[1] = PAGE_SIZE;
1661         /*
1662          * Count usually is less than current->mm->map_count,
1663          * we need to move filenames down.
1664          */
1665         n = current->mm->map_count - count;
1666         if (n != 0) {
1667                 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1668                 memmove(name_base - shift_bytes, name_base,
1669                         name_curpos - name_base);
1670                 name_curpos -= shift_bytes;
1671         }
1672
1673         size = name_curpos - (char *)data;
1674         fill_note(note, "CORE", NT_FILE, size, data);
1675         return 0;
1676 }
1677
1678 #ifdef CORE_DUMP_USE_REGSET
1679 #include <linux/regset.h>
1680
1681 struct elf_thread_core_info {
1682         struct elf_thread_core_info *next;
1683         struct task_struct *task;
1684         struct elf_prstatus prstatus;
1685         struct memelfnote notes[0];
1686 };
1687
1688 struct elf_note_info {
1689         struct elf_thread_core_info *thread;
1690         struct memelfnote psinfo;
1691         struct memelfnote signote;
1692         struct memelfnote auxv;
1693         struct memelfnote files;
1694         user_siginfo_t csigdata;
1695         size_t size;
1696         int thread_notes;
1697 };
1698
1699 /*
1700  * When a regset has a writeback hook, we call it on each thread before
1701  * dumping user memory.  On register window machines, this makes sure the
1702  * user memory backing the register data is up to date before we read it.
1703  */
1704 static void do_thread_regset_writeback(struct task_struct *task,
1705                                        const struct user_regset *regset)
1706 {
1707         if (regset->writeback)
1708                 regset->writeback(task, regset, 1);
1709 }
1710
1711 #ifndef PRSTATUS_SIZE
1712 #define PRSTATUS_SIZE(S, R) sizeof(S)
1713 #endif
1714
1715 #ifndef SET_PR_FPVALID
1716 #define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1717 #endif
1718
1719 static int fill_thread_core_info(struct elf_thread_core_info *t,
1720                                  const struct user_regset_view *view,
1721                                  long signr, size_t *total)
1722 {
1723         unsigned int i;
1724         unsigned int regset0_size = regset_size(t->task, &view->regsets[0]);
1725
1726         /*
1727          * NT_PRSTATUS is the one special case, because the regset data
1728          * goes into the pr_reg field inside the note contents, rather
1729          * than being the whole note contents.  We fill the reset in here.
1730          * We assume that regset 0 is NT_PRSTATUS.
1731          */
1732         fill_prstatus(&t->prstatus, t->task, signr);
1733         (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset0_size,
1734                                     &t->prstatus.pr_reg, NULL);
1735
1736         fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1737                   PRSTATUS_SIZE(t->prstatus, regset0_size), &t->prstatus);
1738         *total += notesize(&t->notes[0]);
1739
1740         do_thread_regset_writeback(t->task, &view->regsets[0]);
1741
1742         /*
1743          * Each other regset might generate a note too.  For each regset
1744          * that has no core_note_type or is inactive, we leave t->notes[i]
1745          * all zero and we'll know to skip writing it later.
1746          */
1747         for (i = 1; i < view->n; ++i) {
1748                 const struct user_regset *regset = &view->regsets[i];
1749                 do_thread_regset_writeback(t->task, regset);
1750                 if (regset->core_note_type && regset->get &&
1751                     (!regset->active || regset->active(t->task, regset) > 0)) {
1752                         int ret;
1753                         size_t size = regset_size(t->task, regset);
1754                         void *data = kmalloc(size, GFP_KERNEL);
1755                         if (unlikely(!data))
1756                                 return 0;
1757                         ret = regset->get(t->task, regset,
1758                                           0, size, data, NULL);
1759                         if (unlikely(ret))
1760                                 kfree(data);
1761                         else {
1762                                 if (regset->core_note_type != NT_PRFPREG)
1763                                         fill_note(&t->notes[i], "LINUX",
1764                                                   regset->core_note_type,
1765                                                   size, data);
1766                                 else {
1767                                         SET_PR_FPVALID(&t->prstatus,
1768                                                         1, regset0_size);
1769                                         fill_note(&t->notes[i], "CORE",
1770                                                   NT_PRFPREG, size, data);
1771                                 }
1772                                 *total += notesize(&t->notes[i]);
1773                         }
1774                 }
1775         }
1776
1777         return 1;
1778 }
1779
1780 static int fill_note_info(struct elfhdr *elf, int phdrs,
1781                           struct elf_note_info *info,
1782                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
1783 {
1784         struct task_struct *dump_task = current;
1785         const struct user_regset_view *view = task_user_regset_view(dump_task);
1786         struct elf_thread_core_info *t;
1787         struct elf_prpsinfo *psinfo;
1788         struct core_thread *ct;
1789         unsigned int i;
1790
1791         info->size = 0;
1792         info->thread = NULL;
1793
1794         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1795         if (psinfo == NULL) {
1796                 info->psinfo.data = NULL; /* So we don't free this wrongly */
1797                 return 0;
1798         }
1799
1800         fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1801
1802         /*
1803          * Figure out how many notes we're going to need for each thread.
1804          */
1805         info->thread_notes = 0;
1806         for (i = 0; i < view->n; ++i)
1807                 if (view->regsets[i].core_note_type != 0)
1808                         ++info->thread_notes;
1809
1810         /*
1811          * Sanity check.  We rely on regset 0 being in NT_PRSTATUS,
1812          * since it is our one special case.
1813          */
1814         if (unlikely(info->thread_notes == 0) ||
1815             unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1816                 WARN_ON(1);
1817                 return 0;
1818         }
1819
1820         /*
1821          * Initialize the ELF file header.
1822          */
1823         fill_elf_header(elf, phdrs,
1824                         view->e_machine, view->e_flags);
1825
1826         /*
1827          * Allocate a structure for each thread.
1828          */
1829         for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1830                 t = kzalloc(offsetof(struct elf_thread_core_info,
1831                                      notes[info->thread_notes]),
1832                             GFP_KERNEL);
1833                 if (unlikely(!t))
1834                         return 0;
1835
1836                 t->task = ct->task;
1837                 if (ct->task == dump_task || !info->thread) {
1838                         t->next = info->thread;
1839                         info->thread = t;
1840                 } else {
1841                         /*
1842                          * Make sure to keep the original task at
1843                          * the head of the list.
1844                          */
1845                         t->next = info->thread->next;
1846                         info->thread->next = t;
1847                 }
1848         }
1849
1850         /*
1851          * Now fill in each thread's information.
1852          */
1853         for (t = info->thread; t != NULL; t = t->next)
1854                 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
1855                         return 0;
1856
1857         /*
1858          * Fill in the two process-wide notes.
1859          */
1860         fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1861         info->size += notesize(&info->psinfo);
1862
1863         fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1864         info->size += notesize(&info->signote);
1865
1866         fill_auxv_note(&info->auxv, current->mm);
1867         info->size += notesize(&info->auxv);
1868
1869         if (fill_files_note(&info->files) == 0)
1870                 info->size += notesize(&info->files);
1871
1872         return 1;
1873 }
1874
1875 static size_t get_note_info_size(struct elf_note_info *info)
1876 {
1877         return info->size;
1878 }
1879
1880 /*
1881  * Write all the notes for each thread.  When writing the first thread, the
1882  * process-wide notes are interleaved after the first thread-specific note.
1883  */
1884 static int write_note_info(struct elf_note_info *info,
1885                            struct coredump_params *cprm)
1886 {
1887         bool first = true;
1888         struct elf_thread_core_info *t = info->thread;
1889
1890         do {
1891                 int i;
1892
1893                 if (!writenote(&t->notes[0], cprm))
1894                         return 0;
1895
1896                 if (first && !writenote(&info->psinfo, cprm))
1897                         return 0;
1898                 if (first && !writenote(&info->signote, cprm))
1899                         return 0;
1900                 if (first && !writenote(&info->auxv, cprm))
1901                         return 0;
1902                 if (first && info->files.data &&
1903                                 !writenote(&info->files, cprm))
1904                         return 0;
1905
1906                 for (i = 1; i < info->thread_notes; ++i)
1907                         if (t->notes[i].data &&
1908                             !writenote(&t->notes[i], cprm))
1909                                 return 0;
1910
1911                 first = false;
1912                 t = t->next;
1913         } while (t);
1914
1915         return 1;
1916 }
1917
1918 static void free_note_info(struct elf_note_info *info)
1919 {
1920         struct elf_thread_core_info *threads = info->thread;
1921         while (threads) {
1922                 unsigned int i;
1923                 struct elf_thread_core_info *t = threads;
1924                 threads = t->next;
1925                 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1926                 for (i = 1; i < info->thread_notes; ++i)
1927                         kfree(t->notes[i].data);
1928                 kfree(t);
1929         }
1930         kfree(info->psinfo.data);
1931         kvfree(info->files.data);
1932 }
1933
1934 #else
1935
1936 /* Here is the structure in which status of each thread is captured. */
1937 struct elf_thread_status
1938 {
1939         struct list_head list;
1940         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1941         elf_fpregset_t fpu;             /* NT_PRFPREG */
1942         struct task_struct *thread;
1943 #ifdef ELF_CORE_COPY_XFPREGS
1944         elf_fpxregset_t xfpu;           /* ELF_CORE_XFPREG_TYPE */
1945 #endif
1946         struct memelfnote notes[3];
1947         int num_notes;
1948 };
1949
1950 /*
1951  * In order to add the specific thread information for the elf file format,
1952  * we need to keep a linked list of every threads pr_status and then create
1953  * a single section for them in the final core file.
1954  */
1955 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1956 {
1957         int sz = 0;
1958         struct task_struct *p = t->thread;
1959         t->num_notes = 0;
1960
1961         fill_prstatus(&t->prstatus, p, signr);
1962         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1963
1964         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1965                   &(t->prstatus));
1966         t->num_notes++;
1967         sz += notesize(&t->notes[0]);
1968
1969         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1970                                                                 &t->fpu))) {
1971                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1972                           &(t->fpu));
1973                 t->num_notes++;
1974                 sz += notesize(&t->notes[1]);
1975         }
1976
1977 #ifdef ELF_CORE_COPY_XFPREGS
1978         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1979                 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1980                           sizeof(t->xfpu), &t->xfpu);
1981                 t->num_notes++;
1982                 sz += notesize(&t->notes[2]);
1983         }
1984 #endif
1985         return sz;
1986 }
1987
1988 struct elf_note_info {
1989         struct memelfnote *notes;
1990         struct memelfnote *notes_files;
1991         struct elf_prstatus *prstatus;  /* NT_PRSTATUS */
1992         struct elf_prpsinfo *psinfo;    /* NT_PRPSINFO */
1993         struct list_head thread_list;
1994         elf_fpregset_t *fpu;
1995 #ifdef ELF_CORE_COPY_XFPREGS
1996         elf_fpxregset_t *xfpu;
1997 #endif
1998         user_siginfo_t csigdata;
1999         int thread_status_size;
2000         int numnote;
2001 };
2002
2003 static int elf_note_info_init(struct elf_note_info *info)
2004 {
2005         memset(info, 0, sizeof(*info));
2006         INIT_LIST_HEAD(&info->thread_list);
2007
2008         /* Allocate space for ELF notes */
2009         info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL);
2010         if (!info->notes)
2011                 return 0;
2012         info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
2013         if (!info->psinfo)
2014                 return 0;
2015         info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
2016         if (!info->prstatus)
2017                 return 0;
2018         info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
2019         if (!info->fpu)
2020                 return 0;
2021 #ifdef ELF_CORE_COPY_XFPREGS
2022         info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
2023         if (!info->xfpu)
2024                 return 0;
2025 #endif
2026         return 1;
2027 }
2028
2029 static int fill_note_info(struct elfhdr *elf, int phdrs,
2030                           struct elf_note_info *info,
2031                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
2032 {
2033         struct core_thread *ct;
2034         struct elf_thread_status *ets;
2035
2036         if (!elf_note_info_init(info))
2037                 return 0;
2038
2039         for (ct = current->mm->core_state->dumper.next;
2040                                         ct; ct = ct->next) {
2041                 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2042                 if (!ets)
2043                         return 0;
2044
2045                 ets->thread = ct->task;
2046                 list_add(&ets->list, &info->thread_list);
2047         }
2048
2049         list_for_each_entry(ets, &info->thread_list, list) {
2050                 int sz;
2051
2052                 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2053                 info->thread_status_size += sz;
2054         }
2055         /* now collect the dump for the current */
2056         memset(info->prstatus, 0, sizeof(*info->prstatus));
2057         fill_prstatus(info->prstatus, current, siginfo->si_signo);
2058         elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2059
2060         /* Set up header */
2061         fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
2062
2063         /*
2064          * Set up the notes in similar form to SVR4 core dumps made
2065          * with info from their /proc.
2066          */
2067
2068         fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2069                   sizeof(*info->prstatus), info->prstatus);
2070         fill_psinfo(info->psinfo, current->group_leader, current->mm);
2071         fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2072                   sizeof(*info->psinfo), info->psinfo);
2073
2074         fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2075         fill_auxv_note(info->notes + 3, current->mm);
2076         info->numnote = 4;
2077
2078         if (fill_files_note(info->notes + info->numnote) == 0) {
2079                 info->notes_files = info->notes + info->numnote;
2080                 info->numnote++;
2081         }
2082
2083         /* Try to dump the FPU. */
2084         info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2085                                                                info->fpu);
2086         if (info->prstatus->pr_fpvalid)
2087                 fill_note(info->notes + info->numnote++,
2088                           "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2089 #ifdef ELF_CORE_COPY_XFPREGS
2090         if (elf_core_copy_task_xfpregs(current, info->xfpu))
2091                 fill_note(info->notes + info->numnote++,
2092                           "LINUX", ELF_CORE_XFPREG_TYPE,
2093                           sizeof(*info->xfpu), info->xfpu);
2094 #endif
2095
2096         return 1;
2097 }
2098
2099 static size_t get_note_info_size(struct elf_note_info *info)
2100 {
2101         int sz = 0;
2102         int i;
2103
2104         for (i = 0; i < info->numnote; i++)
2105                 sz += notesize(info->notes + i);
2106
2107         sz += info->thread_status_size;
2108
2109         return sz;
2110 }
2111
2112 static int write_note_info(struct elf_note_info *info,
2113                            struct coredump_params *cprm)
2114 {
2115         struct elf_thread_status *ets;
2116         int i;
2117
2118         for (i = 0; i < info->numnote; i++)
2119                 if (!writenote(info->notes + i, cprm))
2120                         return 0;
2121
2122         /* write out the thread status notes section */
2123         list_for_each_entry(ets, &info->thread_list, list) {
2124                 for (i = 0; i < ets->num_notes; i++)
2125                         if (!writenote(&ets->notes[i], cprm))
2126                                 return 0;
2127         }
2128
2129         return 1;
2130 }
2131
2132 static void free_note_info(struct elf_note_info *info)
2133 {
2134         while (!list_empty(&info->thread_list)) {
2135                 struct list_head *tmp = info->thread_list.next;
2136                 list_del(tmp);
2137                 kfree(list_entry(tmp, struct elf_thread_status, list));
2138         }
2139
2140         /* Free data possibly allocated by fill_files_note(): */
2141         if (info->notes_files)
2142                 kvfree(info->notes_files->data);
2143
2144         kfree(info->prstatus);
2145         kfree(info->psinfo);
2146         kfree(info->notes);
2147         kfree(info->fpu);
2148 #ifdef ELF_CORE_COPY_XFPREGS
2149         kfree(info->xfpu);
2150 #endif
2151 }
2152
2153 #endif
2154
2155 static struct vm_area_struct *first_vma(struct task_struct *tsk,
2156                                         struct vm_area_struct *gate_vma)
2157 {
2158         struct vm_area_struct *ret = tsk->mm->mmap;
2159
2160         if (ret)
2161                 return ret;
2162         return gate_vma;
2163 }
2164 /*
2165  * Helper function for iterating across a vma list.  It ensures that the caller
2166  * will visit `gate_vma' prior to terminating the search.
2167  */
2168 static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2169                                         struct vm_area_struct *gate_vma)
2170 {
2171         struct vm_area_struct *ret;
2172
2173         ret = this_vma->vm_next;
2174         if (ret)
2175                 return ret;
2176         if (this_vma == gate_vma)
2177                 return NULL;
2178         return gate_vma;
2179 }
2180
2181 static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2182                              elf_addr_t e_shoff, int segs)
2183 {
2184         elf->e_shoff = e_shoff;
2185         elf->e_shentsize = sizeof(*shdr4extnum);
2186         elf->e_shnum = 1;
2187         elf->e_shstrndx = SHN_UNDEF;
2188
2189         memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2190
2191         shdr4extnum->sh_type = SHT_NULL;
2192         shdr4extnum->sh_size = elf->e_shnum;
2193         shdr4extnum->sh_link = elf->e_shstrndx;
2194         shdr4extnum->sh_info = segs;
2195 }
2196
2197 /*
2198  * Actual dumper
2199  *
2200  * This is a two-pass process; first we find the offsets of the bits,
2201  * and then they are actually written out.  If we run out of core limit
2202  * we just truncate.
2203  */
2204 static int elf_core_dump(struct coredump_params *cprm)
2205 {
2206         int has_dumped = 0;
2207         mm_segment_t fs;
2208         int segs, i;
2209         size_t vma_data_size = 0;
2210         struct vm_area_struct *vma, *gate_vma;
2211         struct elfhdr *elf = NULL;
2212         loff_t offset = 0, dataoff;
2213         struct elf_note_info info = { };
2214         struct elf_phdr *phdr4note = NULL;
2215         struct elf_shdr *shdr4extnum = NULL;
2216         Elf_Half e_phnum;
2217         elf_addr_t e_shoff;
2218         elf_addr_t *vma_filesz = NULL;
2219
2220         /*
2221          * We no longer stop all VM operations.
2222          *
2223          * This is because those proceses that could possibly change map_count
2224          * or the mmap / vma pages are now blocked in do_exit on current
2225          * finishing this core dump.
2226          *
2227          * Only ptrace can touch these memory addresses, but it doesn't change
2228          * the map_count or the pages allocated. So no possibility of crashing
2229          * exists while dumping the mm->vm_next areas to the core file.
2230          */
2231
2232         /* alloc memory for large data structures: too large to be on stack */
2233         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
2234         if (!elf)
2235                 goto out;
2236         /*
2237          * The number of segs are recored into ELF header as 16bit value.
2238          * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2239          */
2240         segs = current->mm->map_count;
2241         segs += elf_core_extra_phdrs();
2242
2243         gate_vma = get_gate_vma(current->mm);
2244         if (gate_vma != NULL)
2245                 segs++;
2246
2247         /* for notes section */
2248         segs++;
2249
2250         /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2251          * this, kernel supports extended numbering. Have a look at
2252          * include/linux/elf.h for further information. */
2253         e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2254
2255         /*
2256          * Collect all the non-memory information about the process for the
2257          * notes.  This also sets up the file header.
2258          */
2259         if (!fill_note_info(elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2260                 goto cleanup;
2261
2262         has_dumped = 1;
2263
2264         fs = get_fs();
2265         set_fs(KERNEL_DS);
2266
2267         offset += sizeof(*elf);                         /* Elf header */
2268         offset += segs * sizeof(struct elf_phdr);       /* Program headers */
2269
2270         /* Write notes phdr entry */
2271         {
2272                 size_t sz = get_note_info_size(&info);
2273
2274                 sz += elf_coredump_extra_notes_size();
2275
2276                 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2277                 if (!phdr4note)
2278                         goto end_coredump;
2279
2280                 fill_elf_note_phdr(phdr4note, sz, offset);
2281                 offset += sz;
2282         }
2283
2284         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2285
2286         if (segs - 1 > ULONG_MAX / sizeof(*vma_filesz))
2287                 goto end_coredump;
2288         vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2289                               GFP_KERNEL);
2290         if (ZERO_OR_NULL_PTR(vma_filesz))
2291                 goto end_coredump;
2292
2293         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2294                         vma = next_vma(vma, gate_vma)) {
2295                 unsigned long dump_size;
2296
2297                 dump_size = vma_dump_size(vma, cprm->mm_flags);
2298                 vma_filesz[i++] = dump_size;
2299                 vma_data_size += dump_size;
2300         }
2301
2302         offset += vma_data_size;
2303         offset += elf_core_extra_data_size();
2304         e_shoff = offset;
2305
2306         if (e_phnum == PN_XNUM) {
2307                 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2308                 if (!shdr4extnum)
2309                         goto end_coredump;
2310                 fill_extnum_info(elf, shdr4extnum, e_shoff, segs);
2311         }
2312
2313         offset = dataoff;
2314
2315         if (!dump_emit(cprm, elf, sizeof(*elf)))
2316                 goto end_coredump;
2317
2318         if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
2319                 goto end_coredump;
2320
2321         /* Write program headers for segments dump */
2322         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2323                         vma = next_vma(vma, gate_vma)) {
2324                 struct elf_phdr phdr;
2325
2326                 phdr.p_type = PT_LOAD;
2327                 phdr.p_offset = offset;
2328                 phdr.p_vaddr = vma->vm_start;
2329                 phdr.p_paddr = 0;
2330                 phdr.p_filesz = vma_filesz[i++];
2331                 phdr.p_memsz = vma->vm_end - vma->vm_start;
2332                 offset += phdr.p_filesz;
2333                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
2334                 if (vma->vm_flags & VM_WRITE)
2335                         phdr.p_flags |= PF_W;
2336                 if (vma->vm_flags & VM_EXEC)
2337                         phdr.p_flags |= PF_X;
2338                 phdr.p_align = ELF_EXEC_PAGESIZE;
2339
2340                 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
2341                         goto end_coredump;
2342         }
2343
2344         if (!elf_core_write_extra_phdrs(cprm, offset))
2345                 goto end_coredump;
2346
2347         /* write out the notes section */
2348         if (!write_note_info(&info, cprm))
2349                 goto end_coredump;
2350
2351         if (elf_coredump_extra_notes_write(cprm))
2352                 goto end_coredump;
2353
2354         /* Align to page */
2355         if (!dump_skip(cprm, dataoff - cprm->pos))
2356                 goto end_coredump;
2357
2358         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2359                         vma = next_vma(vma, gate_vma)) {
2360                 unsigned long addr;
2361                 unsigned long end;
2362
2363                 end = vma->vm_start + vma_filesz[i++];
2364
2365                 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2366                         struct page *page;
2367                         int stop;
2368
2369                         page = get_dump_page(addr);
2370                         if (page) {
2371                                 void *kaddr = kmap(page);
2372                                 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
2373                                 kunmap(page);
2374                                 put_page(page);
2375                         } else
2376                                 stop = !dump_skip(cprm, PAGE_SIZE);
2377                         if (stop)
2378                                 goto end_coredump;
2379                 }
2380         }
2381         dump_truncate(cprm);
2382
2383         if (!elf_core_write_extra_data(cprm))
2384                 goto end_coredump;
2385
2386         if (e_phnum == PN_XNUM) {
2387                 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
2388                         goto end_coredump;
2389         }
2390
2391 end_coredump:
2392         set_fs(fs);
2393
2394 cleanup:
2395         free_note_info(&info);
2396         kfree(shdr4extnum);
2397         kvfree(vma_filesz);
2398         kfree(phdr4note);
2399         kfree(elf);
2400 out:
2401         return has_dumped;
2402 }
2403
2404 #endif          /* CONFIG_ELF_CORE */
2405
2406 static int __init init_elf_binfmt(void)
2407 {
2408         register_binfmt(&elf_format);
2409         return 0;
2410 }
2411
2412 static void __exit exit_elf_binfmt(void)
2413 {
2414         /* Remove the COFF and ELF loaders. */
2415         unregister_binfmt(&elf_format);
2416 }
2417
2418 core_initcall(init_elf_binfmt);
2419 module_exit(exit_elf_binfmt);
2420 MODULE_LICENSE("GPL");