fs/binfmt_elf.c

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