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>
39 #include <asm/uaccess.h>
40 #include <asm/param.h>
41 #include <asm/pgalloc.h>
43 typedef char *elf_caddr_t
;
46 #define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
48 #define kdebug(fmt, ...) do {} while(0)
52 #define kdcore(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
54 #define kdcore(fmt, ...) do {} while(0)
57 MODULE_LICENSE("GPL");
59 static int load_elf_fdpic_binary(struct linux_binprm
*);
60 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*, struct file
*);
61 static int elf_fdpic_map_file(struct elf_fdpic_params
*, struct file
*,
62 struct mm_struct
*, const char *);
64 static int create_elf_fdpic_tables(struct linux_binprm
*, struct mm_struct
*,
65 struct elf_fdpic_params
*,
66 struct elf_fdpic_params
*);
69 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*,
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 (elf_fdpic_transfer_args_to_stack(bprm
, &sp
) < 0)
522 * If this architecture has a platform capability string, copy it
523 * to userspace. In some cases (Sparc), this info is impossible
524 * for userspace to get any other way, in others (i386) it is
527 k_platform
= ELF_PLATFORM
;
531 platform_len
= strlen(k_platform
) + 1;
533 u_platform
= (char __user
*) sp
;
534 if (__copy_to_user(u_platform
, k_platform
, platform_len
) != 0)
539 * If this architecture has a "base" platform capability
540 * string, copy it to userspace.
542 k_base_platform
= ELF_BASE_PLATFORM
;
543 u_base_platform
= NULL
;
545 if (k_base_platform
) {
546 platform_len
= strlen(k_base_platform
) + 1;
548 u_base_platform
= (char __user
*) sp
;
549 if (__copy_to_user(u_base_platform
, k_base_platform
, platform_len
) != 0)
555 /* stack the load map(s) */
556 len
= sizeof(struct elf32_fdpic_loadmap
);
557 len
+= sizeof(struct elf32_fdpic_loadseg
) * exec_params
->loadmap
->nsegs
;
558 sp
= (sp
- len
) & ~7UL;
559 exec_params
->map_addr
= sp
;
561 if (copy_to_user((void __user
*) sp
, exec_params
->loadmap
, len
) != 0)
564 current
->mm
->context
.exec_fdpic_loadmap
= (unsigned long) sp
;
566 if (interp_params
->loadmap
) {
567 len
= sizeof(struct elf32_fdpic_loadmap
);
568 len
+= sizeof(struct elf32_fdpic_loadseg
) *
569 interp_params
->loadmap
->nsegs
;
570 sp
= (sp
- len
) & ~7UL;
571 interp_params
->map_addr
= sp
;
573 if (copy_to_user((void __user
*) sp
, interp_params
->loadmap
,
577 current
->mm
->context
.interp_fdpic_loadmap
= (unsigned long) sp
;
580 /* force 16 byte _final_ alignment here for generality */
581 #define DLINFO_ITEMS 15
583 nitems
= 1 + DLINFO_ITEMS
+ (k_platform
? 1 : 0) +
584 (k_base_platform
? 1 : 0) + AT_VECTOR_SIZE_ARCH
;
586 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
)
590 sp
-= nitems
* 2 * sizeof(unsigned long);
591 sp
-= (bprm
->envc
+ 1) * sizeof(char *); /* envv[] */
592 sp
-= (bprm
->argc
+ 1) * sizeof(char *); /* argv[] */
593 sp
-= 1 * sizeof(unsigned long); /* argc */
598 /* put the ELF interpreter info on the stack */
599 #define NEW_AUX_ENT(id, val) \
601 struct { unsigned long _id, _val; } __user *ent; \
603 ent = (void __user *) csp; \
604 __put_user((id), &ent[nr]._id); \
605 __put_user((val), &ent[nr]._val); \
610 csp
-= 2 * sizeof(unsigned long);
611 NEW_AUX_ENT(AT_NULL
, 0);
614 csp
-= 2 * sizeof(unsigned long);
615 NEW_AUX_ENT(AT_PLATFORM
,
616 (elf_addr_t
) (unsigned long) u_platform
);
619 if (k_base_platform
) {
621 csp
-= 2 * sizeof(unsigned long);
622 NEW_AUX_ENT(AT_BASE_PLATFORM
,
623 (elf_addr_t
) (unsigned long) u_base_platform
);
626 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
) {
628 csp
-= 2 * sizeof(unsigned long);
629 NEW_AUX_ENT(AT_EXECFD
, bprm
->interp_data
);
633 csp
-= DLINFO_ITEMS
* 2 * sizeof(unsigned long);
634 NEW_AUX_ENT(AT_HWCAP
, ELF_HWCAP
);
636 NEW_AUX_ENT(AT_HWCAP2
, ELF_HWCAP2
);
638 NEW_AUX_ENT(AT_PAGESZ
, PAGE_SIZE
);
639 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
640 NEW_AUX_ENT(AT_PHDR
, exec_params
->ph_addr
);
641 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
642 NEW_AUX_ENT(AT_PHNUM
, exec_params
->hdr
.e_phnum
);
643 NEW_AUX_ENT(AT_BASE
, interp_params
->elfhdr_addr
);
644 NEW_AUX_ENT(AT_FLAGS
, 0);
645 NEW_AUX_ENT(AT_ENTRY
, exec_params
->entry_addr
);
646 NEW_AUX_ENT(AT_UID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->uid
));
647 NEW_AUX_ENT(AT_EUID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->euid
));
648 NEW_AUX_ENT(AT_GID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->gid
));
649 NEW_AUX_ENT(AT_EGID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->egid
));
650 NEW_AUX_ENT(AT_SECURE
, security_bprm_secureexec(bprm
));
651 NEW_AUX_ENT(AT_EXECFN
, bprm
->exec
);
655 csp
-= AT_VECTOR_SIZE_ARCH
* 2 * sizeof(unsigned long);
657 /* ARCH_DLINFO must come last so platform specific code can enforce
658 * special alignment requirements on the AUXV if necessary (eg. PPC).
664 /* allocate room for argv[] and envv[] */
665 csp
-= (bprm
->envc
+ 1) * sizeof(elf_caddr_t
);
666 envp
= (elf_caddr_t __user
*) csp
;
667 csp
-= (bprm
->argc
+ 1) * sizeof(elf_caddr_t
);
668 argv
= (elf_caddr_t __user
*) csp
;
671 csp
-= sizeof(unsigned long);
672 __put_user(bprm
->argc
, (unsigned long __user
*) csp
);
676 /* fill in the argv[] array */
678 current
->mm
->arg_start
= bprm
->p
;
680 current
->mm
->arg_start
= current
->mm
->start_stack
-
681 (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
);
684 p
= (char __user
*) current
->mm
->arg_start
;
685 for (loop
= bprm
->argc
; loop
> 0; loop
--) {
686 __put_user((elf_caddr_t
) p
, argv
++);
687 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
688 if (!len
|| len
> MAX_ARG_STRLEN
)
692 __put_user(NULL
, argv
);
693 current
->mm
->arg_end
= (unsigned long) p
;
695 /* fill in the envv[] array */
696 current
->mm
->env_start
= (unsigned long) p
;
697 for (loop
= bprm
->envc
; loop
> 0; loop
--) {
698 __put_user((elf_caddr_t
)(unsigned long) p
, envp
++);
699 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
700 if (!len
|| len
> MAX_ARG_STRLEN
)
704 __put_user(NULL
, envp
);
705 current
->mm
->env_end
= (unsigned long) p
;
707 mm
->start_stack
= (unsigned long) sp
;
711 /*****************************************************************************/
713 * transfer the program arguments and environment from the holding pages onto
717 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*bprm
,
720 unsigned long index
, stop
, sp
;
724 stop
= bprm
->p
>> PAGE_SHIFT
;
727 for (index
= MAX_ARG_PAGES
- 1; index
>= stop
; index
--) {
728 src
= kmap(bprm
->page
[index
]);
730 if (copy_to_user((void *) sp
, src
, PAGE_SIZE
) != 0)
732 kunmap(bprm
->page
[index
]);
737 *_sp
= (*_sp
- (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
)) & ~15;
744 /*****************************************************************************/
746 * load the appropriate binary image (executable or interpreter) into memory
747 * - we assume no MMU is available
748 * - if no other PIC bits are set in params->hdr->e_flags
749 * - we assume that the LOADable segments in the binary are independently relocatable
750 * - we assume R/O executable segments are shareable
752 * - we assume the loadable parts of the image to require fixed displacement
753 * - the image is not shareable
755 static int elf_fdpic_map_file(struct elf_fdpic_params
*params
,
757 struct mm_struct
*mm
,
760 struct elf32_fdpic_loadmap
*loadmap
;
762 struct elf32_fdpic_loadseg
*mseg
;
764 struct elf32_fdpic_loadseg
*seg
;
765 struct elf32_phdr
*phdr
;
766 unsigned long load_addr
, stop
;
767 unsigned nloads
, tmp
;
771 /* allocate a load map table */
773 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++)
774 if (params
->phdrs
[loop
].p_type
== PT_LOAD
)
780 size
= sizeof(*loadmap
) + nloads
* sizeof(*seg
);
781 loadmap
= kzalloc(size
, GFP_KERNEL
);
785 params
->loadmap
= loadmap
;
787 loadmap
->version
= ELF32_FDPIC_LOADMAP_VERSION
;
788 loadmap
->nsegs
= nloads
;
790 load_addr
= params
->load_addr
;
793 /* map the requested LOADs into the memory space */
794 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
795 case ELF_FDPIC_FLAG_CONSTDISP
:
796 case ELF_FDPIC_FLAG_CONTIGUOUS
:
798 ret
= elf_fdpic_map_file_constdisp_on_uclinux(params
, file
, mm
);
804 ret
= elf_fdpic_map_file_by_direct_mmap(params
, file
, mm
);
810 /* map the entry point */
811 if (params
->hdr
.e_entry
) {
813 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
814 if (params
->hdr
.e_entry
>= seg
->p_vaddr
&&
815 params
->hdr
.e_entry
< seg
->p_vaddr
+ seg
->p_memsz
) {
817 (params
->hdr
.e_entry
- seg
->p_vaddr
) +
824 /* determine where the program header table has wound up if mapped */
825 stop
= params
->hdr
.e_phoff
;
826 stop
+= params
->hdr
.e_phnum
* sizeof (struct elf_phdr
);
827 phdr
= params
->phdrs
;
829 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
830 if (phdr
->p_type
!= PT_LOAD
)
833 if (phdr
->p_offset
> params
->hdr
.e_phoff
||
834 phdr
->p_offset
+ phdr
->p_filesz
< stop
)
838 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
839 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
840 phdr
->p_vaddr
+ phdr
->p_filesz
<=
841 seg
->p_vaddr
+ seg
->p_memsz
) {
843 (phdr
->p_vaddr
- seg
->p_vaddr
) +
845 params
->hdr
.e_phoff
- phdr
->p_offset
;
852 /* determine where the dynamic section has wound up if there is one */
853 phdr
= params
->phdrs
;
854 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
855 if (phdr
->p_type
!= PT_DYNAMIC
)
859 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
860 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
861 phdr
->p_vaddr
+ phdr
->p_memsz
<=
862 seg
->p_vaddr
+ seg
->p_memsz
) {
863 params
->dynamic_addr
=
864 (phdr
->p_vaddr
- seg
->p_vaddr
) +
867 /* check the dynamic section contains at least
868 * one item, and that the last item is a NULL
870 if (phdr
->p_memsz
== 0 ||
871 phdr
->p_memsz
% sizeof(Elf32_Dyn
) != 0)
874 tmp
= phdr
->p_memsz
/ sizeof(Elf32_Dyn
);
876 params
->dynamic_addr
)[tmp
- 1].d_tag
!= 0)
884 /* now elide adjacent segments in the load map on MMU linux
885 * - on uClinux the holes between may actually be filled with system
886 * stuff or stuff from other processes
889 nloads
= loadmap
->nsegs
;
890 mseg
= loadmap
->segs
;
892 for (loop
= 1; loop
< nloads
; loop
++) {
893 /* see if we have a candidate for merging */
894 if (seg
->p_vaddr
- mseg
->p_vaddr
== seg
->addr
- mseg
->addr
) {
895 load_addr
= PAGE_ALIGN(mseg
->addr
+ mseg
->p_memsz
);
896 if (load_addr
== (seg
->addr
& PAGE_MASK
)) {
899 (mseg
->addr
+ mseg
->p_memsz
);
900 mseg
->p_memsz
+= seg
->addr
& ~PAGE_MASK
;
901 mseg
->p_memsz
+= seg
->p_memsz
;
913 kdebug("Mapped Object [%s]:", what
);
914 kdebug("- elfhdr : %lx", params
->elfhdr_addr
);
915 kdebug("- entry : %lx", params
->entry_addr
);
916 kdebug("- PHDR[] : %lx", params
->ph_addr
);
917 kdebug("- DYNAMIC[]: %lx", params
->dynamic_addr
);
919 for (loop
= 0; loop
< loadmap
->nsegs
; loop
++, seg
++)
920 kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
922 seg
->addr
, seg
->addr
+ seg
->p_memsz
- 1,
923 seg
->p_vaddr
, seg
->p_memsz
);
928 printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
929 what
, file_inode(file
)->i_ino
);
933 /*****************************************************************************/
935 * map a file with constant displacement under uClinux
938 static int elf_fdpic_map_file_constdisp_on_uclinux(
939 struct elf_fdpic_params
*params
,
941 struct mm_struct
*mm
)
943 struct elf32_fdpic_loadseg
*seg
;
944 struct elf32_phdr
*phdr
;
945 unsigned long load_addr
, base
= ULONG_MAX
, top
= 0, maddr
= 0, mflags
;
948 load_addr
= params
->load_addr
;
949 seg
= params
->loadmap
->segs
;
951 /* determine the bounds of the contiguous overall allocation we must
953 phdr
= params
->phdrs
;
954 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
955 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
958 if (base
> phdr
->p_vaddr
)
959 base
= phdr
->p_vaddr
;
960 if (top
< phdr
->p_vaddr
+ phdr
->p_memsz
)
961 top
= phdr
->p_vaddr
+ phdr
->p_memsz
;
964 /* allocate one big anon block for everything */
965 mflags
= MAP_PRIVATE
;
966 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
967 mflags
|= MAP_EXECUTABLE
;
969 maddr
= vm_mmap(NULL
, load_addr
, top
- base
,
970 PROT_READ
| PROT_WRITE
| PROT_EXEC
, mflags
, 0);
971 if (IS_ERR_VALUE(maddr
))
975 load_addr
+= PAGE_ALIGN(top
- base
);
977 /* and then load the file segments into it */
978 phdr
= params
->phdrs
;
979 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
980 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
983 seg
->addr
= maddr
+ (phdr
->p_vaddr
- base
);
984 seg
->p_vaddr
= phdr
->p_vaddr
;
985 seg
->p_memsz
= phdr
->p_memsz
;
987 ret
= read_code(file
, seg
->addr
, phdr
->p_offset
,
992 /* map the ELF header address if in this segment */
993 if (phdr
->p_offset
== 0)
994 params
->elfhdr_addr
= seg
->addr
;
996 /* clear any space allocated but not loaded */
997 if (phdr
->p_filesz
< phdr
->p_memsz
) {
998 if (clear_user((void *) (seg
->addr
+ phdr
->p_filesz
),
999 phdr
->p_memsz
- phdr
->p_filesz
))
1004 if (phdr
->p_flags
& PF_X
) {
1005 if (!mm
->start_code
) {
1006 mm
->start_code
= seg
->addr
;
1007 mm
->end_code
= seg
->addr
+
1010 } else if (!mm
->start_data
) {
1011 mm
->start_data
= seg
->addr
;
1012 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
1023 /*****************************************************************************/
1025 * map a binary by direct mmap() of the individual PT_LOAD segments
1027 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*params
,
1029 struct mm_struct
*mm
)
1031 struct elf32_fdpic_loadseg
*seg
;
1032 struct elf32_phdr
*phdr
;
1033 unsigned long load_addr
, delta_vaddr
;
1036 load_addr
= params
->load_addr
;
1040 seg
= params
->loadmap
->segs
;
1042 /* deal with each load segment separately */
1043 phdr
= params
->phdrs
;
1044 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
1045 unsigned long maddr
, disp
, excess
, excess1
;
1046 int prot
= 0, flags
;
1048 if (phdr
->p_type
!= PT_LOAD
)
1051 kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1052 (unsigned long) phdr
->p_vaddr
,
1053 (unsigned long) phdr
->p_offset
,
1054 (unsigned long) phdr
->p_filesz
,
1055 (unsigned long) phdr
->p_memsz
);
1057 /* determine the mapping parameters */
1058 if (phdr
->p_flags
& PF_R
) prot
|= PROT_READ
;
1059 if (phdr
->p_flags
& PF_W
) prot
|= PROT_WRITE
;
1060 if (phdr
->p_flags
& PF_X
) prot
|= PROT_EXEC
;
1062 flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1063 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
1064 flags
|= MAP_EXECUTABLE
;
1068 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
1069 case ELF_FDPIC_FLAG_INDEPENDENT
:
1070 /* PT_LOADs are independently locatable */
1073 case ELF_FDPIC_FLAG_HONOURVADDR
:
1074 /* the specified virtual address must be honoured */
1075 maddr
= phdr
->p_vaddr
;
1079 case ELF_FDPIC_FLAG_CONSTDISP
:
1080 /* constant displacement
1081 * - can be mapped anywhere, but must be mapped as a
1086 delta_vaddr
= phdr
->p_vaddr
;
1089 maddr
= load_addr
+ phdr
->p_vaddr
- delta_vaddr
;
1094 case ELF_FDPIC_FLAG_CONTIGUOUS
:
1095 /* contiguity handled later */
1104 /* create the mapping */
1105 disp
= phdr
->p_vaddr
& ~PAGE_MASK
;
1106 maddr
= vm_mmap(file
, maddr
, phdr
->p_memsz
+ disp
, prot
, flags
,
1107 phdr
->p_offset
- disp
);
1109 kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1110 loop
, phdr
->p_memsz
+ disp
, prot
, flags
,
1111 phdr
->p_offset
- disp
, maddr
);
1113 if (IS_ERR_VALUE(maddr
))
1116 if ((params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) ==
1117 ELF_FDPIC_FLAG_CONTIGUOUS
)
1118 load_addr
+= PAGE_ALIGN(phdr
->p_memsz
+ disp
);
1120 seg
->addr
= maddr
+ disp
;
1121 seg
->p_vaddr
= phdr
->p_vaddr
;
1122 seg
->p_memsz
= phdr
->p_memsz
;
1124 /* map the ELF header address if in this segment */
1125 if (phdr
->p_offset
== 0)
1126 params
->elfhdr_addr
= seg
->addr
;
1128 /* clear the bit between beginning of mapping and beginning of
1130 if (prot
& PROT_WRITE
&& disp
> 0) {
1131 kdebug("clear[%d] ad=%lx sz=%lx", loop
, maddr
, disp
);
1132 if (clear_user((void __user
*) maddr
, disp
))
1137 /* clear any space allocated but not loaded
1138 * - on uClinux we can just clear the lot
1139 * - on MMU linux we'll get a SIGBUS beyond the last page
1140 * extant in the file
1142 excess
= phdr
->p_memsz
- phdr
->p_filesz
;
1143 excess1
= PAGE_SIZE
- ((maddr
+ phdr
->p_filesz
) & ~PAGE_MASK
);
1146 if (excess
> excess1
) {
1147 unsigned long xaddr
= maddr
+ phdr
->p_filesz
+ excess1
;
1148 unsigned long xmaddr
;
1150 flags
|= MAP_FIXED
| MAP_ANONYMOUS
;
1151 xmaddr
= vm_mmap(NULL
, xaddr
, excess
- excess1
,
1154 kdebug("mmap[%d] <anon>"
1155 " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1156 loop
, xaddr
, excess
- excess1
, prot
, flags
,
1159 if (xmaddr
!= xaddr
)
1163 if (prot
& PROT_WRITE
&& excess1
> 0) {
1164 kdebug("clear[%d] ad=%lx sz=%lx",
1165 loop
, maddr
+ phdr
->p_filesz
, excess1
);
1166 if (clear_user((void __user
*) maddr
+ phdr
->p_filesz
,
1173 kdebug("clear[%d] ad=%lx sz=%lx",
1174 loop
, maddr
+ phdr
->p_filesz
, excess
);
1175 if (clear_user((void *) maddr
+ phdr
->p_filesz
, excess
))
1181 if (phdr
->p_flags
& PF_X
) {
1182 if (!mm
->start_code
) {
1183 mm
->start_code
= maddr
;
1184 mm
->end_code
= maddr
+ phdr
->p_memsz
;
1186 } else if (!mm
->start_data
) {
1187 mm
->start_data
= maddr
;
1188 mm
->end_data
= maddr
+ phdr
->p_memsz
;
1198 /*****************************************************************************/
1200 * ELF-FDPIC core dumper
1202 * Modelled on fs/exec.c:aout_core_dump()
1203 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1205 * Modelled on fs/binfmt_elf.c core dumper
1207 #ifdef CONFIG_ELF_CORE
1210 * Decide whether a segment is worth dumping; default is yes to be
1211 * sure (missing info is worse than too much; etc).
1212 * Personally I'd include everything, and use the coredump limit...
1214 * I think we should skip something. But I am not sure how. H.J.
1216 static int maydump(struct vm_area_struct
*vma
, unsigned long mm_flags
)
1220 /* Do not dump I/O mapped devices or special mappings */
1221 if (vma
->vm_flags
& VM_IO
) {
1222 kdcore("%08lx: %08lx: no (IO)", vma
->vm_start
, vma
->vm_flags
);
1226 /* If we may not read the contents, don't allow us to dump
1227 * them either. "dump_write()" can't handle it anyway.
1229 if (!(vma
->vm_flags
& VM_READ
)) {
1230 kdcore("%08lx: %08lx: no (!read)", vma
->vm_start
, vma
->vm_flags
);
1234 /* By default, dump shared memory if mapped from an anonymous file. */
1235 if (vma
->vm_flags
& VM_SHARED
) {
1236 if (file_inode(vma
->vm_file
)->i_nlink
== 0) {
1237 dump_ok
= test_bit(MMF_DUMP_ANON_SHARED
, &mm_flags
);
1238 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1239 vma
->vm_flags
, dump_ok
? "yes" : "no");
1243 dump_ok
= test_bit(MMF_DUMP_MAPPED_SHARED
, &mm_flags
);
1244 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1245 vma
->vm_flags
, dump_ok
? "yes" : "no");
1250 /* By default, if it hasn't been written to, don't write it out */
1251 if (!vma
->anon_vma
) {
1252 dump_ok
= test_bit(MMF_DUMP_MAPPED_PRIVATE
, &mm_flags
);
1253 kdcore("%08lx: %08lx: %s (!anon)", vma
->vm_start
,
1254 vma
->vm_flags
, dump_ok
? "yes" : "no");
1259 dump_ok
= test_bit(MMF_DUMP_ANON_PRIVATE
, &mm_flags
);
1260 kdcore("%08lx: %08lx: %s", vma
->vm_start
, vma
->vm_flags
,
1261 dump_ok
? "yes" : "no");
1265 /* An ELF note in memory */
1270 unsigned int datasz
;
1274 static int notesize(struct memelfnote
*en
)
1278 sz
= sizeof(struct elf_note
);
1279 sz
+= roundup(strlen(en
->name
) + 1, 4);
1280 sz
+= roundup(en
->datasz
, 4);
1287 static int writenote(struct memelfnote
*men
, struct coredump_params
*cprm
)
1290 en
.n_namesz
= strlen(men
->name
) + 1;
1291 en
.n_descsz
= men
->datasz
;
1292 en
.n_type
= men
->type
;
1294 return dump_emit(cprm
, &en
, sizeof(en
)) &&
1295 dump_emit(cprm
, men
->name
, en
.n_namesz
) && dump_align(cprm
, 4) &&
1296 dump_emit(cprm
, men
->data
, men
->datasz
) && dump_align(cprm
, 4);
1299 static inline void fill_elf_fdpic_header(struct elfhdr
*elf
, int segs
)
1301 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1302 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1303 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1304 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1305 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1306 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1308 elf
->e_type
= ET_CORE
;
1309 elf
->e_machine
= ELF_ARCH
;
1310 elf
->e_version
= EV_CURRENT
;
1312 elf
->e_phoff
= sizeof(struct elfhdr
);
1314 elf
->e_flags
= ELF_FDPIC_CORE_EFLAGS
;
1315 elf
->e_ehsize
= sizeof(struct elfhdr
);
1316 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1317 elf
->e_phnum
= segs
;
1318 elf
->e_shentsize
= 0;
1320 elf
->e_shstrndx
= 0;
1324 static inline void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1326 phdr
->p_type
= PT_NOTE
;
1327 phdr
->p_offset
= offset
;
1330 phdr
->p_filesz
= sz
;
1337 static inline void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1338 unsigned int sz
, void *data
)
1348 * fill up all the fields in prstatus from the given task struct, except
1349 * registers which need to be filled up separately.
1351 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1352 struct task_struct
*p
, long signr
)
1354 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1355 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1356 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1358 prstatus
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1360 prstatus
->pr_pid
= task_pid_vnr(p
);
1361 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1362 prstatus
->pr_sid
= task_session_vnr(p
);
1363 if (thread_group_leader(p
)) {
1364 struct task_cputime cputime
;
1367 * This is the record for the group leader. It shows the
1368 * group-wide total, not its individual thread total.
1370 thread_group_cputime(p
, &cputime
);
1371 cputime_to_timeval(cputime
.utime
, &prstatus
->pr_utime
);
1372 cputime_to_timeval(cputime
.stime
, &prstatus
->pr_stime
);
1374 cputime_t utime
, stime
;
1376 task_cputime(p
, &utime
, &stime
);
1377 cputime_to_timeval(utime
, &prstatus
->pr_utime
);
1378 cputime_to_timeval(stime
, &prstatus
->pr_stime
);
1380 cputime_to_timeval(p
->signal
->cutime
, &prstatus
->pr_cutime
);
1381 cputime_to_timeval(p
->signal
->cstime
, &prstatus
->pr_cstime
);
1383 prstatus
->pr_exec_fdpic_loadmap
= p
->mm
->context
.exec_fdpic_loadmap
;
1384 prstatus
->pr_interp_fdpic_loadmap
= p
->mm
->context
.interp_fdpic_loadmap
;
1387 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1388 struct mm_struct
*mm
)
1390 const struct cred
*cred
;
1391 unsigned int i
, len
;
1393 /* first copy the parameters from user space */
1394 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1396 len
= mm
->arg_end
- mm
->arg_start
;
1397 if (len
>= ELF_PRARGSZ
)
1398 len
= ELF_PRARGSZ
- 1;
1399 if (copy_from_user(&psinfo
->pr_psargs
,
1400 (const char __user
*) mm
->arg_start
, len
))
1402 for (i
= 0; i
< len
; i
++)
1403 if (psinfo
->pr_psargs
[i
] == 0)
1404 psinfo
->pr_psargs
[i
] = ' ';
1405 psinfo
->pr_psargs
[len
] = 0;
1408 psinfo
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1410 psinfo
->pr_pid
= task_pid_vnr(p
);
1411 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1412 psinfo
->pr_sid
= task_session_vnr(p
);
1414 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1415 psinfo
->pr_state
= i
;
1416 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1417 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1418 psinfo
->pr_nice
= task_nice(p
);
1419 psinfo
->pr_flag
= p
->flags
;
1421 cred
= __task_cred(p
);
1422 SET_UID(psinfo
->pr_uid
, from_kuid_munged(cred
->user_ns
, cred
->uid
));
1423 SET_GID(psinfo
->pr_gid
, from_kgid_munged(cred
->user_ns
, cred
->gid
));
1425 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1430 /* Here is the structure in which status of each thread is captured. */
1431 struct elf_thread_status
1433 struct list_head list
;
1434 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1435 elf_fpregset_t fpu
; /* NT_PRFPREG */
1436 struct task_struct
*thread
;
1437 #ifdef ELF_CORE_COPY_XFPREGS
1438 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1440 struct memelfnote notes
[3];
1445 * In order to add the specific thread information for the elf file format,
1446 * we need to keep a linked list of every thread's pr_status and then create
1447 * a single section for them in the final core file.
1449 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1451 struct task_struct
*p
= t
->thread
;
1456 fill_prstatus(&t
->prstatus
, p
, signr
);
1457 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1459 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1462 sz
+= notesize(&t
->notes
[0]);
1464 t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
, &t
->fpu
);
1465 if (t
->prstatus
.pr_fpvalid
) {
1466 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1469 sz
+= notesize(&t
->notes
[1]);
1472 #ifdef ELF_CORE_COPY_XFPREGS
1473 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1474 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1475 sizeof(t
->xfpu
), &t
->xfpu
);
1477 sz
+= notesize(&t
->notes
[2]);
1483 static void fill_extnum_info(struct elfhdr
*elf
, struct elf_shdr
*shdr4extnum
,
1484 elf_addr_t e_shoff
, int segs
)
1486 elf
->e_shoff
= e_shoff
;
1487 elf
->e_shentsize
= sizeof(*shdr4extnum
);
1489 elf
->e_shstrndx
= SHN_UNDEF
;
1491 memset(shdr4extnum
, 0, sizeof(*shdr4extnum
));
1493 shdr4extnum
->sh_type
= SHT_NULL
;
1494 shdr4extnum
->sh_size
= elf
->e_shnum
;
1495 shdr4extnum
->sh_link
= elf
->e_shstrndx
;
1496 shdr4extnum
->sh_info
= segs
;
1500 * dump the segments for an MMU process
1502 static bool elf_fdpic_dump_segments(struct coredump_params
*cprm
)
1504 struct vm_area_struct
*vma
;
1506 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1509 if (!maydump(vma
, cprm
->mm_flags
))
1513 for (addr
= vma
->vm_start
; addr
< vma
->vm_end
;
1514 addr
+= PAGE_SIZE
) {
1516 struct page
*page
= get_dump_page(addr
);
1518 void *kaddr
= kmap(page
);
1519 res
= dump_emit(cprm
, kaddr
, PAGE_SIZE
);
1521 page_cache_release(page
);
1523 res
= dump_skip(cprm
, PAGE_SIZE
);
1529 if (!dump_emit(cprm
, (void *) vma
->vm_start
,
1530 vma
->vm_end
- vma
->vm_start
))
1537 static size_t elf_core_vma_data_size(unsigned long mm_flags
)
1539 struct vm_area_struct
*vma
;
1542 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
)
1543 if (maydump(vma
, mm_flags
))
1544 size
+= vma
->vm_end
- vma
->vm_start
;
1551 * This is a two-pass process; first we find the offsets of the bits,
1552 * and then they are actually written out. If we run out of core limit
1555 static int elf_fdpic_core_dump(struct coredump_params
*cprm
)
1562 struct vm_area_struct
*vma
;
1563 struct elfhdr
*elf
= NULL
;
1564 loff_t offset
= 0, dataoff
;
1566 struct memelfnote
*notes
= NULL
;
1567 struct elf_prstatus
*prstatus
= NULL
; /* NT_PRSTATUS */
1568 struct elf_prpsinfo
*psinfo
= NULL
; /* NT_PRPSINFO */
1569 LIST_HEAD(thread_list
);
1570 struct list_head
*t
;
1571 elf_fpregset_t
*fpu
= NULL
;
1572 #ifdef ELF_CORE_COPY_XFPREGS
1573 elf_fpxregset_t
*xfpu
= NULL
;
1575 int thread_status_size
= 0;
1577 struct elf_phdr
*phdr4note
= NULL
;
1578 struct elf_shdr
*shdr4extnum
= NULL
;
1581 struct core_thread
*ct
;
1582 struct elf_thread_status
*tmp
;
1585 * We no longer stop all VM operations.
1587 * This is because those proceses that could possibly change map_count
1588 * or the mmap / vma pages are now blocked in do_exit on current
1589 * finishing this core dump.
1591 * Only ptrace can touch these memory addresses, but it doesn't change
1592 * the map_count or the pages allocated. So no possibility of crashing
1593 * exists while dumping the mm->vm_next areas to the core file.
1596 /* alloc memory for large data structures: too large to be on stack */
1597 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
1600 prstatus
= kzalloc(sizeof(*prstatus
), GFP_KERNEL
);
1603 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1606 notes
= kmalloc(NUM_NOTES
* sizeof(struct memelfnote
), GFP_KERNEL
);
1609 fpu
= kmalloc(sizeof(*fpu
), GFP_KERNEL
);
1612 #ifdef ELF_CORE_COPY_XFPREGS
1613 xfpu
= kmalloc(sizeof(*xfpu
), GFP_KERNEL
);
1618 for (ct
= current
->mm
->core_state
->dumper
.next
;
1619 ct
; ct
= ct
->next
) {
1620 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1624 tmp
->thread
= ct
->task
;
1625 list_add(&tmp
->list
, &thread_list
);
1628 list_for_each(t
, &thread_list
) {
1629 struct elf_thread_status
*tmp
;
1632 tmp
= list_entry(t
, struct elf_thread_status
, list
);
1633 sz
= elf_dump_thread_status(cprm
->siginfo
->si_signo
, tmp
);
1634 thread_status_size
+= sz
;
1637 /* now collect the dump for the current */
1638 fill_prstatus(prstatus
, current
, cprm
->siginfo
->si_signo
);
1639 elf_core_copy_regs(&prstatus
->pr_reg
, cprm
->regs
);
1641 segs
= current
->mm
->map_count
;
1642 segs
+= elf_core_extra_phdrs();
1644 /* for notes section */
1647 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1648 * this, kernel supports extended numbering. Have a look at
1649 * include/linux/elf.h for further information. */
1650 e_phnum
= segs
> PN_XNUM
? PN_XNUM
: segs
;
1653 fill_elf_fdpic_header(elf
, e_phnum
);
1657 * Set up the notes in similar form to SVR4 core dumps made
1658 * with info from their /proc.
1661 fill_note(notes
+ 0, "CORE", NT_PRSTATUS
, sizeof(*prstatus
), prstatus
);
1662 fill_psinfo(psinfo
, current
->group_leader
, current
->mm
);
1663 fill_note(notes
+ 1, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1667 auxv
= (elf_addr_t
*) current
->mm
->saved_auxv
;
1672 while (auxv
[i
- 2] != AT_NULL
);
1673 fill_note(¬es
[numnote
++], "CORE", NT_AUXV
,
1674 i
* sizeof(elf_addr_t
), auxv
);
1676 /* Try to dump the FPU. */
1677 if ((prstatus
->pr_fpvalid
=
1678 elf_core_copy_task_fpregs(current
, cprm
->regs
, fpu
)))
1679 fill_note(notes
+ numnote
++,
1680 "CORE", NT_PRFPREG
, sizeof(*fpu
), fpu
);
1681 #ifdef ELF_CORE_COPY_XFPREGS
1682 if (elf_core_copy_task_xfpregs(current
, xfpu
))
1683 fill_note(notes
+ numnote
++,
1684 "LINUX", ELF_CORE_XFPREG_TYPE
, sizeof(*xfpu
), xfpu
);
1690 offset
+= sizeof(*elf
); /* Elf header */
1691 offset
+= segs
* sizeof(struct elf_phdr
); /* Program headers */
1693 /* Write notes phdr entry */
1697 for (i
= 0; i
< numnote
; i
++)
1698 sz
+= notesize(notes
+ i
);
1700 sz
+= thread_status_size
;
1702 phdr4note
= kmalloc(sizeof(*phdr4note
), GFP_KERNEL
);
1706 fill_elf_note_phdr(phdr4note
, sz
, offset
);
1710 /* Page-align dumped data */
1711 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1713 offset
+= elf_core_vma_data_size(cprm
->mm_flags
);
1714 offset
+= elf_core_extra_data_size();
1717 if (e_phnum
== PN_XNUM
) {
1718 shdr4extnum
= kmalloc(sizeof(*shdr4extnum
), GFP_KERNEL
);
1721 fill_extnum_info(elf
, shdr4extnum
, e_shoff
, segs
);
1726 if (!dump_emit(cprm
, elf
, sizeof(*elf
)))
1729 if (!dump_emit(cprm
, phdr4note
, sizeof(*phdr4note
)))
1732 /* write program headers for segments dump */
1733 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1734 struct elf_phdr phdr
;
1737 sz
= vma
->vm_end
- vma
->vm_start
;
1739 phdr
.p_type
= PT_LOAD
;
1740 phdr
.p_offset
= offset
;
1741 phdr
.p_vaddr
= vma
->vm_start
;
1743 phdr
.p_filesz
= maydump(vma
, cprm
->mm_flags
) ? sz
: 0;
1745 offset
+= phdr
.p_filesz
;
1746 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1747 if (vma
->vm_flags
& VM_WRITE
)
1748 phdr
.p_flags
|= PF_W
;
1749 if (vma
->vm_flags
& VM_EXEC
)
1750 phdr
.p_flags
|= PF_X
;
1751 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1753 if (!dump_emit(cprm
, &phdr
, sizeof(phdr
)))
1757 if (!elf_core_write_extra_phdrs(cprm
, offset
))
1760 /* write out the notes section */
1761 for (i
= 0; i
< numnote
; i
++)
1762 if (!writenote(notes
+ i
, cprm
))
1765 /* write out the thread status notes section */
1766 list_for_each(t
, &thread_list
) {
1767 struct elf_thread_status
*tmp
=
1768 list_entry(t
, struct elf_thread_status
, list
);
1770 for (i
= 0; i
< tmp
->num_notes
; i
++)
1771 if (!writenote(&tmp
->notes
[i
], cprm
))
1775 if (!dump_skip(cprm
, dataoff
- cprm
->written
))
1778 if (!elf_fdpic_dump_segments(cprm
))
1781 if (!elf_core_write_extra_data(cprm
))
1784 if (e_phnum
== PN_XNUM
) {
1785 if (!dump_emit(cprm
, shdr4extnum
, sizeof(*shdr4extnum
)))
1789 if (cprm
->file
->f_pos
!= offset
) {
1792 "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1793 cprm
->file
->f_pos
, offset
);
1800 while (!list_empty(&thread_list
)) {
1801 struct list_head
*tmp
= thread_list
.next
;
1803 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
1812 #ifdef ELF_CORE_COPY_XFPREGS
1819 #endif /* CONFIG_ELF_CORE */