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
*, struct pt_regs
*);
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
|| !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
,
168 struct pt_regs
*regs
)
170 struct elf_fdpic_params exec_params
, interp_params
;
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 down_write(¤t
->mm
->mmap_sem
);
393 current
->mm
->start_brk
= do_mmap(NULL
, 0, stack_size
, stack_prot
,
394 MAP_PRIVATE
| MAP_ANONYMOUS
|
395 MAP_UNINITIALIZED
| MAP_GROWSDOWN
,
398 if (IS_ERR_VALUE(current
->mm
->start_brk
)) {
399 up_write(¤t
->mm
->mmap_sem
);
400 retval
= current
->mm
->start_brk
;
401 current
->mm
->start_brk
= 0;
405 up_write(¤t
->mm
->mmap_sem
);
407 current
->mm
->brk
= current
->mm
->start_brk
;
408 current
->mm
->context
.end_brk
= current
->mm
->start_brk
;
409 current
->mm
->context
.end_brk
+=
410 (stack_size
> PAGE_SIZE
) ? (stack_size
- PAGE_SIZE
) : 0;
411 current
->mm
->start_stack
= current
->mm
->start_brk
+ stack_size
;
414 install_exec_creds(bprm
);
415 if (create_elf_fdpic_tables(bprm
, current
->mm
,
416 &exec_params
, &interp_params
) < 0)
419 kdebug("- start_code %lx", current
->mm
->start_code
);
420 kdebug("- end_code %lx", current
->mm
->end_code
);
421 kdebug("- start_data %lx", current
->mm
->start_data
);
422 kdebug("- end_data %lx", current
->mm
->end_data
);
423 kdebug("- start_brk %lx", current
->mm
->start_brk
);
424 kdebug("- brk %lx", current
->mm
->brk
);
425 kdebug("- start_stack %lx", current
->mm
->start_stack
);
427 #ifdef ELF_FDPIC_PLAT_INIT
429 * The ABI may specify that certain registers be set up in special
430 * ways (on i386 %edx is the address of a DT_FINI function, for
431 * example. This macro performs whatever initialization to
432 * the regs structure is required.
434 dynaddr
= interp_params
.dynamic_addr
?: exec_params
.dynamic_addr
;
435 ELF_FDPIC_PLAT_INIT(regs
, exec_params
.map_addr
, interp_params
.map_addr
,
439 /* everything is now ready... get the userspace context ready to roll */
440 entryaddr
= interp_params
.entry_addr
?: exec_params
.entry_addr
;
441 start_thread(regs
, entryaddr
, current
->mm
->start_stack
);
447 allow_write_access(interpreter
);
450 kfree(interpreter_name
);
451 kfree(exec_params
.phdrs
);
452 kfree(exec_params
.loadmap
);
453 kfree(interp_params
.phdrs
);
454 kfree(interp_params
.loadmap
);
457 /* unrecoverable error - kill the process */
459 send_sig(SIGSEGV
, current
, 0);
464 /*****************************************************************************/
466 #ifndef ELF_BASE_PLATFORM
468 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
469 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
470 * will be copied to the user stack in the same manner as AT_PLATFORM.
472 #define ELF_BASE_PLATFORM NULL
476 * present useful information to the program by shovelling it onto the new
479 static int create_elf_fdpic_tables(struct linux_binprm
*bprm
,
480 struct mm_struct
*mm
,
481 struct elf_fdpic_params
*exec_params
,
482 struct elf_fdpic_params
*interp_params
)
484 const struct cred
*cred
= current_cred();
485 unsigned long sp
, csp
, nitems
;
486 elf_caddr_t __user
*argv
, *envp
;
487 size_t platform_len
= 0, len
;
488 char *k_platform
, *k_base_platform
;
489 char __user
*u_platform
, *u_base_platform
, *p
;
492 int nr
; /* reset for each csp adjustment */
495 /* In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
496 * by the processes running on the same package. One thing we can do is
497 * to shuffle the initial stack for them, so we give the architecture
498 * an opportunity to do so here.
500 sp
= arch_align_stack(bprm
->p
);
502 sp
= mm
->start_stack
;
504 /* stack the program arguments and environment */
505 if (elf_fdpic_transfer_args_to_stack(bprm
, &sp
) < 0)
512 * If this architecture has a platform capability string, copy it
513 * to userspace. In some cases (Sparc), this info is impossible
514 * for userspace to get any other way, in others (i386) it is
517 k_platform
= ELF_PLATFORM
;
521 platform_len
= strlen(k_platform
) + 1;
523 u_platform
= (char __user
*) sp
;
524 if (__copy_to_user(u_platform
, k_platform
, platform_len
) != 0)
529 * If this architecture has a "base" platform capability
530 * string, copy it to userspace.
532 k_base_platform
= ELF_BASE_PLATFORM
;
533 u_base_platform
= NULL
;
535 if (k_base_platform
) {
536 platform_len
= strlen(k_base_platform
) + 1;
538 u_base_platform
= (char __user
*) sp
;
539 if (__copy_to_user(u_base_platform
, k_base_platform
, platform_len
) != 0)
545 /* stack the load map(s) */
546 len
= sizeof(struct elf32_fdpic_loadmap
);
547 len
+= sizeof(struct elf32_fdpic_loadseg
) * exec_params
->loadmap
->nsegs
;
548 sp
= (sp
- len
) & ~7UL;
549 exec_params
->map_addr
= sp
;
551 if (copy_to_user((void __user
*) sp
, exec_params
->loadmap
, len
) != 0)
554 current
->mm
->context
.exec_fdpic_loadmap
= (unsigned long) sp
;
556 if (interp_params
->loadmap
) {
557 len
= sizeof(struct elf32_fdpic_loadmap
);
558 len
+= sizeof(struct elf32_fdpic_loadseg
) *
559 interp_params
->loadmap
->nsegs
;
560 sp
= (sp
- len
) & ~7UL;
561 interp_params
->map_addr
= sp
;
563 if (copy_to_user((void __user
*) sp
, interp_params
->loadmap
,
567 current
->mm
->context
.interp_fdpic_loadmap
= (unsigned long) sp
;
570 /* force 16 byte _final_ alignment here for generality */
571 #define DLINFO_ITEMS 15
573 nitems
= 1 + DLINFO_ITEMS
+ (k_platform
? 1 : 0) +
574 (k_base_platform
? 1 : 0) + AT_VECTOR_SIZE_ARCH
;
576 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
)
580 sp
-= nitems
* 2 * sizeof(unsigned long);
581 sp
-= (bprm
->envc
+ 1) * sizeof(char *); /* envv[] */
582 sp
-= (bprm
->argc
+ 1) * sizeof(char *); /* argv[] */
583 sp
-= 1 * sizeof(unsigned long); /* argc */
588 /* put the ELF interpreter info on the stack */
589 #define NEW_AUX_ENT(id, val) \
591 struct { unsigned long _id, _val; } __user *ent; \
593 ent = (void __user *) csp; \
594 __put_user((id), &ent[nr]._id); \
595 __put_user((val), &ent[nr]._val); \
600 csp
-= 2 * sizeof(unsigned long);
601 NEW_AUX_ENT(AT_NULL
, 0);
604 csp
-= 2 * sizeof(unsigned long);
605 NEW_AUX_ENT(AT_PLATFORM
,
606 (elf_addr_t
) (unsigned long) u_platform
);
609 if (k_base_platform
) {
611 csp
-= 2 * sizeof(unsigned long);
612 NEW_AUX_ENT(AT_BASE_PLATFORM
,
613 (elf_addr_t
) (unsigned long) u_base_platform
);
616 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
) {
618 csp
-= 2 * sizeof(unsigned long);
619 NEW_AUX_ENT(AT_EXECFD
, bprm
->interp_data
);
623 csp
-= DLINFO_ITEMS
* 2 * sizeof(unsigned long);
624 NEW_AUX_ENT(AT_HWCAP
, hwcap
);
625 NEW_AUX_ENT(AT_PAGESZ
, PAGE_SIZE
);
626 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
627 NEW_AUX_ENT(AT_PHDR
, exec_params
->ph_addr
);
628 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
629 NEW_AUX_ENT(AT_PHNUM
, exec_params
->hdr
.e_phnum
);
630 NEW_AUX_ENT(AT_BASE
, interp_params
->elfhdr_addr
);
631 NEW_AUX_ENT(AT_FLAGS
, 0);
632 NEW_AUX_ENT(AT_ENTRY
, exec_params
->entry_addr
);
633 NEW_AUX_ENT(AT_UID
, (elf_addr_t
) cred
->uid
);
634 NEW_AUX_ENT(AT_EUID
, (elf_addr_t
) cred
->euid
);
635 NEW_AUX_ENT(AT_GID
, (elf_addr_t
) cred
->gid
);
636 NEW_AUX_ENT(AT_EGID
, (elf_addr_t
) cred
->egid
);
637 NEW_AUX_ENT(AT_SECURE
, security_bprm_secureexec(bprm
));
638 NEW_AUX_ENT(AT_EXECFN
, bprm
->exec
);
642 csp
-= AT_VECTOR_SIZE_ARCH
* 2 * sizeof(unsigned long);
644 /* ARCH_DLINFO must come last so platform specific code can enforce
645 * special alignment requirements on the AUXV if necessary (eg. PPC).
651 /* allocate room for argv[] and envv[] */
652 csp
-= (bprm
->envc
+ 1) * sizeof(elf_caddr_t
);
653 envp
= (elf_caddr_t __user
*) csp
;
654 csp
-= (bprm
->argc
+ 1) * sizeof(elf_caddr_t
);
655 argv
= (elf_caddr_t __user
*) csp
;
658 csp
-= sizeof(unsigned long);
659 __put_user(bprm
->argc
, (unsigned long __user
*) csp
);
663 /* fill in the argv[] array */
665 current
->mm
->arg_start
= bprm
->p
;
667 current
->mm
->arg_start
= current
->mm
->start_stack
-
668 (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
);
671 p
= (char __user
*) current
->mm
->arg_start
;
672 for (loop
= bprm
->argc
; loop
> 0; loop
--) {
673 __put_user((elf_caddr_t
) p
, argv
++);
674 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
675 if (!len
|| len
> MAX_ARG_STRLEN
)
679 __put_user(NULL
, argv
);
680 current
->mm
->arg_end
= (unsigned long) p
;
682 /* fill in the envv[] array */
683 current
->mm
->env_start
= (unsigned long) p
;
684 for (loop
= bprm
->envc
; loop
> 0; loop
--) {
685 __put_user((elf_caddr_t
)(unsigned long) p
, envp
++);
686 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
687 if (!len
|| len
> MAX_ARG_STRLEN
)
691 __put_user(NULL
, envp
);
692 current
->mm
->env_end
= (unsigned long) p
;
694 mm
->start_stack
= (unsigned long) sp
;
698 /*****************************************************************************/
700 * transfer the program arguments and environment from the holding pages onto
704 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*bprm
,
707 unsigned long index
, stop
, sp
;
711 stop
= bprm
->p
>> PAGE_SHIFT
;
714 for (index
= MAX_ARG_PAGES
- 1; index
>= stop
; index
--) {
715 src
= kmap(bprm
->page
[index
]);
717 if (copy_to_user((void *) sp
, src
, PAGE_SIZE
) != 0)
719 kunmap(bprm
->page
[index
]);
724 *_sp
= (*_sp
- (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
)) & ~15;
731 /*****************************************************************************/
733 * load the appropriate binary image (executable or interpreter) into memory
734 * - we assume no MMU is available
735 * - if no other PIC bits are set in params->hdr->e_flags
736 * - we assume that the LOADable segments in the binary are independently relocatable
737 * - we assume R/O executable segments are shareable
739 * - we assume the loadable parts of the image to require fixed displacement
740 * - the image is not shareable
742 static int elf_fdpic_map_file(struct elf_fdpic_params
*params
,
744 struct mm_struct
*mm
,
747 struct elf32_fdpic_loadmap
*loadmap
;
749 struct elf32_fdpic_loadseg
*mseg
;
751 struct elf32_fdpic_loadseg
*seg
;
752 struct elf32_phdr
*phdr
;
753 unsigned long load_addr
, stop
;
754 unsigned nloads
, tmp
;
758 /* allocate a load map table */
760 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++)
761 if (params
->phdrs
[loop
].p_type
== PT_LOAD
)
767 size
= sizeof(*loadmap
) + nloads
* sizeof(*seg
);
768 loadmap
= kzalloc(size
, GFP_KERNEL
);
772 params
->loadmap
= loadmap
;
774 loadmap
->version
= ELF32_FDPIC_LOADMAP_VERSION
;
775 loadmap
->nsegs
= nloads
;
777 load_addr
= params
->load_addr
;
780 /* map the requested LOADs into the memory space */
781 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
782 case ELF_FDPIC_FLAG_CONSTDISP
:
783 case ELF_FDPIC_FLAG_CONTIGUOUS
:
785 ret
= elf_fdpic_map_file_constdisp_on_uclinux(params
, file
, mm
);
791 ret
= elf_fdpic_map_file_by_direct_mmap(params
, file
, mm
);
797 /* map the entry point */
798 if (params
->hdr
.e_entry
) {
800 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
801 if (params
->hdr
.e_entry
>= seg
->p_vaddr
&&
802 params
->hdr
.e_entry
< seg
->p_vaddr
+ seg
->p_memsz
) {
804 (params
->hdr
.e_entry
- seg
->p_vaddr
) +
811 /* determine where the program header table has wound up if mapped */
812 stop
= params
->hdr
.e_phoff
;
813 stop
+= params
->hdr
.e_phnum
* sizeof (struct elf_phdr
);
814 phdr
= params
->phdrs
;
816 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
817 if (phdr
->p_type
!= PT_LOAD
)
820 if (phdr
->p_offset
> params
->hdr
.e_phoff
||
821 phdr
->p_offset
+ phdr
->p_filesz
< stop
)
825 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
826 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
827 phdr
->p_vaddr
+ phdr
->p_filesz
<=
828 seg
->p_vaddr
+ seg
->p_memsz
) {
830 (phdr
->p_vaddr
- seg
->p_vaddr
) +
832 params
->hdr
.e_phoff
- phdr
->p_offset
;
839 /* determine where the dynamic section has wound up if there is one */
840 phdr
= params
->phdrs
;
841 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
842 if (phdr
->p_type
!= PT_DYNAMIC
)
846 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
847 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
848 phdr
->p_vaddr
+ phdr
->p_memsz
<=
849 seg
->p_vaddr
+ seg
->p_memsz
) {
850 params
->dynamic_addr
=
851 (phdr
->p_vaddr
- seg
->p_vaddr
) +
854 /* check the dynamic section contains at least
855 * one item, and that the last item is a NULL
857 if (phdr
->p_memsz
== 0 ||
858 phdr
->p_memsz
% sizeof(Elf32_Dyn
) != 0)
861 tmp
= phdr
->p_memsz
/ sizeof(Elf32_Dyn
);
863 params
->dynamic_addr
)[tmp
- 1].d_tag
!= 0)
871 /* now elide adjacent segments in the load map on MMU linux
872 * - on uClinux the holes between may actually be filled with system
873 * stuff or stuff from other processes
876 nloads
= loadmap
->nsegs
;
877 mseg
= loadmap
->segs
;
879 for (loop
= 1; loop
< nloads
; loop
++) {
880 /* see if we have a candidate for merging */
881 if (seg
->p_vaddr
- mseg
->p_vaddr
== seg
->addr
- mseg
->addr
) {
882 load_addr
= PAGE_ALIGN(mseg
->addr
+ mseg
->p_memsz
);
883 if (load_addr
== (seg
->addr
& PAGE_MASK
)) {
886 (mseg
->addr
+ mseg
->p_memsz
);
887 mseg
->p_memsz
+= seg
->addr
& ~PAGE_MASK
;
888 mseg
->p_memsz
+= seg
->p_memsz
;
900 kdebug("Mapped Object [%s]:", what
);
901 kdebug("- elfhdr : %lx", params
->elfhdr_addr
);
902 kdebug("- entry : %lx", params
->entry_addr
);
903 kdebug("- PHDR[] : %lx", params
->ph_addr
);
904 kdebug("- DYNAMIC[]: %lx", params
->dynamic_addr
);
906 for (loop
= 0; loop
< loadmap
->nsegs
; loop
++, seg
++)
907 kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
909 seg
->addr
, seg
->addr
+ seg
->p_memsz
- 1,
910 seg
->p_vaddr
, seg
->p_memsz
);
915 printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
916 what
, file
->f_path
.dentry
->d_inode
->i_ino
);
920 /*****************************************************************************/
922 * map a file with constant displacement under uClinux
925 static int elf_fdpic_map_file_constdisp_on_uclinux(
926 struct elf_fdpic_params
*params
,
928 struct mm_struct
*mm
)
930 struct elf32_fdpic_loadseg
*seg
;
931 struct elf32_phdr
*phdr
;
932 unsigned long load_addr
, base
= ULONG_MAX
, top
= 0, maddr
= 0, mflags
;
936 load_addr
= params
->load_addr
;
937 seg
= params
->loadmap
->segs
;
939 /* determine the bounds of the contiguous overall allocation we must
941 phdr
= params
->phdrs
;
942 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
943 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
946 if (base
> phdr
->p_vaddr
)
947 base
= phdr
->p_vaddr
;
948 if (top
< phdr
->p_vaddr
+ phdr
->p_memsz
)
949 top
= phdr
->p_vaddr
+ phdr
->p_memsz
;
952 /* allocate one big anon block for everything */
953 mflags
= MAP_PRIVATE
;
954 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
955 mflags
|= MAP_EXECUTABLE
;
957 down_write(&mm
->mmap_sem
);
958 maddr
= do_mmap(NULL
, load_addr
, top
- base
,
959 PROT_READ
| PROT_WRITE
| PROT_EXEC
, mflags
, 0);
960 up_write(&mm
->mmap_sem
);
961 if (IS_ERR_VALUE(maddr
))
965 load_addr
+= PAGE_ALIGN(top
- base
);
967 /* and then load the file segments into it */
968 phdr
= params
->phdrs
;
969 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
970 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
973 fpos
= phdr
->p_offset
;
975 seg
->addr
= maddr
+ (phdr
->p_vaddr
- base
);
976 seg
->p_vaddr
= phdr
->p_vaddr
;
977 seg
->p_memsz
= phdr
->p_memsz
;
979 ret
= file
->f_op
->read(file
, (void *) seg
->addr
,
980 phdr
->p_filesz
, &fpos
);
984 /* map the ELF header address if in this segment */
985 if (phdr
->p_offset
== 0)
986 params
->elfhdr_addr
= seg
->addr
;
988 /* clear any space allocated but not loaded */
989 if (phdr
->p_filesz
< phdr
->p_memsz
) {
990 if (clear_user((void *) (seg
->addr
+ phdr
->p_filesz
),
991 phdr
->p_memsz
- phdr
->p_filesz
))
996 if (phdr
->p_flags
& PF_X
) {
997 if (!mm
->start_code
) {
998 mm
->start_code
= seg
->addr
;
999 mm
->end_code
= seg
->addr
+
1002 } else if (!mm
->start_data
) {
1003 mm
->start_data
= seg
->addr
;
1004 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
1015 /*****************************************************************************/
1017 * map a binary by direct mmap() of the individual PT_LOAD segments
1019 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*params
,
1021 struct mm_struct
*mm
)
1023 struct elf32_fdpic_loadseg
*seg
;
1024 struct elf32_phdr
*phdr
;
1025 unsigned long load_addr
, delta_vaddr
;
1028 load_addr
= params
->load_addr
;
1032 seg
= params
->loadmap
->segs
;
1034 /* deal with each load segment separately */
1035 phdr
= params
->phdrs
;
1036 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
1037 unsigned long maddr
, disp
, excess
, excess1
;
1038 int prot
= 0, flags
;
1040 if (phdr
->p_type
!= PT_LOAD
)
1043 kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1044 (unsigned long) phdr
->p_vaddr
,
1045 (unsigned long) phdr
->p_offset
,
1046 (unsigned long) phdr
->p_filesz
,
1047 (unsigned long) phdr
->p_memsz
);
1049 /* determine the mapping parameters */
1050 if (phdr
->p_flags
& PF_R
) prot
|= PROT_READ
;
1051 if (phdr
->p_flags
& PF_W
) prot
|= PROT_WRITE
;
1052 if (phdr
->p_flags
& PF_X
) prot
|= PROT_EXEC
;
1054 flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1055 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
1056 flags
|= MAP_EXECUTABLE
;
1060 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
1061 case ELF_FDPIC_FLAG_INDEPENDENT
:
1062 /* PT_LOADs are independently locatable */
1065 case ELF_FDPIC_FLAG_HONOURVADDR
:
1066 /* the specified virtual address must be honoured */
1067 maddr
= phdr
->p_vaddr
;
1071 case ELF_FDPIC_FLAG_CONSTDISP
:
1072 /* constant displacement
1073 * - can be mapped anywhere, but must be mapped as a
1078 delta_vaddr
= phdr
->p_vaddr
;
1081 maddr
= load_addr
+ phdr
->p_vaddr
- delta_vaddr
;
1086 case ELF_FDPIC_FLAG_CONTIGUOUS
:
1087 /* contiguity handled later */
1096 /* create the mapping */
1097 disp
= phdr
->p_vaddr
& ~PAGE_MASK
;
1098 down_write(&mm
->mmap_sem
);
1099 maddr
= do_mmap(file
, maddr
, phdr
->p_memsz
+ disp
, prot
, flags
,
1100 phdr
->p_offset
- disp
);
1101 up_write(&mm
->mmap_sem
);
1103 kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1104 loop
, phdr
->p_memsz
+ disp
, prot
, flags
,
1105 phdr
->p_offset
- disp
, maddr
);
1107 if (IS_ERR_VALUE(maddr
))
1110 if ((params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) ==
1111 ELF_FDPIC_FLAG_CONTIGUOUS
)
1112 load_addr
+= PAGE_ALIGN(phdr
->p_memsz
+ disp
);
1114 seg
->addr
= maddr
+ disp
;
1115 seg
->p_vaddr
= phdr
->p_vaddr
;
1116 seg
->p_memsz
= phdr
->p_memsz
;
1118 /* map the ELF header address if in this segment */
1119 if (phdr
->p_offset
== 0)
1120 params
->elfhdr_addr
= seg
->addr
;
1122 /* clear the bit between beginning of mapping and beginning of
1124 if (prot
& PROT_WRITE
&& disp
> 0) {
1125 kdebug("clear[%d] ad=%lx sz=%lx", loop
, maddr
, disp
);
1126 if (clear_user((void __user
*) maddr
, disp
))
1131 /* clear any space allocated but not loaded
1132 * - on uClinux we can just clear the lot
1133 * - on MMU linux we'll get a SIGBUS beyond the last page
1134 * extant in the file
1136 excess
= phdr
->p_memsz
- phdr
->p_filesz
;
1137 excess1
= PAGE_SIZE
- ((maddr
+ phdr
->p_filesz
) & ~PAGE_MASK
);
1140 if (excess
> excess1
) {
1141 unsigned long xaddr
= maddr
+ phdr
->p_filesz
+ excess1
;
1142 unsigned long xmaddr
;
1144 flags
|= MAP_FIXED
| MAP_ANONYMOUS
;
1145 down_write(&mm
->mmap_sem
);
1146 xmaddr
= do_mmap(NULL
, xaddr
, excess
- excess1
,
1148 up_write(&mm
->mmap_sem
);
1150 kdebug("mmap[%d] <anon>"
1151 " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1152 loop
, xaddr
, excess
- excess1
, prot
, flags
,
1155 if (xmaddr
!= xaddr
)
1159 if (prot
& PROT_WRITE
&& excess1
> 0) {
1160 kdebug("clear[%d] ad=%lx sz=%lx",
1161 loop
, maddr
+ phdr
->p_filesz
, excess1
);
1162 if (clear_user((void __user
*) maddr
+ phdr
->p_filesz
,
1169 kdebug("clear[%d] ad=%lx sz=%lx",
1170 loop
, maddr
+ phdr
->p_filesz
, excess
);
1171 if (clear_user((void *) maddr
+ phdr
->p_filesz
, excess
))
1177 if (phdr
->p_flags
& PF_X
) {
1178 if (!mm
->start_code
) {
1179 mm
->start_code
= maddr
;
1180 mm
->end_code
= maddr
+ phdr
->p_memsz
;
1182 } else if (!mm
->start_data
) {
1183 mm
->start_data
= maddr
;
1184 mm
->end_data
= maddr
+ phdr
->p_memsz
;
1194 /*****************************************************************************/
1196 * ELF-FDPIC core dumper
1198 * Modelled on fs/exec.c:aout_core_dump()
1199 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1201 * Modelled on fs/binfmt_elf.c core dumper
1203 #ifdef CONFIG_ELF_CORE
1206 * Decide whether a segment is worth dumping; default is yes to be
1207 * sure (missing info is worse than too much; etc).
1208 * Personally I'd include everything, and use the coredump limit...
1210 * I think we should skip something. But I am not sure how. H.J.
1212 static int maydump(struct vm_area_struct
*vma
, unsigned long mm_flags
)
1216 /* Do not dump I/O mapped devices or special mappings */
1217 if (vma
->vm_flags
& (VM_IO
| VM_RESERVED
)) {
1218 kdcore("%08lx: %08lx: no (IO)", vma
->vm_start
, vma
->vm_flags
);
1222 /* If we may not read the contents, don't allow us to dump
1223 * them either. "dump_write()" can't handle it anyway.
1225 if (!(vma
->vm_flags
& VM_READ
)) {
1226 kdcore("%08lx: %08lx: no (!read)", vma
->vm_start
, vma
->vm_flags
);
1230 /* By default, dump shared memory if mapped from an anonymous file. */
1231 if (vma
->vm_flags
& VM_SHARED
) {
1232 if (vma
->vm_file
->f_path
.dentry
->d_inode
->i_nlink
== 0) {
1233 dump_ok
= test_bit(MMF_DUMP_ANON_SHARED
, &mm_flags
);
1234 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1235 vma
->vm_flags
, dump_ok
? "yes" : "no");
1239 dump_ok
= test_bit(MMF_DUMP_MAPPED_SHARED
, &mm_flags
);
1240 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1241 vma
->vm_flags
, dump_ok
? "yes" : "no");
1246 /* By default, if it hasn't been written to, don't write it out */
1247 if (!vma
->anon_vma
) {
1248 dump_ok
= test_bit(MMF_DUMP_MAPPED_PRIVATE
, &mm_flags
);
1249 kdcore("%08lx: %08lx: %s (!anon)", vma
->vm_start
,
1250 vma
->vm_flags
, dump_ok
? "yes" : "no");
1255 dump_ok
= test_bit(MMF_DUMP_ANON_PRIVATE
, &mm_flags
);
1256 kdcore("%08lx: %08lx: %s", vma
->vm_start
, vma
->vm_flags
,
1257 dump_ok
? "yes" : "no");
1261 /* An ELF note in memory */
1266 unsigned int datasz
;
1270 static int notesize(struct memelfnote
*en
)
1274 sz
= sizeof(struct elf_note
);
1275 sz
+= roundup(strlen(en
->name
) + 1, 4);
1276 sz
+= roundup(en
->datasz
, 4);
1283 #define DUMP_WRITE(addr, nr, foffset) \
1284 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
1286 static int alignfile(struct file
*file
, loff_t
*foffset
)
1288 static const char buf
[4] = { 0, };
1289 DUMP_WRITE(buf
, roundup(*foffset
, 4) - *foffset
, foffset
);
1293 static int writenote(struct memelfnote
*men
, struct file
*file
,
1297 en
.n_namesz
= strlen(men
->name
) + 1;
1298 en
.n_descsz
= men
->datasz
;
1299 en
.n_type
= men
->type
;
1301 DUMP_WRITE(&en
, sizeof(en
), foffset
);
1302 DUMP_WRITE(men
->name
, en
.n_namesz
, foffset
);
1303 if (!alignfile(file
, foffset
))
1305 DUMP_WRITE(men
->data
, men
->datasz
, foffset
);
1306 if (!alignfile(file
, foffset
))
1313 static inline void fill_elf_fdpic_header(struct elfhdr
*elf
, int segs
)
1315 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1316 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1317 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1318 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1319 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1320 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1322 elf
->e_type
= ET_CORE
;
1323 elf
->e_machine
= ELF_ARCH
;
1324 elf
->e_version
= EV_CURRENT
;
1326 elf
->e_phoff
= sizeof(struct elfhdr
);
1328 elf
->e_flags
= ELF_FDPIC_CORE_EFLAGS
;
1329 elf
->e_ehsize
= sizeof(struct elfhdr
);
1330 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1331 elf
->e_phnum
= segs
;
1332 elf
->e_shentsize
= 0;
1334 elf
->e_shstrndx
= 0;
1338 static inline void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1340 phdr
->p_type
= PT_NOTE
;
1341 phdr
->p_offset
= offset
;
1344 phdr
->p_filesz
= sz
;
1351 static inline void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1352 unsigned int sz
, void *data
)
1362 * fill up all the fields in prstatus from the given task struct, except
1363 * registers which need to be filled up separately.
1365 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1366 struct task_struct
*p
, long signr
)
1368 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1369 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1370 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1372 prstatus
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1374 prstatus
->pr_pid
= task_pid_vnr(p
);
1375 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1376 prstatus
->pr_sid
= task_session_vnr(p
);
1377 if (thread_group_leader(p
)) {
1378 struct task_cputime cputime
;
1381 * This is the record for the group leader. It shows the
1382 * group-wide total, not its individual thread total.
1384 thread_group_cputime(p
, &cputime
);
1385 cputime_to_timeval(cputime
.utime
, &prstatus
->pr_utime
);
1386 cputime_to_timeval(cputime
.stime
, &prstatus
->pr_stime
);
1388 cputime_to_timeval(p
->utime
, &prstatus
->pr_utime
);
1389 cputime_to_timeval(p
->stime
, &prstatus
->pr_stime
);
1391 cputime_to_timeval(p
->signal
->cutime
, &prstatus
->pr_cutime
);
1392 cputime_to_timeval(p
->signal
->cstime
, &prstatus
->pr_cstime
);
1394 prstatus
->pr_exec_fdpic_loadmap
= p
->mm
->context
.exec_fdpic_loadmap
;
1395 prstatus
->pr_interp_fdpic_loadmap
= p
->mm
->context
.interp_fdpic_loadmap
;
1398 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1399 struct mm_struct
*mm
)
1401 const struct cred
*cred
;
1402 unsigned int i
, len
;
1404 /* first copy the parameters from user space */
1405 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1407 len
= mm
->arg_end
- mm
->arg_start
;
1408 if (len
>= ELF_PRARGSZ
)
1409 len
= ELF_PRARGSZ
- 1;
1410 if (copy_from_user(&psinfo
->pr_psargs
,
1411 (const char __user
*) mm
->arg_start
, len
))
1413 for (i
= 0; i
< len
; i
++)
1414 if (psinfo
->pr_psargs
[i
] == 0)
1415 psinfo
->pr_psargs
[i
] = ' ';
1416 psinfo
->pr_psargs
[len
] = 0;
1419 psinfo
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1421 psinfo
->pr_pid
= task_pid_vnr(p
);
1422 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1423 psinfo
->pr_sid
= task_session_vnr(p
);
1425 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1426 psinfo
->pr_state
= i
;
1427 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1428 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1429 psinfo
->pr_nice
= task_nice(p
);
1430 psinfo
->pr_flag
= p
->flags
;
1432 cred
= __task_cred(p
);
1433 SET_UID(psinfo
->pr_uid
, cred
->uid
);
1434 SET_GID(psinfo
->pr_gid
, cred
->gid
);
1436 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1441 /* Here is the structure in which status of each thread is captured. */
1442 struct elf_thread_status
1444 struct list_head list
;
1445 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1446 elf_fpregset_t fpu
; /* NT_PRFPREG */
1447 struct task_struct
*thread
;
1448 #ifdef ELF_CORE_COPY_XFPREGS
1449 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1451 struct memelfnote notes
[3];
1456 * In order to add the specific thread information for the elf file format,
1457 * we need to keep a linked list of every thread's pr_status and then create
1458 * a single section for them in the final core file.
1460 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1462 struct task_struct
*p
= t
->thread
;
1467 fill_prstatus(&t
->prstatus
, p
, signr
);
1468 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1470 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1473 sz
+= notesize(&t
->notes
[0]);
1475 t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
, &t
->fpu
);
1476 if (t
->prstatus
.pr_fpvalid
) {
1477 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1480 sz
+= notesize(&t
->notes
[1]);
1483 #ifdef ELF_CORE_COPY_XFPREGS
1484 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1485 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1486 sizeof(t
->xfpu
), &t
->xfpu
);
1488 sz
+= notesize(&t
->notes
[2]);
1494 static void fill_extnum_info(struct elfhdr
*elf
, struct elf_shdr
*shdr4extnum
,
1495 elf_addr_t e_shoff
, int segs
)
1497 elf
->e_shoff
= e_shoff
;
1498 elf
->e_shentsize
= sizeof(*shdr4extnum
);
1500 elf
->e_shstrndx
= SHN_UNDEF
;
1502 memset(shdr4extnum
, 0, sizeof(*shdr4extnum
));
1504 shdr4extnum
->sh_type
= SHT_NULL
;
1505 shdr4extnum
->sh_size
= elf
->e_shnum
;
1506 shdr4extnum
->sh_link
= elf
->e_shstrndx
;
1507 shdr4extnum
->sh_info
= segs
;
1511 * dump the segments for an MMU process
1514 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1515 unsigned long *limit
, unsigned long mm_flags
)
1517 struct vm_area_struct
*vma
;
1520 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1523 if (!maydump(vma
, mm_flags
))
1526 for (addr
= vma
->vm_start
; addr
< vma
->vm_end
;
1527 addr
+= PAGE_SIZE
) {
1528 struct page
*page
= get_dump_page(addr
);
1530 void *kaddr
= kmap(page
);
1534 else if (!dump_write(file
, kaddr
, PAGE_SIZE
))
1537 page_cache_release(page
);
1538 } else if (!dump_seek(file
, PAGE_SIZE
))
1550 * dump the segments for a NOMMU process
1553 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1554 unsigned long *limit
, unsigned long mm_flags
)
1556 struct vm_area_struct
*vma
;
1558 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1559 if (!maydump(vma
, mm_flags
))
1562 if ((*size
+= PAGE_SIZE
) > *limit
)
1565 if (!dump_write(file
, (void *) vma
->vm_start
,
1566 vma
->vm_end
- vma
->vm_start
))
1574 static size_t elf_core_vma_data_size(unsigned long mm_flags
)
1576 struct vm_area_struct
*vma
;
1579 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
)
1580 if (maydump(vma
, mm_flags
))
1581 size
+= vma
->vm_end
- vma
->vm_start
;
1588 * This is a two-pass process; first we find the offsets of the bits,
1589 * and then they are actually written out. If we run out of core limit
1592 static int elf_fdpic_core_dump(struct coredump_params
*cprm
)
1600 struct vm_area_struct
*vma
;
1601 struct elfhdr
*elf
= NULL
;
1602 loff_t offset
= 0, dataoff
, foffset
;
1604 struct memelfnote
*notes
= NULL
;
1605 struct elf_prstatus
*prstatus
= NULL
; /* NT_PRSTATUS */
1606 struct elf_prpsinfo
*psinfo
= NULL
; /* NT_PRPSINFO */
1607 LIST_HEAD(thread_list
);
1608 struct list_head
*t
;
1609 elf_fpregset_t
*fpu
= NULL
;
1610 #ifdef ELF_CORE_COPY_XFPREGS
1611 elf_fpxregset_t
*xfpu
= NULL
;
1613 int thread_status_size
= 0;
1615 struct elf_phdr
*phdr4note
= NULL
;
1616 struct elf_shdr
*shdr4extnum
= NULL
;
1621 * We no longer stop all VM operations.
1623 * This is because those proceses that could possibly change map_count
1624 * or the mmap / vma pages are now blocked in do_exit on current
1625 * finishing this core dump.
1627 * Only ptrace can touch these memory addresses, but it doesn't change
1628 * the map_count or the pages allocated. So no possibility of crashing
1629 * exists while dumping the mm->vm_next areas to the core file.
1632 /* alloc memory for large data structures: too large to be on stack */
1633 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
1636 prstatus
= kzalloc(sizeof(*prstatus
), GFP_KERNEL
);
1639 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1642 notes
= kmalloc(NUM_NOTES
* sizeof(struct memelfnote
), GFP_KERNEL
);
1645 fpu
= kmalloc(sizeof(*fpu
), GFP_KERNEL
);
1648 #ifdef ELF_CORE_COPY_XFPREGS
1649 xfpu
= kmalloc(sizeof(*xfpu
), GFP_KERNEL
);
1655 struct core_thread
*ct
;
1656 struct elf_thread_status
*tmp
;
1658 for (ct
= current
->mm
->core_state
->dumper
.next
;
1659 ct
; ct
= ct
->next
) {
1660 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1664 tmp
->thread
= ct
->task
;
1665 list_add(&tmp
->list
, &thread_list
);
1668 list_for_each(t
, &thread_list
) {
1669 struct elf_thread_status
*tmp
;
1672 tmp
= list_entry(t
, struct elf_thread_status
, list
);
1673 sz
= elf_dump_thread_status(cprm
->signr
, tmp
);
1674 thread_status_size
+= sz
;
1678 /* now collect the dump for the current */
1679 fill_prstatus(prstatus
, current
, cprm
->signr
);
1680 elf_core_copy_regs(&prstatus
->pr_reg
, cprm
->regs
);
1682 segs
= current
->mm
->map_count
;
1683 segs
+= elf_core_extra_phdrs();
1685 /* for notes section */
1688 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
1689 * this, kernel supports extended numbering. Have a look at
1690 * include/linux/elf.h for further information. */
1691 e_phnum
= segs
> PN_XNUM
? PN_XNUM
: segs
;
1694 fill_elf_fdpic_header(elf
, e_phnum
);
1697 current
->flags
|= PF_DUMPCORE
;
1700 * Set up the notes in similar form to SVR4 core dumps made
1701 * with info from their /proc.
1704 fill_note(notes
+ 0, "CORE", NT_PRSTATUS
, sizeof(*prstatus
), prstatus
);
1705 fill_psinfo(psinfo
, current
->group_leader
, current
->mm
);
1706 fill_note(notes
+ 1, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1710 auxv
= (elf_addr_t
*) current
->mm
->saved_auxv
;
1715 while (auxv
[i
- 2] != AT_NULL
);
1716 fill_note(¬es
[numnote
++], "CORE", NT_AUXV
,
1717 i
* sizeof(elf_addr_t
), auxv
);
1719 /* Try to dump the FPU. */
1720 if ((prstatus
->pr_fpvalid
=
1721 elf_core_copy_task_fpregs(current
, cprm
->regs
, fpu
)))
1722 fill_note(notes
+ numnote
++,
1723 "CORE", NT_PRFPREG
, sizeof(*fpu
), fpu
);
1724 #ifdef ELF_CORE_COPY_XFPREGS
1725 if (elf_core_copy_task_xfpregs(current
, xfpu
))
1726 fill_note(notes
+ numnote
++,
1727 "LINUX", ELF_CORE_XFPREG_TYPE
, sizeof(*xfpu
), xfpu
);
1733 offset
+= sizeof(*elf
); /* Elf header */
1734 offset
+= segs
* sizeof(struct elf_phdr
); /* Program headers */
1737 /* Write notes phdr entry */
1741 for (i
= 0; i
< numnote
; i
++)
1742 sz
+= notesize(notes
+ i
);
1744 sz
+= thread_status_size
;
1746 phdr4note
= kmalloc(sizeof(*phdr4note
), GFP_KERNEL
);
1750 fill_elf_note_phdr(phdr4note
, sz
, offset
);
1754 /* Page-align dumped data */
1755 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1757 offset
+= elf_core_vma_data_size(cprm
->mm_flags
);
1758 offset
+= elf_core_extra_data_size();
1761 if (e_phnum
== PN_XNUM
) {
1762 shdr4extnum
= kmalloc(sizeof(*shdr4extnum
), GFP_KERNEL
);
1765 fill_extnum_info(elf
, shdr4extnum
, e_shoff
, segs
);
1770 size
+= sizeof(*elf
);
1771 if (size
> cprm
->limit
|| !dump_write(cprm
->file
, elf
, sizeof(*elf
)))
1774 size
+= sizeof(*phdr4note
);
1775 if (size
> cprm
->limit
1776 || !dump_write(cprm
->file
, phdr4note
, sizeof(*phdr4note
)))
1779 /* write program headers for segments dump */
1780 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1781 struct elf_phdr phdr
;
1784 sz
= vma
->vm_end
- vma
->vm_start
;
1786 phdr
.p_type
= PT_LOAD
;
1787 phdr
.p_offset
= offset
;
1788 phdr
.p_vaddr
= vma
->vm_start
;
1790 phdr
.p_filesz
= maydump(vma
, cprm
->mm_flags
) ? sz
: 0;
1792 offset
+= phdr
.p_filesz
;
1793 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1794 if (vma
->vm_flags
& VM_WRITE
)
1795 phdr
.p_flags
|= PF_W
;
1796 if (vma
->vm_flags
& VM_EXEC
)
1797 phdr
.p_flags
|= PF_X
;
1798 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1800 size
+= sizeof(phdr
);
1801 if (size
> cprm
->limit
1802 || !dump_write(cprm
->file
, &phdr
, sizeof(phdr
)))
1806 if (!elf_core_write_extra_phdrs(cprm
->file
, offset
, &size
, cprm
->limit
))
1809 /* write out the notes section */
1810 for (i
= 0; i
< numnote
; i
++)
1811 if (!writenote(notes
+ i
, cprm
->file
, &foffset
))
1814 /* write out the thread status notes section */
1815 list_for_each(t
, &thread_list
) {
1816 struct elf_thread_status
*tmp
=
1817 list_entry(t
, struct elf_thread_status
, list
);
1819 for (i
= 0; i
< tmp
->num_notes
; i
++)
1820 if (!writenote(&tmp
->notes
[i
], cprm
->file
, &foffset
))
1824 if (!dump_seek(cprm
->file
, dataoff
- foffset
))
1827 if (elf_fdpic_dump_segments(cprm
->file
, &size
, &cprm
->limit
,
1828 cprm
->mm_flags
) < 0)
1831 if (!elf_core_write_extra_data(cprm
->file
, &size
, cprm
->limit
))
1834 if (e_phnum
== PN_XNUM
) {
1835 size
+= sizeof(*shdr4extnum
);
1836 if (size
> cprm
->limit
1837 || !dump_write(cprm
->file
, shdr4extnum
,
1838 sizeof(*shdr4extnum
)))
1842 if (cprm
->file
->f_pos
!= offset
) {
1845 "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1846 cprm
->file
->f_pos
, offset
);
1853 while (!list_empty(&thread_list
)) {
1854 struct list_head
*tmp
= thread_list
.next
;
1856 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
1865 #ifdef ELF_CORE_COPY_XFPREGS
1872 #endif /* CONFIG_ELF_CORE */