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