2 * linux/fs/binfmt_elf.c
4 * These are the functions used to load ELF format executables as used
5 * on SVr4 machines. Information on the format may be found in the book
6 * "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support
9 * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
12 #include <linux/module.h>
13 #include <linux/kernel.h>
16 #include <linux/mman.h>
17 #include <linux/errno.h>
18 #include <linux/signal.h>
19 #include <linux/binfmts.h>
20 #include <linux/string.h>
21 #include <linux/file.h>
22 #include <linux/slab.h>
23 #include <linux/personality.h>
24 #include <linux/elfcore.h>
25 #include <linux/init.h>
26 #include <linux/highuid.h>
27 #include <linux/compiler.h>
28 #include <linux/highmem.h>
29 #include <linux/pagemap.h>
30 #include <linux/vmalloc.h>
31 #include <linux/security.h>
32 #include <linux/random.h>
33 #include <linux/elf.h>
34 #include <linux/elf-randomize.h>
35 #include <linux/utsname.h>
36 #include <linux/coredump.h>
37 #include <linux/sched.h>
38 #include <linux/sched/coredump.h>
39 #include <linux/sched/task_stack.h>
40 #include <linux/sched/cputime.h>
41 #include <linux/cred.h>
42 #include <linux/dax.h>
43 #include <linux/uaccess.h>
44 #include <asm/param.h>
48 #define user_long_t long
50 #ifndef user_siginfo_t
51 #define user_siginfo_t siginfo_t
54 /* That's for binfmt_elf_fdpic to deal with */
55 #ifndef elf_check_fdpic
56 #define elf_check_fdpic(ex) false
59 static int load_elf_binary(struct linux_binprm
*bprm
);
60 static unsigned long elf_map(struct file
*, unsigned long, struct elf_phdr
*,
61 int, int, unsigned long);
64 static int load_elf_library(struct file
*);
66 #define load_elf_library NULL
70 * If we don't support core dumping, then supply a NULL so we
73 #ifdef CONFIG_ELF_CORE
74 static int elf_core_dump(struct coredump_params
*cprm
);
76 #define elf_core_dump NULL
79 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
80 #define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
82 #define ELF_MIN_ALIGN PAGE_SIZE
85 #ifndef ELF_CORE_EFLAGS
86 #define ELF_CORE_EFLAGS 0
89 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
90 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
91 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
93 static struct linux_binfmt elf_format
= {
94 .module
= THIS_MODULE
,
95 .load_binary
= load_elf_binary
,
96 .load_shlib
= load_elf_library
,
97 .core_dump
= elf_core_dump
,
98 .min_coredump
= ELF_EXEC_PAGESIZE
,
101 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
103 static int set_brk(unsigned long start
, unsigned long end
, int prot
)
105 start
= ELF_PAGEALIGN(start
);
106 end
= ELF_PAGEALIGN(end
);
109 * Map the last of the bss segment.
110 * If the header is requesting these pages to be
111 * executable, honour that (ppc32 needs this).
113 int error
= vm_brk_flags(start
, end
- start
,
114 prot
& PROT_EXEC
? VM_EXEC
: 0);
118 current
->mm
->start_brk
= current
->mm
->brk
= end
;
122 /* We need to explicitly zero any fractional pages
123 after the data section (i.e. bss). This would
124 contain the junk from the file that should not
127 static int padzero(unsigned long elf_bss
)
131 nbyte
= ELF_PAGEOFFSET(elf_bss
);
133 nbyte
= ELF_MIN_ALIGN
- nbyte
;
134 if (clear_user((void __user
*) elf_bss
, nbyte
))
140 /* Let's use some macros to make this stack manipulation a little clearer */
141 #ifdef CONFIG_STACK_GROWSUP
142 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
143 #define STACK_ROUND(sp, items) \
144 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
145 #define STACK_ALLOC(sp, len) ({ \
146 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
149 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
150 #define STACK_ROUND(sp, items) \
151 (((unsigned long) (sp - items)) &~ 15UL)
152 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
155 #ifndef ELF_BASE_PLATFORM
157 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
158 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
159 * will be copied to the user stack in the same manner as AT_PLATFORM.
161 #define ELF_BASE_PLATFORM NULL
165 create_elf_tables(struct linux_binprm
*bprm
, struct elfhdr
*exec
,
166 unsigned long load_addr
, unsigned long interp_load_addr
)
168 unsigned long p
= bprm
->p
;
169 int argc
= bprm
->argc
;
170 int envc
= bprm
->envc
;
171 elf_addr_t __user
*sp
;
172 elf_addr_t __user
*u_platform
;
173 elf_addr_t __user
*u_base_platform
;
174 elf_addr_t __user
*u_rand_bytes
;
175 const char *k_platform
= ELF_PLATFORM
;
176 const char *k_base_platform
= ELF_BASE_PLATFORM
;
177 unsigned char k_rand_bytes
[16];
179 elf_addr_t
*elf_info
;
181 const struct cred
*cred
= current_cred();
182 struct vm_area_struct
*vma
;
185 * In some cases (e.g. Hyper-Threading), we want to avoid L1
186 * evictions by the processes running on the same package. One
187 * thing we can do is to shuffle the initial stack for them.
190 p
= arch_align_stack(p
);
193 * If this architecture has a platform capability string, copy it
194 * to userspace. In some cases (Sparc), this info is impossible
195 * for userspace to get any other way, in others (i386) it is
200 size_t len
= strlen(k_platform
) + 1;
202 u_platform
= (elf_addr_t __user
*)STACK_ALLOC(p
, len
);
203 if (__copy_to_user(u_platform
, k_platform
, len
))
208 * If this architecture has a "base" platform capability
209 * string, copy it to userspace.
211 u_base_platform
= NULL
;
212 if (k_base_platform
) {
213 size_t len
= strlen(k_base_platform
) + 1;
215 u_base_platform
= (elf_addr_t __user
*)STACK_ALLOC(p
, len
);
216 if (__copy_to_user(u_base_platform
, k_base_platform
, len
))
221 * Generate 16 random bytes for userspace PRNG seeding.
223 get_random_bytes(k_rand_bytes
, sizeof(k_rand_bytes
));
224 u_rand_bytes
= (elf_addr_t __user
*)
225 STACK_ALLOC(p
, sizeof(k_rand_bytes
));
226 if (__copy_to_user(u_rand_bytes
, k_rand_bytes
, sizeof(k_rand_bytes
)))
229 /* Create the ELF interpreter info */
230 elf_info
= (elf_addr_t
*)current
->mm
->saved_auxv
;
231 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
232 #define NEW_AUX_ENT(id, val) \
234 elf_info[ei_index++] = id; \
235 elf_info[ei_index++] = val; \
240 * ARCH_DLINFO must come first so PPC can do its special alignment of
242 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
243 * ARCH_DLINFO changes
247 NEW_AUX_ENT(AT_HWCAP
, ELF_HWCAP
);
248 NEW_AUX_ENT(AT_PAGESZ
, ELF_EXEC_PAGESIZE
);
249 NEW_AUX_ENT(AT_CLKTCK
, CLOCKS_PER_SEC
);
250 NEW_AUX_ENT(AT_PHDR
, load_addr
+ exec
->e_phoff
);
251 NEW_AUX_ENT(AT_PHENT
, sizeof(struct elf_phdr
));
252 NEW_AUX_ENT(AT_PHNUM
, exec
->e_phnum
);
253 NEW_AUX_ENT(AT_BASE
, interp_load_addr
);
254 NEW_AUX_ENT(AT_FLAGS
, 0);
255 NEW_AUX_ENT(AT_ENTRY
, exec
->e_entry
);
256 NEW_AUX_ENT(AT_UID
, from_kuid_munged(cred
->user_ns
, cred
->uid
));
257 NEW_AUX_ENT(AT_EUID
, from_kuid_munged(cred
->user_ns
, cred
->euid
));
258 NEW_AUX_ENT(AT_GID
, from_kgid_munged(cred
->user_ns
, cred
->gid
));
259 NEW_AUX_ENT(AT_EGID
, from_kgid_munged(cred
->user_ns
, cred
->egid
));
260 NEW_AUX_ENT(AT_SECURE
, bprm
->secureexec
);
261 NEW_AUX_ENT(AT_RANDOM
, (elf_addr_t
)(unsigned long)u_rand_bytes
);
263 NEW_AUX_ENT(AT_HWCAP2
, ELF_HWCAP2
);
265 NEW_AUX_ENT(AT_EXECFN
, bprm
->exec
);
267 NEW_AUX_ENT(AT_PLATFORM
,
268 (elf_addr_t
)(unsigned long)u_platform
);
270 if (k_base_platform
) {
271 NEW_AUX_ENT(AT_BASE_PLATFORM
,
272 (elf_addr_t
)(unsigned long)u_base_platform
);
274 if (bprm
->interp_flags
& BINPRM_FLAGS_EXECFD
) {
275 NEW_AUX_ENT(AT_EXECFD
, bprm
->interp_data
);
278 /* AT_NULL is zero; clear the rest too */
279 memset(&elf_info
[ei_index
], 0,
280 sizeof current
->mm
->saved_auxv
- ei_index
* sizeof elf_info
[0]);
282 /* And advance past the AT_NULL entry. */
285 sp
= STACK_ADD(p
, ei_index
);
287 items
= (argc
+ 1) + (envc
+ 1) + 1;
288 bprm
->p
= STACK_ROUND(sp
, items
);
290 /* Point sp at the lowest address on the stack */
291 #ifdef CONFIG_STACK_GROWSUP
292 sp
= (elf_addr_t __user
*)bprm
->p
- items
- ei_index
;
293 bprm
->exec
= (unsigned long)sp
; /* XXX: PARISC HACK */
295 sp
= (elf_addr_t __user
*)bprm
->p
;
300 * Grow the stack manually; some architectures have a limit on how
301 * far ahead a user-space access may be in order to grow the stack.
303 vma
= find_extend_vma(current
->mm
, bprm
->p
);
307 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
308 if (__put_user(argc
, sp
++))
311 /* Populate list of argv pointers back to argv strings. */
312 p
= current
->mm
->arg_end
= current
->mm
->arg_start
;
315 if (__put_user((elf_addr_t
)p
, sp
++))
317 len
= strnlen_user((void __user
*)p
, MAX_ARG_STRLEN
);
318 if (!len
|| len
> MAX_ARG_STRLEN
)
322 if (__put_user(0, sp
++))
324 current
->mm
->arg_end
= p
;
326 /* Populate list of envp pointers back to envp strings. */
327 current
->mm
->env_end
= current
->mm
->env_start
= p
;
330 if (__put_user((elf_addr_t
)p
, sp
++))
332 len
= strnlen_user((void __user
*)p
, MAX_ARG_STRLEN
);
333 if (!len
|| len
> MAX_ARG_STRLEN
)
337 if (__put_user(0, sp
++))
339 current
->mm
->env_end
= p
;
341 /* Put the elf_info on the stack in the right place. */
342 if (copy_to_user(sp
, elf_info
, ei_index
* sizeof(elf_addr_t
)))
349 static unsigned long elf_map(struct file
*filep
, unsigned long addr
,
350 struct elf_phdr
*eppnt
, int prot
, int type
,
351 unsigned long total_size
)
353 unsigned long map_addr
;
354 unsigned long size
= eppnt
->p_filesz
+ ELF_PAGEOFFSET(eppnt
->p_vaddr
);
355 unsigned long off
= eppnt
->p_offset
- ELF_PAGEOFFSET(eppnt
->p_vaddr
);
356 addr
= ELF_PAGESTART(addr
);
357 size
= ELF_PAGEALIGN(size
);
359 /* mmap() will return -EINVAL if given a zero size, but a
360 * segment with zero filesize is perfectly valid */
365 * total_size is the size of the ELF (interpreter) image.
366 * The _first_ mmap needs to know the full size, otherwise
367 * randomization might put this image into an overlapping
368 * position with the ELF binary image. (since size < total_size)
369 * So we first map the 'big' image - and unmap the remainder at
370 * the end. (which unmap is needed for ELF images with holes.)
373 total_size
= ELF_PAGEALIGN(total_size
);
374 map_addr
= vm_mmap(filep
, addr
, total_size
, prot
, type
, off
);
375 if (!BAD_ADDR(map_addr
))
376 vm_munmap(map_addr
+size
, total_size
-size
);
378 map_addr
= vm_mmap(filep
, addr
, size
, prot
, type
, off
);
383 #endif /* !elf_map */
385 static unsigned long total_mapping_size(struct elf_phdr
*cmds
, int nr
)
387 int i
, first_idx
= -1, last_idx
= -1;
389 for (i
= 0; i
< nr
; i
++) {
390 if (cmds
[i
].p_type
== PT_LOAD
) {
399 return cmds
[last_idx
].p_vaddr
+ cmds
[last_idx
].p_memsz
-
400 ELF_PAGESTART(cmds
[first_idx
].p_vaddr
);
404 * load_elf_phdrs() - load ELF program headers
405 * @elf_ex: ELF header of the binary whose program headers should be loaded
406 * @elf_file: the opened ELF binary file
408 * Loads ELF program headers from the binary file elf_file, which has the ELF
409 * header pointed to by elf_ex, into a newly allocated array. The caller is
410 * responsible for freeing the allocated data. Returns an ERR_PTR upon failure.
412 static struct elf_phdr
*load_elf_phdrs(struct elfhdr
*elf_ex
,
413 struct file
*elf_file
)
415 struct elf_phdr
*elf_phdata
= NULL
;
416 int retval
, size
, err
= -1;
417 loff_t pos
= elf_ex
->e_phoff
;
420 * If the size of this structure has changed, then punt, since
421 * we will be doing the wrong thing.
423 if (elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
))
426 /* Sanity check the number of program headers... */
427 if (elf_ex
->e_phnum
< 1 ||
428 elf_ex
->e_phnum
> 65536U / sizeof(struct elf_phdr
))
431 /* ...and their total size. */
432 size
= sizeof(struct elf_phdr
) * elf_ex
->e_phnum
;
433 if (size
> ELF_MIN_ALIGN
)
436 elf_phdata
= kmalloc(size
, GFP_KERNEL
);
440 /* Read in the program headers */
441 retval
= kernel_read(elf_file
, elf_phdata
, size
, &pos
);
442 if (retval
!= size
) {
443 err
= (retval
< 0) ? retval
: -EIO
;
457 #ifndef CONFIG_ARCH_BINFMT_ELF_STATE
460 * struct arch_elf_state - arch-specific ELF loading state
462 * This structure is used to preserve architecture specific data during
463 * the loading of an ELF file, throughout the checking of architecture
464 * specific ELF headers & through to the point where the ELF load is
465 * known to be proceeding (ie. SET_PERSONALITY).
467 * This implementation is a dummy for architectures which require no
470 struct arch_elf_state
{
473 #define INIT_ARCH_ELF_STATE {}
476 * arch_elf_pt_proc() - check a PT_LOPROC..PT_HIPROC ELF program header
477 * @ehdr: The main ELF header
478 * @phdr: The program header to check
479 * @elf: The open ELF file
480 * @is_interp: True if the phdr is from the interpreter of the ELF being
481 * loaded, else false.
482 * @state: Architecture-specific state preserved throughout the process
483 * of loading the ELF.
485 * Inspects the program header phdr to validate its correctness and/or
486 * suitability for the system. Called once per ELF program header in the
487 * range PT_LOPROC to PT_HIPROC, for both the ELF being loaded and its
490 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
491 * with that return code.
493 static inline int arch_elf_pt_proc(struct elfhdr
*ehdr
,
494 struct elf_phdr
*phdr
,
495 struct file
*elf
, bool is_interp
,
496 struct arch_elf_state
*state
)
498 /* Dummy implementation, always proceed */
503 * arch_check_elf() - check an ELF executable
504 * @ehdr: The main ELF header
505 * @has_interp: True if the ELF has an interpreter, else false.
506 * @interp_ehdr: The interpreter's ELF header
507 * @state: Architecture-specific state preserved throughout the process
508 * of loading the ELF.
510 * Provides a final opportunity for architecture code to reject the loading
511 * of the ELF & cause an exec syscall to return an error. This is called after
512 * all program headers to be checked by arch_elf_pt_proc have been.
514 * Return: Zero to proceed with the ELF load, non-zero to fail the ELF load
515 * with that return code.
517 static inline int arch_check_elf(struct elfhdr
*ehdr
, bool has_interp
,
518 struct elfhdr
*interp_ehdr
,
519 struct arch_elf_state
*state
)
521 /* Dummy implementation, always proceed */
525 #endif /* !CONFIG_ARCH_BINFMT_ELF_STATE */
527 /* This is much more generalized than the library routine read function,
528 so we keep this separate. Technically the library read function
529 is only provided so that we can read a.out libraries that have
532 static unsigned long load_elf_interp(struct elfhdr
*interp_elf_ex
,
533 struct file
*interpreter
, unsigned long *interp_map_addr
,
534 unsigned long no_base
, struct elf_phdr
*interp_elf_phdata
)
536 struct elf_phdr
*eppnt
;
537 unsigned long load_addr
= 0;
538 int load_addr_set
= 0;
539 unsigned long last_bss
= 0, elf_bss
= 0;
541 unsigned long error
= ~0UL;
542 unsigned long total_size
;
545 /* First of all, some simple consistency checks */
546 if (interp_elf_ex
->e_type
!= ET_EXEC
&&
547 interp_elf_ex
->e_type
!= ET_DYN
)
549 if (!elf_check_arch(interp_elf_ex
) ||
550 elf_check_fdpic(interp_elf_ex
))
552 if (!interpreter
->f_op
->mmap
)
555 total_size
= total_mapping_size(interp_elf_phdata
,
556 interp_elf_ex
->e_phnum
);
562 eppnt
= interp_elf_phdata
;
563 for (i
= 0; i
< interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
564 if (eppnt
->p_type
== PT_LOAD
) {
565 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
567 unsigned long vaddr
= 0;
568 unsigned long k
, map_addr
;
570 if (eppnt
->p_flags
& PF_R
)
571 elf_prot
= PROT_READ
;
572 if (eppnt
->p_flags
& PF_W
)
573 elf_prot
|= PROT_WRITE
;
574 if (eppnt
->p_flags
& PF_X
)
575 elf_prot
|= PROT_EXEC
;
576 vaddr
= eppnt
->p_vaddr
;
577 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
)
578 elf_type
|= MAP_FIXED
;
579 else if (no_base
&& interp_elf_ex
->e_type
== ET_DYN
)
582 map_addr
= elf_map(interpreter
, load_addr
+ vaddr
,
583 eppnt
, elf_prot
, elf_type
, total_size
);
585 if (!*interp_map_addr
)
586 *interp_map_addr
= map_addr
;
588 if (BAD_ADDR(map_addr
))
591 if (!load_addr_set
&&
592 interp_elf_ex
->e_type
== ET_DYN
) {
593 load_addr
= map_addr
- ELF_PAGESTART(vaddr
);
598 * Check to see if the section's size will overflow the
599 * allowed task size. Note that p_filesz must always be
600 * <= p_memsize so it's only necessary to check p_memsz.
602 k
= load_addr
+ eppnt
->p_vaddr
;
604 eppnt
->p_filesz
> eppnt
->p_memsz
||
605 eppnt
->p_memsz
> TASK_SIZE
||
606 TASK_SIZE
- eppnt
->p_memsz
< k
) {
612 * Find the end of the file mapping for this phdr, and
613 * keep track of the largest address we see for this.
615 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
620 * Do the same thing for the memory mapping - between
621 * elf_bss and last_bss is the bss section.
623 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_memsz
;
632 * Now fill out the bss section: first pad the last page from
633 * the file up to the page boundary, and zero it from elf_bss
634 * up to the end of the page.
636 if (padzero(elf_bss
)) {
641 * Next, align both the file and mem bss up to the page size,
642 * since this is where elf_bss was just zeroed up to, and where
643 * last_bss will end after the vm_brk_flags() below.
645 elf_bss
= ELF_PAGEALIGN(elf_bss
);
646 last_bss
= ELF_PAGEALIGN(last_bss
);
647 /* Finally, if there is still more bss to allocate, do it. */
648 if (last_bss
> elf_bss
) {
649 error
= vm_brk_flags(elf_bss
, last_bss
- elf_bss
,
650 bss_prot
& PROT_EXEC
? VM_EXEC
: 0);
661 * These are the functions used to load ELF style executables and shared
662 * libraries. There is no binary dependent code anywhere else.
665 #ifndef STACK_RND_MASK
666 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
669 static unsigned long randomize_stack_top(unsigned long stack_top
)
671 unsigned long random_variable
= 0;
673 if (current
->flags
& PF_RANDOMIZE
) {
674 random_variable
= get_random_long();
675 random_variable
&= STACK_RND_MASK
;
676 random_variable
<<= PAGE_SHIFT
;
678 #ifdef CONFIG_STACK_GROWSUP
679 return PAGE_ALIGN(stack_top
) + random_variable
;
681 return PAGE_ALIGN(stack_top
) - random_variable
;
685 static int load_elf_binary(struct linux_binprm
*bprm
)
687 struct file
*interpreter
= NULL
; /* to shut gcc up */
688 unsigned long load_addr
= 0, load_bias
= 0;
689 int load_addr_set
= 0;
690 char * elf_interpreter
= NULL
;
692 struct elf_phdr
*elf_ppnt
, *elf_phdata
, *interp_elf_phdata
= NULL
;
693 unsigned long elf_bss
, elf_brk
;
696 unsigned long elf_entry
;
697 unsigned long interp_load_addr
= 0;
698 unsigned long start_code
, end_code
, start_data
, end_data
;
699 unsigned long reloc_func_desc __maybe_unused
= 0;
700 int executable_stack
= EXSTACK_DEFAULT
;
701 struct pt_regs
*regs
= current_pt_regs();
703 struct elfhdr elf_ex
;
704 struct elfhdr interp_elf_ex
;
706 struct arch_elf_state arch_state
= INIT_ARCH_ELF_STATE
;
709 loc
= kmalloc(sizeof(*loc
), GFP_KERNEL
);
715 /* Get the exec-header */
716 loc
->elf_ex
= *((struct elfhdr
*)bprm
->buf
);
719 /* First of all, some simple consistency checks */
720 if (memcmp(loc
->elf_ex
.e_ident
, ELFMAG
, SELFMAG
) != 0)
723 if (loc
->elf_ex
.e_type
!= ET_EXEC
&& loc
->elf_ex
.e_type
!= ET_DYN
)
725 if (!elf_check_arch(&loc
->elf_ex
))
727 if (elf_check_fdpic(&loc
->elf_ex
))
729 if (!bprm
->file
->f_op
->mmap
)
732 elf_phdata
= load_elf_phdrs(&loc
->elf_ex
, bprm
->file
);
736 elf_ppnt
= elf_phdata
;
745 for (i
= 0; i
< loc
->elf_ex
.e_phnum
; i
++) {
746 if (elf_ppnt
->p_type
== PT_INTERP
) {
747 /* This is the program interpreter used for
748 * shared libraries - for now assume that this
749 * is an a.out format binary
752 if (elf_ppnt
->p_filesz
> PATH_MAX
||
753 elf_ppnt
->p_filesz
< 2)
757 elf_interpreter
= kmalloc(elf_ppnt
->p_filesz
,
759 if (!elf_interpreter
)
762 pos
= elf_ppnt
->p_offset
;
763 retval
= kernel_read(bprm
->file
, elf_interpreter
,
764 elf_ppnt
->p_filesz
, &pos
);
765 if (retval
!= elf_ppnt
->p_filesz
) {
768 goto out_free_interp
;
770 /* make sure path is NULL terminated */
772 if (elf_interpreter
[elf_ppnt
->p_filesz
- 1] != '\0')
773 goto out_free_interp
;
775 interpreter
= open_exec(elf_interpreter
);
776 retval
= PTR_ERR(interpreter
);
777 if (IS_ERR(interpreter
))
778 goto out_free_interp
;
781 * If the binary is not readable then enforce
782 * mm->dumpable = 0 regardless of the interpreter's
785 would_dump(bprm
, interpreter
);
787 /* Get the exec headers */
789 retval
= kernel_read(interpreter
, &loc
->interp_elf_ex
,
790 sizeof(loc
->interp_elf_ex
), &pos
);
791 if (retval
!= sizeof(loc
->interp_elf_ex
)) {
794 goto out_free_dentry
;
802 elf_ppnt
= elf_phdata
;
803 for (i
= 0; i
< loc
->elf_ex
.e_phnum
; i
++, elf_ppnt
++)
804 switch (elf_ppnt
->p_type
) {
806 if (elf_ppnt
->p_flags
& PF_X
)
807 executable_stack
= EXSTACK_ENABLE_X
;
809 executable_stack
= EXSTACK_DISABLE_X
;
812 case PT_LOPROC
... PT_HIPROC
:
813 retval
= arch_elf_pt_proc(&loc
->elf_ex
, elf_ppnt
,
817 goto out_free_dentry
;
821 /* Some simple consistency checks for the interpreter */
822 if (elf_interpreter
) {
824 /* Not an ELF interpreter */
825 if (memcmp(loc
->interp_elf_ex
.e_ident
, ELFMAG
, SELFMAG
) != 0)
826 goto out_free_dentry
;
827 /* Verify the interpreter has a valid arch */
828 if (!elf_check_arch(&loc
->interp_elf_ex
) ||
829 elf_check_fdpic(&loc
->interp_elf_ex
))
830 goto out_free_dentry
;
832 /* Load the interpreter program headers */
833 interp_elf_phdata
= load_elf_phdrs(&loc
->interp_elf_ex
,
835 if (!interp_elf_phdata
)
836 goto out_free_dentry
;
838 /* Pass PT_LOPROC..PT_HIPROC headers to arch code */
839 elf_ppnt
= interp_elf_phdata
;
840 for (i
= 0; i
< loc
->interp_elf_ex
.e_phnum
; i
++, elf_ppnt
++)
841 switch (elf_ppnt
->p_type
) {
842 case PT_LOPROC
... PT_HIPROC
:
843 retval
= arch_elf_pt_proc(&loc
->interp_elf_ex
,
844 elf_ppnt
, interpreter
,
847 goto out_free_dentry
;
853 * Allow arch code to reject the ELF at this point, whilst it's
854 * still possible to return an error to the code that invoked
857 retval
= arch_check_elf(&loc
->elf_ex
,
858 !!interpreter
, &loc
->interp_elf_ex
,
861 goto out_free_dentry
;
863 /* Flush all traces of the currently running executable */
864 retval
= flush_old_exec(bprm
);
866 goto out_free_dentry
;
868 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
869 may depend on the personality. */
870 SET_PERSONALITY2(loc
->elf_ex
, &arch_state
);
871 if (elf_read_implies_exec(loc
->elf_ex
, executable_stack
))
872 current
->personality
|= READ_IMPLIES_EXEC
;
874 if (!(current
->personality
& ADDR_NO_RANDOMIZE
) && randomize_va_space
)
875 current
->flags
|= PF_RANDOMIZE
;
877 setup_new_exec(bprm
);
878 install_exec_creds(bprm
);
880 /* Do this so that we can load the interpreter, if need be. We will
881 change some of these later */
882 retval
= setup_arg_pages(bprm
, randomize_stack_top(STACK_TOP
),
885 goto out_free_dentry
;
887 current
->mm
->start_stack
= bprm
->p
;
889 /* Now we do a little grungy work by mmapping the ELF image into
890 the correct location in memory. */
891 for(i
= 0, elf_ppnt
= elf_phdata
;
892 i
< loc
->elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
893 int elf_prot
= 0, elf_flags
;
894 unsigned long k
, vaddr
;
895 unsigned long total_size
= 0;
897 if (elf_ppnt
->p_type
!= PT_LOAD
)
900 if (unlikely (elf_brk
> elf_bss
)) {
903 /* There was a PT_LOAD segment with p_memsz > p_filesz
904 before this one. Map anonymous pages, if needed,
905 and clear the area. */
906 retval
= set_brk(elf_bss
+ load_bias
,
910 goto out_free_dentry
;
911 nbyte
= ELF_PAGEOFFSET(elf_bss
);
913 nbyte
= ELF_MIN_ALIGN
- nbyte
;
914 if (nbyte
> elf_brk
- elf_bss
)
915 nbyte
= elf_brk
- elf_bss
;
916 if (clear_user((void __user
*)elf_bss
+
919 * This bss-zeroing can fail if the ELF
920 * file specifies odd protections. So
921 * we don't check the return value
927 if (elf_ppnt
->p_flags
& PF_R
)
928 elf_prot
|= PROT_READ
;
929 if (elf_ppnt
->p_flags
& PF_W
)
930 elf_prot
|= PROT_WRITE
;
931 if (elf_ppnt
->p_flags
& PF_X
)
932 elf_prot
|= PROT_EXEC
;
934 elf_flags
= MAP_PRIVATE
| MAP_DENYWRITE
| MAP_EXECUTABLE
;
936 vaddr
= elf_ppnt
->p_vaddr
;
938 * If we are loading ET_EXEC or we have already performed
939 * the ET_DYN load_addr calculations, proceed normally.
941 if (loc
->elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
942 elf_flags
|= MAP_FIXED
;
943 } else if (loc
->elf_ex
.e_type
== ET_DYN
) {
945 * This logic is run once for the first LOAD Program
946 * Header for ET_DYN binaries to calculate the
947 * randomization (load_bias) for all the LOAD
948 * Program Headers, and to calculate the entire
949 * size of the ELF mapping (total_size). (Note that
950 * load_addr_set is set to true later once the
951 * initial mapping is performed.)
953 * There are effectively two types of ET_DYN
954 * binaries: programs (i.e. PIE: ET_DYN with INTERP)
955 * and loaders (ET_DYN without INTERP, since they
956 * _are_ the ELF interpreter). The loaders must
957 * be loaded away from programs since the program
958 * may otherwise collide with the loader (especially
959 * for ET_EXEC which does not have a randomized
960 * position). For example to handle invocations of
961 * "./ld.so someprog" to test out a new version of
962 * the loader, the subsequent program that the
963 * loader loads must avoid the loader itself, so
964 * they cannot share the same load range. Sufficient
965 * room for the brk must be allocated with the
966 * loader as well, since brk must be available with
969 * Therefore, programs are loaded offset from
970 * ELF_ET_DYN_BASE and loaders are loaded into the
971 * independently randomized mmap region (0 load_bias
972 * without MAP_FIXED).
974 if (elf_interpreter
) {
975 load_bias
= ELF_ET_DYN_BASE
;
976 if (current
->flags
& PF_RANDOMIZE
)
977 load_bias
+= arch_mmap_rnd();
978 elf_flags
|= MAP_FIXED
;
983 * Since load_bias is used for all subsequent loading
984 * calculations, we must lower it by the first vaddr
985 * so that the remaining calculations based on the
986 * ELF vaddrs will be correctly offset. The result
987 * is then page aligned.
989 load_bias
= ELF_PAGESTART(load_bias
- vaddr
);
991 total_size
= total_mapping_size(elf_phdata
,
992 loc
->elf_ex
.e_phnum
);
995 goto out_free_dentry
;
999 error
= elf_map(bprm
->file
, load_bias
+ vaddr
, elf_ppnt
,
1000 elf_prot
, elf_flags
, total_size
);
1001 if (BAD_ADDR(error
)) {
1002 retval
= IS_ERR((void *)error
) ?
1003 PTR_ERR((void*)error
) : -EINVAL
;
1004 goto out_free_dentry
;
1007 if (!load_addr_set
) {
1009 load_addr
= (elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
);
1010 if (loc
->elf_ex
.e_type
== ET_DYN
) {
1011 load_bias
+= error
-
1012 ELF_PAGESTART(load_bias
+ vaddr
);
1013 load_addr
+= load_bias
;
1014 reloc_func_desc
= load_bias
;
1017 k
= elf_ppnt
->p_vaddr
;
1024 * Check to see if the section's size will overflow the
1025 * allowed task size. Note that p_filesz must always be
1026 * <= p_memsz so it is only necessary to check p_memsz.
1028 if (BAD_ADDR(k
) || elf_ppnt
->p_filesz
> elf_ppnt
->p_memsz
||
1029 elf_ppnt
->p_memsz
> TASK_SIZE
||
1030 TASK_SIZE
- elf_ppnt
->p_memsz
< k
) {
1031 /* set_brk can never work. Avoid overflows. */
1033 goto out_free_dentry
;
1036 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
1040 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
1044 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
1046 bss_prot
= elf_prot
;
1051 loc
->elf_ex
.e_entry
+= load_bias
;
1052 elf_bss
+= load_bias
;
1053 elf_brk
+= load_bias
;
1054 start_code
+= load_bias
;
1055 end_code
+= load_bias
;
1056 start_data
+= load_bias
;
1057 end_data
+= load_bias
;
1059 /* Calling set_brk effectively mmaps the pages that we need
1060 * for the bss and break sections. We must do this before
1061 * mapping in the interpreter, to make sure it doesn't wind
1062 * up getting placed where the bss needs to go.
1064 retval
= set_brk(elf_bss
, elf_brk
, bss_prot
);
1066 goto out_free_dentry
;
1067 if (likely(elf_bss
!= elf_brk
) && unlikely(padzero(elf_bss
))) {
1068 retval
= -EFAULT
; /* Nobody gets to see this, but.. */
1069 goto out_free_dentry
;
1072 if (elf_interpreter
) {
1073 unsigned long interp_map_addr
= 0;
1075 elf_entry
= load_elf_interp(&loc
->interp_elf_ex
,
1078 load_bias
, interp_elf_phdata
);
1079 if (!IS_ERR((void *)elf_entry
)) {
1081 * load_elf_interp() returns relocation
1084 interp_load_addr
= elf_entry
;
1085 elf_entry
+= loc
->interp_elf_ex
.e_entry
;
1087 if (BAD_ADDR(elf_entry
)) {
1088 retval
= IS_ERR((void *)elf_entry
) ?
1089 (int)elf_entry
: -EINVAL
;
1090 goto out_free_dentry
;
1092 reloc_func_desc
= interp_load_addr
;
1094 allow_write_access(interpreter
);
1096 kfree(elf_interpreter
);
1098 elf_entry
= loc
->elf_ex
.e_entry
;
1099 if (BAD_ADDR(elf_entry
)) {
1101 goto out_free_dentry
;
1105 kfree(interp_elf_phdata
);
1108 set_binfmt(&elf_format
);
1110 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1111 retval
= arch_setup_additional_pages(bprm
, !!elf_interpreter
);
1114 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1116 retval
= create_elf_tables(bprm
, &loc
->elf_ex
,
1117 load_addr
, interp_load_addr
);
1120 /* N.B. passed_fileno might not be initialized? */
1121 current
->mm
->end_code
= end_code
;
1122 current
->mm
->start_code
= start_code
;
1123 current
->mm
->start_data
= start_data
;
1124 current
->mm
->end_data
= end_data
;
1125 current
->mm
->start_stack
= bprm
->p
;
1127 if ((current
->flags
& PF_RANDOMIZE
) && (randomize_va_space
> 1)) {
1129 * For architectures with ELF randomization, when executing
1130 * a loader directly (i.e. no interpreter listed in ELF
1131 * headers), move the brk area out of the mmap region
1132 * (since it grows up, and may collide early with the stack
1133 * growing down), and into the unused ELF_ET_DYN_BASE region.
1135 if (IS_ENABLED(CONFIG_ARCH_HAS_ELF_RANDOMIZE
) &&
1136 loc
->elf_ex
.e_type
== ET_DYN
&& !interpreter
)
1137 current
->mm
->brk
= current
->mm
->start_brk
=
1140 current
->mm
->brk
= current
->mm
->start_brk
=
1141 arch_randomize_brk(current
->mm
);
1142 #ifdef compat_brk_randomized
1143 current
->brk_randomized
= 1;
1147 if (current
->personality
& MMAP_PAGE_ZERO
) {
1148 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1149 and some applications "depend" upon this behavior.
1150 Since we do not have the power to recompile these, we
1151 emulate the SVr4 behavior. Sigh. */
1152 error
= vm_mmap(NULL
, 0, PAGE_SIZE
, PROT_READ
| PROT_EXEC
,
1153 MAP_FIXED
| MAP_PRIVATE
, 0);
1156 #ifdef ELF_PLAT_INIT
1158 * The ABI may specify that certain registers be set up in special
1159 * ways (on i386 %edx is the address of a DT_FINI function, for
1160 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1161 * that the e_entry field is the address of the function descriptor
1162 * for the startup routine, rather than the address of the startup
1163 * routine itself. This macro performs whatever initialization to
1164 * the regs structure is required as well as any relocations to the
1165 * function descriptor entries when executing dynamically links apps.
1167 ELF_PLAT_INIT(regs
, reloc_func_desc
);
1170 start_thread(regs
, elf_entry
, bprm
->p
);
1179 kfree(interp_elf_phdata
);
1180 allow_write_access(interpreter
);
1184 kfree(elf_interpreter
);
1190 #ifdef CONFIG_USELIB
1191 /* This is really simpleminded and specialized - we are loading an
1192 a.out library that is given an ELF header. */
1193 static int load_elf_library(struct file
*file
)
1195 struct elf_phdr
*elf_phdata
;
1196 struct elf_phdr
*eppnt
;
1197 unsigned long elf_bss
, bss
, len
;
1198 int retval
, error
, i
, j
;
1199 struct elfhdr elf_ex
;
1203 retval
= kernel_read(file
, &elf_ex
, sizeof(elf_ex
), &pos
);
1204 if (retval
!= sizeof(elf_ex
))
1207 if (memcmp(elf_ex
.e_ident
, ELFMAG
, SELFMAG
) != 0)
1210 /* First of all, some simple consistency checks */
1211 if (elf_ex
.e_type
!= ET_EXEC
|| elf_ex
.e_phnum
> 2 ||
1212 !elf_check_arch(&elf_ex
) || !file
->f_op
->mmap
)
1214 if (elf_check_fdpic(&elf_ex
))
1217 /* Now read in all of the header information */
1219 j
= sizeof(struct elf_phdr
) * elf_ex
.e_phnum
;
1220 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1223 elf_phdata
= kmalloc(j
, GFP_KERNEL
);
1229 pos
= elf_ex
.e_phoff
;
1230 retval
= kernel_read(file
, eppnt
, j
, &pos
);
1234 for (j
= 0, i
= 0; i
<elf_ex
.e_phnum
; i
++)
1235 if ((eppnt
+ i
)->p_type
== PT_LOAD
)
1240 while (eppnt
->p_type
!= PT_LOAD
)
1243 /* Now use mmap to map the library into memory. */
1244 error
= vm_mmap(file
,
1245 ELF_PAGESTART(eppnt
->p_vaddr
),
1247 ELF_PAGEOFFSET(eppnt
->p_vaddr
)),
1248 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
1249 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
,
1251 ELF_PAGEOFFSET(eppnt
->p_vaddr
)));
1252 if (error
!= ELF_PAGESTART(eppnt
->p_vaddr
))
1255 elf_bss
= eppnt
->p_vaddr
+ eppnt
->p_filesz
;
1256 if (padzero(elf_bss
)) {
1261 len
= ELF_PAGEALIGN(eppnt
->p_filesz
+ eppnt
->p_vaddr
);
1262 bss
= ELF_PAGEALIGN(eppnt
->p_memsz
+ eppnt
->p_vaddr
);
1264 error
= vm_brk(len
, bss
- len
);
1275 #endif /* #ifdef CONFIG_USELIB */
1277 #ifdef CONFIG_ELF_CORE
1281 * Modelled on fs/exec.c:aout_core_dump()
1282 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1286 * The purpose of always_dump_vma() is to make sure that special kernel mappings
1287 * that are useful for post-mortem analysis are included in every core dump.
1288 * In that way we ensure that the core dump is fully interpretable later
1289 * without matching up the same kernel and hardware config to see what PC values
1290 * meant. These special mappings include - vDSO, vsyscall, and other
1291 * architecture specific mappings
1293 static bool always_dump_vma(struct vm_area_struct
*vma
)
1295 /* Any vsyscall mappings? */
1296 if (vma
== get_gate_vma(vma
->vm_mm
))
1300 * Assume that all vmas with a .name op should always be dumped.
1301 * If this changes, a new vm_ops field can easily be added.
1303 if (vma
->vm_ops
&& vma
->vm_ops
->name
&& vma
->vm_ops
->name(vma
))
1307 * arch_vma_name() returns non-NULL for special architecture mappings,
1308 * such as vDSO sections.
1310 if (arch_vma_name(vma
))
1317 * Decide what to dump of a segment, part, all or none.
1319 static unsigned long vma_dump_size(struct vm_area_struct
*vma
,
1320 unsigned long mm_flags
)
1322 #define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1324 /* always dump the vdso and vsyscall sections */
1325 if (always_dump_vma(vma
))
1328 if (vma
->vm_flags
& VM_DONTDUMP
)
1331 /* support for DAX */
1332 if (vma_is_dax(vma
)) {
1333 if ((vma
->vm_flags
& VM_SHARED
) && FILTER(DAX_SHARED
))
1335 if (!(vma
->vm_flags
& VM_SHARED
) && FILTER(DAX_PRIVATE
))
1340 /* Hugetlb memory check */
1341 if (vma
->vm_flags
& VM_HUGETLB
) {
1342 if ((vma
->vm_flags
& VM_SHARED
) && FILTER(HUGETLB_SHARED
))
1344 if (!(vma
->vm_flags
& VM_SHARED
) && FILTER(HUGETLB_PRIVATE
))
1349 /* Do not dump I/O mapped devices or special mappings */
1350 if (vma
->vm_flags
& VM_IO
)
1353 /* By default, dump shared memory if mapped from an anonymous file. */
1354 if (vma
->vm_flags
& VM_SHARED
) {
1355 if (file_inode(vma
->vm_file
)->i_nlink
== 0 ?
1356 FILTER(ANON_SHARED
) : FILTER(MAPPED_SHARED
))
1361 /* Dump segments that have been written to. */
1362 if (vma
->anon_vma
&& FILTER(ANON_PRIVATE
))
1364 if (vma
->vm_file
== NULL
)
1367 if (FILTER(MAPPED_PRIVATE
))
1371 * If this looks like the beginning of a DSO or executable mapping,
1372 * check for an ELF header. If we find one, dump the first page to
1373 * aid in determining what was mapped here.
1375 if (FILTER(ELF_HEADERS
) &&
1376 vma
->vm_pgoff
== 0 && (vma
->vm_flags
& VM_READ
)) {
1377 u32 __user
*header
= (u32 __user
*) vma
->vm_start
;
1379 mm_segment_t fs
= get_fs();
1381 * Doing it this way gets the constant folded by GCC.
1385 char elfmag
[SELFMAG
];
1387 BUILD_BUG_ON(SELFMAG
!= sizeof word
);
1388 magic
.elfmag
[EI_MAG0
] = ELFMAG0
;
1389 magic
.elfmag
[EI_MAG1
] = ELFMAG1
;
1390 magic
.elfmag
[EI_MAG2
] = ELFMAG2
;
1391 magic
.elfmag
[EI_MAG3
] = ELFMAG3
;
1393 * Switch to the user "segment" for get_user(),
1394 * then put back what elf_core_dump() had in place.
1397 if (unlikely(get_user(word
, header
)))
1400 if (word
== magic
.cmp
)
1409 return vma
->vm_end
- vma
->vm_start
;
1412 /* An ELF note in memory */
1417 unsigned int datasz
;
1421 static int notesize(struct memelfnote
*en
)
1425 sz
= sizeof(struct elf_note
);
1426 sz
+= roundup(strlen(en
->name
) + 1, 4);
1427 sz
+= roundup(en
->datasz
, 4);
1432 static int writenote(struct memelfnote
*men
, struct coredump_params
*cprm
)
1435 en
.n_namesz
= strlen(men
->name
) + 1;
1436 en
.n_descsz
= men
->datasz
;
1437 en
.n_type
= men
->type
;
1439 return dump_emit(cprm
, &en
, sizeof(en
)) &&
1440 dump_emit(cprm
, men
->name
, en
.n_namesz
) && dump_align(cprm
, 4) &&
1441 dump_emit(cprm
, men
->data
, men
->datasz
) && dump_align(cprm
, 4);
1444 static void fill_elf_header(struct elfhdr
*elf
, int segs
,
1445 u16 machine
, u32 flags
)
1447 memset(elf
, 0, sizeof(*elf
));
1449 memcpy(elf
->e_ident
, ELFMAG
, SELFMAG
);
1450 elf
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1451 elf
->e_ident
[EI_DATA
] = ELF_DATA
;
1452 elf
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1453 elf
->e_ident
[EI_OSABI
] = ELF_OSABI
;
1455 elf
->e_type
= ET_CORE
;
1456 elf
->e_machine
= machine
;
1457 elf
->e_version
= EV_CURRENT
;
1458 elf
->e_phoff
= sizeof(struct elfhdr
);
1459 elf
->e_flags
= flags
;
1460 elf
->e_ehsize
= sizeof(struct elfhdr
);
1461 elf
->e_phentsize
= sizeof(struct elf_phdr
);
1462 elf
->e_phnum
= segs
;
1467 static void fill_elf_note_phdr(struct elf_phdr
*phdr
, int sz
, loff_t offset
)
1469 phdr
->p_type
= PT_NOTE
;
1470 phdr
->p_offset
= offset
;
1473 phdr
->p_filesz
= sz
;
1480 static void fill_note(struct memelfnote
*note
, const char *name
, int type
,
1481 unsigned int sz
, void *data
)
1491 * fill up all the fields in prstatus from the given task struct, except
1492 * registers which need to be filled up separately.
1494 static void fill_prstatus(struct elf_prstatus
*prstatus
,
1495 struct task_struct
*p
, long signr
)
1497 prstatus
->pr_info
.si_signo
= prstatus
->pr_cursig
= signr
;
1498 prstatus
->pr_sigpend
= p
->pending
.signal
.sig
[0];
1499 prstatus
->pr_sighold
= p
->blocked
.sig
[0];
1501 prstatus
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1503 prstatus
->pr_pid
= task_pid_vnr(p
);
1504 prstatus
->pr_pgrp
= task_pgrp_vnr(p
);
1505 prstatus
->pr_sid
= task_session_vnr(p
);
1506 if (thread_group_leader(p
)) {
1507 struct task_cputime cputime
;
1510 * This is the record for the group leader. It shows the
1511 * group-wide total, not its individual thread total.
1513 thread_group_cputime(p
, &cputime
);
1514 prstatus
->pr_utime
= ns_to_timeval(cputime
.utime
);
1515 prstatus
->pr_stime
= ns_to_timeval(cputime
.stime
);
1519 task_cputime(p
, &utime
, &stime
);
1520 prstatus
->pr_utime
= ns_to_timeval(utime
);
1521 prstatus
->pr_stime
= ns_to_timeval(stime
);
1524 prstatus
->pr_cutime
= ns_to_timeval(p
->signal
->cutime
);
1525 prstatus
->pr_cstime
= ns_to_timeval(p
->signal
->cstime
);
1528 static int fill_psinfo(struct elf_prpsinfo
*psinfo
, struct task_struct
*p
,
1529 struct mm_struct
*mm
)
1531 const struct cred
*cred
;
1532 unsigned int i
, len
;
1534 /* first copy the parameters from user space */
1535 memset(psinfo
, 0, sizeof(struct elf_prpsinfo
));
1537 len
= mm
->arg_end
- mm
->arg_start
;
1538 if (len
>= ELF_PRARGSZ
)
1539 len
= ELF_PRARGSZ
-1;
1540 if (copy_from_user(&psinfo
->pr_psargs
,
1541 (const char __user
*)mm
->arg_start
, len
))
1543 for(i
= 0; i
< len
; i
++)
1544 if (psinfo
->pr_psargs
[i
] == 0)
1545 psinfo
->pr_psargs
[i
] = ' ';
1546 psinfo
->pr_psargs
[len
] = 0;
1549 psinfo
->pr_ppid
= task_pid_vnr(rcu_dereference(p
->real_parent
));
1551 psinfo
->pr_pid
= task_pid_vnr(p
);
1552 psinfo
->pr_pgrp
= task_pgrp_vnr(p
);
1553 psinfo
->pr_sid
= task_session_vnr(p
);
1555 i
= p
->state
? ffz(~p
->state
) + 1 : 0;
1556 psinfo
->pr_state
= i
;
1557 psinfo
->pr_sname
= (i
> 5) ? '.' : "RSDTZW"[i
];
1558 psinfo
->pr_zomb
= psinfo
->pr_sname
== 'Z';
1559 psinfo
->pr_nice
= task_nice(p
);
1560 psinfo
->pr_flag
= p
->flags
;
1562 cred
= __task_cred(p
);
1563 SET_UID(psinfo
->pr_uid
, from_kuid_munged(cred
->user_ns
, cred
->uid
));
1564 SET_GID(psinfo
->pr_gid
, from_kgid_munged(cred
->user_ns
, cred
->gid
));
1566 strncpy(psinfo
->pr_fname
, p
->comm
, sizeof(psinfo
->pr_fname
));
1571 static void fill_auxv_note(struct memelfnote
*note
, struct mm_struct
*mm
)
1573 elf_addr_t
*auxv
= (elf_addr_t
*) mm
->saved_auxv
;
1577 while (auxv
[i
- 2] != AT_NULL
);
1578 fill_note(note
, "CORE", NT_AUXV
, i
* sizeof(elf_addr_t
), auxv
);
1581 static void fill_siginfo_note(struct memelfnote
*note
, user_siginfo_t
*csigdata
,
1582 const siginfo_t
*siginfo
)
1584 mm_segment_t old_fs
= get_fs();
1586 copy_siginfo_to_user((user_siginfo_t __user
*) csigdata
, siginfo
);
1588 fill_note(note
, "CORE", NT_SIGINFO
, sizeof(*csigdata
), csigdata
);
1591 #define MAX_FILE_NOTE_SIZE (4*1024*1024)
1593 * Format of NT_FILE note:
1595 * long count -- how many files are mapped
1596 * long page_size -- units for file_ofs
1597 * array of [COUNT] elements of
1601 * followed by COUNT filenames in ASCII: "FILE1" NUL "FILE2" NUL...
1603 static int fill_files_note(struct memelfnote
*note
)
1605 struct vm_area_struct
*vma
;
1606 unsigned count
, size
, names_ofs
, remaining
, n
;
1608 user_long_t
*start_end_ofs
;
1609 char *name_base
, *name_curpos
;
1611 /* *Estimated* file count and total data size needed */
1612 count
= current
->mm
->map_count
;
1615 names_ofs
= (2 + 3 * count
) * sizeof(data
[0]);
1617 if (size
>= MAX_FILE_NOTE_SIZE
) /* paranoia check */
1619 size
= round_up(size
, PAGE_SIZE
);
1620 data
= vmalloc(size
);
1624 start_end_ofs
= data
+ 2;
1625 name_base
= name_curpos
= ((char *)data
) + names_ofs
;
1626 remaining
= size
- names_ofs
;
1628 for (vma
= current
->mm
->mmap
; vma
!= NULL
; vma
= vma
->vm_next
) {
1630 const char *filename
;
1632 file
= vma
->vm_file
;
1635 filename
= file_path(file
, name_curpos
, remaining
);
1636 if (IS_ERR(filename
)) {
1637 if (PTR_ERR(filename
) == -ENAMETOOLONG
) {
1639 size
= size
* 5 / 4;
1645 /* file_path() fills at the end, move name down */
1646 /* n = strlen(filename) + 1: */
1647 n
= (name_curpos
+ remaining
) - filename
;
1648 remaining
= filename
- name_curpos
;
1649 memmove(name_curpos
, filename
, n
);
1652 *start_end_ofs
++ = vma
->vm_start
;
1653 *start_end_ofs
++ = vma
->vm_end
;
1654 *start_end_ofs
++ = vma
->vm_pgoff
;
1658 /* Now we know exact count of files, can store it */
1660 data
[1] = PAGE_SIZE
;
1662 * Count usually is less than current->mm->map_count,
1663 * we need to move filenames down.
1665 n
= current
->mm
->map_count
- count
;
1667 unsigned shift_bytes
= n
* 3 * sizeof(data
[0]);
1668 memmove(name_base
- shift_bytes
, name_base
,
1669 name_curpos
- name_base
);
1670 name_curpos
-= shift_bytes
;
1673 size
= name_curpos
- (char *)data
;
1674 fill_note(note
, "CORE", NT_FILE
, size
, data
);
1678 #ifdef CORE_DUMP_USE_REGSET
1679 #include <linux/regset.h>
1681 struct elf_thread_core_info
{
1682 struct elf_thread_core_info
*next
;
1683 struct task_struct
*task
;
1684 struct elf_prstatus prstatus
;
1685 struct memelfnote notes
[0];
1688 struct elf_note_info
{
1689 struct elf_thread_core_info
*thread
;
1690 struct memelfnote psinfo
;
1691 struct memelfnote signote
;
1692 struct memelfnote auxv
;
1693 struct memelfnote files
;
1694 user_siginfo_t csigdata
;
1700 * When a regset has a writeback hook, we call it on each thread before
1701 * dumping user memory. On register window machines, this makes sure the
1702 * user memory backing the register data is up to date before we read it.
1704 static void do_thread_regset_writeback(struct task_struct
*task
,
1705 const struct user_regset
*regset
)
1707 if (regset
->writeback
)
1708 regset
->writeback(task
, regset
, 1);
1711 #ifndef PRSTATUS_SIZE
1712 #define PRSTATUS_SIZE(S, R) sizeof(S)
1715 #ifndef SET_PR_FPVALID
1716 #define SET_PR_FPVALID(S, V, R) ((S)->pr_fpvalid = (V))
1719 static int fill_thread_core_info(struct elf_thread_core_info
*t
,
1720 const struct user_regset_view
*view
,
1721 long signr
, size_t *total
)
1724 unsigned int regset0_size
= regset_size(t
->task
, &view
->regsets
[0]);
1727 * NT_PRSTATUS is the one special case, because the regset data
1728 * goes into the pr_reg field inside the note contents, rather
1729 * than being the whole note contents. We fill the reset in here.
1730 * We assume that regset 0 is NT_PRSTATUS.
1732 fill_prstatus(&t
->prstatus
, t
->task
, signr
);
1733 (void) view
->regsets
[0].get(t
->task
, &view
->regsets
[0], 0, regset0_size
,
1734 &t
->prstatus
.pr_reg
, NULL
);
1736 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
,
1737 PRSTATUS_SIZE(t
->prstatus
, regset0_size
), &t
->prstatus
);
1738 *total
+= notesize(&t
->notes
[0]);
1740 do_thread_regset_writeback(t
->task
, &view
->regsets
[0]);
1743 * Each other regset might generate a note too. For each regset
1744 * that has no core_note_type or is inactive, we leave t->notes[i]
1745 * all zero and we'll know to skip writing it later.
1747 for (i
= 1; i
< view
->n
; ++i
) {
1748 const struct user_regset
*regset
= &view
->regsets
[i
];
1749 do_thread_regset_writeback(t
->task
, regset
);
1750 if (regset
->core_note_type
&& regset
->get
&&
1751 (!regset
->active
|| regset
->active(t
->task
, regset
) > 0)) {
1753 size_t size
= regset_size(t
->task
, regset
);
1754 void *data
= kmalloc(size
, GFP_KERNEL
);
1755 if (unlikely(!data
))
1757 ret
= regset
->get(t
->task
, regset
,
1758 0, size
, data
, NULL
);
1762 if (regset
->core_note_type
!= NT_PRFPREG
)
1763 fill_note(&t
->notes
[i
], "LINUX",
1764 regset
->core_note_type
,
1767 SET_PR_FPVALID(&t
->prstatus
,
1769 fill_note(&t
->notes
[i
], "CORE",
1770 NT_PRFPREG
, size
, data
);
1772 *total
+= notesize(&t
->notes
[i
]);
1780 static int fill_note_info(struct elfhdr
*elf
, int phdrs
,
1781 struct elf_note_info
*info
,
1782 const siginfo_t
*siginfo
, struct pt_regs
*regs
)
1784 struct task_struct
*dump_task
= current
;
1785 const struct user_regset_view
*view
= task_user_regset_view(dump_task
);
1786 struct elf_thread_core_info
*t
;
1787 struct elf_prpsinfo
*psinfo
;
1788 struct core_thread
*ct
;
1792 info
->thread
= NULL
;
1794 psinfo
= kmalloc(sizeof(*psinfo
), GFP_KERNEL
);
1795 if (psinfo
== NULL
) {
1796 info
->psinfo
.data
= NULL
; /* So we don't free this wrongly */
1800 fill_note(&info
->psinfo
, "CORE", NT_PRPSINFO
, sizeof(*psinfo
), psinfo
);
1803 * Figure out how many notes we're going to need for each thread.
1805 info
->thread_notes
= 0;
1806 for (i
= 0; i
< view
->n
; ++i
)
1807 if (view
->regsets
[i
].core_note_type
!= 0)
1808 ++info
->thread_notes
;
1811 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1812 * since it is our one special case.
1814 if (unlikely(info
->thread_notes
== 0) ||
1815 unlikely(view
->regsets
[0].core_note_type
!= NT_PRSTATUS
)) {
1821 * Initialize the ELF file header.
1823 fill_elf_header(elf
, phdrs
,
1824 view
->e_machine
, view
->e_flags
);
1827 * Allocate a structure for each thread.
1829 for (ct
= &dump_task
->mm
->core_state
->dumper
; ct
; ct
= ct
->next
) {
1830 t
= kzalloc(offsetof(struct elf_thread_core_info
,
1831 notes
[info
->thread_notes
]),
1837 if (ct
->task
== dump_task
|| !info
->thread
) {
1838 t
->next
= info
->thread
;
1842 * Make sure to keep the original task at
1843 * the head of the list.
1845 t
->next
= info
->thread
->next
;
1846 info
->thread
->next
= t
;
1851 * Now fill in each thread's information.
1853 for (t
= info
->thread
; t
!= NULL
; t
= t
->next
)
1854 if (!fill_thread_core_info(t
, view
, siginfo
->si_signo
, &info
->size
))
1858 * Fill in the two process-wide notes.
1860 fill_psinfo(psinfo
, dump_task
->group_leader
, dump_task
->mm
);
1861 info
->size
+= notesize(&info
->psinfo
);
1863 fill_siginfo_note(&info
->signote
, &info
->csigdata
, siginfo
);
1864 info
->size
+= notesize(&info
->signote
);
1866 fill_auxv_note(&info
->auxv
, current
->mm
);
1867 info
->size
+= notesize(&info
->auxv
);
1869 if (fill_files_note(&info
->files
) == 0)
1870 info
->size
+= notesize(&info
->files
);
1875 static size_t get_note_info_size(struct elf_note_info
*info
)
1881 * Write all the notes for each thread. When writing the first thread, the
1882 * process-wide notes are interleaved after the first thread-specific note.
1884 static int write_note_info(struct elf_note_info
*info
,
1885 struct coredump_params
*cprm
)
1888 struct elf_thread_core_info
*t
= info
->thread
;
1893 if (!writenote(&t
->notes
[0], cprm
))
1896 if (first
&& !writenote(&info
->psinfo
, cprm
))
1898 if (first
&& !writenote(&info
->signote
, cprm
))
1900 if (first
&& !writenote(&info
->auxv
, cprm
))
1902 if (first
&& info
->files
.data
&&
1903 !writenote(&info
->files
, cprm
))
1906 for (i
= 1; i
< info
->thread_notes
; ++i
)
1907 if (t
->notes
[i
].data
&&
1908 !writenote(&t
->notes
[i
], cprm
))
1918 static void free_note_info(struct elf_note_info
*info
)
1920 struct elf_thread_core_info
*threads
= info
->thread
;
1923 struct elf_thread_core_info
*t
= threads
;
1925 WARN_ON(t
->notes
[0].data
&& t
->notes
[0].data
!= &t
->prstatus
);
1926 for (i
= 1; i
< info
->thread_notes
; ++i
)
1927 kfree(t
->notes
[i
].data
);
1930 kfree(info
->psinfo
.data
);
1931 vfree(info
->files
.data
);
1936 /* Here is the structure in which status of each thread is captured. */
1937 struct elf_thread_status
1939 struct list_head list
;
1940 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1941 elf_fpregset_t fpu
; /* NT_PRFPREG */
1942 struct task_struct
*thread
;
1943 #ifdef ELF_CORE_COPY_XFPREGS
1944 elf_fpxregset_t xfpu
; /* ELF_CORE_XFPREG_TYPE */
1946 struct memelfnote notes
[3];
1951 * In order to add the specific thread information for the elf file format,
1952 * we need to keep a linked list of every threads pr_status and then create
1953 * a single section for them in the final core file.
1955 static int elf_dump_thread_status(long signr
, struct elf_thread_status
*t
)
1958 struct task_struct
*p
= t
->thread
;
1961 fill_prstatus(&t
->prstatus
, p
, signr
);
1962 elf_core_copy_task_regs(p
, &t
->prstatus
.pr_reg
);
1964 fill_note(&t
->notes
[0], "CORE", NT_PRSTATUS
, sizeof(t
->prstatus
),
1967 sz
+= notesize(&t
->notes
[0]);
1969 if ((t
->prstatus
.pr_fpvalid
= elf_core_copy_task_fpregs(p
, NULL
,
1971 fill_note(&t
->notes
[1], "CORE", NT_PRFPREG
, sizeof(t
->fpu
),
1974 sz
+= notesize(&t
->notes
[1]);
1977 #ifdef ELF_CORE_COPY_XFPREGS
1978 if (elf_core_copy_task_xfpregs(p
, &t
->xfpu
)) {
1979 fill_note(&t
->notes
[2], "LINUX", ELF_CORE_XFPREG_TYPE
,
1980 sizeof(t
->xfpu
), &t
->xfpu
);
1982 sz
+= notesize(&t
->notes
[2]);
1988 struct elf_note_info
{
1989 struct memelfnote
*notes
;
1990 struct memelfnote
*notes_files
;
1991 struct elf_prstatus
*prstatus
; /* NT_PRSTATUS */
1992 struct elf_prpsinfo
*psinfo
; /* NT_PRPSINFO */
1993 struct list_head thread_list
;
1994 elf_fpregset_t
*fpu
;
1995 #ifdef ELF_CORE_COPY_XFPREGS
1996 elf_fpxregset_t
*xfpu
;
1998 user_siginfo_t csigdata
;
1999 int thread_status_size
;
2003 static int elf_note_info_init(struct elf_note_info
*info
)
2005 memset(info
, 0, sizeof(*info
));
2006 INIT_LIST_HEAD(&info
->thread_list
);
2008 /* Allocate space for ELF notes */
2009 info
->notes
= kmalloc(8 * sizeof(struct memelfnote
), GFP_KERNEL
);
2012 info
->psinfo
= kmalloc(sizeof(*info
->psinfo
), GFP_KERNEL
);
2015 info
->prstatus
= kmalloc(sizeof(*info
->prstatus
), GFP_KERNEL
);
2016 if (!info
->prstatus
)
2018 info
->fpu
= kmalloc(sizeof(*info
->fpu
), GFP_KERNEL
);
2021 #ifdef ELF_CORE_COPY_XFPREGS
2022 info
->xfpu
= kmalloc(sizeof(*info
->xfpu
), GFP_KERNEL
);
2029 static int fill_note_info(struct elfhdr
*elf
, int phdrs
,
2030 struct elf_note_info
*info
,
2031 const siginfo_t
*siginfo
, struct pt_regs
*regs
)
2033 struct list_head
*t
;
2034 struct core_thread
*ct
;
2035 struct elf_thread_status
*ets
;
2037 if (!elf_note_info_init(info
))
2040 for (ct
= current
->mm
->core_state
->dumper
.next
;
2041 ct
; ct
= ct
->next
) {
2042 ets
= kzalloc(sizeof(*ets
), GFP_KERNEL
);
2046 ets
->thread
= ct
->task
;
2047 list_add(&ets
->list
, &info
->thread_list
);
2050 list_for_each(t
, &info
->thread_list
) {
2053 ets
= list_entry(t
, struct elf_thread_status
, list
);
2054 sz
= elf_dump_thread_status(siginfo
->si_signo
, ets
);
2055 info
->thread_status_size
+= sz
;
2057 /* now collect the dump for the current */
2058 memset(info
->prstatus
, 0, sizeof(*info
->prstatus
));
2059 fill_prstatus(info
->prstatus
, current
, siginfo
->si_signo
);
2060 elf_core_copy_regs(&info
->prstatus
->pr_reg
, regs
);
2063 fill_elf_header(elf
, phdrs
, ELF_ARCH
, ELF_CORE_EFLAGS
);
2066 * Set up the notes in similar form to SVR4 core dumps made
2067 * with info from their /proc.
2070 fill_note(info
->notes
+ 0, "CORE", NT_PRSTATUS
,
2071 sizeof(*info
->prstatus
), info
->prstatus
);
2072 fill_psinfo(info
->psinfo
, current
->group_leader
, current
->mm
);
2073 fill_note(info
->notes
+ 1, "CORE", NT_PRPSINFO
,
2074 sizeof(*info
->psinfo
), info
->psinfo
);
2076 fill_siginfo_note(info
->notes
+ 2, &info
->csigdata
, siginfo
);
2077 fill_auxv_note(info
->notes
+ 3, current
->mm
);
2080 if (fill_files_note(info
->notes
+ info
->numnote
) == 0) {
2081 info
->notes_files
= info
->notes
+ info
->numnote
;
2085 /* Try to dump the FPU. */
2086 info
->prstatus
->pr_fpvalid
= elf_core_copy_task_fpregs(current
, regs
,
2088 if (info
->prstatus
->pr_fpvalid
)
2089 fill_note(info
->notes
+ info
->numnote
++,
2090 "CORE", NT_PRFPREG
, sizeof(*info
->fpu
), info
->fpu
);
2091 #ifdef ELF_CORE_COPY_XFPREGS
2092 if (elf_core_copy_task_xfpregs(current
, info
->xfpu
))
2093 fill_note(info
->notes
+ info
->numnote
++,
2094 "LINUX", ELF_CORE_XFPREG_TYPE
,
2095 sizeof(*info
->xfpu
), info
->xfpu
);
2101 static size_t get_note_info_size(struct elf_note_info
*info
)
2106 for (i
= 0; i
< info
->numnote
; i
++)
2107 sz
+= notesize(info
->notes
+ i
);
2109 sz
+= info
->thread_status_size
;
2114 static int write_note_info(struct elf_note_info
*info
,
2115 struct coredump_params
*cprm
)
2118 struct list_head
*t
;
2120 for (i
= 0; i
< info
->numnote
; i
++)
2121 if (!writenote(info
->notes
+ i
, cprm
))
2124 /* write out the thread status notes section */
2125 list_for_each(t
, &info
->thread_list
) {
2126 struct elf_thread_status
*tmp
=
2127 list_entry(t
, struct elf_thread_status
, list
);
2129 for (i
= 0; i
< tmp
->num_notes
; i
++)
2130 if (!writenote(&tmp
->notes
[i
], cprm
))
2137 static void free_note_info(struct elf_note_info
*info
)
2139 while (!list_empty(&info
->thread_list
)) {
2140 struct list_head
*tmp
= info
->thread_list
.next
;
2142 kfree(list_entry(tmp
, struct elf_thread_status
, list
));
2145 /* Free data possibly allocated by fill_files_note(): */
2146 if (info
->notes_files
)
2147 vfree(info
->notes_files
->data
);
2149 kfree(info
->prstatus
);
2150 kfree(info
->psinfo
);
2153 #ifdef ELF_CORE_COPY_XFPREGS
2160 static struct vm_area_struct
*first_vma(struct task_struct
*tsk
,
2161 struct vm_area_struct
*gate_vma
)
2163 struct vm_area_struct
*ret
= tsk
->mm
->mmap
;
2170 * Helper function for iterating across a vma list. It ensures that the caller
2171 * will visit `gate_vma' prior to terminating the search.
2173 static struct vm_area_struct
*next_vma(struct vm_area_struct
*this_vma
,
2174 struct vm_area_struct
*gate_vma
)
2176 struct vm_area_struct
*ret
;
2178 ret
= this_vma
->vm_next
;
2181 if (this_vma
== gate_vma
)
2186 static void fill_extnum_info(struct elfhdr
*elf
, struct elf_shdr
*shdr4extnum
,
2187 elf_addr_t e_shoff
, int segs
)
2189 elf
->e_shoff
= e_shoff
;
2190 elf
->e_shentsize
= sizeof(*shdr4extnum
);
2192 elf
->e_shstrndx
= SHN_UNDEF
;
2194 memset(shdr4extnum
, 0, sizeof(*shdr4extnum
));
2196 shdr4extnum
->sh_type
= SHT_NULL
;
2197 shdr4extnum
->sh_size
= elf
->e_shnum
;
2198 shdr4extnum
->sh_link
= elf
->e_shstrndx
;
2199 shdr4extnum
->sh_info
= segs
;
2205 * This is a two-pass process; first we find the offsets of the bits,
2206 * and then they are actually written out. If we run out of core limit
2209 static int elf_core_dump(struct coredump_params
*cprm
)
2214 size_t vma_data_size
= 0;
2215 struct vm_area_struct
*vma
, *gate_vma
;
2216 struct elfhdr
*elf
= NULL
;
2217 loff_t offset
= 0, dataoff
;
2218 struct elf_note_info info
= { };
2219 struct elf_phdr
*phdr4note
= NULL
;
2220 struct elf_shdr
*shdr4extnum
= NULL
;
2223 elf_addr_t
*vma_filesz
= NULL
;
2226 * We no longer stop all VM operations.
2228 * This is because those proceses that could possibly change map_count
2229 * or the mmap / vma pages are now blocked in do_exit on current
2230 * finishing this core dump.
2232 * Only ptrace can touch these memory addresses, but it doesn't change
2233 * the map_count or the pages allocated. So no possibility of crashing
2234 * exists while dumping the mm->vm_next areas to the core file.
2237 /* alloc memory for large data structures: too large to be on stack */
2238 elf
= kmalloc(sizeof(*elf
), GFP_KERNEL
);
2242 * The number of segs are recored into ELF header as 16bit value.
2243 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
2245 segs
= current
->mm
->map_count
;
2246 segs
+= elf_core_extra_phdrs();
2248 gate_vma
= get_gate_vma(current
->mm
);
2249 if (gate_vma
!= NULL
)
2252 /* for notes section */
2255 /* If segs > PN_XNUM(0xffff), then e_phnum overflows. To avoid
2256 * this, kernel supports extended numbering. Have a look at
2257 * include/linux/elf.h for further information. */
2258 e_phnum
= segs
> PN_XNUM
? PN_XNUM
: segs
;
2261 * Collect all the non-memory information about the process for the
2262 * notes. This also sets up the file header.
2264 if (!fill_note_info(elf
, e_phnum
, &info
, cprm
->siginfo
, cprm
->regs
))
2272 offset
+= sizeof(*elf
); /* Elf header */
2273 offset
+= segs
* sizeof(struct elf_phdr
); /* Program headers */
2275 /* Write notes phdr entry */
2277 size_t sz
= get_note_info_size(&info
);
2279 sz
+= elf_coredump_extra_notes_size();
2281 phdr4note
= kmalloc(sizeof(*phdr4note
), GFP_KERNEL
);
2285 fill_elf_note_phdr(phdr4note
, sz
, offset
);
2289 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
2291 if (segs
- 1 > ULONG_MAX
/ sizeof(*vma_filesz
))
2293 vma_filesz
= vmalloc((segs
- 1) * sizeof(*vma_filesz
));
2297 for (i
= 0, vma
= first_vma(current
, gate_vma
); vma
!= NULL
;
2298 vma
= next_vma(vma
, gate_vma
)) {
2299 unsigned long dump_size
;
2301 dump_size
= vma_dump_size(vma
, cprm
->mm_flags
);
2302 vma_filesz
[i
++] = dump_size
;
2303 vma_data_size
+= dump_size
;
2306 offset
+= vma_data_size
;
2307 offset
+= elf_core_extra_data_size();
2310 if (e_phnum
== PN_XNUM
) {
2311 shdr4extnum
= kmalloc(sizeof(*shdr4extnum
), GFP_KERNEL
);
2314 fill_extnum_info(elf
, shdr4extnum
, e_shoff
, segs
);
2319 if (!dump_emit(cprm
, elf
, sizeof(*elf
)))
2322 if (!dump_emit(cprm
, phdr4note
, sizeof(*phdr4note
)))
2325 /* Write program headers for segments dump */
2326 for (i
= 0, vma
= first_vma(current
, gate_vma
); vma
!= NULL
;
2327 vma
= next_vma(vma
, gate_vma
)) {
2328 struct elf_phdr phdr
;
2330 phdr
.p_type
= PT_LOAD
;
2331 phdr
.p_offset
= offset
;
2332 phdr
.p_vaddr
= vma
->vm_start
;
2334 phdr
.p_filesz
= vma_filesz
[i
++];
2335 phdr
.p_memsz
= vma
->vm_end
- vma
->vm_start
;
2336 offset
+= phdr
.p_filesz
;
2337 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
2338 if (vma
->vm_flags
& VM_WRITE
)
2339 phdr
.p_flags
|= PF_W
;
2340 if (vma
->vm_flags
& VM_EXEC
)
2341 phdr
.p_flags
|= PF_X
;
2342 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
2344 if (!dump_emit(cprm
, &phdr
, sizeof(phdr
)))
2348 if (!elf_core_write_extra_phdrs(cprm
, offset
))
2351 /* write out the notes section */
2352 if (!write_note_info(&info
, cprm
))
2355 if (elf_coredump_extra_notes_write(cprm
))
2359 if (!dump_skip(cprm
, dataoff
- cprm
->pos
))
2362 for (i
= 0, vma
= first_vma(current
, gate_vma
); vma
!= NULL
;
2363 vma
= next_vma(vma
, gate_vma
)) {
2367 end
= vma
->vm_start
+ vma_filesz
[i
++];
2369 for (addr
= vma
->vm_start
; addr
< end
; addr
+= PAGE_SIZE
) {
2373 page
= get_dump_page(addr
);
2375 void *kaddr
= kmap(page
);
2376 stop
= !dump_emit(cprm
, kaddr
, PAGE_SIZE
);
2380 stop
= !dump_skip(cprm
, PAGE_SIZE
);
2385 dump_truncate(cprm
);
2387 if (!elf_core_write_extra_data(cprm
))
2390 if (e_phnum
== PN_XNUM
) {
2391 if (!dump_emit(cprm
, shdr4extnum
, sizeof(*shdr4extnum
)))
2399 free_note_info(&info
);
2408 #endif /* CONFIG_ELF_CORE */
2410 static int __init
init_elf_binfmt(void)
2412 register_binfmt(&elf_format
);
2416 static void __exit
exit_elf_binfmt(void)
2418 /* Remove the COFF and ELF loaders. */
2419 unregister_binfmt(&elf_format
);
2422 core_initcall(init_elf_binfmt
);
2423 module_exit(exit_elf_binfmt
);
2424 MODULE_LICENSE("GPL");