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
 862         /* Do this so that we can load the interpreter, if need be.  We will
 863            change some of these later */
 864         retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
 865                                  executable_stack);
 866         if (retval < 0)
 867                 goto out_free_dentry;
 868
 869         elf_bss = 0;
 870         elf_brk = 0;
 871
 872         start_code = ~0UL;
 873         end_code = 0;
 874         start_data = 0;
 875         end_data = 0;
 876
 877         /* Now we do a little grungy work by mmapping the ELF image into
 878            the correct location in memory. */
 879         for(i = 0, elf_ppnt = elf_phdata;
 880             i < elf_ex->e_phnum; i++, elf_ppnt++) {
 881                 int elf_prot, elf_flags;
 882                 unsigned long k, vaddr;
 883                 unsigned long total_size = 0;
 884
 885                 if (elf_ppnt->p_type != PT_LOAD)
 886                         continue;
 887
 888                 if (unlikely (elf_brk > elf_bss)) {
 889                         unsigned long nbyte;
 890
 891                         /* There was a PT_LOAD segment with p_memsz > p_filesz
 892                            before this one. Map anonymous pages, if needed,
 893                            and clear the area.  */
 894                         retval = set_brk(elf_bss + load_bias,
 895                                          elf_brk + load_bias,
 896                                          bss_prot);
 897                         if (retval)
 898                                 goto out_free_dentry;
 899                         nbyte = ELF_PAGEOFFSET(elf_bss);
 900                         if (nbyte) {
 901                                 nbyte = ELF_MIN_ALIGN - nbyte;
 902                                 if (nbyte > elf_brk - elf_bss)
 903                                         nbyte = elf_brk - elf_bss;
 904                                 if (clear_user((void __user *)elf_bss +
 905                                                         load_bias, nbyte)) {
 906                                         /*
 907                                          * This bss-zeroing can fail if the ELF
 908                                          * file specifies odd protections. So
 909                                          * we don't check the return value
 910                                          */
 911                                 }
 912                         }
 913                 }
 914
 915                 elf_prot = make_prot(elf_ppnt->p_flags);
 916
 917                 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
 918
 919                 vaddr = elf_ppnt->p_vaddr;
 920                 /*
 921                  * If we are loading ET_EXEC or we have already performed
 922                  * the ET_DYN load_addr calculations, proceed normally.
 923                  */
 924                 if (elf_ex->e_type == ET_EXEC || load_addr_set) {
 925                         elf_flags |= MAP_FIXED;
 926                 } else if (elf_ex->e_type == ET_DYN) {
 927                         /*
 928                          * This logic is run once for the first LOAD Program
 929                          * Header for ET_DYN binaries to calculate the
 930                          * randomization (load_bias) for all the LOAD
 931                          * Program Headers, and to calculate the entire
 932                          * size of the ELF mapping (total_size). (Note that
 933                          * load_addr_set is set to true later once the
 934                          * initial mapping is performed.)
 935                          *
 936                          * There are effectively two types of ET_DYN
 937                          * binaries: programs (i.e. PIE: ET_DYN with INTERP)
 938                          * and loaders (ET_DYN without INTERP, since they
 939                          * _are_ the ELF interpreter). The loaders must
 940                          * be loaded away from programs since the program
 941                          * may otherwise collide with the loader (especially
 942                          * for ET_EXEC which does not have a randomized
 943                          * position). For example to handle invocations of
 944                          * "./ld.so someprog" to test out a new version of
 945                          * the loader, the subsequent program that the
 946                          * loader loads must avoid the loader itself, so
 947                          * they cannot share the same load range. Sufficient
 948                          * room for the brk must be allocated with the
 949                          * loader as well, since brk must be available with
 950                          * the loader.
 951                          *
 952                          * Therefore, programs are loaded offset from
 953                          * ELF_ET_DYN_BASE and loaders are loaded into the
 954                          * independently randomized mmap region (0 load_bias
 955                          * without MAP_FIXED).
 956                          */
 957                         if (interpreter) {
 958                                 load_bias = ELF_ET_DYN_BASE;
 959                                 if (current->flags & PF_RANDOMIZE)
 960                                         load_bias += arch_mmap_rnd();
 961                                 elf_flags |= MAP_FIXED;
 962                         } else
 963                                 load_bias = 0;
 964
 965                         /*
 966                          * Since load_bias is used for all subsequent loading
 967                          * calculations, we must lower it by the first vaddr
 968                          * so that the remaining calculations based on the
 969                          * ELF vaddrs will be correctly offset. The result
 970                          * is then page aligned.
 971                          */
 972                         load_bias = ELF_PAGESTART(load_bias - vaddr);
 973
 974                         total_size = total_mapping_size(elf_phdata,
 975                                                         elf_ex->e_phnum);
 976                         if (!total_size) {
 977                                 retval = -EINVAL;
 978                                 goto out_free_dentry;
 979                         }
 980                 }
 981
 982                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
 983                                 elf_prot, elf_flags, total_size);
 984                 if (BAD_ADDR(error)) {
 985                         retval = IS_ERR((void *)error) ?
 986                                 PTR_ERR((void*)error) : -EINVAL;
 987                         goto out_free_dentry;
 988                 }
 989
 990                 if (!load_addr_set) {
 991                         load_addr_set = 1;
 992                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
 993                         if (elf_ex->e_type == ET_DYN) {
 994                                 load_bias += error -
 995                                              ELF_PAGESTART(load_bias + vaddr);
 996                                 load_addr += load_bias;
 997                                 reloc_func_desc = load_bias;
 998                         }
 999                 }
