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/highmem.h>
29 #include <linux/highuid.h>
30 #include <linux/personality.h>
31 #include <linux/ptrace.h>
32 #include <linux/init.h>
33 #include <linux/elf.h>
34 #include <linux/elf-fdpic.h>
35 #include <linux/elfcore.h>
37 #include <asm/uaccess.h>
38 #include <asm/param.h>
39 #include <asm/pgalloc.h>
41 typedef char *elf_caddr_t
;
44 #define kdebug(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
46 #define kdebug(fmt, ...) do {} while(0)
50 #define kdcore(fmt, ...) printk("FDPIC "fmt"\n" ,##__VA_ARGS__ )
52 #define kdcore(fmt, ...) do {} while(0)
55 MODULE_LICENSE("GPL");
57 static int load_elf_fdpic_binary(struct linux_binprm
*, struct pt_regs
*);
58 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*, struct file
*);
59 static int elf_fdpic_map_file(struct elf_fdpic_params
*, struct file
*,
60 struct mm_struct
*, const char *);
62 static int create_elf_fdpic_tables(struct linux_binprm
*, struct mm_struct
*,
63 struct elf_fdpic_params
*,
64 struct elf_fdpic_params
*);
67 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*,
69 static int elf_fdpic_map_file_constdisp_on_uclinux(struct elf_fdpic_params
*,
74 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*,
75 struct file
*, struct mm_struct
*);
77 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
78 static int elf_fdpic_core_dump(long, struct pt_regs
*, struct file
*, unsigned long limit
);
81 static struct linux_binfmt elf_fdpic_format
= {
82 .module
= THIS_MODULE
,
83 .load_binary
= load_elf_fdpic_binary
,
84 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
85 .core_dump
= elf_fdpic_core_dump
,
87 .min_coredump
= ELF_EXEC_PAGESIZE
,
90 static int __init
init_elf_fdpic_binfmt(void)
92 return register_binfmt(&elf_fdpic_format
);
95 static void __exit
exit_elf_fdpic_binfmt(void)
97 unregister_binfmt(&elf_fdpic_format
);
100 core_initcall(init_elf_fdpic_binfmt
);
101 module_exit(exit_elf_fdpic_binfmt
);
103 static int is_elf_fdpic(struct elfhdr
*hdr
, struct file
*file
)
105 if (memcmp(hdr
->e_ident
, ELFMAG
, SELFMAG
) != 0)
107 if (hdr
->e_type
!= ET_EXEC
&& hdr
->e_type
!= ET_DYN
)
109 if (!elf_check_arch(hdr
) || !elf_check_fdpic(hdr
))
111 if (!file
->f_op
|| !file
->f_op
->mmap
)
116 /*****************************************************************************/
118 * read the program headers table into memory
120 static int elf_fdpic_fetch_phdrs(struct elf_fdpic_params
*params
,
123 struct elf32_phdr
*phdr
;
127 if (params
->hdr
.e_phentsize
!= sizeof(struct elf_phdr
))
129 if (params
->hdr
.e_phnum
> 65536U / sizeof(struct elf_phdr
))
132 size
= params
->hdr
.e_phnum
* sizeof(struct elf_phdr
);
133 params
->phdrs
= kmalloc(size
, GFP_KERNEL
);
137 retval
= kernel_read(file
, params
->hdr
.e_phoff
,
138 (char *) params
->phdrs
, size
);
139 if (unlikely(retval
!= size
))
140 return retval
< 0 ? retval
: -ENOEXEC
;
142 /* determine stack size for this binary */
143 phdr
= params
->phdrs
;
144 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
145 if (phdr
->p_type
!= PT_GNU_STACK
)
148 if (phdr
->p_flags
& PF_X
)
149 params
->flags
|= ELF_FDPIC_FLAG_EXEC_STACK
;
151 params
->flags
|= ELF_FDPIC_FLAG_NOEXEC_STACK
;
153 params
->stack_size
= phdr
->p_memsz
;
160 /*****************************************************************************/
162 * load an fdpic binary into various bits of memory
164 static int load_elf_fdpic_binary(struct linux_binprm
*bprm
,
165 struct pt_regs
*regs
)
167 struct elf_fdpic_params exec_params
, interp_params
;
168 struct elf_phdr
*phdr
;
169 unsigned long stack_size
, entryaddr
;
171 unsigned long fullsize
;
173 #ifdef ELF_FDPIC_PLAT_INIT
174 unsigned long dynaddr
;
176 struct file
*interpreter
= NULL
; /* to shut gcc up */
177 char *interpreter_name
= NULL
;
178 int executable_stack
;
181 kdebug("____ LOAD %d ____", current
->pid
);
183 memset(&exec_params
, 0, sizeof(exec_params
));
184 memset(&interp_params
, 0, sizeof(interp_params
));
186 exec_params
.hdr
= *(struct elfhdr
*) bprm
->buf
;
187 exec_params
.flags
= ELF_FDPIC_FLAG_PRESENT
| ELF_FDPIC_FLAG_EXECUTABLE
;
189 /* check that this is a binary we know how to deal with */
191 if (!is_elf_fdpic(&exec_params
.hdr
, bprm
->file
))
194 /* read the program header table */
195 retval
= elf_fdpic_fetch_phdrs(&exec_params
, bprm
->file
);
199 /* scan for a program header that specifies an interpreter */
200 phdr
= exec_params
.phdrs
;
202 for (i
= 0; i
< exec_params
.hdr
.e_phnum
; i
++, phdr
++) {
203 switch (phdr
->p_type
) {
206 if (phdr
->p_filesz
> PATH_MAX
)
209 if (phdr
->p_filesz
< 2)
212 /* read the name of the interpreter into memory */
213 interpreter_name
= kmalloc(phdr
->p_filesz
, GFP_KERNEL
);
214 if (!interpreter_name
)
217 retval
= kernel_read(bprm
->file
,
221 if (unlikely(retval
!= phdr
->p_filesz
)) {
228 if (interpreter_name
[phdr
->p_filesz
- 1] != '\0')
231 kdebug("Using ELF interpreter %s", interpreter_name
);
233 /* replace the program with the interpreter */
234 interpreter
= open_exec(interpreter_name
);
235 retval
= PTR_ERR(interpreter
);
236 if (IS_ERR(interpreter
)) {
242 * If the binary is not readable then enforce
243 * mm->dumpable = 0 regardless of the interpreter's
246 if (file_permission(interpreter
, MAY_READ
) < 0)
247 bprm
->interp_flags
|= BINPRM_FLAGS_ENFORCE_NONDUMP
;
249 retval
= kernel_read(interpreter
, 0, bprm
->buf
,
251 if (unlikely(retval
!= BINPRM_BUF_SIZE
)) {
257 interp_params
.hdr
= *((struct elfhdr
*) bprm
->buf
);
262 if (exec_params
.load_addr
== 0)
263 exec_params
.load_addr
= phdr
->p_vaddr
;
270 if (elf_check_const_displacement(&exec_params
.hdr
))
271 exec_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
273 /* perform insanity checks on the interpreter */
274 if (interpreter_name
) {
276 if (!is_elf_fdpic(&interp_params
.hdr
, interpreter
))
279 interp_params
.flags
= ELF_FDPIC_FLAG_PRESENT
;
281 /* read the interpreter's program header table */
282 retval
= elf_fdpic_fetch_phdrs(&interp_params
, interpreter
);
287 stack_size
= exec_params
.stack_size
;
288 if (stack_size
< interp_params
.stack_size
)
289 stack_size
= interp_params
.stack_size
;
291 if (exec_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
292 executable_stack
= EXSTACK_ENABLE_X
;
293 else if (exec_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
294 executable_stack
= EXSTACK_DISABLE_X
;
295 else if (interp_params
.flags
& ELF_FDPIC_FLAG_EXEC_STACK
)
296 executable_stack
= EXSTACK_ENABLE_X
;
297 else if (interp_params
.flags
& ELF_FDPIC_FLAG_NOEXEC_STACK
)
298 executable_stack
= EXSTACK_DISABLE_X
;
300 executable_stack
= EXSTACK_DEFAULT
;
306 if (elf_check_const_displacement(&interp_params
.hdr
))
307 interp_params
.flags
|= ELF_FDPIC_FLAG_CONSTDISP
;
309 /* flush all traces of the currently running executable */
310 retval
= flush_old_exec(bprm
);
314 /* there's now no turning back... the old userspace image is dead,
315 * defunct, deceased, etc. after this point we have to exit via
317 set_personality(PER_LINUX_FDPIC
);
318 set_binfmt(&elf_fdpic_format
);
320 current
->mm
->start_code
= 0;
321 current
->mm
->end_code
= 0;
322 current
->mm
->start_stack
= 0;
323 current
->mm
->start_data
= 0;
324 current
->mm
->end_data
= 0;
325 current
->mm
->context
.exec_fdpic_loadmap
= 0;
326 current
->mm
->context
.interp_fdpic_loadmap
= 0;
328 current
->flags
&= ~PF_FORKNOEXEC
;
331 elf_fdpic_arch_lay_out_mm(&exec_params
,
333 ¤t
->mm
->start_stack
,
334 ¤t
->mm
->start_brk
);
336 retval
= setup_arg_pages(bprm
, current
->mm
->start_stack
,
339 send_sig(SIGKILL
, current
, 0);
344 /* load the executable and interpreter into memory */
345 retval
= elf_fdpic_map_file(&exec_params
, bprm
->file
, current
->mm
,
350 if (interpreter_name
) {
351 retval
= elf_fdpic_map_file(&interp_params
, interpreter
,
352 current
->mm
, "interpreter");
354 printk(KERN_ERR
"Unable to load interpreter\n");
358 allow_write_access(interpreter
);
364 if (!current
->mm
->start_brk
)
365 current
->mm
->start_brk
= current
->mm
->end_data
;
367 current
->mm
->brk
= current
->mm
->start_brk
=
368 PAGE_ALIGN(current
->mm
->start_brk
);
371 /* create a stack and brk area big enough for everyone
372 * - the brk heap starts at the bottom and works up
373 * - the stack starts at the top and works down
375 stack_size
= (stack_size
+ PAGE_SIZE
- 1) & PAGE_MASK
;
376 if (stack_size
< PAGE_SIZE
* 2)
377 stack_size
= PAGE_SIZE
* 2;
379 down_write(¤t
->mm
->mmap_sem
);
380 current
->mm
->start_brk
= do_mmap(NULL
, 0, stack_size
,
381 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
382 MAP_PRIVATE
| MAP_ANONYMOUS
| MAP_GROWSDOWN
,
385 if (IS_ERR_VALUE(current
->mm
->start_brk
)) {
386 up_write(¤t
->mm
->mmap_sem
);
387 retval
= current
->mm
->start_brk
;
388 current
->mm
->start_brk
= 0;
392 /* expand the stack mapping to use up the entire allocation granule */
393 fullsize
= kobjsize((char *) current
->mm
->start_brk
);
394 if (!IS_ERR_VALUE(do_mremap(current
->mm
->start_brk
, stack_size
,
396 stack_size
= fullsize
;
397 up_write(¤t
->mm
->mmap_sem
);
399 current
->mm
->brk
= current
->mm
->start_brk
;
400 current
->mm
->context
.end_brk
= current
->mm
->start_brk
;
401 current
->mm
->context
.end_brk
+=
402 (stack_size
> PAGE_SIZE
) ? (stack_size
- PAGE_SIZE
) : 0;
403 current
->mm
->start_stack
= current
->mm
->start_brk
+ stack_size
;
407 current
->flags
&= ~PF_FORKNOEXEC
;
408 if (create_elf_fdpic_tables(bprm
, current
->mm
,
409 &exec_params
, &interp_params
) < 0)
412 kdebug("- start_code %lx", current
->mm
->start_code
);
413 kdebug("- end_code %lx", current
->mm
->end_code
);
414 kdebug("- start_data %lx", current
->mm
->start_data
);
415 kdebug("- end_data %lx", current
->mm
->end_data
);
416 kdebug("- start_brk %lx", current
->mm
->start_brk
);
417 kdebug("- brk %lx", current
->mm
->brk
);
418 kdebug("- start_stack %lx", current
->mm
->start_stack
);
420 #ifdef ELF_FDPIC_PLAT_INIT
422 * The ABI may specify that certain registers be set up in special
423 * ways (on i386 %edx is the address of a DT_FINI function, for
424 * example. This macro performs whatever initialization to
425 * the regs structure is required.
427 dynaddr
= interp_params
.dynamic_addr
?: exec_params
.dynamic_addr
;
428 ELF_FDPIC_PLAT_INIT(regs
, exec_params
.map_addr
, interp_params
.map_addr
,
432 /* everything is now ready... get the userspace context ready to roll */
433 entryaddr
= interp_params
.entry_addr
?: exec_params
.entry_addr
;
434 start_thread(regs
, entryaddr
, current
->mm
->start_stack
);
440 allow_write_access(interpreter
);
443 kfree(interpreter_name
);
444 kfree(exec_params
.phdrs
);
445 kfree(exec_params
.loadmap
);
446 kfree(interp_params
.phdrs
);
447 kfree(interp_params
.loadmap
);
450 /* unrecoverable error - kill the process */
452 send_sig(SIGSEGV
, current
, 0);
457 /*****************************************************************************/
459 #ifndef ELF_BASE_PLATFORM
461 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
462 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
463 * will be copied to the user stack in the same manner as AT_PLATFORM.
465 #define ELF_BASE_PLATFORM NULL
469 * present useful information to the program by shovelling it onto the new
472 static int create_elf_fdpic_tables(struct linux_binprm
*bprm
,
473 struct mm_struct
*mm
,
474 struct elf_fdpic_params
*exec_params
,
475 struct elf_fdpic_params
*interp_params
)
477 unsigned long sp
, csp
, nitems
;
478 elf_caddr_t __user
*argv
, *envp
;
479 size_t platform_len
= 0, len
;
480 char *k_platform
, *k_base_platform
;
481 char __user
*u_platform
, *u_base_platform
, *p
;
484 int nr
; /* reset for each csp adjustment */
487 /* In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
488 * by the processes running on the same package. One thing we can do is
489 * to shuffle the initial stack for them, so we give the architecture
490 * an opportunity to do so here.
492 sp
= arch_align_stack(bprm
->p
);
494 sp
= mm
->start_stack
;
496 /* stack the program arguments and environment */
497 if (elf_fdpic_transfer_args_to_stack(bprm
, &sp
) < 0)
504 * If this architecture has a platform capability string, copy it
505 * to userspace. In some cases (Sparc), this info is impossible
506 * for userspace to get any other way, in others (i386) it is
509 k_platform
= ELF_PLATFORM
;
513 platform_len
= strlen(k_platform
) + 1;
515 u_platform
= (char __user
*) sp
;
516 if (__copy_to_user(u_platform
, k_platform
, platform_len
) != 0)
521 * If this architecture has a "base" platform capability
522 * string, copy it to userspace.
524 k_base_platform
= ELF_BASE_PLATFORM
;
525 u_base_platform
= NULL
;
527 if (k_base_platform
) {
528 platform_len
= strlen(k_base_platform
) + 1;
530 u_base_platform
= (char __user
*) sp
;
531 if (__copy_to_user(u_base_platform
, k_base_platform
, platform_len
) != 0)
537 /* stack the load map(s) */
538 len
= sizeof(struct elf32_fdpic_loadmap
);
539 len
+= sizeof(struct elf32_fdpic_loadseg
) * exec_params
->loadmap
->nsegs
;
540 sp
= (sp
- len
) & ~7UL;
541 exec_params
->map_addr
= sp
;
543 if (copy_to_user((void __user
*) sp
, exec_params
->loadmap
, len
) != 0)
546 current
->mm
->context
.exec_fdpic_loadmap
= (unsigned long) sp
;
548 if (interp_params
->loadmap
) {
549 len
= sizeof(struct elf32_fdpic_loadmap
);
550 len
+= sizeof(struct elf32_fdpic_loadseg
) *
551 interp_params
->loadmap
->nsegs
;
552 sp
= (sp
- len
) & ~7UL;
553 interp_params
->map_addr
= sp
;
555 if (copy_to_user((void __user
*) sp
, interp_params
->loadmap
,
559 current
->mm
->context
.interp_fdpic_loadmap
= (unsigned long) sp
;
562 /* force 16 byte _final_ alignment here for generality */
563 #define DLINFO_ITEMS 13
565 nitems
= 1 + DLINFO_ITEMS
+ (k_platform
? 1 : 0) +
566 (k_base_platform
? 1 : 0) + AT_VECTOR_SIZE_ARCH
;
569 sp
-= nitems
* 2 * sizeof(unsigned long);
570 sp
-= (bprm
->envc
+ 1) * sizeof(char *); /* envv[] */
571 sp
-= (bprm
->argc
+ 1) * sizeof(char *); /* argv[] */
572 sp
-= 1 * sizeof(unsigned long); /* argc */
577 /* put the ELF interpreter info on the stack */
578 #define NEW_AUX_ENT(id, val) \
580 struct { unsigned long _id, _val; } __user *ent; \
582 ent = (void __user *) csp; \
583 __put_user((id), &ent[nr]._id); \
584 __put_user((val), &ent[nr]._val); \
589 csp
-= 2 * sizeof(unsigned long);
590 NEW_AUX_ENT(AT_NULL
, 0);
593 csp
-= 2 * sizeof(unsigned long);
594 NEW_AUX_ENT(AT_PLATFORM
,
595 (elf_addr_t
) (unsigned long) u_platform
);
598 if (k_base_platform
) {
600 csp
-= 2 * sizeof(unsigned long);
601 NEW_AUX_ENT(AT_BASE_PLATFORM
,
602 (elf_addr_t
) (unsigned long) u_base_platform
);
606 csp
-= DLINFO_ITEMS
* 2 * sizeof(unsigned long);
607 NEW_AUX_ENT(AT_HWCAP
, hwcap
);
608 NEW_AUX_ENT(AT_PAGESZ
, PAGE_SIZE
);
609 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
610 NEW_AUX_ENT(AT_PHDR
, exec_params
->ph_addr
);
611 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
612 NEW_AUX_ENT(AT_PHNUM
, exec_params
->hdr
.e_phnum
);
613 NEW_AUX_ENT(AT_BASE
, interp_params
->elfhdr_addr
);
614 NEW_AUX_ENT(AT_FLAGS
, 0);
615 NEW_AUX_ENT(AT_ENTRY
, exec_params
->entry_addr
);
616 NEW_AUX_ENT(AT_UID
, (elf_addr_t
) current
->uid
);
617 NEW_AUX_ENT(AT_EUID
, (elf_addr_t
) current
->euid
);
618 NEW_AUX_ENT(AT_GID
, (elf_addr_t
) current
->gid
);
619 NEW_AUX_ENT(AT_EGID
, (elf_addr_t
) current
->egid
);
623 csp
-= AT_VECTOR_SIZE_ARCH
* 2 * sizeof(unsigned long);
625 /* ARCH_DLINFO must come last so platform specific code can enforce
626 * special alignment requirements on the AUXV if necessary (eg. PPC).
632 /* allocate room for argv[] and envv[] */
633 csp
-= (bprm
->envc
+ 1) * sizeof(elf_caddr_t
);
634 envp
= (elf_caddr_t __user
*) csp
;
635 csp
-= (bprm
->argc
+ 1) * sizeof(elf_caddr_t
);
636 argv
= (elf_caddr_t __user
*) csp
;
639 csp
-= sizeof(unsigned long);
640 __put_user(bprm
->argc
, (unsigned long __user
*) csp
);
644 /* fill in the argv[] array */
646 current
->mm
->arg_start
= bprm
->p
;
648 current
->mm
->arg_start
= current
->mm
->start_stack
-
649 (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
);
652 p
= (char __user
*) current
->mm
->arg_start
;
653 for (loop
= bprm
->argc
; loop
> 0; loop
--) {
654 __put_user((elf_caddr_t
) p
, argv
++);
655 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
656 if (!len
|| len
> MAX_ARG_STRLEN
)
660 __put_user(NULL
, argv
);
661 current
->mm
->arg_end
= (unsigned long) p
;
663 /* fill in the envv[] array */
664 current
->mm
->env_start
= (unsigned long) p
;
665 for (loop
= bprm
->envc
; loop
> 0; loop
--) {
666 __put_user((elf_caddr_t
)(unsigned long) p
, envp
++);
667 len
= strnlen_user(p
, MAX_ARG_STRLEN
);
668 if (!len
|| len
> MAX_ARG_STRLEN
)
672 __put_user(NULL
, envp
);
673 current
->mm
->env_end
= (unsigned long) p
;
675 mm
->start_stack
= (unsigned long) sp
;
679 /*****************************************************************************/
681 * transfer the program arguments and environment from the holding pages onto
685 static int elf_fdpic_transfer_args_to_stack(struct linux_binprm
*bprm
,
688 unsigned long index
, stop
, sp
;
692 stop
= bprm
->p
>> PAGE_SHIFT
;
695 for (index
= MAX_ARG_PAGES
- 1; index
>= stop
; index
--) {
696 src
= kmap(bprm
->page
[index
]);
698 if (copy_to_user((void *) sp
, src
, PAGE_SIZE
) != 0)
700 kunmap(bprm
->page
[index
]);
705 *_sp
= (*_sp
- (MAX_ARG_PAGES
* PAGE_SIZE
- bprm
->p
)) & ~15;
712 /*****************************************************************************/
714 * load the appropriate binary image (executable or interpreter) into memory
715 * - we assume no MMU is available
716 * - if no other PIC bits are set in params->hdr->e_flags
717 * - we assume that the LOADable segments in the binary are independently relocatable
718 * - we assume R/O executable segments are shareable
720 * - we assume the loadable parts of the image to require fixed displacement
721 * - the image is not shareable
723 static int elf_fdpic_map_file(struct elf_fdpic_params
*params
,
725 struct mm_struct
*mm
,
728 struct elf32_fdpic_loadmap
*loadmap
;
730 struct elf32_fdpic_loadseg
*mseg
;
732 struct elf32_fdpic_loadseg
*seg
;
733 struct elf32_phdr
*phdr
;
734 unsigned long load_addr
, stop
;
735 unsigned nloads
, tmp
;
739 /* allocate a load map table */
741 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++)
742 if (params
->phdrs
[loop
].p_type
== PT_LOAD
)
748 size
= sizeof(*loadmap
) + nloads
* sizeof(*seg
);
749 loadmap
= kzalloc(size
, GFP_KERNEL
);
753 params
->loadmap
= loadmap
;
755 loadmap
->version
= ELF32_FDPIC_LOADMAP_VERSION
;
756 loadmap
->nsegs
= nloads
;
758 load_addr
= params
->load_addr
;
761 /* map the requested LOADs into the memory space */
762 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
763 case ELF_FDPIC_FLAG_CONSTDISP
:
764 case ELF_FDPIC_FLAG_CONTIGUOUS
:
766 ret
= elf_fdpic_map_file_constdisp_on_uclinux(params
, file
, mm
);
772 ret
= elf_fdpic_map_file_by_direct_mmap(params
, file
, mm
);
778 /* map the entry point */
779 if (params
->hdr
.e_entry
) {
781 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
782 if (params
->hdr
.e_entry
>= seg
->p_vaddr
&&
783 params
->hdr
.e_entry
< seg
->p_vaddr
+ seg
->p_memsz
) {
785 (params
->hdr
.e_entry
- seg
->p_vaddr
) +
792 /* determine where the program header table has wound up if mapped */
793 stop
= params
->hdr
.e_phoff
;
794 stop
+= params
->hdr
.e_phnum
* sizeof (struct elf_phdr
);
795 phdr
= params
->phdrs
;
797 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
798 if (phdr
->p_type
!= PT_LOAD
)
801 if (phdr
->p_offset
> params
->hdr
.e_phoff
||
802 phdr
->p_offset
+ phdr
->p_filesz
< stop
)
806 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
807 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
808 phdr
->p_vaddr
+ phdr
->p_filesz
<=
809 seg
->p_vaddr
+ seg
->p_memsz
) {
811 (phdr
->p_vaddr
- seg
->p_vaddr
) +
813 params
->hdr
.e_phoff
- phdr
->p_offset
;
820 /* determine where the dynamic section has wound up if there is one */
821 phdr
= params
->phdrs
;
822 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
823 if (phdr
->p_type
!= PT_DYNAMIC
)
827 for (loop
= loadmap
->nsegs
; loop
> 0; loop
--, seg
++) {
828 if (phdr
->p_vaddr
>= seg
->p_vaddr
&&
829 phdr
->p_vaddr
+ phdr
->p_memsz
<=
830 seg
->p_vaddr
+ seg
->p_memsz
) {
831 params
->dynamic_addr
=
832 (phdr
->p_vaddr
- seg
->p_vaddr
) +
835 /* check the dynamic section contains at least
836 * one item, and that the last item is a NULL
838 if (phdr
->p_memsz
== 0 ||
839 phdr
->p_memsz
% sizeof(Elf32_Dyn
) != 0)
842 tmp
= phdr
->p_memsz
/ sizeof(Elf32_Dyn
);
844 params
->dynamic_addr
)[tmp
- 1].d_tag
!= 0)
852 /* now elide adjacent segments in the load map on MMU linux
853 * - on uClinux the holes between may actually be filled with system
854 * stuff or stuff from other processes
857 nloads
= loadmap
->nsegs
;
858 mseg
= loadmap
->segs
;
860 for (loop
= 1; loop
< nloads
; loop
++) {
861 /* see if we have a candidate for merging */
862 if (seg
->p_vaddr
- mseg
->p_vaddr
== seg
->addr
- mseg
->addr
) {
863 load_addr
= PAGE_ALIGN(mseg
->addr
+ mseg
->p_memsz
);
864 if (load_addr
== (seg
->addr
& PAGE_MASK
)) {
867 (mseg
->addr
+ mseg
->p_memsz
);
868 mseg
->p_memsz
+= seg
->addr
& ~PAGE_MASK
;
869 mseg
->p_memsz
+= seg
->p_memsz
;
881 kdebug("Mapped Object [%s]:", what
);
882 kdebug("- elfhdr : %lx", params
->elfhdr_addr
);
883 kdebug("- entry : %lx", params
->entry_addr
);
884 kdebug("- PHDR[] : %lx", params
->ph_addr
);
885 kdebug("- DYNAMIC[]: %lx", params
->dynamic_addr
);
887 for (loop
= 0; loop
< loadmap
->nsegs
; loop
++, seg
++)
888 kdebug("- LOAD[%d] : %08x-%08x [va=%x ms=%x]",
890 seg
->addr
, seg
->addr
+ seg
->p_memsz
- 1,
891 seg
->p_vaddr
, seg
->p_memsz
);
896 printk("ELF FDPIC %s with invalid DYNAMIC section (inode=%lu)\n",
897 what
, file
->f_path
.dentry
->d_inode
->i_ino
);
901 /*****************************************************************************/
903 * map a file with constant displacement under uClinux
906 static int elf_fdpic_map_file_constdisp_on_uclinux(
907 struct elf_fdpic_params
*params
,
909 struct mm_struct
*mm
)
911 struct elf32_fdpic_loadseg
*seg
;
912 struct elf32_phdr
*phdr
;
913 unsigned long load_addr
, base
= ULONG_MAX
, top
= 0, maddr
= 0, mflags
;
917 load_addr
= params
->load_addr
;
918 seg
= params
->loadmap
->segs
;
920 /* determine the bounds of the contiguous overall allocation we must
922 phdr
= params
->phdrs
;
923 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
924 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
927 if (base
> phdr
->p_vaddr
)
928 base
= phdr
->p_vaddr
;
929 if (top
< phdr
->p_vaddr
+ phdr
->p_memsz
)
930 top
= phdr
->p_vaddr
+ phdr
->p_memsz
;
933 /* allocate one big anon block for everything */
934 mflags
= MAP_PRIVATE
;
935 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
936 mflags
|= MAP_EXECUTABLE
;
938 down_write(&mm
->mmap_sem
);
939 maddr
= do_mmap(NULL
, load_addr
, top
- base
,
940 PROT_READ
| PROT_WRITE
| PROT_EXEC
, mflags
, 0);
941 up_write(&mm
->mmap_sem
);
942 if (IS_ERR_VALUE(maddr
))
946 load_addr
+= PAGE_ALIGN(top
- base
);
948 /* and then load the file segments into it */
949 phdr
= params
->phdrs
;
950 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
951 if (params
->phdrs
[loop
].p_type
!= PT_LOAD
)
954 fpos
= phdr
->p_offset
;
956 seg
->addr
= maddr
+ (phdr
->p_vaddr
- base
);
957 seg
->p_vaddr
= phdr
->p_vaddr
;
958 seg
->p_memsz
= phdr
->p_memsz
;
960 ret
= file
->f_op
->read(file
, (void *) seg
->addr
,
961 phdr
->p_filesz
, &fpos
);
965 /* map the ELF header address if in this segment */
966 if (phdr
->p_offset
== 0)
967 params
->elfhdr_addr
= seg
->addr
;
969 /* clear any space allocated but not loaded */
970 if (phdr
->p_filesz
< phdr
->p_memsz
)
971 clear_user((void *) (seg
->addr
+ phdr
->p_filesz
),
972 phdr
->p_memsz
- phdr
->p_filesz
);
975 if (phdr
->p_flags
& PF_X
) {
976 if (!mm
->start_code
) {
977 mm
->start_code
= seg
->addr
;
978 mm
->end_code
= seg
->addr
+
981 } else if (!mm
->start_data
) {
982 mm
->start_data
= seg
->addr
;
984 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
989 if (seg
->addr
+ phdr
->p_memsz
> mm
->end_data
)
990 mm
->end_data
= seg
->addr
+ phdr
->p_memsz
;
1001 /*****************************************************************************/
1003 * map a binary by direct mmap() of the individual PT_LOAD segments
1005 static int elf_fdpic_map_file_by_direct_mmap(struct elf_fdpic_params
*params
,
1007 struct mm_struct
*mm
)
1009 struct elf32_fdpic_loadseg
*seg
;
1010 struct elf32_phdr
*phdr
;
1011 unsigned long load_addr
, delta_vaddr
;
1014 load_addr
= params
->load_addr
;
1018 seg
= params
->loadmap
->segs
;
1020 /* deal with each load segment separately */
1021 phdr
= params
->phdrs
;
1022 for (loop
= 0; loop
< params
->hdr
.e_phnum
; loop
++, phdr
++) {
1023 unsigned long maddr
, disp
, excess
, excess1
;
1024 int prot
= 0, flags
;
1026 if (phdr
->p_type
!= PT_LOAD
)
1029 kdebug("[LOAD] va=%lx of=%lx fs=%lx ms=%lx",
1030 (unsigned long) phdr
->p_vaddr
,
1031 (unsigned long) phdr
->p_offset
,
1032 (unsigned long) phdr
->p_filesz
,
1033 (unsigned long) phdr
->p_memsz
);
1035 /* determine the mapping parameters */
1036 if (phdr
->p_flags
& PF_R
) prot
|= PROT_READ
;
1037 if (phdr
->p_flags
& PF_W
) prot
|= PROT_WRITE
;
1038 if (phdr
->p_flags
& PF_X
) prot
|= PROT_EXEC
;
1040 flags
= MAP_PRIVATE
| MAP_DENYWRITE
;
1041 if (params
->flags
& ELF_FDPIC_FLAG_EXECUTABLE
)
1042 flags
|= MAP_EXECUTABLE
;
1046 switch (params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) {
1047 case ELF_FDPIC_FLAG_INDEPENDENT
:
1048 /* PT_LOADs are independently locatable */
1051 case ELF_FDPIC_FLAG_HONOURVADDR
:
1052 /* the specified virtual address must be honoured */
1053 maddr
= phdr
->p_vaddr
;
1057 case ELF_FDPIC_FLAG_CONSTDISP
:
1058 /* constant displacement
1059 * - can be mapped anywhere, but must be mapped as a
1064 delta_vaddr
= phdr
->p_vaddr
;
1067 maddr
= load_addr
+ phdr
->p_vaddr
- delta_vaddr
;
1072 case ELF_FDPIC_FLAG_CONTIGUOUS
:
1073 /* contiguity handled later */
1082 /* create the mapping */
1083 disp
= phdr
->p_vaddr
& ~PAGE_MASK
;
1084 down_write(&mm
->mmap_sem
);
1085 maddr
= do_mmap(file
, maddr
, phdr
->p_memsz
+ disp
, prot
, flags
,
1086 phdr
->p_offset
- disp
);
1087 up_write(&mm
->mmap_sem
);
1089 kdebug("mmap[%d] <file> sz=%lx pr=%x fl=%x of=%lx --> %08lx",
1090 loop
, phdr
->p_memsz
+ disp
, prot
, flags
,
1091 phdr
->p_offset
- disp
, maddr
);
1093 if (IS_ERR_VALUE(maddr
))
1096 if ((params
->flags
& ELF_FDPIC_FLAG_ARRANGEMENT
) ==
1097 ELF_FDPIC_FLAG_CONTIGUOUS
)
1098 load_addr
+= PAGE_ALIGN(phdr
->p_memsz
+ disp
);
1100 seg
->addr
= maddr
+ disp
;
1101 seg
->p_vaddr
= phdr
->p_vaddr
;
1102 seg
->p_memsz
= phdr
->p_memsz
;
1104 /* map the ELF header address if in this segment */
1105 if (phdr
->p_offset
== 0)
1106 params
->elfhdr_addr
= seg
->addr
;
1108 /* clear the bit between beginning of mapping and beginning of
1110 if (prot
& PROT_WRITE
&& disp
> 0) {
1111 kdebug("clear[%d] ad=%lx sz=%lx", loop
, maddr
, disp
);
1112 clear_user((void __user
*) maddr
, disp
);
1116 /* clear any space allocated but not loaded
1117 * - on uClinux we can just clear the lot
1118 * - on MMU linux we'll get a SIGBUS beyond the last page
1119 * extant in the file
1121 excess
= phdr
->p_memsz
- phdr
->p_filesz
;
1122 excess1
= PAGE_SIZE
- ((maddr
+ phdr
->p_filesz
) & ~PAGE_MASK
);
1125 if (excess
> excess1
) {
1126 unsigned long xaddr
= maddr
+ phdr
->p_filesz
+ excess1
;
1127 unsigned long xmaddr
;
1129 flags
|= MAP_FIXED
| MAP_ANONYMOUS
;
1130 down_write(&mm
->mmap_sem
);
1131 xmaddr
= do_mmap(NULL
, xaddr
, excess
- excess1
,
1133 up_write(&mm
->mmap_sem
);
1135 kdebug("mmap[%d] <anon>"
1136 " ad=%lx sz=%lx pr=%x fl=%x of=0 --> %08lx",
1137 loop
, xaddr
, excess
- excess1
, prot
, flags
,
1140 if (xmaddr
!= xaddr
)
1144 if (prot
& PROT_WRITE
&& excess1
> 0) {
1145 kdebug("clear[%d] ad=%lx sz=%lx",
1146 loop
, maddr
+ phdr
->p_filesz
, excess1
);
1147 clear_user((void __user
*) maddr
+ phdr
->p_filesz
,
1153 kdebug("clear[%d] ad=%lx sz=%lx",
1154 loop
, maddr
+ phdr
->p_filesz
, excess
);
1155 clear_user((void *) maddr
+ phdr
->p_filesz
, excess
);
1160 if (phdr
->p_flags
& PF_X
) {
1161 if (!mm
->start_code
) {
1162 mm
->start_code
= maddr
;
1163 mm
->end_code
= maddr
+ phdr
->p_memsz
;
1165 } else if (!mm
->start_data
) {
1166 mm
->start_data
= maddr
;
1167 mm
->end_data
= maddr
+ phdr
->p_memsz
;
1177 /*****************************************************************************/
1179 * ELF-FDPIC core dumper
1181 * Modelled on fs/exec.c:aout_core_dump()
1182 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1184 * Modelled on fs/binfmt_elf.c core dumper
1186 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1189 * These are the only things you should do on a core-file: use only these
1190 * functions to write out all the necessary info.
1192 static int dump_write(struct file
*file
, const void *addr
, int nr
)
1194 return file
->f_op
->write(file
, addr
, nr
, &file
->f_pos
) == nr
;
1197 static int dump_seek(struct file
*file
, loff_t off
)
1199 if (file
->f_op
->llseek
) {
1200 if (file
->f_op
->llseek(file
, off
, SEEK_SET
) != off
)
1209 * Decide whether a segment is worth dumping; default is yes to be
1210 * sure (missing info is worse than too much; etc).
1211 * Personally I'd include everything, and use the coredump limit...
1213 * I think we should skip something. But I am not sure how. H.J.
1215 static int maydump(struct vm_area_struct
*vma
, unsigned long mm_flags
)
1219 /* Do not dump I/O mapped devices or special mappings */
1220 if (vma
->vm_flags
& (VM_IO
| VM_RESERVED
)) {
1221 kdcore("%08lx: %08lx: no (IO)", vma
->vm_start
, vma
->vm_flags
);
1225 /* If we may not read the contents, don't allow us to dump
1226 * them either. "dump_write()" can't handle it anyway.
1228 if (!(vma
->vm_flags
& VM_READ
)) {
1229 kdcore("%08lx: %08lx: no (!read)", vma
->vm_start
, vma
->vm_flags
);
1233 /* By default, dump shared memory if mapped from an anonymous file. */
1234 if (vma
->vm_flags
& VM_SHARED
) {
1235 if (vma
->vm_file
->f_path
.dentry
->d_inode
->i_nlink
== 0) {
1236 dump_ok
= test_bit(MMF_DUMP_ANON_SHARED
, &mm_flags
);
1237 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1238 vma
->vm_flags
, dump_ok
? "yes" : "no");
1242 dump_ok
= test_bit(MMF_DUMP_MAPPED_SHARED
, &mm_flags
);
1243 kdcore("%08lx: %08lx: %s (share)", vma
->vm_start
,
1244 vma
->vm_flags
, dump_ok
? "yes" : "no");
1249 /* By default, if it hasn't been written to, don't write it out */
1250 if (!vma
->anon_vma
) {
1251 dump_ok
= test_bit(MMF_DUMP_MAPPED_PRIVATE
, &mm_flags
);
1252 kdcore("%08lx: %08lx: %s (!anon)", vma
->vm_start
,
1253 vma
->vm_flags
, dump_ok
? "yes" : "no");
1258 dump_ok
= test_bit(MMF_DUMP_ANON_PRIVATE
, &mm_flags
);
1259 kdcore("%08lx: %08lx: %s", vma
->vm_start
, vma
->vm_flags
,
1260 dump_ok
? "yes" : "no");
1264 /* An ELF note in memory */
1269 unsigned int datasz
;
1273 static int notesize(struct memelfnote
*en
)
1277 sz
= sizeof(struct elf_note
);
1278 sz
+= roundup(strlen(en
->name
) + 1, 4);
1279 sz
+= roundup(en
->datasz
, 4);
1286 #define DUMP_WRITE(addr, nr) \
1287 do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1288 #define DUMP_SEEK(off) \
1289 do { if (!dump_seek(file, (off))) return 0; } while(0)
1291 static int writenote(struct memelfnote
*men
, struct file
*file
)
1295 en
.n_namesz
= strlen(men
->name
) + 1;
1296 en
.n_descsz
= men
->datasz
;
1297 en
.n_type
= men
->type
;
1299 DUMP_WRITE(&en
, sizeof(en
));
1300 DUMP_WRITE(men
->name
, en
.n_namesz
);
1301 /* XXX - cast from long long to long to avoid need for libgcc.a */
1302 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1303 DUMP_WRITE(men
->data
, men
->datasz
);
1304 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1311 #define DUMP_WRITE(addr, nr) \
1312 if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1314 #define DUMP_SEEK(off) \
1315 if (!dump_seek(file, (off))) \
1318 static inline void fill_elf_fdpic_header(struct elfhdr
*elf
, int segs
)
1320 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1321 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1322 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1323 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1324 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1325 memset(elf
->e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1327 elf
->e_type
= ET_CORE
;
1328 elf
->e_machine
= ELF_ARCH
;
1329 elf
->e_version
= EV_CURRENT
;
1331 elf
->e_phoff
= sizeof(struct elfhdr
);
1333 elf
->e_flags
= ELF_FDPIC_CORE_EFLAGS
;
1334 elf
->e_ehsize
= sizeof(struct elfhdr
);
1335 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1336 elf
->e_phnum
= segs
;
1337 elf
->e_shentsize
= 0;
1339 elf
->e_shstrndx
= 0;
1343 static inline void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1345 phdr
->p_type
= PT_NOTE
;
1346 phdr
->p_offset
= offset
;
1349 phdr
->p_filesz
= sz
;
1356 static inline void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1357 unsigned int sz
, void *data
)
1367 * fill up all the fields in prstatus from the given task struct, except
1368 * registers which need to be filled up seperately.
1370 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1371 struct task_struct
*p
, long signr
)
1373 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1374 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1375 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1376 prstatus
->pr_pid
= task_pid_vnr(p
);
1377 prstatus
->pr_ppid
= task_pid_vnr(p
->parent
);
1378 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1379 prstatus
->pr_sid
= task_session_vnr(p
);
1380 if (thread_group_leader(p
)) {
1382 * This is the record for the group leader. Add in the
1383 * cumulative times of previous dead threads. This total
1384 * won't include the time of each live thread whose state
1385 * is included in the core dump. The final total reported
1386 * to our parent process when it calls wait4 will include
1387 * those sums as well as the little bit more time it takes
1388 * this and each other thread to finish dying after the
1389 * core dump synchronization phase.
1391 cputime_to_timeval(cputime_add(p
->utime
, p
->signal
->utime
),
1392 &prstatus
->pr_utime
);
1393 cputime_to_timeval(cputime_add(p
->stime
, p
->signal
->stime
),
1394 &prstatus
->pr_stime
);
1396 cputime_to_timeval(p
->utime
, &prstatus
->pr_utime
);
1397 cputime_to_timeval(p
->stime
, &prstatus
->pr_stime
);
1399 cputime_to_timeval(p
->signal
->cutime
, &prstatus
->pr_cutime
);
1400 cputime_to_timeval(p
->signal
->cstime
, &prstatus
->pr_cstime
);
1402 prstatus
->pr_exec_fdpic_loadmap
= p
->mm
->context
.exec_fdpic_loadmap
;
1403 prstatus
->pr_interp_fdpic_loadmap
= p
->mm
->context
.interp_fdpic_loadmap
;
1406 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1407 struct mm_struct
*mm
)
1409 unsigned int i
, len
;
1411 /* first copy the parameters from user space */
1412 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1414 len
= mm
->arg_end
- mm
->arg_start
;
1415 if (len
>= ELF_PRARGSZ
)
1416 len
= ELF_PRARGSZ
- 1;
1417 if (copy_from_user(&psinfo
->pr_psargs
,
1418 (const char __user
*) mm
->arg_start
, len
))
1420 for (i
= 0; i
< len
; i
++)
1421 if (psinfo
->pr_psargs
[i
] == 0)
1422 psinfo
->pr_psargs
[i
] = ' ';
1423 psinfo
->pr_psargs
[len
] = 0;
1425 psinfo
->pr_pid
= task_pid_vnr(p
);
1426 psinfo
->pr_ppid
= task_pid_vnr(p
->parent
);
1427 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1428 psinfo
->pr_sid
= task_session_vnr(p
);
1430 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1431 psinfo
->pr_state
= i
;
1432 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1433 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1434 psinfo
->pr_nice
= task_nice(p
);
1435 psinfo
->pr_flag
= p
->flags
;
1436 SET_UID(psinfo
->pr_uid
, p
->uid
);
1437 SET_GID(psinfo
->pr_gid
, p
->gid
);
1438 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1443 /* Here is the structure in which status of each thread is captured. */
1444 struct elf_thread_status
1446 struct list_head list
;
1447 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1448 elf_fpregset_t fpu
; /* NT_PRFPREG */
1449 struct task_struct
*thread
;
1450 #ifdef ELF_CORE_COPY_XFPREGS
1451 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1453 struct memelfnote notes
[3];
1458 * In order to add the specific thread information for the elf file format,
1459 * we need to keep a linked list of every thread's pr_status and then create
1460 * a single section for them in the final core file.
1462 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1464 struct task_struct
*p
= t
->thread
;
1469 fill_prstatus(&t
->prstatus
, p
, signr
);
1470 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1472 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1475 sz
+= notesize(&t
->notes
[0]);
1477 t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
, &t
->fpu
);
1478 if (t
->prstatus
.pr_fpvalid
) {
1479 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1482 sz
+= notesize(&t
->notes
[1]);
1485 #ifdef ELF_CORE_COPY_XFPREGS
1486 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1487 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1488 sizeof(t
->xfpu
), &t
->xfpu
);
1490 sz
+= notesize(&t
->notes
[2]);
1497 * dump the segments for an MMU process
1500 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1501 unsigned long *limit
, unsigned long mm_flags
)
1503 struct vm_area_struct
*vma
;
1505 for (vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
) {
1508 if (!maydump(vma
, mm_flags
))
1511 for (addr
= vma
->vm_start
;
1515 struct vm_area_struct
*vma
;
1518 if (get_user_pages(current
, current
->mm
, addr
, 1, 0, 1,
1519 &page
, &vma
) <= 0) {
1520 DUMP_SEEK(file
->f_pos
+ PAGE_SIZE
);
1522 else if (page
== ZERO_PAGE(0)) {
1523 page_cache_release(page
);
1524 DUMP_SEEK(file
->f_pos
+ PAGE_SIZE
);
1529 flush_cache_page(vma
, addr
, page_to_pfn(page
));
1531 if ((*size
+= PAGE_SIZE
) > *limit
||
1532 !dump_write(file
, kaddr
, PAGE_SIZE
)
1535 page_cache_release(page
);
1539 page_cache_release(page
);
1552 * dump the segments for a NOMMU process
1555 static int elf_fdpic_dump_segments(struct file
*file
, size_t *size
,
1556 unsigned long *limit
, unsigned long mm_flags
)
1558 struct vm_list_struct
*vml
;
1560 for (vml
= current
->mm
->context
.vmlist
; vml
; vml
= vml
->next
) {
1561 struct vm_area_struct
*vma
= vml
->vma
;
1563 if (!maydump(vma
, mm_flags
))
1566 if ((*size
+= PAGE_SIZE
) > *limit
)
1569 if (!dump_write(file
, (void *) vma
->vm_start
,
1570 vma
->vm_end
- vma
->vm_start
))
1581 * This is a two-pass process; first we find the offsets of the bits,
1582 * and then they are actually written out. If we run out of core limit
1585 static int elf_fdpic_core_dump(long signr
, struct pt_regs
*regs
,
1586 struct file
*file
, unsigned long limit
)
1594 struct vm_area_struct
*vma
;
1595 struct elfhdr
*elf
= NULL
;
1596 loff_t offset
= 0, dataoff
;
1598 struct memelfnote
*notes
= NULL
;
1599 struct elf_prstatus
*prstatus
= NULL
; /* NT_PRSTATUS */
1600 struct elf_prpsinfo
*psinfo
= NULL
; /* NT_PRPSINFO */
1601 LIST_HEAD(thread_list
);
1602 struct list_head
*t
;
1603 elf_fpregset_t
*fpu
= NULL
;
1604 #ifdef ELF_CORE_COPY_XFPREGS
1605 elf_fpxregset_t
*xfpu
= NULL
;
1607 int thread_status_size
= 0;
1609 struct vm_list_struct
*vml
;
1612 unsigned long mm_flags
;
1615 * We no longer stop all VM operations.
1617 * This is because those proceses that could possibly change map_count
1618 * or the mmap / vma pages are now blocked in do_exit on current
1619 * finishing this core dump.
1621 * Only ptrace can touch these memory addresses, but it doesn't change
1622 * the map_count or the pages allocated. So no possibility of crashing
1623 * exists while dumping the mm->vm_next areas to the core file.
1626 /* alloc memory for large data structures: too large to be on stack */
1627 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
1630 prstatus
= kzalloc(sizeof(*prstatus
), GFP_KERNEL
);
1633 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1636 notes
= kmalloc(NUM_NOTES
* sizeof(struct memelfnote
), GFP_KERNEL
);
1639 fpu
= kmalloc(sizeof(*fpu
), GFP_KERNEL
);
1642 #ifdef ELF_CORE_COPY_XFPREGS
1643 xfpu
= kmalloc(sizeof(*xfpu
), GFP_KERNEL
);
1649 struct core_thread
*ct
;
1650 struct elf_thread_status
*tmp
;
1652 for (ct
= current
->mm
->core_state
->dumper
.next
;
1653 ct
; ct
= ct
->next
) {
1654 tmp
= kzalloc(sizeof(*tmp
), GFP_KERNEL
);
1658 tmp
->thread
= ct
->task
;
1659 list_add(&tmp
->list
, &thread_list
);
1662 list_for_each(t
, &thread_list
) {
1663 struct elf_thread_status
*tmp
;
1666 tmp
= list_entry(t
, struct elf_thread_status
, list
);
1667 sz
= elf_dump_thread_status(signr
, tmp
);
1668 thread_status_size
+= sz
;
1672 /* now collect the dump for the current */
1673 fill_prstatus(prstatus
, current
, signr
);
1674 elf_core_copy_regs(&prstatus
->pr_reg
, regs
);
1677 segs
= current
->mm
->map_count
;
1680 for (vml
= current
->mm
->context
.vmlist
; vml
; vml
= vml
->next
)
1683 #ifdef ELF_CORE_EXTRA_PHDRS
1684 segs
+= ELF_CORE_EXTRA_PHDRS
;
1688 fill_elf_fdpic_header(elf
, segs
+ 1); /* including notes section */
1691 current
->flags
|= PF_DUMPCORE
;
1694 * Set up the notes in similar form to SVR4 core dumps made
1695 * with info from their /proc.
1698 fill_note(notes
+ 0, "CORE", NT_PRSTATUS
, sizeof(*prstatus
), prstatus
);
1699 fill_psinfo(psinfo
, current
->group_leader
, current
->mm
);
1700 fill_note(notes
+ 1, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1704 auxv
= (elf_addr_t
*) current
->mm
->saved_auxv
;
1709 while (auxv
[i
- 2] != AT_NULL
);
1710 fill_note(¬es
[numnote
++], "CORE", NT_AUXV
,
1711 i
* sizeof(elf_addr_t
), auxv
);
1713 /* Try to dump the FPU. */
1714 if ((prstatus
->pr_fpvalid
=
1715 elf_core_copy_task_fpregs(current
, regs
, fpu
)))
1716 fill_note(notes
+ numnote
++,
1717 "CORE", NT_PRFPREG
, sizeof(*fpu
), fpu
);
1718 #ifdef ELF_CORE_COPY_XFPREGS
1719 if (elf_core_copy_task_xfpregs(current
, xfpu
))
1720 fill_note(notes
+ numnote
++,
1721 "LINUX", ELF_CORE_XFPREG_TYPE
, sizeof(*xfpu
), xfpu
);
1727 DUMP_WRITE(elf
, sizeof(*elf
));
1728 offset
+= sizeof(*elf
); /* Elf header */
1729 offset
+= (segs
+1) * sizeof(struct elf_phdr
); /* Program headers */
1731 /* Write notes phdr entry */
1733 struct elf_phdr phdr
;
1736 for (i
= 0; i
< numnote
; i
++)
1737 sz
+= notesize(notes
+ i
);
1739 sz
+= thread_status_size
;
1741 fill_elf_note_phdr(&phdr
, sz
, offset
);
1743 DUMP_WRITE(&phdr
, sizeof(phdr
));
1746 /* Page-align dumped data */
1747 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1750 * We must use the same mm->flags while dumping core to avoid
1751 * inconsistency between the program headers and bodies, otherwise an
1752 * unusable core file can be generated.
1754 mm_flags
= current
->mm
->flags
;
1756 /* write program headers for segments dump */
1759 vma
= current
->mm
->mmap
; vma
; vma
= vma
->vm_next
1761 vml
= current
->mm
->context
.vmlist
; vml
; vml
= vml
->next
1764 struct elf_phdr phdr
;
1771 sz
= vma
->vm_end
- vma
->vm_start
;
1773 phdr
.p_type
= PT_LOAD
;
1774 phdr
.p_offset
= offset
;
1775 phdr
.p_vaddr
= vma
->vm_start
;
1777 phdr
.p_filesz
= maydump(vma
, mm_flags
) ? sz
: 0;
1779 offset
+= phdr
.p_filesz
;
1780 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1781 if (vma
->vm_flags
& VM_WRITE
)
1782 phdr
.p_flags
|= PF_W
;
1783 if (vma
->vm_flags
& VM_EXEC
)
1784 phdr
.p_flags
|= PF_X
;
1785 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1787 DUMP_WRITE(&phdr
, sizeof(phdr
));
1790 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1791 ELF_CORE_WRITE_EXTRA_PHDRS
;
1794 /* write out the notes section */
1795 for (i
= 0; i
< numnote
; i
++)
1796 if (!writenote(notes
+ i
, file
))
1799 /* write out the thread status notes section */
1800 list_for_each(t
, &thread_list
) {
1801 struct elf_thread_status
*tmp
=
1802 list_entry(t
, struct elf_thread_status
, list
);
1804 for (i
= 0; i
< tmp
->num_notes
; i
++)
1805 if (!writenote(&tmp
->notes
[i
], file
))
1811 if (elf_fdpic_dump_segments(file
, &size
, &limit
, mm_flags
) < 0)
1814 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1815 ELF_CORE_WRITE_EXTRA_DATA
;
1818 if (file
->f_pos
!= offset
) {
1821 "elf_core_dump: file->f_pos (%lld) != offset (%lld)\n",
1822 file
->f_pos
, offset
);
1829 while (!list_empty(&thread_list
)) {
1830 struct list_head
*tmp
= thread_list
.next
;
1832 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
1840 #ifdef ELF_CORE_COPY_XFPREGS
1847 #endif /* USE_ELF_CORE_DUMP */