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_fdpic(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
) || !elf_check_fdpic(hdr
))
114 if (!file
->f_op
->mmap
)
119 /*****************************************************************************/
121 * read the program headers table into memory
123 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*params
,
126 struct elf32_phdr
*phdr
;
130 if (params
->hdr
.e_phentsize
!= sizeof(struct elf_phdr
))
132 if (params
->hdr
.e_phnum
> 65536U / sizeof(struct elf_phdr
))
135 size
= params
->hdr
.e_phnum
* sizeof(struct elf_phdr
);
136 params
->phdrs
= kmalloc(size
, GFP_KERNEL
);
140 retval
= kernel_read(file
, params
->hdr
.e_phoff
,
141 (char *) params
->phdrs
, size
);
142 if (unlikely(retval
!= size
))
143 return retval
< 0 ? retval
: -ENOEXEC
;
145 /* determine stack size for this binary */
146 phdr
= params
->phdrs
;
147 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
148 if (phdr
->p_type
!= PT_GNU_STACK
)
151 if (phdr
->p_flags
& PF_X
)
152 params
->flags
|= ELF_FDPIC_FLAG_EXEC_STACK
;
154 params
->flags
|= ELF_FDPIC_FLAG_NOEXEC_STACK
;
156 params
->stack_size
= phdr
->p_memsz
;
163 /*****************************************************************************/
165 * load an fdpic binary into various bits of memory
167 static int load_elf_fdpic_binary(struct linux_binprm
*bprm
)
169 struct elf_fdpic_params exec_params
, interp_params
;
170 struct pt_regs
*regs
= current_pt_regs();
171 struct elf_phdr
*phdr
;
172 unsigned long stack_size
, entryaddr
;
173 #ifdef ELF_FDPIC_PLAT_INIT
174 unsigned long dynaddr
;
177 unsigned long stack_prot
;
179 struct file
*interpreter
= NULL
; /* to shut gcc up */
180 char *interpreter_name
= NULL
;
181 int executable_stack
;
184 kdebug("____ LOAD %d ____", current
->pid
);
186 memset(&exec_params
, 0, sizeof(exec_params
));
187 memset(&interp_params
, 0, sizeof(interp_params
));
189 exec_params
.hdr
= *(struct elfhdr
*) bprm
->buf
;
190 exec_params
.flags
= ELF_FDPIC_FLAG_PRESENT
| ELF_FDPIC_FLAG_EXECUTABLE
;
192 /* check that this is a binary we know how to deal with */
194 if (!is_elf_fdpic(&exec_params
.hdr
, bprm
->file
))
197 /* read the program header table */
198 retval
= elf_fdpic_fetch_phdrs(&exec_params
, bprm
->file
);
202 /* scan for a program header that specifies an interpreter */
203 phdr
= exec_params
.phdrs
;
205 for (i
= 0; i
< exec_params
.hdr
.e_phnum
; i
++, phdr
++) {
206 switch (phdr
->p_type
) {
209 if (phdr
->p_filesz
> PATH_MAX
)
212 if (phdr
->p_filesz
< 2)
215 /* read the name of the interpreter into memory */
216 interpreter_name
= kmalloc(phdr
->p_filesz
, GFP_KERNEL
);
217 if (!interpreter_name
)
220 retval
= kernel_read(bprm
->file
,
224 if (unlikely(retval
!= phdr
->p_filesz
)) {
231 if (interpreter_name
[phdr
->p_filesz
- 1] != '\0')
234 kdebug("Using ELF interpreter %s", interpreter_name
);
236 /* replace the program with the interpreter */
237 interpreter
= open_exec(interpreter_name
);
238 retval
= PTR_ERR(interpreter
);
239 if (IS_ERR(interpreter
)) {
245 * If the binary is not readable then enforce
246 * mm->dumpable = 0 regardless of the interpreter's
249 would_dump(bprm
, interpreter
);
251 retval
= kernel_read(interpreter
, 0, bprm
->buf
,
253 if (unlikely(retval
!= BINPRM_BUF_SIZE
)) {
259 interp_params
.hdr
= *((struct elfhdr
*) bprm
->buf
);
264 if (exec_params
.load_addr
== 0)
265 exec_params
.load_addr
= phdr
->p_vaddr
;
272 if (elf_check_const_displacement(&exec_params
.hdr
))
273 exec_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
275 /* perform insanity checks on the interpreter */
276 if (interpreter_name
) {
278 if (!is_elf_fdpic(&interp_params
.hdr
, interpreter
))
281 interp_params
.flags
= ELF_FDPIC_FLAG_PRESENT
;
283 /* read the interpreter's program header table */
284 retval
= elf_fdpic_fetch_phdrs(&interp_params
, interpreter
);
289 stack_size
= exec_params
.stack_size
;
290 if (exec_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
291 executable_stack
= EXSTACK_ENABLE_X
;
292 else if (exec_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
293 executable_stack
= EXSTACK_DISABLE_X
;
295 executable_stack
= EXSTACK_DEFAULT
;
297 if (stack_size
== 0) {
298 stack_size
= interp_params
.stack_size
;
299 if (interp_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
300 executable_stack
= EXSTACK_ENABLE_X
;
301 else if (interp_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
302 executable_stack
= EXSTACK_DISABLE_X
;
304 executable_stack
= EXSTACK_DEFAULT
;
311 if (elf_check_const_displacement(&interp_params
.hdr
))
312 interp_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
314 /* flush all traces of the currently running executable */
315 retval
= flush_old_exec(bprm
);
319 /* there's now no turning back... the old userspace image is dead,
320 * defunct, deceased, etc. after this point we have to exit via
322 set_personality(PER_LINUX_FDPIC
);
323 if (elf_read_implies_exec(&exec_params
.hdr
, executable_stack
))
324 current
->personality
|= READ_IMPLIES_EXEC
;
326 setup_new_exec(bprm
);
328 set_binfmt(&elf_fdpic_format
);
330 current
->mm
->start_code
= 0;
331 current
->mm
->end_code
= 0;
332 current
->mm
->start_stack
= 0;
333 current
->mm
->start_data
= 0;
334 current
->mm
->end_data
= 0;
335 current
->mm
->context
.exec_fdpic_loadmap
= 0;
336 current
->mm
->context
.interp_fdpic_loadmap
= 0;
339 elf_fdpic_arch_lay_out_mm(&exec_params
,
341 ¤t
->mm
->start_stack
,
342 ¤t
->mm
->start_brk
);
344 retval
= setup_arg_pages(bprm
, current
->mm
->start_stack
,
347 send_sig(SIGKILL
, current
, 0);
352 /* load the executable and interpreter into memory */
353 retval
= elf_fdpic_map_file(&exec_params
, bprm
->file
, current
->mm
,
358 if (interpreter_name
) {
359 retval
= elf_fdpic_map_file(&interp_params
, interpreter
,
360 current
->mm
, "interpreter");
362 printk(KERN_ERR
"Unable to load interpreter\n");
366 allow_write_access(interpreter
);
372 if (!current
->mm
->start_brk
)
373 current
->mm
->start_brk
= current
->mm
->end_data
;
375 current
->mm
->brk
= current
->mm
->start_brk
=
376 PAGE_ALIGN(current
->mm
->start_brk
);
379 /* create a stack and brk area big enough for everyone
380 * - the brk heap starts at the bottom and works up
381 * - the stack starts at the top and works down
383 stack_size
= (stack_size
+ PAGE_SIZE
- 1) & PAGE_MASK
;
384 if (stack_size
< PAGE_SIZE
* 2)
385 stack_size
= PAGE_SIZE
* 2;
387 stack_prot
= PROT_READ
| PROT_WRITE
;
388 if (executable_stack
== EXSTACK_ENABLE_X
||
389 (executable_stack
== EXSTACK_DEFAULT
&& VM_STACK_FLAGS
& VM_EXEC
))
390 stack_prot
|= PROT_EXEC
;
392 current
->mm
->start_brk
= vm_mmap(NULL
, 0, stack_size
, stack_prot
,
393 MAP_PRIVATE
| MAP_ANONYMOUS
|
394 MAP_UNINITIALIZED
| MAP_GROWSDOWN
,
397 if (IS_ERR_VALUE(current
->mm
->start_brk
)) {
398 retval
= current
->mm
->start_brk
;
399 current
->mm
->start_brk
= 0;
403 current
->mm
->brk
= current
->mm
->start_brk
;
404 current
->mm
->context
.end_brk
= current
->mm
->start_brk
;
405 current
->mm
->context
.end_brk
+=
406 (stack_size
> PAGE_SIZE
) ? (stack_size
- PAGE_SIZE
) : 0;
407 current
->mm
->start_stack
= current
->mm
->start_brk
+ stack_size
;
410 install_exec_creds(bprm
);
411 if (create_elf_fdpic_tables(bprm
, current
->mm
,
412 &exec_params
, &interp_params
) < 0)
415 kdebug("- start_code %lx", current
->mm
->start_code
);
416 kdebug("- end_code %lx", current
->mm
->end_code
);
417 kdebug("- start_data %lx", current
->mm
->start_data
);
418 kdebug("- end_data %lx", current
->mm
->end_data
);
419 kdebug("- start_brk %lx", current
->mm
->start_brk
);
420 kdebug("- brk %lx", current
->mm
->brk
);
421 kdebug("- start_stack %lx", current
->mm
->start_stack
);
423 #ifdef ELF_FDPIC_PLAT_INIT
425 * The ABI may specify that certain registers be set up in special
426 * ways (on i386 %edx is the address of a DT_FINI function, for
427 * example. This macro performs whatever initialization to
428 * the regs structure is required.
430 dynaddr
= interp_params
.dynamic_addr
?: exec_params
.dynamic_addr
;
431 ELF_FDPIC_PLAT_INIT(regs
, exec_params
.map_addr
, interp_params
.map_addr
,
435 /* everything is now ready... get the userspace context ready to roll */
436 entryaddr
= interp_params
.entry_addr
?: exec_params
.entry_addr
;
437 start_thread(regs
, entryaddr
, current
->mm
->start_stack
);
443 allow_write_access(interpreter
);
446 kfree(interpreter_name
);
447 kfree(exec_params
.phdrs
);
448 kfree(exec_params
.loadmap
);
449 kfree(interp_params
.phdrs
);
450 kfree(interp_params
.loadmap
);
453 /* unrecoverable error - kill the process */
455 send_sig(SIGSEGV
, current
, 0);
460 /*****************************************************************************/
462 #ifndef ELF_BASE_PLATFORM
464 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
465 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
466 * will be copied to the user stack in the same manner as AT_PLATFORM.
468 #define ELF_BASE_PLATFORM NULL
472 * present useful information to the program by shovelling it onto the new
475 static int create_elf_fdpic_tables(struct linux_binprm
*bprm
,
476 struct mm_struct
*mm
,
477 struct elf_fdpic_params
*exec_params
,
478 struct elf_fdpic_params
*interp_params
)
480 const struct cred
*cred
= current_cred();
481 unsigned long sp
, csp
, nitems
;
482 elf_caddr_t __user
*argv
, *envp
;
483 size_t platform_len
= 0, len
;
484 char *k_platform
, *k_base_platform
;
485 char __user
*u_platform
, *u_base_platform
, *p
;
487 int nr
; /* reset for each csp adjustment */
490 /* In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
491 * by the processes running on the same package. One thing we can do is
492 * to shuffle the initial stack for them, so we give the architecture
493 * an opportunity to do so here.
495 sp
= arch_align_stack(bprm
->p
);
497 sp
= mm
->start_stack
;
499 /* stack the program arguments and environment */
500 if (elf_fdpic_transfer_args_to_stack(bprm
, &sp
) < 0)
505 * If this architecture has a platform capability string, copy it
506 * to userspace. In some cases (Sparc), this info is impossible
507 * for userspace to get any other way, in others (i386) it is
510 k_platform
= ELF_PLATFORM
;
514 platform_len
= strlen(k_platform
) + 1;
516 u_platform
= (char __user
*) sp
;
517 if (__copy_to_user(u_platform
, k_platform
, platform_len
) != 0)
522 * If this architecture has a "base" platform capability
523 * string, copy it to userspace.
525 k_base_platform
= ELF_BASE_PLATFORM
;
526 u_base_platform
= NULL
;
528 if (k_base_platform
) {
529 platform_len
= strlen(k_base_platform
) + 1;
531 u_base_platform
= (char __user
*) sp
;
532 if (__copy_to_user(u_base_platform
, k_base_platform
, platform_len
) != 0)
538 /* stack the load map(s) */
539 len
= sizeof(struct elf32_fdpic_loadmap
);
540 len
+= sizeof(struct elf32_fdpic_loadseg
) * exec_params
->loadmap
->nsegs
;
541 sp
= (sp
- len
) & ~7UL;
542 exec_params
->map_addr
= sp
;
544 if (copy_to_user((void __user
*) sp
, exec_params
->loadmap
, len
) != 0)
547 current
->mm
->context
.exec_fdpic_loadmap
= (unsigned long) sp
;
549 if (interp_params
->loadmap
) {
550 len
= sizeof(struct elf32_fdpic_loadmap
);
551 len
+= sizeof(struct elf32_fdpic_loadseg
) *
552 interp_params
->loadmap
->nsegs
;
553 sp
= (sp
- len
) & ~7UL;
554 interp_params
->map_addr
= sp
;
556 if (copy_to_user((void __user
*) sp
, interp_params
->loadmap
,
560 current
->mm
->context
.interp_fdpic_loadmap
= (unsigned long) sp
;
563 /* force 16 byte _final_ alignment here for generality */
564 #define DLINFO_ITEMS 15
566 nitems
= 1 + DLINFO_ITEMS
+ (k_platform
? 1 : 0) +
567 (k_base_platform
? 1 : 0) + AT_VECTOR_SIZE_ARCH
;
569 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
)
573 sp
-= nitems
* 2 * sizeof(unsigned long);
574 sp
-= (bprm
->envc
+ 1) * sizeof(char *); /* envv[] */
575 sp
-= (bprm
->argc
+ 1) * sizeof(char *); /* argv[] */
576 sp
-= 1 * sizeof(unsigned long); /* argc */
581 /* put the ELF interpreter info on the stack */
582 #define NEW_AUX_ENT(id, val) \
584 struct { unsigned long _id, _val; } __user *ent; \
586 ent = (void __user *) csp; \
587 __put_user((id), &ent[nr]._id); \
588 __put_user((val), &ent[nr]._val); \
593 csp
-= 2 * sizeof(unsigned long);
594 NEW_AUX_ENT(AT_NULL
, 0);
597 csp
-= 2 * sizeof(unsigned long);
598 NEW_AUX_ENT(AT_PLATFORM
,
599 (elf_addr_t
) (unsigned long) u_platform
);
602 if (k_base_platform
) {
604 csp
-= 2 * sizeof(unsigned long);
605 NEW_AUX_ENT(AT_BASE_PLATFORM
,
606 (elf_addr_t
) (unsigned long) u_base_platform
);
609 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
) {
611 csp
-= 2 * sizeof(unsigned long);
612 NEW_AUX_ENT(AT_EXECFD
, bprm
->interp_data
);
616 csp
-= DLINFO_ITEMS
* 2 * sizeof(unsigned long);
617 NEW_AUX_ENT(AT_HWCAP
, ELF_HWCAP
);
619 NEW_AUX_ENT(AT_HWCAP2
, ELF_HWCAP2
);
621 NEW_AUX_ENT(AT_PAGESZ
, PAGE_SIZE
);
622 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
623 NEW_AUX_ENT(AT_PHDR
, exec_params
->ph_addr
);
624 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
625 NEW_AUX_ENT(AT_PHNUM
, exec_params
->hdr
.e_phnum
);
626 NEW_AUX_ENT(AT_BASE
, interp_params
->elfhdr_addr
);
627 NEW_AUX_ENT(AT_FLAGS
, 0);
628 NEW_AUX_ENT(AT_ENTRY
, exec_params
->entry_addr
);
629 NEW_AUX_ENT(AT_UID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->uid
));
630 NEW_AUX_ENT(AT_EUID
, (elf_addr_t
) from_kuid_munged(cred
->user_ns
, cred
->euid
));
631 NEW_AUX_ENT(AT_GID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->gid
));
632 NEW_AUX_ENT(AT_EGID
, (elf_addr_t
) from_kgid_munged(cred
->user_ns
, cred
->egid
));
633 NEW_AUX_ENT(AT_SECURE
, security_bprm_secureexec(bprm
));
634 NEW_AUX_ENT(AT_EXECFN
, bprm
->exec
);
638 csp
-= AT_VECTOR_SIZE_ARCH
* 2 * sizeof(unsigned long);
640 /* ARCH_DLINFO must come last so platform specific code can enforce
641 * special alignment requirements on the AUXV if necessary (eg. PPC).
647 /* allocate room for argv[] and envv[] */
648 csp
-= (bprm
->envc
+ 1) * sizeof(elf_caddr_t
);
649 envp
= (elf_caddr_t __user
*) csp
;
650 csp
-= (bprm
->argc
+ 1) * sizeof(elf_caddr_t
);
651 argv
= (elf_caddr_t __user
*) csp
;
654 csp
-= sizeof(unsigned long);
655 __put_user(bprm
->argc
, (unsigned long __user
*) csp
);
659 /* fill in the argv[] array */
661 current
->mm
->arg_start
= bprm
->p
;
663 current
->mm
->arg_start
= current
->mm
->start_stack
-
664 (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
);
667 p
= (char __user
*) current
->mm
->arg_start
;
668 for (loop
= bprm
->argc
; loop
> 0; loop
--) {
669 __put_user((elf_caddr_t
) p
, argv
++);
670 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
671 if (!len
|| len
> MAX_ARG_STRLEN
)
675 __put_user(NULL
, argv
);
676 current
->mm
->arg_end
= (unsigned long) p
;
678 /* fill in the envv[] array */
679 current
->mm
->env_start
= (unsigned long) p
;
680 for (loop
= bprm
->envc
; loop
> 0; loop
--) {
681 __put_user((elf_caddr_t
)(unsigned long) p
, envp
++);
682 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
683 if (!len
|| len
> MAX_ARG_STRLEN
)
687 __put_user(NULL
, envp
);
688 current
->mm
->env_end
= (unsigned long) p
;
690 mm
->start_stack
= (unsigned long) sp
;
694 /*****************************************************************************/
696 * transfer the program arguments and environment from the holding pages onto
700 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*bprm
,
703 unsigned long index
, stop
, sp
;
707 stop
= bprm
->p
>> PAGE_SHIFT
;
710 for (index
= MAX_ARG_PAGES
- 1; index
>= stop
; index
--) {
711 src
= kmap(bprm
->page
[index
]);
713 if (copy_to_user((void *) sp
, src
, PAGE_SIZE
) != 0)
715 kunmap(bprm
->page
[index
]);
720 *_sp
= (*_sp
- (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
)) & ~15;
727 /*****************************************************************************/
729 * load the appropriate binary image (executable or interpreter) into memory
730 * - we assume no MMU is available
731 * - if no other PIC bits are set in params->hdr->e_flags
732 * - we assume that the LOADable segments in the binary are independently relocatable
733 * - we assume R/O executable segments are shareable
735 * - we assume the loadable parts of the image to require fixed displacement
736 * - the image is not shareable
738 static int elf_fdpic_map_file(struct elf_fdpic_params
*params
,
740 struct mm_struct
*mm
,
743 struct elf32_fdpic_loadmap
*loadmap
;
745 struct elf32_fdpic_loadseg
*mseg
;
747 struct elf32_fdpic_loadseg
*seg
;
748 struct elf32_phdr
*phdr
;
749 unsigned long load_addr
, stop
;
750 unsigned nloads
, tmp
;
754 /* allocate a load map table */
756 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++)
757 if (params
->phdrs
[loop
].p_type
== PT_LOAD
)
763 size
= sizeof(*loadmap
) + nloads
* sizeof(*seg
);
764 loadmap
= kzalloc(size
, GFP_KERNEL
);
768 params
->loadmap
= loadmap
;
770 loadmap
->version
= ELF32_FDPIC_LOADMAP_VERSION
;
771 loadmap
->nsegs
= nloads
;
773 load_addr
= params
->load_addr
;
776 /* map the requested LOADs into the memory space */
777 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
778 case ELF_FDPIC_FLAG_CONSTDISP
:
779 case ELF_FDPIC_FLAG_CONTIGUOUS
:
781 ret
= elf_fdpic_map_file_constdisp_on_uclinux(params
, file
, mm
);
787 ret
= elf_fdpic_map_file_by_direct_mmap(params
, file
, mm
);
793 /* map the entry point */
794 if (params
->hdr
.e_entry
) {
796 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
797 if (params
->hdr
.e_entry
>= seg
->p_vaddr
&&
798 params
->hdr
.e_entry
< seg
->p_vaddr
+ seg
->p_memsz
) {
800 (params
->hdr
.e_entry
- seg
->p_vaddr
) +
807 /* determine where the program header table has wound up if mapped */
808 stop
= params
->hdr
.e_phoff
;
809 stop
+= params
->hdr
.e_phnum
* sizeof (struct elf_phdr
);
810 phdr
= params
->phdrs
;
812 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
813 if (phdr
->p_type
!= PT_LOAD
)
816 if (phdr
->p_offset
> params
->hdr
.e_phoff
||
817 phdr
->p_offset
+ phdr
->p_filesz
< stop
)
821 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
822 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
823 phdr
->p_vaddr
+ phdr
->p_filesz
<=
824 seg
->p_vaddr
+ seg
->p_memsz
) {
826 (phdr
->p_vaddr
- seg
->p_vaddr
) +
828 params
->hdr
.e_phoff
- phdr
->p_offset
;
835 /* determine where the dynamic section has wound up if there is one */
836 phdr
= params
->phdrs
;
837 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
838 if (phdr
->p_type
!= PT_DYNAMIC
)
842 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
843 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
844 phdr
->p_vaddr
+ phdr
->p_memsz
<=
845 seg
->p_vaddr
+ seg
->p_memsz
) {
846 params
->dynamic_addr
=
847 (phdr
->p_vaddr
- seg
->p_vaddr
) +
850 /* check the dynamic section contains at least
851 * one item, and that the last item is a NULL
853 if (phdr
->p_memsz
== 0 ||
854 phdr
->p_memsz
% sizeof(Elf32_Dyn
) != 0)
857 tmp
= phdr
->p_memsz
/ sizeof(Elf32_Dyn
);
859 params
->dynamic_addr
)[tmp
- 1].d_tag
!= 0)
867 /* now elide adjacent segments in the load map on MMU linux
868 * - on uClinux the holes between may actually be filled with system
869 * stuff or stuff from other processes
872 nloads
= loadmap
->nsegs
;
873 mseg
= loadmap
->segs
;
875 for (loop
= 1; loop
< nloads
; loop
++) {
876 /* see if we have a candidate for merging */
877 if (seg
->p_vaddr
- mseg
->p_vaddr
== seg
->addr
- mseg
->addr
) {
878 load_addr
= PAGE_ALIGN(mseg
->addr
+ mseg
->p_memsz
);
879 if (load_addr
== (seg
->addr
& PAGE_MASK
)) {
882 (mseg
->addr
+ mseg
->p_memsz
);
883 mseg
->p_memsz
+= seg
->addr
& ~PAGE_MASK
;
884 mseg
->p_memsz
+= seg
->p_memsz
;
896 kdebug("Mapped Object [%s]:", what
);
897 kdebug("- elfhdr : %lx", params
->elfhdr_addr
);
898 kdebug("- entry : %lx", params
->entry_addr
);
899 kdebug("- PHDR[] : %lx", params
->ph_addr
);
900 kdebug("- DYNAMIC[]: %lx", params
->dynamic_addr
);
902 for (loop
= 0; loop
< loadmap
->nsegs
; loop
++, seg
++)
903 kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
905 seg
->addr
, seg
->addr
+ seg
->p_memsz
- 1,
906 seg
->p_vaddr
, seg
->p_memsz
);
911 printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
912 what
, file_inode(file
)->i_ino
);
916 /*****************************************************************************/
918 * map a file with constant displacement under uClinux
921 static int elf_fdpic_map_file_constdisp_on_uclinux(
922 struct elf_fdpic_params
*params
,
924 struct mm_struct
*mm
)
926 struct elf32_fdpic_loadseg
*seg
;
927 struct elf32_phdr
*phdr
;
928 unsigned long load_addr
, base
= ULONG_MAX
, top
= 0, maddr
= 0, mflags
;
931 load_addr
= params
->load_addr
;
932 seg
= params
->loadmap
->segs
;
934 /* determine the bounds of the contiguous overall allocation we must
936 phdr
= params
->phdrs
;
937 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
938 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
941 if (base
> phdr
->p_vaddr
)
942 base
= phdr
->p_vaddr
;
943 if (top
< phdr
->p_vaddr
+ phdr
->p_memsz
)
944 top
= phdr
->p_vaddr
+ phdr
->p_memsz
;
947 /* allocate one big anon block for everything */
948 mflags
= MAP_PRIVATE
;
949 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
950 mflags
|= MAP_EXECUTABLE
;
952 maddr
= vm_mmap(NULL
, load_addr
, top
- base
,
953 PROT_READ
| PROT_WRITE
| PROT_EXEC
, mflags
, 0);
954 if (IS_ERR_VALUE(maddr
))
958 load_addr
+= PAGE_ALIGN(top
- base
);
960 /* and then load the file segments into it */
961 phdr
= params
->phdrs
;
962 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
963 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
966 seg
->addr
= maddr
+ (phdr
->p_vaddr
- base
);
967 seg
->p_vaddr
= phdr
->p_vaddr
;
968 seg
->p_memsz
= phdr
->p_memsz
;
970 ret
= read_code(file
, seg
->addr
, phdr
->p_offset
,
975 /* map the ELF header address if in this segment */
976 if (phdr
->p_offset
== 0)
977 params
->elfhdr_addr
= seg
->addr
;
979 /* clear any space allocated but not loaded */
980 if (phdr
->p_filesz
< phdr
->p_memsz
) {
981 if (clear_user((void *) (seg
->addr
+ phdr
->p_filesz
),
982 phdr
->p_memsz
- phdr
->p_filesz
))
987 if (phdr
->p_flags
& PF_X
) {
988 if (!mm
->start_code
) {
989 mm
->start_code
= seg
->addr
;
990 mm
->end_code
= seg
->addr
+
993 } else if (!mm
->start_data
) {
994 mm
->start_data
= seg
->addr
;
995 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
1006 /*****************************************************************************/
1008 * map a binary by direct mmap() of the individual PT_LOAD segments
1010 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*params
,
1012 struct mm_struct
*mm
)
1014 struct elf32_fdpic_loadseg
*seg
;
1015 struct elf32_phdr
*phdr
;
1016 unsigned long load_addr
, delta_vaddr
;
1019 load_addr
= params
->load_addr
;
1023 seg
= params
->loadmap
->segs
;
1025 /* deal with each load segment separately */
1026 phdr
= params
->phdrs
;
1027 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
1028 unsigned long maddr
, disp
, excess
, excess1
;
1029 int prot
= 0, flags
;
1031 if (phdr
->p_type
!= PT_LOAD
)
1034 kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1035 (unsigned long) phdr
->p_vaddr
,
1036 (unsigned long) phdr
->p_offset
,
1037 (unsigned long) phdr
->p_filesz
,
1038 (unsigned long) phdr
->p_memsz
);
1040 /* determine the mapping parameters */
1041 if (phdr
->p_flags
& PF_R
) prot
|= PROT_READ
;
1042 if (phdr
->p_flags
& PF_W
) prot
|= PROT_WRITE
;
1043 if (phdr
->p_flags
& PF_X
) prot
|= PROT_EXEC
;
1045 flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1046 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
1047 flags
|= MAP_EXECUTABLE
;
1051 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
1052 case ELF_FDPIC_FLAG_INDEPENDENT
:
1053 /* PT_LOADs are independently locatable */
1056 case ELF_FDPIC_FLAG_HONOURVADDR
:
1057 /* the specified virtual address must be honoured */
1058 maddr
= phdr
->p_vaddr
;
1062 case ELF_FDPIC_FLAG_CONSTDISP
:
1063 /* constant displacement
1064 * - can be mapped anywhere, but must be mapped as a
1069 delta_vaddr
= phdr
->p_vaddr
;
1072 maddr
= load_addr
+ phdr
->p_vaddr
- delta_vaddr
;
1077 case ELF_FDPIC_FLAG_CONTIGUOUS
:
1078 /* contiguity handled later */
1087 /* create the mapping */
1088 disp
= phdr
->p_vaddr
& ~PAGE_MASK
;
1089 maddr
= vm_mmap(file
, maddr
, phdr
->p_memsz
+ disp
, prot
, flags
,
1090 phdr
->p_offset
- disp
);
1092 kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1093 loop
, phdr
->p_memsz
+ disp
, prot
, flags
,
1094 phdr
->p_offset
- disp
, maddr
);
1096 if (IS_ERR_VALUE(maddr
))
1099 if ((params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) ==
1100 ELF_FDPIC_FLAG_CONTIGUOUS
)
1101 load_addr
+= PAGE_ALIGN(phdr
->p_memsz
+ disp
);
1103 seg
->addr
= maddr
+ disp
;
1104 seg
->p_vaddr
= phdr
->p_vaddr
;
1105 seg
->p_memsz
= phdr
->p_memsz
;
1107 /* map the ELF header address if in this segment */
1108 if (phdr
->p_offset
== 0)
1109 params
->elfhdr_addr
= seg
->addr
;
1111 /* clear the bit between beginning of mapping and beginning of
1113 if (prot
& PROT_WRITE
&& disp
> 0) {
1114 kdebug("clear[%d] ad=%lx sz=%lx", loop
, maddr
, disp
);
1115 if (clear_user((void __user
*) maddr
, disp
))
1120 /* clear any space allocated but not loaded
1121 * - on uClinux we can just clear the lot
1122 * - on MMU linux we'll get a SIGBUS beyond the last page
1123 * extant in the file
1125 excess
= phdr
->p_memsz
- phdr
->p_filesz
;
1126 excess1
= PAGE_SIZE
- ((maddr
+ phdr
->p_filesz
) & ~PAGE_MASK
);
1129 if (excess
> excess1
) {
1130 unsigned long xaddr
= maddr
+ phdr
->p_filesz
+ excess1
;
1131 unsigned long xmaddr
;
1133 flags
|= MAP_FIXED
| MAP_ANONYMOUS
;
1134 xmaddr
= vm_mmap(NULL
, xaddr
, excess
- excess1
,
1137 kdebug("mmap[%d] <anon>"
1138 " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1139 loop
, xaddr
, excess
- excess1
, prot
, flags
,
1142 if (xmaddr
!= xaddr
)
1146 if (prot
& PROT_WRITE
&& excess1
> 0) {
1147 kdebug("clear[%d] ad=%lx sz=%lx",
1148 loop
, maddr
+ phdr
->p_filesz
, excess1
);
1149 if (clear_user((void __user
*) maddr
+ phdr
->p_filesz
,
1156 kdebug("clear[%d] ad=%lx sz=%lx",
1157 loop
, maddr
+ phdr
->p_filesz
, excess
);
1158 if (clear_user((void *) maddr
+ phdr
->p_filesz
, excess
))
1164 if (phdr
->p_flags
& PF_X
) {
1165 if (!mm
->start_code
) {
1166 mm
->start_code
= maddr
;
1167 mm
->end_code
= maddr
+ phdr
->p_memsz
;
1169 } else if (!mm
->start_data
) {
1170 mm
->start_data
= maddr
;
1171 mm
->end_data
= maddr
+ phdr
->p_memsz
;
1181 /*****************************************************************************/
1183 * ELF-FDPIC core dumper
1185 * Modelled on fs/exec.c:aout_core_dump()
1186 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1188 * Modelled on fs/binfmt_elf.c core dumper
1190 #ifdef CONFIG_ELF_CORE
1193 * Decide whether a segment is worth dumping; default is yes to be
1194 * sure (missing info is worse than too much; etc).
1195 * Personally I'd include everything, and use the coredump limit...
1197 * I think we should skip something. But I am not sure how. H.J.
1199 static int maydump(struct vm_area_struct
*vma
, unsigned long mm_flags
)
1203 /* Do not dump I/O mapped devices or special mappings */
1204 if (vma
->vm_flags
& VM_IO
) {
1205 kdcore("%08lx: %08lx: no (IO)", vma
->vm_start
, vma
->vm_flags
);
1209 /* If we may not read the contents, don't allow us to dump
1210 * them either. "dump_write()" can't handle it anyway.
1212 if (!(vma
->vm_flags
& VM_READ
)) {
1213 kdcore("%08lx: %08lx: no (!read)", vma
->vm_start
, vma
->vm_flags
);
1217 /* By default, dump shared memory if mapped from an anonymous file. */
1218 if (vma
->vm_flags
& VM_SHARED
) {
1219 if (file_inode(vma
->vm_file
)->i_nlink
== 0) {
1220 dump_ok
= test_bit(MMF_DUMP_ANON_SHARED
, &mm_flags
);
1221 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1222 vma
->vm_flags
, dump_ok
? "yes" : "no");
1226 dump_ok
= test_bit(MMF_DUMP_MAPPED_SHARED
, &mm_flags
);
1227 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1228 vma
->vm_flags
, dump_ok
? "yes" : "no");
1233 /* By default, if it hasn't been written to, don't write it out */
1234 if (!vma
->anon_vma
) {
1235 dump_ok
= test_bit(MMF_DUMP_MAPPED_PRIVATE
, &mm_flags
);
1236 kdcore("%08lx: %08lx: %s (!anon)", vma
->vm_start
,
1237 vma
->vm_flags
, dump_ok
? "yes" : "no");
1242 dump_ok
= test_bit(MMF_DUMP_ANON_PRIVATE
, &mm_flags
);
1243 kdcore("%08lx: %08lx: %s", vma
->vm_start
, vma
->vm_flags
,
1244 dump_ok
? "yes" : "no");
1248 /* An ELF note in memory */
1253 unsigned int datasz
;
1257 static int notesize(struct memelfnote
*en
)
1261 sz
= sizeof(struct elf_note
);
1262 sz
+= roundup(strlen(en
->name
) + 1, 4);
1263 sz
+= roundup(en
->datasz
, 4);
1270 #define DUMP_WRITE(addr, nr, foffset) \
1271 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
1273 static int alignfile(struct file
*file
, loff_t
*foffset
)
1275 static const char buf
[4] = { 0, };
1276 DUMP_WRITE(buf
, roundup(*foffset
, 4) - *foffset
, foffset
);
1280 static int writenote(struct memelfnote
*men
, struct file
*file
,
1284 en
.n_namesz
= strlen(men
->name
) + 1;
1285 en
.n_descsz
= men
->datasz
;
1286 en
.n_type
= men
->type
;
1288 DUMP_WRITE(&en
, sizeof(en
), foffset
);
1289 DUMP_WRITE(men
->name
, en
.n_namesz
, foffset
);
1290 if (!alignfile(file
, foffset
))
1292 DUMP_WRITE(men
->data
, men
->datasz
, foffset
);
1293 if (!alignfile(file
, foffset
))
1300 static inline void fill_elf_fdpic_header(struct elfhdr
*elf
, int segs
)
1302 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1303 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1304 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1305 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1306 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1307 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1309 elf
->e_type
= ET_CORE
;
1310 elf
->e_machine
= ELF_ARCH
;
1311 elf
->e_version
= EV_CURRENT
;
1313 elf
->e_phoff
= sizeof(struct elfhdr
);
1315 elf
->e_flags
= ELF_FDPIC_CORE_EFLAGS
;
1316 elf
->e_ehsize
= sizeof(struct elfhdr
);
1317 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1318 elf
->e_phnum
= segs
;
1319 elf
->e_shentsize
= 0;
1321 elf
->e_shstrndx
= 0;
1325 static inline void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1327 phdr
->p_type
= PT_NOTE
;
1328 phdr
->p_offset
= offset
;
1331 phdr
->p_filesz
= sz
;
1338 static inline void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1339 unsigned int sz
, void *data
)
1349 * fill up all the fields in prstatus from the given task struct, except
1350 * registers which need to be filled up separately.
1352 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1353 struct task_struct
*p
, long signr
)
1355 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1356 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1357 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1359 prstatus
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1361 prstatus
->pr_pid
= task_pid_vnr(p
);
1362 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1363 prstatus
->pr_sid
= task_session_vnr(p
);
1364 if (thread_group_leader(p
)) {
1365 struct task_cputime cputime
;
1368 * This is the record for the group leader. It shows the
1369 * group-wide total, not its individual thread total.
1371 thread_group_cputime(p
, &cputime
);
1372 cputime_to_timeval(cputime
.utime
, &prstatus
->pr_utime
);
1373 cputime_to_timeval(cputime
.stime
, &prstatus
->pr_stime
);
1375 cputime_t utime
, stime
;
1377 task_cputime(p
, &utime
, &stime
);
1378 cputime_to_timeval(utime
, &prstatus
->pr_utime
);
1379 cputime_to_timeval(stime
, &prstatus
->pr_stime
);
1381 cputime_to_timeval(p
->signal
->cutime
, &prstatus
->pr_cutime
);
1382 cputime_to_timeval(p
->signal
->cstime
, &prstatus
->pr_cstime
);
1384 prstatus
->pr_exec_fdpic_loadmap
= p
->mm
->context
.exec_fdpic_loadmap
;
1385 prstatus
->pr_interp_fdpic_loadmap
= p
->mm
->context
.interp_fdpic_loadmap
;
1388 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1389 struct mm_struct
*mm
)
1391 const struct cred
*cred
;
1392 unsigned int i
, len
;
1394 /* first copy the parameters from user space */
1395 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1397 len
= mm
->arg_end
- mm
->arg_start
;
1398 if (len
>= ELF_PRARGSZ
)
1399 len
= ELF_PRARGSZ
- 1;
1400 if (copy_from_user(&psinfo
->pr_psargs
,
1401 (const char __user
*) mm
->arg_start
, len
))
1403 for (i
= 0; i
< len
; i
++)
1404 if (psinfo
->pr_psargs
[i
] == 0)
1405 psinfo
->pr_psargs
[i
] = ' ';
1406 psinfo
->pr_psargs
[len
] = 0;
1409 psinfo
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1411 psinfo
->pr_pid
= task_pid_vnr(p
);
1412 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1413 psinfo
->pr_sid
= task_session_vnr(p
);
1415 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1416 psinfo
->pr_state
= i
;
1417 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1418 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1419 psinfo
->pr_nice
= task_nice(p
);
1420 psinfo
->pr_flag
= p
->flags
;
1422 cred
= __task_cred(p
);
1423 SET_UID(psinfo
->pr_uid
, from_kuid_munged(cred
->user_ns
, cred
->uid
));
1424 SET_GID(psinfo
->pr_gid
, from_kgid_munged(cred
->user_ns
, cred
->gid
));
1426 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1431 /* Here is the structure in which status of each thread is captured. */
1432 struct elf_thread_status
1434 struct list_head list
;
1435 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1436 elf_fpregset_t fpu
; /* NT_PRFPREG */
1437 struct task_struct
*thread
;
1438 #ifdef ELF_CORE_COPY_XFPREGS
1439 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1441 struct memelfnote notes
[3];
1446 * In order to add the specific thread information for the elf file format,
1447 * we need to keep a linked list of every thread's pr_status and then create
1448 * a single section for them in the final core file.
1450 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1452 struct task_struct
*p
= t
->thread
;
1457 fill_prstatus(&t
->prstatus
, p
, signr
);
1458 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1460 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1463 sz
+= notesize(&t
->notes
[0]);
1465 t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
, &t
->fpu
);
1466 if (t
->prstatus
.pr_fpvalid
) {
1467 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1470 sz
+= notesize(&t
->notes
[1]);
1473 #ifdef ELF_CORE_COPY_XFPREGS
1474 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1475 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1476 sizeof(t
->xfpu
), &t
->xfpu
);
1478 sz
+= notesize(&t
->notes
[2]);
1484 static void fill_extnum_info(struct elfhdr
*elf
, struct elf_shdr
*shdr4extnum
,
1485 elf_addr_t e_shoff
, int segs
)
1487 elf
->e_shoff
= e_shoff
;
1488 elf
->e_shentsize
= sizeof(*shdr4extnum
);
1490 elf
->e_shstrndx
= SHN_UNDEF
;
1492 memset(shdr4extnum
, 0, sizeof(*shdr4extnum
));
1494 shdr4extnum
->sh_type
= SHT_NULL
;
1495 shdr4extnum
->sh_size
= elf
->e_shnum
;
1496 shdr4extnum
->sh_link
= elf
->e_shstrndx
;
1497 shdr4extnum
->sh_info
= segs
;
1501 * dump the segments for an MMU process
1504 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1505 unsigned long *limit
, unsigned long mm_flags
)
1507 struct vm_area_struct
*vma
;
1510 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1513 if (!maydump(vma
, mm_flags
))
1516 for (addr
= vma
->vm_start
; addr
< vma
->vm_end
;
1517 addr
+= PAGE_SIZE
) {
1518 struct page
*page
= get_dump_page(addr
);
1520 void *kaddr
= kmap(page
);
1524 else if (!dump_write(file
, kaddr
, PAGE_SIZE
))
1527 page_cache_release(page
);
1528 } else if (!dump_seek(file
, PAGE_SIZE
))
1540 * dump the segments for a NOMMU process
1543 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1544 unsigned long *limit
, unsigned long mm_flags
)
1546 struct vm_area_struct
*vma
;
1548 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1549 if (!maydump(vma
, mm_flags
))
1552 if ((*size
+= PAGE_SIZE
) > *limit
)
1555 if (!dump_write(file
, (void *) vma
->vm_start
,
1556 vma
->vm_end
- vma
->vm_start
))
1564 static size_t elf_core_vma_data_size(unsigned long mm_flags
)
1566 struct vm_area_struct
*vma
;
1569 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
)
1570 if (maydump(vma
, mm_flags
))
1571 size
+= vma
->vm_end
- vma
->vm_start
;
1578 * This is a two-pass process; first we find the offsets of the bits,
1579 * and then they are actually written out. If we run out of core limit
1582 static int elf_fdpic_core_dump(struct coredump_params
*cprm
)
1590 struct vm_area_struct
*vma
;
1591 struct elfhdr
*elf
= NULL
;
1592 loff_t offset
= 0, dataoff
, foffset
;
1594 struct memelfnote
*notes
= NULL
;
1595 struct elf_prstatus
*prstatus
= NULL
; /* NT_PRSTATUS */
1596 struct elf_prpsinfo
*psinfo
= NULL
; /* NT_PRPSINFO */
1597 LIST_HEAD(thread_list
);
1598 struct list_head
*t
;
1599 elf_fpregset_t
*fpu
= NULL
;
1600 #ifdef ELF_CORE_COPY_XFPREGS
1601 elf_fpxregset_t
*xfpu
= NULL
;
1603 int thread_status_size
= 0;
1605 struct elf_phdr
*phdr4note
= NULL
;
1606 struct elf_shdr
*shdr4extnum
= NULL
;
1611 * We no longer stop all VM operations.
1613 * This is because those proceses that could possibly change map_count
1614 * or the mmap / vma pages are now blocked in do_exit on current
1615 * finishing this core dump.
1617 * Only ptrace can touch these memory addresses, but it doesn't change
1618 * the map_count or the pages allocated. So no possibility of crashing
1619 * exists while dumping the mm->vm_next areas to the core file.
1622 /* alloc memory for large data structures: too large to be on stack */
1623 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
1626 prstatus
= kzalloc(sizeof(*prstatus
), GFP_KERNEL
);
1629 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1632 notes
= kmalloc(NUM_NOTES
* sizeof(struct memelfnote
), GFP_KERNEL
);
1635 fpu
= kmalloc(sizeof(*fpu
), GFP_KERNEL
);
1638 #ifdef ELF_CORE_COPY_XFPREGS
1639 xfpu
= kmalloc(sizeof(*xfpu
), GFP_KERNEL
);
1644 if (cprm
->siginfo
->si_signo
) {
1645 struct core_thread
*ct
;
1646 struct elf_thread_status
*tmp
;
1648 for (ct
= current
->mm
->core_state
->dumper
.next
;
1649 ct
; ct
= ct
->next
) {
1650 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1654 tmp
->thread
= ct
->task
;
1655 list_add(&tmp
->list
, &thread_list
);
1658 list_for_each(t
, &thread_list
) {
1659 struct elf_thread_status
*tmp
;
1662 tmp
= list_entry(t
, struct elf_thread_status
, list
);
1663 sz
= elf_dump_thread_status(cprm
->siginfo
->si_signo
, tmp
);
1664 thread_status_size
+= sz
;
1668 /* now collect the dump for the current */
1669 fill_prstatus(prstatus
, current
, cprm
->siginfo
->si_signo
);
1670 elf_core_copy_regs(&prstatus
->pr_reg
, cprm
->regs
);
1672 segs
= current
->mm
->map_count
;
1673 segs
+= elf_core_extra_phdrs();
1675 /* for notes section */
1678 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1679 * this, kernel supports extended numbering. Have a look at
1680 * include/linux/elf.h for further information. */
1681 e_phnum
= segs
> PN_XNUM
? PN_XNUM
: segs
;
1684 fill_elf_fdpic_header(elf
, e_phnum
);
1688 * Set up the notes in similar form to SVR4 core dumps made
1689 * with info from their /proc.
1692 fill_note(notes
+ 0, "CORE", NT_PRSTATUS
, sizeof(*prstatus
), prstatus
);
1693 fill_psinfo(psinfo
, current
->group_leader
, current
->mm
);
1694 fill_note(notes
+ 1, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1698 auxv
= (elf_addr_t
*) current
->mm
->saved_auxv
;
1703 while (auxv
[i
- 2] != AT_NULL
);
1704 fill_note(¬es
[numnote
++], "CORE", NT_AUXV
,
1705 i
* sizeof(elf_addr_t
), auxv
);
1707 /* Try to dump the FPU. */
1708 if ((prstatus
->pr_fpvalid
=
1709 elf_core_copy_task_fpregs(current
, cprm
->regs
, fpu
)))
1710 fill_note(notes
+ numnote
++,
1711 "CORE", NT_PRFPREG
, sizeof(*fpu
), fpu
);
1712 #ifdef ELF_CORE_COPY_XFPREGS
1713 if (elf_core_copy_task_xfpregs(current
, xfpu
))
1714 fill_note(notes
+ numnote
++,
1715 "LINUX", ELF_CORE_XFPREG_TYPE
, sizeof(*xfpu
), xfpu
);
1721 offset
+= sizeof(*elf
); /* Elf header */
1722 offset
+= segs
* sizeof(struct elf_phdr
); /* Program headers */
1725 /* Write notes phdr entry */
1729 for (i
= 0; i
< numnote
; i
++)
1730 sz
+= notesize(notes
+ i
);
1732 sz
+= thread_status_size
;
1734 phdr4note
= kmalloc(sizeof(*phdr4note
), GFP_KERNEL
);
1738 fill_elf_note_phdr(phdr4note
, sz
, offset
);
1742 /* Page-align dumped data */
1743 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1745 offset
+= elf_core_vma_data_size(cprm
->mm_flags
);
1746 offset
+= elf_core_extra_data_size();
1749 if (e_phnum
== PN_XNUM
) {
1750 shdr4extnum
= kmalloc(sizeof(*shdr4extnum
), GFP_KERNEL
);
1753 fill_extnum_info(elf
, shdr4extnum
, e_shoff
, segs
);
1758 size
+= sizeof(*elf
);
1759 if (size
> cprm
->limit
|| !dump_write(cprm
->file
, elf
, sizeof(*elf
)))
1762 size
+= sizeof(*phdr4note
);
1763 if (size
> cprm
->limit
1764 || !dump_write(cprm
->file
, phdr4note
, sizeof(*phdr4note
)))
1767 /* write program headers for segments dump */
1768 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1769 struct elf_phdr phdr
;
1772 sz
= vma
->vm_end
- vma
->vm_start
;
1774 phdr
.p_type
= PT_LOAD
;
1775 phdr
.p_offset
= offset
;
1776 phdr
.p_vaddr
= vma
->vm_start
;
1778 phdr
.p_filesz
= maydump(vma
, cprm
->mm_flags
) ? sz
: 0;
1780 offset
+= phdr
.p_filesz
;
1781 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1782 if (vma
->vm_flags
& VM_WRITE
)
1783 phdr
.p_flags
|= PF_W
;
1784 if (vma
->vm_flags
& VM_EXEC
)
1785 phdr
.p_flags
|= PF_X
;
1786 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1788 size
+= sizeof(phdr
);
1789 if (size
> cprm
->limit
1790 || !dump_write(cprm
->file
, &phdr
, sizeof(phdr
)))
1794 if (!elf_core_write_extra_phdrs(cprm
->file
, offset
, &size
, cprm
->limit
))
1797 /* write out the notes section */
1798 for (i
= 0; i
< numnote
; i
++)
1799 if (!writenote(notes
+ i
, cprm
->file
, &foffset
))
1802 /* write out the thread status notes section */
1803 list_for_each(t
, &thread_list
) {
1804 struct elf_thread_status
*tmp
=
1805 list_entry(t
, struct elf_thread_status
, list
);
1807 for (i
= 0; i
< tmp
->num_notes
; i
++)
1808 if (!writenote(&tmp
->notes
[i
], cprm
->file
, &foffset
))
1812 if (!dump_seek(cprm
->file
, dataoff
- foffset
))
1815 if (elf_fdpic_dump_segments(cprm
->file
, &size
, &cprm
->limit
,
1816 cprm
->mm_flags
) < 0)
1819 if (!elf_core_write_extra_data(cprm
->file
, &size
, cprm
->limit
))
1822 if (e_phnum
== PN_XNUM
) {
1823 size
+= sizeof(*shdr4extnum
);
1824 if (size
> cprm
->limit
1825 || !dump_write(cprm
->file
, shdr4extnum
,
1826 sizeof(*shdr4extnum
)))
1830 if (cprm
->file
->f_pos
!= offset
) {
1833 "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1834 cprm
->file
->f_pos
, offset
);
1841 while (!list_empty(&thread_list
)) {
1842 struct list_head
*tmp
= thread_list
.next
;
1844 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
1853 #ifdef ELF_CORE_COPY_XFPREGS
1860 #endif /* CONFIG_ELF_CORE */