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