fs/binfmt_elf.c

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