1 /* binfmt_elf_fdpic.c: FDPIC ELF binary format
3 * Copyright (C) 2003, 2004, 2006 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
5 * Derived from binfmt_elf.c
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License
9 * as published by the Free Software Foundation; either version
10 * 2 of the License, or (at your option) any later version.
13 #include <linux/module.h>
16 #include <linux/stat.h>
17 #include <linux/sched.h>
19 #include <linux/mman.h>
20 #include <linux/errno.h>
21 #include <linux/signal.h>
22 #include <linux/binfmts.h>
23 #include <linux/string.h>
24 #include <linux/file.h>
25 #include <linux/fcntl.h>
26 #include <linux/slab.h>
27 #include <linux/pagemap.h>
28 #include <linux/security.h>
29 #include <linux/highmem.h>
30 #include <linux/highuid.h>
31 #include <linux/personality.h>
32 #include <linux/ptrace.h>
33 #include <linux/init.h>
34 #include <linux/elf.h>
35 #include <linux/elf-fdpic.h>
36 #include <linux/elfcore.h>
37 #include <linux/coredump.h>
38 #include <linux/sched/coredump.h>
39 #include <linux/dax.h>
41 #include <linux/uaccess.h>
42 #include <asm/param.h>
43 #include <asm/pgalloc.h>
45 typedef char *elf_caddr_t
;
48 #define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
50 #define kdebug(fmt, ...) do {} while(0)
54 #define kdcore(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
56 #define kdcore(fmt, ...) do {} while(0)
59 MODULE_LICENSE("GPL");
61 static int load_elf_fdpic_binary(struct linux_binprm
*);
62 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*, struct file
*);
63 static int elf_fdpic_map_file(struct elf_fdpic_params
*, struct file
*,
64 struct mm_struct
*, const char *);
66 static int create_elf_fdpic_tables(struct linux_binprm
*, struct mm_struct
*,
67 struct elf_fdpic_params
*,
68 struct elf_fdpic_params
*);
71 static int elf_fdpic_map_file_constdisp_on_uclinux(struct elf_fdpic_params
*,
76 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*,
77 struct file
*, struct mm_struct
*);
79 #ifdef CONFIG_ELF_CORE
80 static int elf_fdpic_core_dump(struct coredump_params
*cprm
);
83 static struct linux_binfmt elf_fdpic_format
= {
84 .module
= THIS_MODULE
,
85 .load_binary
= load_elf_fdpic_binary
,
86 #ifdef CONFIG_ELF_CORE
87 .core_dump
= elf_fdpic_core_dump
,
89 .min_coredump
= ELF_EXEC_PAGESIZE
,
92 static int __init
init_elf_fdpic_binfmt(void)
94 register_binfmt(&elf_fdpic_format
);
98 static void __exit
exit_elf_fdpic_binfmt(void)
100 unregister_binfmt(&elf_fdpic_format
);
103 core_initcall(init_elf_fdpic_binfmt
);
104 module_exit(exit_elf_fdpic_binfmt
);
106 static int is_elf(struct elfhdr
*hdr
, struct file
*file
)
108 if (memcmp(hdr
->e_ident
, ELFMAG
, SELFMAG
) != 0)
110 if (hdr
->e_type
!= ET_EXEC
&& hdr
->e_type
!= ET_DYN
)
112 if (!elf_check_arch(hdr
))
114 if (!file
->f_op
->mmap
)
119 #ifndef elf_check_fdpic
120 #define elf_check_fdpic(x) 0
123 #ifndef elf_check_const_displacement
124 #define elf_check_const_displacement(x) 0
127 static int is_constdisp(struct elfhdr
*hdr
)
129 if (!elf_check_fdpic(hdr
))
131 if (elf_check_const_displacement(hdr
))
136 /*****************************************************************************/
138 * read the program headers table into memory
140 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*params
,
143 struct elf32_phdr
*phdr
;
147 if (params
->hdr
.e_phentsize
!= sizeof(struct elf_phdr
))
149 if (params
->hdr
.e_phnum
> 65536U / sizeof(struct elf_phdr
))
152 size
= params
->hdr
.e_phnum
* sizeof(struct elf_phdr
);
153 params
->phdrs
= kmalloc(size
, GFP_KERNEL
);
157 retval
= kernel_read(file
, params
->hdr
.e_phoff
,
158 (char *) params
->phdrs
, size
);
159 if (unlikely(retval
!= size
))
160 return retval
< 0 ? retval
: -ENOEXEC
;
162 /* determine stack size for this binary */
163 phdr
= params
->phdrs
;
164 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
165 if (phdr
->p_type
!= PT_GNU_STACK
)
168 if (phdr
->p_flags
& PF_X
)
169 params
->flags
|= ELF_FDPIC_FLAG_EXEC_STACK
;
171 params
->flags
|= ELF_FDPIC_FLAG_NOEXEC_STACK
;
173 params
->stack_size
= phdr
->p_memsz
;
180 /*****************************************************************************/
182 * load an fdpic binary into various bits of memory
184 static int load_elf_fdpic_binary(struct linux_binprm
*bprm
)
186 struct elf_fdpic_params exec_params
, interp_params
;
187 struct pt_regs
*regs
= current_pt_regs();
188 struct elf_phdr
*phdr
;
189 unsigned long stack_size
, entryaddr
;
190 #ifdef ELF_FDPIC_PLAT_INIT
191 unsigned long dynaddr
;
194 unsigned long stack_prot
;
196 struct file
*interpreter
= NULL
; /* to shut gcc up */
197 char *interpreter_name
= NULL
;
198 int executable_stack
;
201 kdebug("____ LOAD %d ____", current
->pid
);
203 memset(&exec_params
, 0, sizeof(exec_params
));
204 memset(&interp_params
, 0, sizeof(interp_params
));
206 exec_params
.hdr
= *(struct elfhdr
*) bprm
->buf
;
207 exec_params
.flags
= ELF_FDPIC_FLAG_PRESENT
| ELF_FDPIC_FLAG_EXECUTABLE
;
209 /* check that this is a binary we know how to deal with */
211 if (!is_elf(&exec_params
.hdr
, bprm
->file
))
213 if (!elf_check_fdpic(&exec_params
.hdr
)) {
215 /* binfmt_elf handles non-fdpic elf except on nommu */
218 /* nommu can only load ET_DYN (PIE) ELF */
219 if (exec_params
.hdr
.e_type
!= ET_DYN
)
224 /* read the program header table */
225 retval
= elf_fdpic_fetch_phdrs(&exec_params
, bprm
->file
);
229 /* scan for a program header that specifies an interpreter */
230 phdr
= exec_params
.phdrs
;
232 for (i
= 0; i
< exec_params
.hdr
.e_phnum
; i
++, phdr
++) {
233 switch (phdr
->p_type
) {
236 if (phdr
->p_filesz
> PATH_MAX
)
239 if (phdr
->p_filesz
< 2)
242 /* read the name of the interpreter into memory */
243 interpreter_name
= kmalloc(phdr
->p_filesz
, GFP_KERNEL
);
244 if (!interpreter_name
)
247 retval
= kernel_read(bprm
->file
,
251 if (unlikely(retval
!= phdr
->p_filesz
)) {
258 if (interpreter_name
[phdr
->p_filesz
- 1] != '\0')
261 kdebug("Using ELF interpreter %s", interpreter_name
);
263 /* replace the program with the interpreter */
264 interpreter
= open_exec(interpreter_name
);
265 retval
= PTR_ERR(interpreter
);
266 if (IS_ERR(interpreter
)) {
272 * If the binary is not readable then enforce
273 * mm->dumpable = 0 regardless of the interpreter's
276 would_dump(bprm
, interpreter
);
278 retval
= kernel_read(interpreter
, 0, bprm
->buf
,
280 if (unlikely(retval
!= BINPRM_BUF_SIZE
)) {
286 interp_params
.hdr
= *((struct elfhdr
*) bprm
->buf
);
291 if (exec_params
.load_addr
== 0)
292 exec_params
.load_addr
= phdr
->p_vaddr
;
299 if (is_constdisp(&exec_params
.hdr
))
300 exec_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
302 /* perform insanity checks on the interpreter */
303 if (interpreter_name
) {
305 if (!is_elf(&interp_params
.hdr
, interpreter
))
308 interp_params
.flags
= ELF_FDPIC_FLAG_PRESENT
;
310 /* read the interpreter's program header table */
311 retval
= elf_fdpic_fetch_phdrs(&interp_params
, interpreter
);
316 stack_size
= exec_params
.stack_size
;
317 if (exec_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
318 executable_stack
= EXSTACK_ENABLE_X
;
319 else if (exec_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
320 executable_stack
= EXSTACK_DISABLE_X
;
322 executable_stack
= EXSTACK_DEFAULT
;
324 if (stack_size
== 0) {
325 stack_size
= interp_params
.stack_size
;
326 if (interp_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
327 executable_stack
= EXSTACK_ENABLE_X
;
328 else if (interp_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
329 executable_stack
= EXSTACK_DISABLE_X
;
331 executable_stack
= EXSTACK_DEFAULT
;
336 stack_size
= 131072UL; /* same as exec.c's default commit */
338 if (is_constdisp(&interp_params
.hdr
))
339 interp_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
341 /* flush all traces of the currently running executable */
342 retval
= flush_old_exec(bprm
);
346 /* there's now no turning back... the old userspace image is dead,
347 * defunct, deceased, etc.
349 if (elf_check_fdpic(&exec_params
.hdr
))
350 set_personality(PER_LINUX_FDPIC
);
352 set_personality(PER_LINUX
);
353 if (elf_read_implies_exec(&exec_params
.hdr
, executable_stack
))
354 current
->personality
|= READ_IMPLIES_EXEC
;
356 setup_new_exec(bprm
);
358 set_binfmt(&elf_fdpic_format
);
360 current
->mm
->start_code
= 0;
361 current
->mm
->end_code
= 0;
362 current
->mm
->start_stack
= 0;
363 current
->mm
->start_data
= 0;
364 current
->mm
->end_data
= 0;
365 current
->mm
->context
.exec_fdpic_loadmap
= 0;
366 current
->mm
->context
.interp_fdpic_loadmap
= 0;
369 elf_fdpic_arch_lay_out_mm(&exec_params
,
371 ¤t
->mm
->start_stack
,
372 ¤t
->mm
->start_brk
);
374 retval
= setup_arg_pages(bprm
, current
->mm
->start_stack
,
380 /* load the executable and interpreter into memory */
381 retval
= elf_fdpic_map_file(&exec_params
, bprm
->file
, current
->mm
,
386 if (interpreter_name
) {
387 retval
= elf_fdpic_map_file(&interp_params
, interpreter
,
388 current
->mm
, "interpreter");
390 printk(KERN_ERR
"Unable to load interpreter\n");
394 allow_write_access(interpreter
);
400 if (!current
->mm
->start_brk
)
401 current
->mm
->start_brk
= current
->mm
->end_data
;
403 current
->mm
->brk
= current
->mm
->start_brk
=
404 PAGE_ALIGN(current
->mm
->start_brk
);
407 /* create a stack area and zero-size brk area */
408 stack_size
= (stack_size
+ PAGE_SIZE
- 1) & PAGE_MASK
;
409 if (stack_size
< PAGE_SIZE
* 2)
410 stack_size
= PAGE_SIZE
* 2;
412 stack_prot
= PROT_READ
| PROT_WRITE
;
413 if (executable_stack
== EXSTACK_ENABLE_X
||
414 (executable_stack
== EXSTACK_DEFAULT
&& VM_STACK_FLAGS
& VM_EXEC
))
415 stack_prot
|= PROT_EXEC
;
417 current
->mm
->start_brk
= vm_mmap(NULL
, 0, stack_size
, stack_prot
,
418 MAP_PRIVATE
| MAP_ANONYMOUS
|
419 MAP_UNINITIALIZED
| MAP_GROWSDOWN
,
422 if (IS_ERR_VALUE(current
->mm
->start_brk
)) {
423 retval
= current
->mm
->start_brk
;
424 current
->mm
->start_brk
= 0;
428 current
->mm
->brk
= current
->mm
->start_brk
;
429 current
->mm
->context
.end_brk
= current
->mm
->start_brk
;
430 current
->mm
->start_stack
= current
->mm
->start_brk
+ stack_size
;
433 install_exec_creds(bprm
);
434 if (create_elf_fdpic_tables(bprm
, current
->mm
,
435 &exec_params
, &interp_params
) < 0)
438 kdebug("- start_code %lx", current
->mm
->start_code
);
439 kdebug("- end_code %lx", current
->mm
->end_code
);
440 kdebug("- start_data %lx", current
->mm
->start_data
);
441 kdebug("- end_data %lx", current
->mm
->end_data
);
442 kdebug("- start_brk %lx", current
->mm
->start_brk
);
443 kdebug("- brk %lx", current
->mm
->brk
);
444 kdebug("- start_stack %lx", current
->mm
->start_stack
);
446 #ifdef ELF_FDPIC_PLAT_INIT
448 * The ABI may specify that certain registers be set up in special
449 * ways (on i386 %edx is the address of a DT_FINI function, for
450 * example. This macro performs whatever initialization to
451 * the regs structure is required.
453 dynaddr
= interp_params
.dynamic_addr
?: exec_params
.dynamic_addr
;
454 ELF_FDPIC_PLAT_INIT(regs
, exec_params
.map_addr
, interp_params
.map_addr
,
458 /* everything is now ready... get the userspace context ready to roll */
459 entryaddr
= interp_params
.entry_addr
?: exec_params
.entry_addr
;
460 start_thread(regs
, entryaddr
, current
->mm
->start_stack
);
466 allow_write_access(interpreter
);
469 kfree(interpreter_name
);
470 kfree(exec_params
.phdrs
);
471 kfree(exec_params
.loadmap
);
472 kfree(interp_params
.phdrs
);
473 kfree(interp_params
.loadmap
);
477 /*****************************************************************************/
479 #ifndef ELF_BASE_PLATFORM
481 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
482 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
483 * will be copied to the user stack in the same manner as AT_PLATFORM.
485 #define ELF_BASE_PLATFORM NULL
489 * present useful information to the program by shovelling it onto the new
492 static int create_elf_fdpic_tables(struct linux_binprm
*bprm
,
493 struct mm_struct
*mm
,
494 struct elf_fdpic_params
*exec_params
,
495 struct elf_fdpic_params
*interp_params
)
497 const struct cred
*cred
= current_cred();
498 unsigned long sp
, csp
, nitems
;
499 elf_caddr_t __user
*argv
, *envp
;
500 size_t platform_len
= 0, len
;
501 char *k_platform
, *k_base_platform
;
502 char __user
*u_platform
, *u_base_platform
, *p
;
504 int nr
; /* reset for each csp adjustment */
507 /* In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
508 * by the processes running on the same package. One thing we can do is
509 * to shuffle the initial stack for them, so we give the architecture
510 * an opportunity to do so here.
512 sp
= arch_align_stack(bprm
->p
);
514 sp
= mm
->start_stack
;
516 /* stack the program arguments and environment */
517 if (transfer_args_to_stack(bprm
, &sp
) < 0)
523 * If this architecture has a platform capability string, copy it
524 * to userspace. In some cases (Sparc), this info is impossible
525 * for userspace to get any other way, in others (i386) it is
528 k_platform
= ELF_PLATFORM
;
532 platform_len
= strlen(k_platform
) + 1;
534 u_platform
= (char __user
*) sp
;
535 if (__copy_to_user(u_platform
, k_platform
, platform_len
) != 0)
540 * If this architecture has a "base" platform capability
541 * string, copy it to userspace.
543 k_base_platform
= ELF_BASE_PLATFORM
;
544 u_base_platform
= NULL
;
546 if (k_base_platform
) {
547 platform_len
= strlen(k_base_platform
) + 1;
549 u_base_platform
= (char __user
*) sp
;
550 if (__copy_to_user(u_base_platform
, k_base_platform
, platform_len
) != 0)
556 /* stack the load map(s) */
557 len
= sizeof(struct elf32_fdpic_loadmap
);
558 len
+= sizeof(struct elf32_fdpic_loadseg
) * exec_params
->loadmap
->nsegs
;
559 sp
= (sp
- len
) & ~7UL;
560 exec_params
->map_addr
= sp
;
562 if (copy_to_user((void __user
*) sp
, exec_params
->loadmap
, len
) != 0)
565 current
->mm
->context
.exec_fdpic_loadmap
= (unsigned long) sp
;
567 if (interp_params
->loadmap
) {
568 len
= sizeof(struct elf32_fdpic_loadmap
);
569 len
+= sizeof(struct elf32_fdpic_loadseg
) *
570 interp_params
->loadmap
->nsegs
;
571 sp
= (sp
- len
) & ~7UL;
572 interp_params
->map_addr
= sp
;
574 if (copy_to_user((void __user
*) sp
, interp_params
->loadmap
,
578 current
->mm
->context
.interp_fdpic_loadmap
= (unsigned long) sp
;
581 /* force 16 byte _final_ alignment here for generality */
582 #define DLINFO_ITEMS 15
584 nitems
= 1 + DLINFO_ITEMS
+ (k_platform
? 1 : 0) +
585 (k_base_platform
? 1 : 0) + AT_VECTOR_SIZE_ARCH
;
587 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
)
591 sp
-= nitems
* 2 * sizeof(unsigned long);
592 sp
-= (bprm
->envc
+ 1) * sizeof(char *); /* envv[] */
593 sp
-= (bprm
->argc
+ 1) * sizeof(char *); /* argv[] */
594 sp
-= 1 * sizeof(unsigned long); /* argc */
599 /* put the ELF interpreter info on the stack */
600 #define NEW_AUX_ENT(id, val) \
602 struct { unsigned long _id, _val; } __user *ent; \
604 ent = (void __user *) csp; \
605 __put_user((id), &ent[nr]._id); \
606 __put_user((val), &ent[nr]._val); \
611 csp
-= 2 * sizeof(unsigned long);
612 NEW_AUX_ENT(AT_NULL
, 0);
615 csp
-= 2 * sizeof(unsigned long);
616 NEW_AUX_ENT(AT_PLATFORM
,
617 (elf_addr_t
) (unsigned long) u_platform
);
620 if (k_base_platform
) {
622 csp
-= 2 * sizeof(unsigned long);
623 NEW_AUX_ENT(AT_BASE_PLATFORM
,
624 (elf_addr_t
) (unsigned long) u_base_platform
);
627 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
) {
629 csp
-= 2 * sizeof(unsigned long);
630 NEW_AUX_ENT(AT_EXECFD
, bprm
->interp_data
);
634 csp
-= DLINFO_ITEMS
* 2 * sizeof(unsigned long);
635 NEW_AUX_ENT(AT_HWCAP
, ELF_HWCAP
);
637 NEW_AUX_ENT(AT_HWCAP2
, ELF_HWCAP2
);
639 NEW_AUX_ENT(AT_PAGESZ
, PAGE_SIZE
);
640 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
641 NEW_AUX_ENT(AT_PHDR
, exec_params
->ph_addr
);
642 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
643 NEW_AUX_ENT(AT_PHNUM
, exec_params
->hdr
.e_phnum
);
644 NEW_AUX_ENT(AT_BASE
, interp_params
->elfhdr_addr
);
645 NEW_AUX_ENT(AT_FLAGS
, 0);
646 NEW_AUX_ENT(AT_ENTRY
, exec_params
->entry_addr
);
647 NEW_AUX_ENT(AT_UID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->uid
));
648 NEW_AUX_ENT(AT_EUID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->euid
));
649 NEW_AUX_ENT(AT_GID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->gid
));
650 NEW_AUX_ENT(AT_EGID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->egid
));
651 NEW_AUX_ENT(AT_SECURE
, security_bprm_secureexec(bprm
));
652 NEW_AUX_ENT(AT_EXECFN
, bprm
->exec
);
656 csp
-= AT_VECTOR_SIZE_ARCH
* 2 * sizeof(unsigned long);
658 /* ARCH_DLINFO must come last so platform specific code can enforce
659 * special alignment requirements on the AUXV if necessary (eg. PPC).
665 /* allocate room for argv[] and envv[] */
666 csp
-= (bprm
->envc
+ 1) * sizeof(elf_caddr_t
);
667 envp
= (elf_caddr_t __user
*) csp
;
668 csp
-= (bprm
->argc
+ 1) * sizeof(elf_caddr_t
);
669 argv
= (elf_caddr_t __user
*) csp
;
672 csp
-= sizeof(unsigned long);
673 __put_user(bprm
->argc
, (unsigned long __user
*) csp
);
677 /* fill in the argv[] array */
679 current
->mm
->arg_start
= bprm
->p
;
681 current
->mm
->arg_start
= current
->mm
->start_stack
-
682 (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
);
685 p
= (char __user
*) current
->mm
->arg_start
;
686 for (loop
= bprm
->argc
; loop
> 0; loop
--) {
687 __put_user((elf_caddr_t
) p
, argv
++);
688 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
689 if (!len
|| len
> MAX_ARG_STRLEN
)
693 __put_user(NULL
, argv
);
694 current
->mm
->arg_end
= (unsigned long) p
;
696 /* fill in the envv[] array */
697 current
->mm
->env_start
= (unsigned long) p
;
698 for (loop
= bprm
->envc
; loop
> 0; loop
--) {
699 __put_user((elf_caddr_t
)(unsigned long) p
, envp
++);
700 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
701 if (!len
|| len
> MAX_ARG_STRLEN
)
705 __put_user(NULL
, envp
);
706 current
->mm
->env_end
= (unsigned long) p
;
708 mm
->start_stack
= (unsigned long) sp
;
712 /*****************************************************************************/
714 * load the appropriate binary image (executable or interpreter) into memory
715 * - we assume no MMU is available
716 * - if no other PIC bits are set in params->hdr->e_flags
717 * - we assume that the LOADable segments in the binary are independently relocatable
718 * - we assume R/O executable segments are shareable
720 * - we assume the loadable parts of the image to require fixed displacement
721 * - the image is not shareable
723 static int elf_fdpic_map_file(struct elf_fdpic_params
*params
,
725 struct mm_struct
*mm
,
728 struct elf32_fdpic_loadmap
*loadmap
;
730 struct elf32_fdpic_loadseg
*mseg
;
732 struct elf32_fdpic_loadseg
*seg
;
733 struct elf32_phdr
*phdr
;
734 unsigned long load_addr
, stop
;
735 unsigned nloads
, tmp
;
739 /* allocate a load map table */
741 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++)
742 if (params
->phdrs
[loop
].p_type
== PT_LOAD
)
748 size
= sizeof(*loadmap
) + nloads
* sizeof(*seg
);
749 loadmap
= kzalloc(size
, GFP_KERNEL
);
753 params
->loadmap
= loadmap
;
755 loadmap
->version
= ELF32_FDPIC_LOADMAP_VERSION
;
756 loadmap
->nsegs
= nloads
;
758 load_addr
= params
->load_addr
;
761 /* map the requested LOADs into the memory space */
762 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
763 case ELF_FDPIC_FLAG_CONSTDISP
:
764 case ELF_FDPIC_FLAG_CONTIGUOUS
:
766 ret
= elf_fdpic_map_file_constdisp_on_uclinux(params
, file
, mm
);
772 ret
= elf_fdpic_map_file_by_direct_mmap(params
, file
, mm
);
778 /* map the entry point */
779 if (params
->hdr
.e_entry
) {
781 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
782 if (params
->hdr
.e_entry
>= seg
->p_vaddr
&&
783 params
->hdr
.e_entry
< seg
->p_vaddr
+ seg
->p_memsz
) {
785 (params
->hdr
.e_entry
- seg
->p_vaddr
) +
792 /* determine where the program header table has wound up if mapped */
793 stop
= params
->hdr
.e_phoff
;
794 stop
+= params
->hdr
.e_phnum
* sizeof (struct elf_phdr
);
795 phdr
= params
->phdrs
;
797 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
798 if (phdr
->p_type
!= PT_LOAD
)
801 if (phdr
->p_offset
> params
->hdr
.e_phoff
||
802 phdr
->p_offset
+ phdr
->p_filesz
< stop
)
806 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
807 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
808 phdr
->p_vaddr
+ phdr
->p_filesz
<=
809 seg
->p_vaddr
+ seg
->p_memsz
) {
811 (phdr
->p_vaddr
- seg
->p_vaddr
) +
813 params
->hdr
.e_phoff
- phdr
->p_offset
;
820 /* determine where the dynamic section has wound up if there is one */
821 phdr
= params
->phdrs
;
822 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
823 if (phdr
->p_type
!= PT_DYNAMIC
)
827 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
828 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
829 phdr
->p_vaddr
+ phdr
->p_memsz
<=
830 seg
->p_vaddr
+ seg
->p_memsz
) {
831 params
->dynamic_addr
=
832 (phdr
->p_vaddr
- seg
->p_vaddr
) +
835 /* check the dynamic section contains at least
836 * one item, and that the last item is a NULL
838 if (phdr
->p_memsz
== 0 ||
839 phdr
->p_memsz
% sizeof(Elf32_Dyn
) != 0)
842 tmp
= phdr
->p_memsz
/ sizeof(Elf32_Dyn
);
844 params
->dynamic_addr
)[tmp
- 1].d_tag
!= 0)
852 /* now elide adjacent segments in the load map on MMU linux
853 * - on uClinux the holes between may actually be filled with system
854 * stuff or stuff from other processes
857 nloads
= loadmap
->nsegs
;
858 mseg
= loadmap
->segs
;
860 for (loop
= 1; loop
< nloads
; loop
++) {
861 /* see if we have a candidate for merging */
862 if (seg
->p_vaddr
- mseg
->p_vaddr
== seg
->addr
- mseg
->addr
) {
863 load_addr
= PAGE_ALIGN(mseg
->addr
+ mseg
->p_memsz
);
864 if (load_addr
== (seg
->addr
& PAGE_MASK
)) {
867 (mseg
->addr
+ mseg
->p_memsz
);
868 mseg
->p_memsz
+= seg
->addr
& ~PAGE_MASK
;
869 mseg
->p_memsz
+= seg
->p_memsz
;
881 kdebug("Mapped Object [%s]:", what
);
882 kdebug("- elfhdr : %lx", params
->elfhdr_addr
);
883 kdebug("- entry : %lx", params
->entry_addr
);
884 kdebug("- PHDR[] : %lx", params
->ph_addr
);
885 kdebug("- DYNAMIC[]: %lx", params
->dynamic_addr
);
887 for (loop
= 0; loop
< loadmap
->nsegs
; loop
++, seg
++)
888 kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
890 seg
->addr
, seg
->addr
+ seg
->p_memsz
- 1,
891 seg
->p_vaddr
, seg
->p_memsz
);
896 printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
897 what
, file_inode(file
)->i_ino
);
901 /*****************************************************************************/
903 * map a file with constant displacement under uClinux
906 static int elf_fdpic_map_file_constdisp_on_uclinux(
907 struct elf_fdpic_params
*params
,
909 struct mm_struct
*mm
)
911 struct elf32_fdpic_loadseg
*seg
;
912 struct elf32_phdr
*phdr
;
913 unsigned long load_addr
, base
= ULONG_MAX
, top
= 0, maddr
= 0, mflags
;
916 load_addr
= params
->load_addr
;
917 seg
= params
->loadmap
->segs
;
919 /* determine the bounds of the contiguous overall allocation we must
921 phdr
= params
->phdrs
;
922 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
923 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
926 if (base
> phdr
->p_vaddr
)
927 base
= phdr
->p_vaddr
;
928 if (top
< phdr
->p_vaddr
+ phdr
->p_memsz
)
929 top
= phdr
->p_vaddr
+ phdr
->p_memsz
;
932 /* allocate one big anon block for everything */
933 mflags
= MAP_PRIVATE
;
934 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
935 mflags
|= MAP_EXECUTABLE
;
937 maddr
= vm_mmap(NULL
, load_addr
, top
- base
,
938 PROT_READ
| PROT_WRITE
| PROT_EXEC
, mflags
, 0);
939 if (IS_ERR_VALUE(maddr
))
943 load_addr
+= PAGE_ALIGN(top
- base
);
945 /* and then load the file segments into it */
946 phdr
= params
->phdrs
;
947 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
948 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
951 seg
->addr
= maddr
+ (phdr
->p_vaddr
- base
);
952 seg
->p_vaddr
= phdr
->p_vaddr
;
953 seg
->p_memsz
= phdr
->p_memsz
;
955 ret
= read_code(file
, seg
->addr
, phdr
->p_offset
,
960 /* map the ELF header address if in this segment */
961 if (phdr
->p_offset
== 0)
962 params
->elfhdr_addr
= seg
->addr
;
964 /* clear any space allocated but not loaded */
965 if (phdr
->p_filesz
< phdr
->p_memsz
) {
966 if (clear_user((void *) (seg
->addr
+ phdr
->p_filesz
),
967 phdr
->p_memsz
- phdr
->p_filesz
))
972 if (phdr
->p_flags
& PF_X
) {
973 if (!mm
->start_code
) {
974 mm
->start_code
= seg
->addr
;
975 mm
->end_code
= seg
->addr
+
978 } else if (!mm
->start_data
) {
979 mm
->start_data
= seg
->addr
;
980 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
991 /*****************************************************************************/
993 * map a binary by direct mmap() of the individual PT_LOAD segments
995 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*params
,
997 struct mm_struct
*mm
)
999 struct elf32_fdpic_loadseg
*seg
;
1000 struct elf32_phdr
*phdr
;
1001 unsigned long load_addr
, delta_vaddr
;
1004 load_addr
= params
->load_addr
;
1008 seg
= params
->loadmap
->segs
;
1010 /* deal with each load segment separately */
1011 phdr
= params
->phdrs
;
1012 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
1013 unsigned long maddr
, disp
, excess
, excess1
;
1014 int prot
= 0, flags
;
1016 if (phdr
->p_type
!= PT_LOAD
)
1019 kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1020 (unsigned long) phdr
->p_vaddr
,
1021 (unsigned long) phdr
->p_offset
,
1022 (unsigned long) phdr
->p_filesz
,
1023 (unsigned long) phdr
->p_memsz
);
1025 /* determine the mapping parameters */
1026 if (phdr
->p_flags
& PF_R
) prot
|= PROT_READ
;
1027 if (phdr
->p_flags
& PF_W
) prot
|= PROT_WRITE
;
1028 if (phdr
->p_flags
& PF_X
) prot
|= PROT_EXEC
;
1030 flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1031 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
1032 flags
|= MAP_EXECUTABLE
;
1036 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
1037 case ELF_FDPIC_FLAG_INDEPENDENT
:
1038 /* PT_LOADs are independently locatable */
1041 case ELF_FDPIC_FLAG_HONOURVADDR
:
1042 /* the specified virtual address must be honoured */
1043 maddr
= phdr
->p_vaddr
;
1047 case ELF_FDPIC_FLAG_CONSTDISP
:
1048 /* constant displacement
1049 * - can be mapped anywhere, but must be mapped as a
1054 delta_vaddr
= phdr
->p_vaddr
;
1057 maddr
= load_addr
+ phdr
->p_vaddr
- delta_vaddr
;
1062 case ELF_FDPIC_FLAG_CONTIGUOUS
:
1063 /* contiguity handled later */
1072 /* create the mapping */
1073 disp
= phdr
->p_vaddr
& ~PAGE_MASK
;
1074 maddr
= vm_mmap(file
, maddr
, phdr
->p_memsz
+ disp
, prot
, flags
,
1075 phdr
->p_offset
- disp
);
1077 kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1078 loop
, phdr
->p_memsz
+ disp
, prot
, flags
,
1079 phdr
->p_offset
- disp
, maddr
);
1081 if (IS_ERR_VALUE(maddr
))
1084 if ((params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) ==
1085 ELF_FDPIC_FLAG_CONTIGUOUS
)
1086 load_addr
+= PAGE_ALIGN(phdr
->p_memsz
+ disp
);
1088 seg
->addr
= maddr
+ disp
;
1089 seg
->p_vaddr
= phdr
->p_vaddr
;
1090 seg
->p_memsz
= phdr
->p_memsz
;
1092 /* map the ELF header address if in this segment */
1093 if (phdr
->p_offset
== 0)
1094 params
->elfhdr_addr
= seg
->addr
;
1096 /* clear the bit between beginning of mapping and beginning of
1098 if (prot
& PROT_WRITE
&& disp
> 0) {
1099 kdebug("clear[%d] ad=%lx sz=%lx", loop
, maddr
, disp
);
1100 if (clear_user((void __user
*) maddr
, disp
))
1105 /* clear any space allocated but not loaded
1106 * - on uClinux we can just clear the lot
1107 * - on MMU linux we'll get a SIGBUS beyond the last page
1108 * extant in the file
1110 excess
= phdr
->p_memsz
- phdr
->p_filesz
;
1111 excess1
= PAGE_SIZE
- ((maddr
+ phdr
->p_filesz
) & ~PAGE_MASK
);
1114 if (excess
> excess1
) {
1115 unsigned long xaddr
= maddr
+ phdr
->p_filesz
+ excess1
;
1116 unsigned long xmaddr
;
1118 flags
|= MAP_FIXED
| MAP_ANONYMOUS
;
1119 xmaddr
= vm_mmap(NULL
, xaddr
, excess
- excess1
,
1122 kdebug("mmap[%d] <anon>"
1123 " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1124 loop
, xaddr
, excess
- excess1
, prot
, flags
,
1127 if (xmaddr
!= xaddr
)
1131 if (prot
& PROT_WRITE
&& excess1
> 0) {
1132 kdebug("clear[%d] ad=%lx sz=%lx",
1133 loop
, maddr
+ phdr
->p_filesz
, excess1
);
1134 if (clear_user((void __user
*) maddr
+ phdr
->p_filesz
,
1141 kdebug("clear[%d] ad=%lx sz=%lx",
1142 loop
, maddr
+ phdr
->p_filesz
, excess
);
1143 if (clear_user((void *) maddr
+ phdr
->p_filesz
, excess
))
1149 if (phdr
->p_flags
& PF_X
) {
1150 if (!mm
->start_code
) {
1151 mm
->start_code
= maddr
;
1152 mm
->end_code
= maddr
+ phdr
->p_memsz
;
1154 } else if (!mm
->start_data
) {
1155 mm
->start_data
= maddr
;
1156 mm
->end_data
= maddr
+ phdr
->p_memsz
;
1166 /*****************************************************************************/
1168 * ELF-FDPIC core dumper
1170 * Modelled on fs/exec.c:aout_core_dump()
1171 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1173 * Modelled on fs/binfmt_elf.c core dumper
1175 #ifdef CONFIG_ELF_CORE
1178 * Decide whether a segment is worth dumping; default is yes to be
1179 * sure (missing info is worse than too much; etc).
1180 * Personally I'd include everything, and use the coredump limit...
1182 * I think we should skip something. But I am not sure how. H.J.
1184 static int maydump(struct vm_area_struct
*vma
, unsigned long mm_flags
)
1188 /* Do not dump I/O mapped devices or special mappings */
1189 if (vma
->vm_flags
& VM_IO
) {
1190 kdcore("%08lx: %08lx: no (IO)", vma
->vm_start
, vma
->vm_flags
);
1194 /* If we may not read the contents, don't allow us to dump
1195 * them either. "dump_write()" can't handle it anyway.
1197 if (!(vma
->vm_flags
& VM_READ
)) {
1198 kdcore("%08lx: %08lx: no (!read)", vma
->vm_start
, vma
->vm_flags
);
1202 /* support for DAX */
1203 if (vma_is_dax(vma
)) {
1204 if (vma
->vm_flags
& VM_SHARED
) {
1205 dump_ok
= test_bit(MMF_DUMP_DAX_SHARED
, &mm_flags
);
1206 kdcore("%08lx: %08lx: %s (DAX shared)", vma
->vm_start
,
1207 vma
->vm_flags
, dump_ok
? "yes" : "no");
1209 dump_ok
= test_bit(MMF_DUMP_DAX_PRIVATE
, &mm_flags
);
1210 kdcore("%08lx: %08lx: %s (DAX private)", vma
->vm_start
,
1211 vma
->vm_flags
, dump_ok
? "yes" : "no");
1216 /* By default, dump shared memory if mapped from an anonymous file. */
1217 if (vma
->vm_flags
& VM_SHARED
) {
1218 if (file_inode(vma
->vm_file
)->i_nlink
== 0) {
1219 dump_ok
= test_bit(MMF_DUMP_ANON_SHARED
, &mm_flags
);
1220 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1221 vma
->vm_flags
, dump_ok
? "yes" : "no");
1225 dump_ok
= test_bit(MMF_DUMP_MAPPED_SHARED
, &mm_flags
);
1226 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1227 vma
->vm_flags
, dump_ok
? "yes" : "no");
1232 /* By default, if it hasn't been written to, don't write it out */
1233 if (!vma
->anon_vma
) {
1234 dump_ok
= test_bit(MMF_DUMP_MAPPED_PRIVATE
, &mm_flags
);
1235 kdcore("%08lx: %08lx: %s (!anon)", vma
->vm_start
,
1236 vma
->vm_flags
, dump_ok
? "yes" : "no");
1241 dump_ok
= test_bit(MMF_DUMP_ANON_PRIVATE
, &mm_flags
);
1242 kdcore("%08lx: %08lx: %s", vma
->vm_start
, vma
->vm_flags
,
1243 dump_ok
? "yes" : "no");
1247 /* An ELF note in memory */
1252 unsigned int datasz
;
1256 static int notesize(struct memelfnote
*en
)
1260 sz
= sizeof(struct elf_note
);
1261 sz
+= roundup(strlen(en
->name
) + 1, 4);
1262 sz
+= roundup(en
->datasz
, 4);
1269 static int writenote(struct memelfnote
*men
, struct coredump_params
*cprm
)
1272 en
.n_namesz
= strlen(men
->name
) + 1;
1273 en
.n_descsz
= men
->datasz
;
1274 en
.n_type
= men
->type
;
1276 return dump_emit(cprm
, &en
, sizeof(en
)) &&
1277 dump_emit(cprm
, men
->name
, en
.n_namesz
) && dump_align(cprm
, 4) &&
1278 dump_emit(cprm
, men
->data
, men
->datasz
) && dump_align(cprm
, 4);
1281 static inline void fill_elf_fdpic_header(struct elfhdr
*elf
, int segs
)
1283 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1284 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1285 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1286 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1287 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1288 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1290 elf
->e_type
= ET_CORE
;
1291 elf
->e_machine
= ELF_ARCH
;
1292 elf
->e_version
= EV_CURRENT
;
1294 elf
->e_phoff
= sizeof(struct elfhdr
);
1296 elf
->e_flags
= ELF_FDPIC_CORE_EFLAGS
;
1297 elf
->e_ehsize
= sizeof(struct elfhdr
);
1298 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1299 elf
->e_phnum
= segs
;
1300 elf
->e_shentsize
= 0;
1302 elf
->e_shstrndx
= 0;
1306 static inline void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1308 phdr
->p_type
= PT_NOTE
;
1309 phdr
->p_offset
= offset
;
1312 phdr
->p_filesz
= sz
;
1319 static inline void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1320 unsigned int sz
, void *data
)
1330 * fill up all the fields in prstatus from the given task struct, except
1331 * registers which need to be filled up separately.
1333 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1334 struct task_struct
*p
, long signr
)
1336 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1337 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1338 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1340 prstatus
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1342 prstatus
->pr_pid
= task_pid_vnr(p
);
1343 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1344 prstatus
->pr_sid
= task_session_vnr(p
);
1345 if (thread_group_leader(p
)) {
1346 struct task_cputime cputime
;
1349 * This is the record for the group leader. It shows the
1350 * group-wide total, not its individual thread total.
1352 thread_group_cputime(p
, &cputime
);
1353 prstatus
->pr_utime
= ns_to_timeval(cputime
.utime
);
1354 prstatus
->pr_stime
= ns_to_timeval(cputime
.stime
);
1358 task_cputime(p
, &utime
, &stime
);
1359 prstatus
->pr_utime
= ns_to_timeval(utime
);
1360 prstatus
->pr_stime
= ns_to_timeval(stime
);
1362 prstatus
->pr_cutime
= ns_to_timeval(p
->signal
->cutime
);
1363 prstatus
->pr_cstime
= ns_to_timeval(p
->signal
->cstime
);
1365 prstatus
->pr_exec_fdpic_loadmap
= p
->mm
->context
.exec_fdpic_loadmap
;
1366 prstatus
->pr_interp_fdpic_loadmap
= p
->mm
->context
.interp_fdpic_loadmap
;
1369 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1370 struct mm_struct
*mm
)
1372 const struct cred
*cred
;
1373 unsigned int i
, len
;
1375 /* first copy the parameters from user space */
1376 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1378 len
= mm
->arg_end
- mm
->arg_start
;
1379 if (len
>= ELF_PRARGSZ
)
1380 len
= ELF_PRARGSZ
- 1;
1381 if (copy_from_user(&psinfo
->pr_psargs
,
1382 (const char __user
*) mm
->arg_start
, len
))
1384 for (i
= 0; i
< len
; i
++)
1385 if (psinfo
->pr_psargs
[i
] == 0)
1386 psinfo
->pr_psargs
[i
] = ' ';
1387 psinfo
->pr_psargs
[len
] = 0;
1390 psinfo
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1392 psinfo
->pr_pid
= task_pid_vnr(p
);
1393 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1394 psinfo
->pr_sid
= task_session_vnr(p
);
1396 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1397 psinfo
->pr_state
= i
;
1398 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1399 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1400 psinfo
->pr_nice
= task_nice(p
);
1401 psinfo
->pr_flag
= p
->flags
;
1403 cred
= __task_cred(p
);
1404 SET_UID(psinfo
->pr_uid
, from_kuid_munged(cred
->user_ns
, cred
->uid
));
1405 SET_GID(psinfo
->pr_gid
, from_kgid_munged(cred
->user_ns
, cred
->gid
));
1407 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1412 /* Here is the structure in which status of each thread is captured. */
1413 struct elf_thread_status
1415 struct list_head list
;
1416 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1417 elf_fpregset_t fpu
; /* NT_PRFPREG */
1418 struct task_struct
*thread
;
1419 #ifdef ELF_CORE_COPY_XFPREGS
1420 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1422 struct memelfnote notes
[3];
1427 * In order to add the specific thread information for the elf file format,
1428 * we need to keep a linked list of every thread's pr_status and then create
1429 * a single section for them in the final core file.
1431 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1433 struct task_struct
*p
= t
->thread
;
1438 fill_prstatus(&t
->prstatus
, p
, signr
);
1439 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1441 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1444 sz
+= notesize(&t
->notes
[0]);
1446 t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
, &t
->fpu
);
1447 if (t
->prstatus
.pr_fpvalid
) {
1448 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1451 sz
+= notesize(&t
->notes
[1]);
1454 #ifdef ELF_CORE_COPY_XFPREGS
1455 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1456 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1457 sizeof(t
->xfpu
), &t
->xfpu
);
1459 sz
+= notesize(&t
->notes
[2]);
1465 static void fill_extnum_info(struct elfhdr
*elf
, struct elf_shdr
*shdr4extnum
,
1466 elf_addr_t e_shoff
, int segs
)
1468 elf
->e_shoff
= e_shoff
;
1469 elf
->e_shentsize
= sizeof(*shdr4extnum
);
1471 elf
->e_shstrndx
= SHN_UNDEF
;
1473 memset(shdr4extnum
, 0, sizeof(*shdr4extnum
));
1475 shdr4extnum
->sh_type
= SHT_NULL
;
1476 shdr4extnum
->sh_size
= elf
->e_shnum
;
1477 shdr4extnum
->sh_link
= elf
->e_shstrndx
;
1478 shdr4extnum
->sh_info
= segs
;
1482 * dump the segments for an MMU process
1484 static bool elf_fdpic_dump_segments(struct coredump_params
*cprm
)
1486 struct vm_area_struct
*vma
;
1488 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1491 if (!maydump(vma
, cprm
->mm_flags
))
1495 for (addr
= vma
->vm_start
; addr
< vma
->vm_end
;
1496 addr
+= PAGE_SIZE
) {
1498 struct page
*page
= get_dump_page(addr
);
1500 void *kaddr
= kmap(page
);
1501 res
= dump_emit(cprm
, kaddr
, PAGE_SIZE
);
1505 res
= dump_skip(cprm
, PAGE_SIZE
);
1511 if (!dump_emit(cprm
, (void *) vma
->vm_start
,
1512 vma
->vm_end
- vma
->vm_start
))
1519 static size_t elf_core_vma_data_size(unsigned long mm_flags
)
1521 struct vm_area_struct
*vma
;
1524 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
)
1525 if (maydump(vma
, mm_flags
))
1526 size
+= vma
->vm_end
- vma
->vm_start
;
1533 * This is a two-pass process; first we find the offsets of the bits,
1534 * and then they are actually written out. If we run out of core limit
1537 static int elf_fdpic_core_dump(struct coredump_params
*cprm
)
1544 struct vm_area_struct
*vma
;
1545 struct elfhdr
*elf
= NULL
;
1546 loff_t offset
= 0, dataoff
;
1548 struct memelfnote
*notes
= NULL
;
1549 struct elf_prstatus
*prstatus
= NULL
; /* NT_PRSTATUS */
1550 struct elf_prpsinfo
*psinfo
= NULL
; /* NT_PRPSINFO */
1551 LIST_HEAD(thread_list
);
1552 struct list_head
*t
;
1553 elf_fpregset_t
*fpu
= NULL
;
1554 #ifdef ELF_CORE_COPY_XFPREGS
1555 elf_fpxregset_t
*xfpu
= NULL
;
1557 int thread_status_size
= 0;
1559 struct elf_phdr
*phdr4note
= NULL
;
1560 struct elf_shdr
*shdr4extnum
= NULL
;
1563 struct core_thread
*ct
;
1564 struct elf_thread_status
*tmp
;
1567 * We no longer stop all VM operations.
1569 * This is because those proceses that could possibly change map_count
1570 * or the mmap / vma pages are now blocked in do_exit on current
1571 * finishing this core dump.
1573 * Only ptrace can touch these memory addresses, but it doesn't change
1574 * the map_count or the pages allocated. So no possibility of crashing
1575 * exists while dumping the mm->vm_next areas to the core file.
1578 /* alloc memory for large data structures: too large to be on stack */
1579 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
1582 prstatus
= kzalloc(sizeof(*prstatus
), GFP_KERNEL
);
1585 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1588 notes
= kmalloc(NUM_NOTES
* sizeof(struct memelfnote
), GFP_KERNEL
);
1591 fpu
= kmalloc(sizeof(*fpu
), GFP_KERNEL
);
1594 #ifdef ELF_CORE_COPY_XFPREGS
1595 xfpu
= kmalloc(sizeof(*xfpu
), GFP_KERNEL
);
1600 for (ct
= current
->mm
->core_state
->dumper
.next
;
1601 ct
; ct
= ct
->next
) {
1602 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1606 tmp
->thread
= ct
->task
;
1607 list_add(&tmp
->list
, &thread_list
);
1610 list_for_each(t
, &thread_list
) {
1611 struct elf_thread_status
*tmp
;
1614 tmp
= list_entry(t
, struct elf_thread_status
, list
);
1615 sz
= elf_dump_thread_status(cprm
->siginfo
->si_signo
, tmp
);
1616 thread_status_size
+= sz
;
1619 /* now collect the dump for the current */
1620 fill_prstatus(prstatus
, current
, cprm
->siginfo
->si_signo
);
1621 elf_core_copy_regs(&prstatus
->pr_reg
, cprm
->regs
);
1623 segs
= current
->mm
->map_count
;
1624 segs
+= elf_core_extra_phdrs();
1626 /* for notes section */
1629 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1630 * this, kernel supports extended numbering. Have a look at
1631 * include/linux/elf.h for further information. */
1632 e_phnum
= segs
> PN_XNUM
? PN_XNUM
: segs
;
1635 fill_elf_fdpic_header(elf
, e_phnum
);
1639 * Set up the notes in similar form to SVR4 core dumps made
1640 * with info from their /proc.
1643 fill_note(notes
+ 0, "CORE", NT_PRSTATUS
, sizeof(*prstatus
), prstatus
);
1644 fill_psinfo(psinfo
, current
->group_leader
, current
->mm
);
1645 fill_note(notes
+ 1, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1649 auxv
= (elf_addr_t
*) current
->mm
->saved_auxv
;
1654 while (auxv
[i
- 2] != AT_NULL
);
1655 fill_note(¬es
[numnote
++], "CORE", NT_AUXV
,
1656 i
* sizeof(elf_addr_t
), auxv
);
1658 /* Try to dump the FPU. */
1659 if ((prstatus
->pr_fpvalid
=
1660 elf_core_copy_task_fpregs(current
, cprm
->regs
, fpu
)))
1661 fill_note(notes
+ numnote
++,
1662 "CORE", NT_PRFPREG
, sizeof(*fpu
), fpu
);
1663 #ifdef ELF_CORE_COPY_XFPREGS
1664 if (elf_core_copy_task_xfpregs(current
, xfpu
))
1665 fill_note(notes
+ numnote
++,
1666 "LINUX", ELF_CORE_XFPREG_TYPE
, sizeof(*xfpu
), xfpu
);
1672 offset
+= sizeof(*elf
); /* Elf header */
1673 offset
+= segs
* sizeof(struct elf_phdr
); /* Program headers */
1675 /* Write notes phdr entry */
1679 for (i
= 0; i
< numnote
; i
++)
1680 sz
+= notesize(notes
+ i
);
1682 sz
+= thread_status_size
;
1684 phdr4note
= kmalloc(sizeof(*phdr4note
), GFP_KERNEL
);
1688 fill_elf_note_phdr(phdr4note
, sz
, offset
);
1692 /* Page-align dumped data */
1693 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1695 offset
+= elf_core_vma_data_size(cprm
->mm_flags
);
1696 offset
+= elf_core_extra_data_size();
1699 if (e_phnum
== PN_XNUM
) {
1700 shdr4extnum
= kmalloc(sizeof(*shdr4extnum
), GFP_KERNEL
);
1703 fill_extnum_info(elf
, shdr4extnum
, e_shoff
, segs
);
1708 if (!dump_emit(cprm
, elf
, sizeof(*elf
)))
1711 if (!dump_emit(cprm
, phdr4note
, sizeof(*phdr4note
)))
1714 /* write program headers for segments dump */
1715 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1716 struct elf_phdr phdr
;
1719 sz
= vma
->vm_end
- vma
->vm_start
;
1721 phdr
.p_type
= PT_LOAD
;
1722 phdr
.p_offset
= offset
;
1723 phdr
.p_vaddr
= vma
->vm_start
;
1725 phdr
.p_filesz
= maydump(vma
, cprm
->mm_flags
) ? sz
: 0;
1727 offset
+= phdr
.p_filesz
;
1728 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1729 if (vma
->vm_flags
& VM_WRITE
)
1730 phdr
.p_flags
|= PF_W
;
1731 if (vma
->vm_flags
& VM_EXEC
)
1732 phdr
.p_flags
|= PF_X
;
1733 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1735 if (!dump_emit(cprm
, &phdr
, sizeof(phdr
)))
1739 if (!elf_core_write_extra_phdrs(cprm
, offset
))
1742 /* write out the notes section */
1743 for (i
= 0; i
< numnote
; i
++)
1744 if (!writenote(notes
+ i
, cprm
))
1747 /* write out the thread status notes section */
1748 list_for_each(t
, &thread_list
) {
1749 struct elf_thread_status
*tmp
=
1750 list_entry(t
, struct elf_thread_status
, list
);
1752 for (i
= 0; i
< tmp
->num_notes
; i
++)
1753 if (!writenote(&tmp
->notes
[i
], cprm
))
1757 if (!dump_skip(cprm
, dataoff
- cprm
->pos
))
1760 if (!elf_fdpic_dump_segments(cprm
))
1763 if (!elf_core_write_extra_data(cprm
))
1766 if (e_phnum
== PN_XNUM
) {
1767 if (!dump_emit(cprm
, shdr4extnum
, sizeof(*shdr4extnum
)))
1771 if (cprm
->file
->f_pos
!= offset
) {
1774 "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1775 cprm
->file
->f_pos
, offset
);
1782 while (!list_empty(&thread_list
)) {
1783 struct list_head
*tmp
= thread_list
.next
;
1785 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
1794 #ifdef ELF_CORE_COPY_XFPREGS
1801 #endif /* CONFIG_ELF_CORE */