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