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