fs/binfmt_elf.c

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