1000                 k = elf_ppnt->p_vaddr;
1001                 if ((elf_ppnt->p_flags & PF_X) && k < start_code)
1002                         start_code = k;
1003                 if (start_data < k)
1004                         start_data = k;
1005
1006                 /*
1007                  * Check to see if the section's size will overflow the
1008                  * allowed task size. Note that p_filesz must always be
1009                  * <= p_memsz so it is only necessary to check p_memsz.
1010                  */
1011                 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
1012                     elf_ppnt->p_memsz > TASK_SIZE ||
1013                     TASK_SIZE - elf_ppnt->p_memsz < k) {
1014                         /* set_brk can never work. Avoid overflows. */
1015                         retval = -EINVAL;
1016                         goto out_free_dentry;
1017                 }
1018
1019                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
1020
1021                 if (k > elf_bss)
1022                         elf_bss = k;
1023                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
1024                         end_code = k;
1025                 if (end_data < k)
1026                         end_data = k;
1027                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
1028                 if (k > elf_brk) {
1029                         bss_prot = elf_prot;
1030                         elf_brk = k;
1031                 }
1032         }
1033
1034         e_entry = elf_ex->e_entry + load_bias;
1035         elf_bss += load_bias;
1036         elf_brk += load_bias;
1037         start_code += load_bias;
1038         end_code += load_bias;
1039         start_data += load_bias;
1040         end_data += load_bias;
1041
1042         /* Calling set_brk effectively mmaps the pages that we need
1043          * for the bss and break sections.  We must do this before
1044          * mapping in the interpreter, to make sure it doesn't wind
1045          * up getting placed where the bss needs to go.
1046          */
1047         retval = set_brk(elf_bss, elf_brk, bss_prot);
1048         if (retval)
1049                 goto out_free_dentry;
1050         if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
1051                 retval = -EFAULT; /* Nobody gets to see this, but.. */
1052                 goto out_free_dentry;
1053         }
1054
1055         if (interpreter) {
1056                 elf_entry = load_elf_interp(interp_elf_ex,
1057                                             interpreter,
1058                                             load_bias, interp_elf_phdata);
1059                 if (!IS_ERR((void *)elf_entry)) {
1060                         /*
1061                          * load_elf_interp() returns relocation
1062                          * adjustment
1063                          */
1064                         interp_load_addr = elf_entry;
1065                         elf_entry += interp_elf_ex->e_entry;
1066                 }
1067                 if (BAD_ADDR(elf_entry)) {
1068                         retval = IS_ERR((void *)elf_entry) ?
1069                                         (int)elf_entry : -EINVAL;
1070                         goto out_free_dentry;
1071                 }
1072                 reloc_func_desc = interp_load_addr;
1073
1074                 allow_write_access(interpreter);
1075                 fput(interpreter);
1076
1077                 kfree(interp_elf_ex);
1078                 kfree(interp_elf_phdata);
1079         } else {
1080                 elf_entry = e_entry;
1081                 if (BAD_ADDR(elf_entry)) {
1082                         retval = -EINVAL;
1083                         goto out_free_dentry;
1084                 }
1085         }
1086
1087         kfree(elf_phdata);
1088
1089         set_binfmt(&elf_format);
1090
1091 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1092         retval = arch_setup_additional_pages(bprm, !!interpreter);
1093         if (retval < 0)
1094                 goto out;
1095 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1096
1097         retval = create_elf_tables(bprm, elf_ex,
1098                           load_addr, interp_load_addr, e_entry);
1099         if (retval < 0)
1100                 goto out;
1101
1102         mm = current->mm;
1103         mm->end_code = end_code;
1104         mm->start_code = start_code;
1105         mm->start_data = start_data;
1106         mm->end_data = end_data;
1107         mm->start_stack = bprm->p;
1108
1109         if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1)) {
1110                 /*
1111                  * For architectures with ELF randomization, when executing
1112                  * a loader directly (i.e. no interpreter listed in ELF
1113                  * headers), move the brk area out of the mmap region
1114                  * (since it grows up, and may collide early with the stack
1115                  * growing down), and into the unused ELF_ET_DYN_BASE region.
1116                  */
1117                 if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE) &&
1118                     elf_ex->e_type == ET_DYN && !interpreter) {
1119                         mm->brk = mm->start_brk = ELF_ET_DYN_BASE;
1120                 }
1121
1122                 mm->brk = mm->start_brk = arch_randomize_brk(mm);
1123 #ifdef compat_brk_randomized
1124                 current->brk_randomized = 1;
1125 #endif
1126         }
1127
1128         if (current->personality & MMAP_PAGE_ZERO) {
1129                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
1130                    and some applications "depend" upon this behavior.
1131                    Since we do not have the power to recompile these, we
1132                    emulate the SVr4 behavior. Sigh. */
1133                 error = vm_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1134                                 MAP_FIXED | MAP_PRIVATE, 0);
1135         }
1136
1137         regs = current_pt_regs();
1138 #ifdef ELF_PLAT_INIT
1139         /*
1140          * The ABI may specify that certain registers be set up in special
1141          * ways (on i386 %edx is the address of a DT_FINI function, for
1142          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1143          * that the e_entry field is the address of the function descriptor
1144          * for the startup routine, rather than the address of the startup
1145          * routine itself.  This macro performs whatever initialization to
1146          * the regs structure is required as well as any relocations to the
1147          * function descriptor entries when executing dynamically links apps.
1148          */
1149         ELF_PLAT_INIT(regs, reloc_func_desc);
1150 #endif
1151
1152         finalize_exec(bprm);
1153         start_thread(regs, elf_entry, bprm->p);
1154         retval = 0;
1155 out:
1156         return retval;
1157
1158         /* error cleanup */
1159 out_free_dentry:
1160         kfree(interp_elf_ex);
1161         kfree(interp_elf_phdata);
1162         allow_write_access(interpreter);
1163         if (interpreter)
1164                 fput(interpreter);
1165 out_free_ph:
1166         kfree(elf_phdata);
1167         goto out;
1168 }
1169
1170 #ifdef CONFIG_USELIB
1171 /* This is really simpleminded and specialized - we are loading an
1172    a.out library that is given an ELF header. */
1173 static int load_elf_library(struct file *file)
1174 {
1175         struct elf_phdr *elf_phdata;
1176         struct elf_phdr *eppnt;
1177         unsigned long elf_bss, bss, len;
1178         int retval, error, i, j;
1179         struct elfhdr elf_ex;
1180
1181         error = -ENOEXEC;
1182         retval = elf_read(file, &elf_ex, sizeof(elf_ex), 0);
1183         if (retval < 0)
1184                 goto out;
1185
1186         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1187                 goto out;
1188
1189         /* First of all, some simple consistency checks */
1190         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1191             !elf_check_arch(&elf_ex) || !file->f_op->mmap)
1192                 goto out;
1193         if (elf_check_fdpic(&elf_ex))
1194                 goto out;
1195
1196         /* Now read in all of the header information */
1197
1198         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1199         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1200
1201         error = -ENOMEM;
1202         elf_phdata = kmalloc(j, GFP_KERNEL);
1203         if (!elf_phdata)
1204                 goto out;
1205
1206         eppnt = elf_phdata;
1207         error = -ENOEXEC;
1208         retval = elf_read(file, eppnt, j, elf_ex.e_phoff);
1209         if (retval < 0)
1210                 goto out_free_ph;
1211
1212         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1213                 if ((eppnt + i)->p_type == PT_LOAD)
1214                         j++;
1215         if (j != 1)
1216                 goto out_free_ph;
1217
1218         while (eppnt->p_type != PT_LOAD)
1219                 eppnt++;
1220
1221         /* Now use mmap to map the library into memory. */
1222         error = vm_mmap(file,
1223                         ELF_PAGESTART(eppnt->p_vaddr),
1224                         (eppnt->p_filesz +
1225                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1226                         PROT_READ | PROT_WRITE | PROT_EXEC,
1227                         MAP_FIXED_NOREPLACE | MAP_PRIVATE | MAP_DENYWRITE,
1228                         (eppnt->p_offset -
1229                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1230         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1231                 goto out_free_ph;
1232
1233         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1234         if (padzero(elf_bss)) {
1235                 error = -EFAULT;
1236                 goto out_free_ph;
1237         }
1238
1239         len = ELF_PAGEALIGN(eppnt->p_filesz + eppnt->p_vaddr);
1240         bss = ELF_PAGEALIGN(eppnt->p_memsz + eppnt->p_vaddr);
1241         if (bss > len) {
1242                 error = vm_brk(len, bss - len);
1243                 if (error)
1244                         goto out_free_ph;
1245         }
1246         error = 0;
1247
1248 out_free_ph:
1249         kfree(elf_phdata);
1250 out:
1251         return error;
1252 }
1253 #endif /* #ifdef CONFIG_USELIB */
1254
1255 #ifdef CONFIG_ELF_CORE
1256 /*
1257  * ELF core dumper
1258  *
1259  * Modelled on fs/exec.c:aout_core_dump()
1260  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1261  */
1262
1263 /*
1264  * The purpose of always_dump_vma() is to make sure that special kernel mappings
1265  * that are useful for post-mortem analysis are included in every core dump.
1266  * In that way we ensure that the core dump is fully interpretable later
1267  * without matching up the same kernel and hardware config to see what PC values
1268  * meant. These special mappings include - vDSO, vsyscall, and other
1269  * architecture specific mappings
1270  */
1271 static bool always_dump_vma(struct vm_area_struct *vma)
1272 {
1273         /* Any vsyscall mappings? */
1274         if (vma == get_gate_vma(vma->vm_mm))
1275                 return true;
1276
1277         /*
1278          * Assume that all vmas with a .name op should always be dumped.
1279          * If this changes, a new vm_ops field can easily be added.
1280          */
1281         if (vma->vm_ops && vma->vm_ops->name && vma->vm_ops->name(vma))
1282                 return true;
1283
1284         /*
1285          * arch_vma_name() returns non-NULL for special architecture mappings,
1286          * such as vDSO sections.
1287          */
1288         if (arch_vma_name(vma))
1289                 return true;
1290
1291         return false;
1292 }
1293
1294 /*
1295  * Decide what to dump of a segment, part, all or none.
1296  */
1297 static unsigned long vma_dump_size(struct vm_area_struct *vma,
1298                                    unsigned long mm_flags)
1299 {
1300 #define FILTER(type)    (mm_flags & (1UL << MMF_DUMP_##type))
1301
1302         /* always dump the vdso and vsyscall sections */
1303         if (always_dump_vma(vma))
1304                 goto whole;
1305
1306         if (vma->vm_flags & VM_DONTDUMP)
1307                 return 0;
1308
1309         /* support for DAX */
1310         if (vma_is_dax(vma)) {
1311                 if ((vma->vm_flags & VM_SHARED) && FILTER(DAX_SHARED))
1312                         goto whole;
1313                 if (!(vma->vm_flags & VM_SHARED) && FILTER(DAX_PRIVATE))
1314                         goto whole;
1315                 return 0;
1316         }
1317
1318         /* Hugetlb memory check */
1319         if (is_vm_hugetlb_page(vma)) {
1320                 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1321                         goto whole;
1322                 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1323                         goto whole;
1324                 return 0;
1325         }
1326
1327         /* Do not dump I/O mapped devices or special mappings */
1328         if (vma->vm_flags & VM_IO)
1329                 return 0;
1330
1331         /* By default, dump shared memory if mapped from an anonymous file. */
1332         if (vma->vm_flags & VM_SHARED) {
1333                 if (file_inode(vma->vm_file)->i_nlink == 0 ?
1334                     FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1335                         goto whole;
1336                 return 0;
1337         }
1338
1339         /* Dump segments that have been written to.  */
1340         if (vma->anon_vma && FILTER(ANON_PRIVATE))
1341                 goto whole;
1342         if (vma->vm_file == NULL)
1343                 return 0;
1344
1345         if (FILTER(MAPPED_PRIVATE))
1346                 goto whole;
1347
1348         /*
1349          * If this looks like the beginning of a DSO or executable mapping,
1350          * check for an ELF header.  If we find one, dump the first page to
1351          * aid in determining what was mapped here.
1352          */
1353         if (FILTER(ELF_HEADERS) &&
1354             vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1355                 u32 __user *header = (u32 __user *) vma->vm_start;
1356                 u32 word;
1357                 mm_segment_t fs = get_fs();
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                 /*
1371                  * Switch to the user "segment" for get_user(),
1372                  * then put back what elf_core_dump() had in place.
1373                  */
1374                 set_fs(USER_DS);
1375                 if (unlikely(get_user(word, header)))
1376                         word = 0;
1377                 set_fs(fs);
1378                 if (word == magic.cmp)
1379                         return PAGE_SIZE;
1380         }
1381
1382 #undef  FILTER
1383
1384         return 0;
1385
1386 whole:
1387         return vma->vm_end - vma->vm_start;
1388 }
1389
1390 /* An ELF note in memory */
1391 struct memelfnote
1392 {
1393         const char *name;
1394         int type;
1395         unsigned int datasz;
1396         void *data;
1397 };
1398
1399 static int notesize(struct memelfnote *en)
1400 {
1401         int sz;
1402
1403         sz = sizeof(struct elf_note);
1404         sz += roundup(strlen(en->name) + 1, 4);
1405         sz += roundup(en->datasz, 4);
1406
1407         return sz;
1408 }
1409
1410 static int writenote(struct memelfnote *men, struct coredump_params *cprm)
1411 {
1412         struct elf_note en;
1413         en.n_namesz = strlen(men->name) + 1;
1414         en.n_descsz = men->datasz;
1415         en.n_type = men->type;
1416
1417         return dump_emit(cprm, &en, sizeof(en)) &&
1418             dump_emit(cprm, men->name, en.n_namesz) && dump_align(cprm, 4) &&
1419             dump_emit(cprm, men->data, men->datasz) && dump_align(cprm, 4);
1420 }
1421
1422 static void fill_elf_header(struct elfhdr *elf, int segs,
1423                             u16 machine, u32 flags)
1424 {
1425         memset(elf, 0, sizeof(*elf));
1426
1427         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1428         elf->e_ident[EI_CLASS] = ELF_CLASS;
1429         elf->e_ident[EI_DATA] = ELF_DATA;
1430         elf->e_ident[EI_VERSION] = EV_CURRENT;
1431         elf->e_ident[EI_OSABI] = ELF_OSABI;
1432
1433         elf->e_type = ET_CORE;
1434         elf->e_machine = machine;
1435         elf->e_version = EV_CURRENT;
1436         elf->e_phoff = sizeof(struct elfhdr);
1437         elf->e_flags = flags;
1438         elf->e_ehsize = sizeof(struct elfhdr);
1439         elf->e_phentsize = sizeof(struct elf_phdr);
1440         elf->e_phnum = segs;
1441 }
1442
1443 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1444 {
1445         phdr->p_type = PT_NOTE;
1446         phdr->p_offset = offset;
1447         phdr->p_vaddr = 0;
1448         phdr->p_paddr = 0;
1449         phdr->p_filesz = sz;
1450         phdr->p_memsz = 0;
1451         phdr->p_flags = 0;
1452         phdr->p_align = 0;
1453 }
1454
1455 static void fill_note(struct memelfnote *note, const char *name, int type,
1456                 unsigned int sz, void *data)
1457 {
1458         note->name = name;
1459         note->type = type;
1460         note->datasz = sz;
1461         note->data = data;
1462 }
1463
1464 /*
1465  * fill up all the fields in prstatus from the given task struct, except
1466  * registers which need to be filled up separately.
1467  */
1468 static void fill_prstatus(struct elf_prstatus *prstatus,
1469                 struct task_struct *p, long signr)
1470 {
1471         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1472         prstatus->pr_sigpend = p->pending.signal.sig[0];
1473         prstatus->pr_sighold = p->blocked.sig[0];
1474         rcu_read_lock();
1475         prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1476         rcu_read_unlock();
1477         prstatus->pr_pid = task_pid_vnr(p);
1478         prstatus->pr_pgrp = task_pgrp_vnr(p);
1479         prstatus->pr_sid = task_session_vnr(p);
1480         if (thread_group_leader(p)) {
1481                 struct task_cputime cputime;
1482
1483                 /*
1484                  * This is the record for the group leader.  It shows the
1485                  * group-wide total, not its individual thread total.
1486                  */
1487                 thread_group_cputime(p, &cputime);
1488                 prstatus->pr_utime = ns_to_kernel_old_timeval(cputime.utime);
1489                 prstatus->pr_stime = ns_to_kernel_old_timeval(cputime.stime);
1490         } else {
1491                 u64 utime, stime;
1492
1493                 task_cputime(p, &utime, &stime);
1494                 prstatus->pr_utime = ns_to_kernel_old_timeval(utime);
1495                 prstatus->pr_stime = ns_to_kernel_old_timeval(stime);
1496         }
1497
1498         prstatus->pr_cutime = ns_to_kernel_old_timeval(p->signal->cutime);
1499         prstatus->pr_cstime = ns_to_kernel_old_timeval(p->signal->cstime);
1500 }
1501
1502 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1503                        struct mm_struct *mm)
1504 {
1505         const struct cred *cred;
1506         unsigned int i, len;
1507
1508         /* first copy the parameters from user space */
1509         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1510
1511         len = mm->arg_end - mm->arg_start;
1512         if (len >= ELF_PRARGSZ)
1513                 len = ELF_PRARGSZ-1;
1514         if (copy_from_user(&psinfo->pr_psargs,
1515                            (const char __user *)mm->arg_start, len))
1516                 return -EFAULT;
1517         for(i = 0; i < len; i++)
1518                 if (psinfo->pr_psargs[i] == 0)
1519                         psinfo->pr_psargs[i] = ' ';
1520         psinfo->pr_psargs[len] = 0;
1521
1522         rcu_read_lock();
1523         psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1524         rcu_read_unlock();
1525         psinfo->pr_pid = task_pid_vnr(p);
1526         psinfo->pr_pgrp = task_pgrp_vnr(p);
1527         psinfo->pr_sid = task_session_vnr(p);
1528
1529         i = p->state ? ffz(~p->state) + 1 : 0;
1530         psinfo->pr_state = i;
1531         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1532         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1533         psinfo->pr_nice = task_nice(p);
1534         psinfo->pr_flag = p->flags;
1535         rcu_read_lock();
1536         cred = __task_cred(p);
1537         SET_UID(psinfo->pr_uid, from_kuid_munged(cred->user_ns, cred->uid));
1538         SET_GID(psinfo->pr_gid, from_kgid_munged(cred->user_ns, cred->gid));
1539         rcu_read_unlock();
1540         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1541
1542         return 0;
1543 }
1544
1545 static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1546 {
1547         elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1548         int i = 0;
1549         do
1550                 i += 2;
1551         while (auxv[i - 2] != AT_NULL);
1552         fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1553 }
1554
1555 static void fill_siginfo_note(struct memelfnote *note, user_siginfo_t *csigdata,
1556                 const kernel_siginfo_t *siginfo)
1557 {
1558         mm_segment_t old_fs = get_fs();
1559         set_fs(KERNEL_DS);
1560         copy_siginfo_to_user((user_siginfo_t __user *) csigdata, siginfo);
1561         set_fs(old_fs);
1562         fill_note(note, "CORE", NT_SIGINFO, sizeof(*csigdata), csigdata);
1563 }
1564
1565 #define MAX_FILE_NOTE_SIZE (4*1024*1024)
1566 /*
1567  * Format of NT_FILE note:
1568  *
1569  * long count     -- how many files are mapped
1570  * long page_size -- units for file_ofs
1571  * array of [COUNT] elements of
1572  *   long start
1573  *   long end
1574  *   long file_ofs
1575  * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1576  */
1577 static int fill_files_note(struct memelfnote *note)
1578 {
1579         struct mm_struct *mm = current->mm;
1580         struct vm_area_struct *vma;
1581         unsigned count, size, names_ofs, remaining, n;
1582         user_long_t *data;
1583         user_long_t *start_end_ofs;
1584         char *name_base, *name_curpos;
1585
1586         /* *Estimated* file count and total data size needed */
1587         count = mm->map_count;
1588         if (count > UINT_MAX / 64)
1589                 return -EINVAL;
1590         size = count * 64;
1591
1592         names_ofs = (2 + 3 * count) * sizeof(data[0]);
1593  alloc:
1594         if (size >= MAX_FILE_NOTE_SIZE) /* paranoia check */
1595                 return -EINVAL;
1596         size = round_up(size, PAGE_SIZE);
1597         /*
1598          * "size" can be 0 here legitimately.
1599          * Let it ENOMEM and omit NT_FILE section which will be empty anyway.
1600          */
1601         data = kvmalloc(size, GFP_KERNEL);
1602         if (ZERO_OR_NULL_PTR(data))
1603                 return -ENOMEM;
1604
1605         start_end_ofs = data + 2;
1606         name_base = name_curpos = ((char *)data) + names_ofs;
1607         remaining = size - names_ofs;
1608         count = 0;
1609         for (vma = mm->mmap; vma != NULL; vma = vma->vm_next) {
1610                 struct file *file;
1611                 const char *filename;
1612
1613                 file = vma->vm_file;
1614                 if (!file)
1615                         continue;
1616                 filename = file_path(file, name_curpos, remaining);
1617                 if (IS_ERR(filename)) {
1618                         if (PTR_ERR(filename) == -ENAMETOOLONG) {
1619                                 kvfree(data);
1620                                 size = size * 5 / 4;
1621                                 goto alloc;
1622                         }
1623                         continue;
1624                 }
1625
1626                 /* file_path() fills at the end, move name down */
1627                 /* n = strlen(filename) + 1: */
1628                 n = (name_curpos + remaining) - filename;
1629                 remaining = filename - name_curpos;
1630                 memmove(name_curpos, filename, n);
1631                 name_curpos += n;
1632
1633                 *start_end_ofs++ = vma->vm_start;
1634                 *start_end_ofs++ = vma->vm_end;
1635                 *start_end_ofs++ = vma->vm_pgoff;
1636                 count++;
1637         }
1638
1639         /* Now we know exact count of files, can store it */
1640         data[0] = count;
1641         data[1] = PAGE_SIZE;
1642         /*
1643          * Count usually is less than mm->map_count,
1644          * we need to move filenames down.
1645          */
1646         n = mm->map_count - count;
1647         if (n != 0) {
1648                 unsigned shift_bytes = n * 3 * sizeof(data[0]);
1649                 memmove(name_base - shift_bytes, name_base,
1650                         name_curpos - name_base);
1651                 name_curpos -= shift_bytes;
1652         }
1653
1654         size = name_curpos - (char *)data;
1655         fill_note(note, "CORE", NT_FILE, size, data);
1656         return 0;
1657 }
1658
1659 #ifdef CORE_DUMP_USE_REGSET
1660 #include <linux/regset.h>
1661
1662 struct elf_thread_core_info {
1663         struct elf_thread_core_info *next;
1664         struct task_struct *task;
1665         struct elf_prstatus prstatus;
1666         struct memelfnote notes[0];
1667 };
1668
1669 struct elf_note_info {
1670         struct elf_thread_core_info *thread;
1671         struct memelfnote psinfo;
1672         struct memelfnote signote;
1673         struct memelfnote auxv;
1674         struct memelfnote files;
1675         user_siginfo_t csigdata;
1676         size_t size;
1677         int thread_notes;
1678 };
1679
1680 /*
1681  * When a regset has a writeback hook, we call it on each thread before
1682  * dumping user memory.  On register window machines, this makes sure the
1683  * user memory backing the register data is up to date before we read it.
1684  */
1685 static void do_thread_regset_writeback(struct task_struct *task,
1686                                        const struct user_regset *regset)
1687 {
1688         if (regset->writeback)
1689                 regset->writeback(task, regset, 1);
1690 }
1691
1692 #ifndef PRSTATUS_SIZE
1693 #define PRSTATUS_SIZE(S, R) sizeof(S)
1694 #endif
1695
1696 #ifndef SET_PR_FPVALID
1697 #define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1698 #endif
1699
1700 static int fill_thread_core_info(struct elf_thread_core_info *t,
1701                                  const struct user_regset_view *view,
1702                                  long signr, size_t *total)
1703 {
1704         unsigned int i;
1705         unsigned int regset0_size = regset_size(t->task, &view->regsets[0]);
1706
1707         /*
1708          * NT_PRSTATUS is the one special case, because the regset data
1709          * goes into the pr_reg field inside the note contents, rather
1710          * than being the whole note contents.  We fill the reset in here.
1711          * We assume that regset 0 is NT_PRSTATUS.
1712          */
1713         fill_prstatus(&t->prstatus, t->task, signr);
1714         (void) view->regsets[0].get(t->task, &view->regsets[0], 0, regset0_size,
1715                                     &t->prstatus.pr_reg, NULL);
1716
1717         fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1718                   PRSTATUS_SIZE(t->prstatus, regset0_size), &t->prstatus);
1719         *total += notesize(&t->notes[0]);
1720
1721         do_thread_regset_writeback(t->task, &view->regsets[0]);
1722
1723         /*
1724          * Each other regset might generate a note too.  For each regset
1725          * that has no core_note_type or is inactive, we leave t->notes[i]
1726          * all zero and we'll know to skip writing it later.
1727          */
1728         for (i = 1; i < view->n; ++i) {
1729                 const struct user_regset *regset = &view->regsets[i];
1730                 do_thread_regset_writeback(t->task, regset);
1731                 if (regset->core_note_type && regset->get &&
1732                     (!regset->active || regset->active(t->task, regset) > 0)) {
1733                         int ret;
1734                         size_t size = regset_size(t->task, regset);
1735                         void *data = kmalloc(size, GFP_KERNEL);
1736                         if (unlikely(!data))
1737                                 return 0;
1738                         ret = regset->get(t->task, regset,
1739                                           0, size, data, NULL);
1740                         if (unlikely(ret))
1741                                 kfree(data);
1742                         else {
1743                                 if (regset->core_note_type != NT_PRFPREG)
1744                                         fill_note(&t->notes[i], "LINUX",
1745                                                   regset->core_note_type,
1746                                                   size, data);
1747                                 else {
1748                                         SET_PR_FPVALID(&t->prstatus,
1749                                                         1, regset0_size);
1750                                         fill_note(&t->notes[i], "CORE",
1751                                                   NT_PRFPREG, size, data);
1752                                 }
1753                                 *total += notesize(&t->notes[i]);
1754                         }
1755                 }
1756         }
1757
1758         return 1;
1759 }
1760
1761 static int fill_note_info(struct elfhdr *elf, int phdrs,
1762                           struct elf_note_info *info,
1763                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
1764 {
1765         struct task_struct *dump_task = current;
1766         const struct user_regset_view *view = task_user_regset_view(dump_task);
1767         struct elf_thread_core_info *t;
1768         struct elf_prpsinfo *psinfo;
1769         struct core_thread *ct;
1770         unsigned int i;
1771
1772         info->size = 0;
1773         info->thread = NULL;
1774
1775         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1776         if (psinfo == NULL) {
1777                 info->psinfo.data = NULL; /* So we don't free this wrongly */
1778                 return 0;
1779         }
1780
1781         fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1782
1783         /*
1784          * Figure out how many notes we're going to need for each thread.
1785          */
1786         info->thread_notes = 0;
1787         for (i = 0; i < view->n; ++i)
1788                 if (view->regsets[i].core_note_type != 0)
1789                         ++info->thread_notes;
1790
1791         /*
1792          * Sanity check.  We rely on regset 0 being in NT_PRSTATUS,
1793          * since it is our one special case.
1794          */
1795         if (unlikely(info->thread_notes == 0) ||
1796             unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1797                 WARN_ON(1);
1798                 return 0;
1799         }
1800
1801         /*
1802          * Initialize the ELF file header.
1803          */
1804         fill_elf_header(elf, phdrs,
1805                         view->e_machine, view->e_flags);
1806
1807         /*
1808          * Allocate a structure for each thread.
1809          */
1810         for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1811                 t = kzalloc(offsetof(struct elf_thread_core_info,
1812                                      notes[info->thread_notes]),
1813                             GFP_KERNEL);
1814                 if (unlikely(!t))
1815                         return 0;
1816
1817                 t->task = ct->task;
1818                 if (ct->task == dump_task || !info->thread) {
1819                         t->next = info->thread;
1820                         info->thread = t;
1821                 } else {
1822                         /*
1823                          * Make sure to keep the original task at
1824                          * the head of the list.
1825                          */
1826                         t->next = info->thread->next;
1827                         info->thread->next = t;
1828                 }
1829         }
1830
1831         /*
1832          * Now fill in each thread's information.
1833          */
1834         for (t = info->thread; t != NULL; t = t->next)
1835                 if (!fill_thread_core_info(t, view, siginfo->si_signo, &info->size))
1836                         return 0;
1837
1838         /*
1839          * Fill in the two process-wide notes.
1840          */
1841         fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1842         info->size += notesize(&info->psinfo);
1843
1844         fill_siginfo_note(&info->signote, &info->csigdata, siginfo);
1845         info->size += notesize(&info->signote);
1846
1847         fill_auxv_note(&info->auxv, current->mm);
1848         info->size += notesize(&info->auxv);
1849
1850         if (fill_files_note(&info->files) == 0)
1851                 info->size += notesize(&info->files);
1852
1853         return 1;
1854 }
1855
1856 static size_t get_note_info_size(struct elf_note_info *info)
1857 {
1858         return info->size;
1859 }
1860
1861 /*
1862  * Write all the notes for each thread.  When writing the first thread, the
1863  * process-wide notes are interleaved after the first thread-specific note.
1864  */
1865 static int write_note_info(struct elf_note_info *info,
1866                            struct coredump_params *cprm)
1867 {
1868         bool first = true;
1869         struct elf_thread_core_info *t = info->thread;
1870
1871         do {
1872                 int i;
1873
1874                 if (!writenote(&t->notes[0], cprm))
1875                         return 0;
1876
1877                 if (first && !writenote(&info->psinfo, cprm))
1878                         return 0;
1879                 if (first && !writenote(&info->signote, cprm))
1880                         return 0;
1881                 if (first && !writenote(&info->auxv, cprm))
1882                         return 0;
1883                 if (first && info->files.data &&
1884                                 !writenote(&info->files, cprm))
1885                         return 0;
1886
1887                 for (i = 1; i < info->thread_notes; ++i)
1888                         if (t->notes[i].data &&
1889                             !writenote(&t->notes[i], cprm))
1890                                 return 0;
1891
1892                 first = false;
1893                 t = t->next;
1894         } while (t);
1895
1896         return 1;
1897 }
1898
1899 static void free_note_info(struct elf_note_info *info)
1900 {
1901         struct elf_thread_core_info *threads = info->thread;
1902         while (threads) {
1903                 unsigned int i;
1904                 struct elf_thread_core_info *t = threads;
1905                 threads = t->next;
1906                 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1907                 for (i = 1; i < info->thread_notes; ++i)
1908                         kfree(t->notes[i].data);
1909                 kfree(t);
1910         }
1911         kfree(info->psinfo.data);
1912         kvfree(info->files.data);
1913 }
1914
1915 #else
1916
1917 /* Here is the structure in which status of each thread is captured. */
1918 struct elf_thread_status
1919 {
1920         struct list_head list;
1921         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1922         elf_fpregset_t fpu;             /* NT_PRFPREG */
1923         struct task_struct *thread;
1924 #ifdef ELF_CORE_COPY_XFPREGS
1925         elf_fpxregset_t xfpu;           /* ELF_CORE_XFPREG_TYPE */
1926 #endif
1927         struct memelfnote notes[3];
1928         int num_notes;
1929 };
1930
1931 /*
1932  * In order to add the specific thread information for the elf file format,
1933  * we need to keep a linked list of every threads pr_status and then create
1934  * a single section for them in the final core file.
1935  */
1936 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1937 {
1938         int sz = 0;
1939         struct task_struct *p = t->thread;
1940         t->num_notes = 0;
1941
1942         fill_prstatus(&t->prstatus, p, signr);
1943         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1944
1945         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1946                   &(t->prstatus));
1947         t->num_notes++;
1948         sz += notesize(&t->notes[0]);
1949
1950         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1951                                                                 &t->fpu))) {
1952                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1953                           &(t->fpu));
1954                 t->num_notes++;
1955                 sz += notesize(&t->notes[1]);
1956         }
1957
1958 #ifdef ELF_CORE_COPY_XFPREGS
1959         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1960                 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1961                           sizeof(t->xfpu), &t->xfpu);
1962                 t->num_notes++;
1963                 sz += notesize(&t->notes[2]);
1964         }
1965 #endif
1966         return sz;
1967 }
1968
1969 struct elf_note_info {
1970         struct memelfnote *notes;
1971         struct memelfnote *notes_files;
1972         struct elf_prstatus *prstatus;  /* NT_PRSTATUS */
1973         struct elf_prpsinfo *psinfo;    /* NT_PRPSINFO */
1974         struct list_head thread_list;
1975         elf_fpregset_t *fpu;
1976 #ifdef ELF_CORE_COPY_XFPREGS
1977         elf_fpxregset_t *xfpu;
1978 #endif
1979         user_siginfo_t csigdata;
1980         int thread_status_size;
1981         int numnote;
1982 };
1983
1984 static int elf_note_info_init(struct elf_note_info *info)
1985 {
1986         memset(info, 0, sizeof(*info));
1987         INIT_LIST_HEAD(&info->thread_list);
1988
1989         /* Allocate space for ELF notes */
1990         info->notes = kmalloc_array(8, sizeof(struct memelfnote), GFP_KERNEL);
1991         if (!info->notes)
1992                 return 0;
1993         info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1994         if (!info->psinfo)
1995                 return 0;
1996         info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1997         if (!info->prstatus)
1998                 return 0;
1999         info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
2000         if (!info->fpu)
2001                 return 0;
2002 #ifdef ELF_CORE_COPY_XFPREGS
2003         info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
2004         if (!info->xfpu)
2005                 return 0;
2006 #endif
2007         return 1;
2008 }
2009
2010 static int fill_note_info(struct elfhdr *elf, int phdrs,
2011                           struct elf_note_info *info,
2012                           const kernel_siginfo_t *siginfo, struct pt_regs *regs)
2013 {
2014         struct core_thread *ct;
2015         struct elf_thread_status *ets;
2016
2017         if (!elf_note_info_init(info))
2018                 return 0;
2019
2020         for (ct = current->mm->core_state->dumper.next;
2021                                         ct; ct = ct->next) {
2022                 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
2023                 if (!ets)
2024                         return 0;
2025
2026                 ets->thread = ct->task;
2027                 list_add(&ets->list, &info->thread_list);
2028         }
2029
2030         list_for_each_entry(ets, &info->thread_list, list) {
2031                 int sz;
2032
2033                 sz = elf_dump_thread_status(siginfo->si_signo, ets);
2034                 info->thread_status_size += sz;
2035         }
2036         /* now collect the dump for the current */
2037         memset(info->prstatus, 0, sizeof(*info->prstatus));
2038         fill_prstatus(info->prstatus, current, siginfo->si_signo);
2039         elf_core_copy_regs(&info->prstatus->pr_reg, regs);
2040
2041         /* Set up header */
2042         fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS);
2043
2044         /*
2045          * Set up the notes in similar form to SVR4 core dumps made
2046          * with info from their /proc.
2047          */
2048
2049         fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
2050                   sizeof(*info->prstatus), info->prstatus);
2051         fill_psinfo(info->psinfo, current->group_leader, current->mm);
2052         fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
2053                   sizeof(*info->psinfo), info->psinfo);
2054
2055         fill_siginfo_note(info->notes + 2, &info->csigdata, siginfo);
2056         fill_auxv_note(info->notes + 3, current->mm);
2057         info->numnote = 4;
2058
2059         if (fill_files_note(info->notes + info->numnote) == 0) {
2060                 info->notes_files = info->notes + info->numnote;
2061                 info->numnote++;
2062         }
2063
2064         /* Try to dump the FPU. */
2065         info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
2066                                                                info->fpu);
2067         if (info->prstatus->pr_fpvalid)
2068                 fill_note(info->notes + info->numnote++,
2069                           "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
2070 #ifdef ELF_CORE_COPY_XFPREGS
2071         if (elf_core_copy_task_xfpregs(current, info->xfpu))
2072                 fill_note(info->notes + info->numnote++,
2073                           "LINUX", ELF_CORE_XFPREG_TYPE,
2074                           sizeof(*info->xfpu), info->xfpu);
2075 #endif
2076
2077         return 1;
2078 }
2079
2080 static size_t get_note_info_size(struct elf_note_info *info)
2081 {
2082         int sz = 0;
2083         int i;
2084
2085         for (i = 0; i < info->numnote; i++)
2086                 sz += notesize(info->notes + i);
2087
2088         sz += info->thread_status_size;
2089
2090         return sz;
2091 }
2092
2093 static int write_note_info(struct elf_note_info *info,
2094                            struct coredump_params *cprm)
2095 {
2096         struct elf_thread_status *ets;
2097         int i;
2098
2099         for (i = 0; i < info->numnote; i++)
2100                 if (!writenote(info->notes + i, cprm))
2101                         return 0;
2102
2103         /* write out the thread status notes section */
2104         list_for_each_entry(ets, &info->thread_list, list) {
2105                 for (i = 0; i < ets->num_notes; i++)
2106                         if (!writenote(&ets->notes[i], cprm))
2107                                 return 0;
2108         }
2109
2110         return 1;
2111 }
2112
2113 static void free_note_info(struct elf_note_info *info)
2114 {
2115         while (!list_empty(&info->thread_list)) {
2116                 struct list_head *tmp = info->thread_list.next;
2117                 list_del(tmp);
2118                 kfree(list_entry(tmp, struct elf_thread_status, list));
2119         }
2120
2121         /* Free data possibly allocated by fill_files_note(): */
2122         if (info->notes_files)
2123                 kvfree(info->notes_files->data);
2124
2125         kfree(info->prstatus);
2126         kfree(info->psinfo);
2127         kfree(info->notes);
2128         kfree(info->fpu);
2129 #ifdef ELF_CORE_COPY_XFPREGS
2130         kfree(info->xfpu);
2131 #endif
2132 }
2133
2134 #endif
2135
2136 static struct vm_area_struct *first_vma(struct task_struct *tsk,
2137                                         struct vm_area_struct *gate_vma)
2138 {
2139         struct vm_area_struct *ret = tsk->mm->mmap;
2140
2141         if (ret)
2142                 return ret;
2143         return gate_vma;
2144 }
2145 /*
2146  * Helper function for iterating across a vma list.  It ensures that the caller
2147  * will visit `gate_vma' prior to terminating the search.
2148  */
2149 static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
2150                                         struct vm_area_struct *gate_vma)
2151 {
2152         struct vm_area_struct *ret;
2153
2154         ret = this_vma->vm_next;
2155         if (ret)
2156                 return ret;
2157         if (this_vma == gate_vma)
2158                 return NULL;
2159         return gate_vma;
2160 }
2161
2162 static void fill_extnum_info(struct elfhdr *elf, struct elf_shdr *shdr4extnum,
2163                              elf_addr_t e_shoff, int segs)
2164 {
2165         elf->e_shoff = e_shoff;
2166         elf->e_shentsize = sizeof(*shdr4extnum);
2167         elf->e_shnum = 1;
2168         elf->e_shstrndx = SHN_UNDEF;
2169
2170         memset(shdr4extnum, 0, sizeof(*shdr4extnum));
2171
2172         shdr4extnum->sh_type = SHT_NULL;
2173         shdr4extnum->sh_size = elf->e_shnum;
2174         shdr4extnum->sh_link = elf->e_shstrndx;
2175         shdr4extnum->sh_info = segs;
2176 }
2177
2178 /*
2179  * Actual dumper
2180  *
2181  * This is a two-pass process; first we find the offsets of the bits,
2182  * and then they are actually written out.  If we run out of core limit
2183  * we just truncate.
2184  */
2185 static int elf_core_dump(struct coredump_params *cprm)
2186 {
2187         int has_dumped = 0;
2188         mm_segment_t fs;
2189         int segs, i;
2190         size_t vma_data_size = 0;
2191         struct vm_area_struct *vma, *gate_vma;
2192         struct elfhdr elf;
2193         loff_t offset = 0, dataoff;
2194         struct elf_note_info info = { };
2195         struct elf_phdr *phdr4note = NULL;
2196         struct elf_shdr *shdr4extnum = NULL;
2197         Elf_Half e_phnum;
2198         elf_addr_t e_shoff;
2199         elf_addr_t *vma_filesz = NULL;
2200
2201         /*
2202          * We no longer stop all VM operations.
2203          *
2204          * This is because those proceses that could possibly change map_count
2205          * or the mmap / vma pages are now blocked in do_exit on current
2206          * finishing this core dump.
2207          *
2208          * Only ptrace can touch these memory addresses, but it doesn't change
2209          * the map_count or the pages allocated. So no possibility of crashing
2210          * exists while dumping the mm->vm_next areas to the core file.
2211          */
2212
2213         /*
2214          * The number of segs are recored into ELF header as 16bit value.
2215          * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2216          */
2217         segs = current->mm->map_count;
2218         segs += elf_core_extra_phdrs();
2219
2220         gate_vma = get_gate_vma(current->mm);
2221         if (gate_vma != NULL)
2222                 segs++;
2223
2224         /* for notes section */
2225         segs++;
2226
2227         /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2228          * this, kernel supports extended numbering. Have a look at
2229          * include/linux/elf.h for further information. */
2230         e_phnum = segs > PN_XNUM ? PN_XNUM : segs;
2231
2232         /*
2233          * Collect all the non-memory information about the process for the
2234          * notes.  This also sets up the file header.
2235          */
2236         if (!fill_note_info(&elf, e_phnum, &info, cprm->siginfo, cprm->regs))
2237                 goto cleanup;
2238
2239         has_dumped = 1;
2240
2241         fs = get_fs();
2242         set_fs(KERNEL_DS);
2243
2244         offset += sizeof(elf);                          /* Elf header */
2245         offset += segs * sizeof(struct elf_phdr);       /* Program headers */
2246
2247         /* Write notes phdr entry */
2248         {
2249                 size_t sz = get_note_info_size(&info);
2250
2251                 sz += elf_coredump_extra_notes_size();
2252
2253                 phdr4note = kmalloc(sizeof(*phdr4note), GFP_KERNEL);
2254                 if (!phdr4note)
2255                         goto end_coredump;
2256
2257                 fill_elf_note_phdr(phdr4note, sz, offset);
2258                 offset += sz;
2259         }
2260
2261         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
2262
2263         /*
2264          * Zero vma process will get ZERO_SIZE_PTR here.
2265          * Let coredump continue for register state at least.
2266          */
2267         vma_filesz = kvmalloc(array_size(sizeof(*vma_filesz), (segs - 1)),
2268                               GFP_KERNEL);
2269         if (!vma_filesz)
2270                 goto end_coredump;
2271
2272         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2273                         vma = next_vma(vma, gate_vma)) {
2274                 unsigned long dump_size;
2275
2276                 dump_size = vma_dump_size(vma, cprm->mm_flags);
2277                 vma_filesz[i++] = dump_size;
2278                 vma_data_size += dump_size;
2279         }
2280
2281         offset += vma_data_size;
2282         offset += elf_core_extra_data_size();
2283         e_shoff = offset;
2284
2285         if (e_phnum == PN_XNUM) {
2286                 shdr4extnum = kmalloc(sizeof(*shdr4extnum), GFP_KERNEL);
2287                 if (!shdr4extnum)
2288                         goto end_coredump;
2289                 fill_extnum_info(&elf, shdr4extnum, e_shoff, segs);
2290         }
2291
2292         offset = dataoff;
2293
2294         if (!dump_emit(cprm, &elf, sizeof(elf)))
2295                 goto end_coredump;
2296
2297         if (!dump_emit(cprm, phdr4note, sizeof(*phdr4note)))
2298                 goto end_coredump;
2299
2300         /* Write program headers for segments dump */
2301         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2302                         vma = next_vma(vma, gate_vma)) {
2303                 struct elf_phdr phdr;
2304
2305                 phdr.p_type = PT_LOAD;
2306                 phdr.p_offset = offset;
2307                 phdr.p_vaddr = vma->vm_start;
2308                 phdr.p_paddr = 0;
2309                 phdr.p_filesz = vma_filesz[i++];
2310                 phdr.p_memsz = vma->vm_end - vma->vm_start;
2311                 offset += phdr.p_filesz;
2312                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
2313                 if (vma->vm_flags & VM_WRITE)
2314                         phdr.p_flags |= PF_W;
2315                 if (vma->vm_flags & VM_EXEC)
2316                         phdr.p_flags |= PF_X;
2317                 phdr.p_align = ELF_EXEC_PAGESIZE;
2318
2319                 if (!dump_emit(cprm, &phdr, sizeof(phdr)))
2320                         goto end_coredump;
2321         }
2322
2323         if (!elf_core_write_extra_phdrs(cprm, offset))
2324                 goto end_coredump;
2325
2326         /* write out the notes section */
2327         if (!write_note_info(&info, cprm))
2328                 goto end_coredump;
2329
2330         if (elf_coredump_extra_notes_write(cprm))
2331                 goto end_coredump;
2332
2333         /* Align to page */
2334         if (!dump_skip(cprm, dataoff - cprm->pos))
2335                 goto end_coredump;
2336
2337         for (i = 0, vma = first_vma(current, gate_vma); vma != NULL;
2338                         vma = next_vma(vma, gate_vma)) {
2339                 unsigned long addr;
2340                 unsigned long end;
2341
2342                 end = vma->vm_start + vma_filesz[i++];
2343
2344                 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2345                         struct page *page;
2346                         int stop;
2347
2348                         page = get_dump_page(addr);
2349                         if (page) {
2350                                 void *kaddr = kmap(page);
2351                                 stop = !dump_emit(cprm, kaddr, PAGE_SIZE);
2352                                 kunmap(page);
2353                                 put_page(page);
2354                         } else
2355                                 stop = !dump_skip(cprm, PAGE_SIZE);
2356                         if (stop)
2357                                 goto end_coredump;
2358                 }
2359         }
2360         dump_truncate(cprm);
2361
2362         if (!elf_core_write_extra_data(cprm))
2363                 goto end_coredump;
2364
2365         if (e_phnum == PN_XNUM) {
2366                 if (!dump_emit(cprm, shdr4extnum, sizeof(*shdr4extnum)))
2367                         goto end_coredump;
2368         }
2369
2370 end_coredump:
2371         set_fs(fs);
2372
2373 cleanup:
2374         free_note_info(&info);
2375         kfree(shdr4extnum);
2376         kvfree(vma_filesz);
2377         kfree(phdr4note);
2378         return has_dumped;
2379 }
2380
2381 #endif          /* CONFIG_ELF_CORE */
2382
2383 static int __init init_elf_binfmt(void)
2384 {
2385         register_binfmt(&elf_format);
2386         return 0;
2387 }
2388
2389 static void __exit exit_elf_binfmt(void)
2390 {
2391         /* Remove the COFF and ELF loaders. */
2392         unregister_binfmt(&elf_format);
2393 }
2394
2395 core_initcall(init_elf_binfmt);
2396 module_exit(exit_elf_binfmt);
2397 MODULE_LICENSE("GPL");