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>
15 #include <linux/stat.h>
16 #include <linux/sched.h>
18 #include <linux/mman.h>
19 #include <linux/a.out.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/ptrace.h>
27 #include <linux/malloc.h>
28 #include <linux/shm.h>
29 #include <linux/personality.h>
30 #include <linux/elfcore.h>
31 #include <linux/init.h>
33 #include <asm/uaccess.h>
34 #include <asm/pgtable.h>
36 #include <linux/config.h>
38 #define DLINFO_ITEMS 13
40 #include <linux/elf.h>
42 static int load_elf_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
);
43 static int load_elf_library(int fd
);
44 extern int dump_fpu (struct pt_regs
*, elf_fpregset_t
*);
45 extern void dump_thread(struct pt_regs
*, struct user
*);
48 #define elf_addr_t unsigned long
49 #define elf_caddr_t char *
53 * If we don't support core dumping, then supply a NULL so we
56 #ifdef USE_ELF_CORE_DUMP
57 static int elf_core_dump(long signr
, struct pt_regs
* regs
);
59 #define elf_core_dump NULL
62 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_EXEC_PAGESIZE-1))
63 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_EXEC_PAGESIZE-1))
64 #define ELF_PAGEALIGN(_v) (((_v) + ELF_EXEC_PAGESIZE - 1) & ~(ELF_EXEC_PAGESIZE - 1))
66 static struct linux_binfmt elf_format
= {
68 NULL
, NULL
, load_elf_binary
, load_elf_library
, elf_core_dump
70 NULL
, &__this_module
, load_elf_binary
, load_elf_library
, elf_core_dump
74 static void set_brk(unsigned long start
, unsigned long end
)
76 start
= ELF_PAGEALIGN(start
);
77 end
= ELF_PAGEALIGN(end
);
80 do_mmap(NULL
, start
, end
- start
,
81 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
82 MAP_FIXED
| MAP_PRIVATE
, 0);
86 /* We need to explicitly zero any fractional pages
87 after the data section (i.e. bss). This would
88 contain the junk from the file that should not
92 static void padzero(unsigned long elf_bss
)
96 nbyte
= ELF_PAGEOFFSET(elf_bss
);
98 nbyte
= ELF_EXEC_PAGESIZE
- nbyte
;
99 clear_user((void *) elf_bss
, nbyte
);
104 create_elf_tables(char *p
, int argc
, int envc
,
105 struct elfhdr
* exec
,
106 unsigned long load_addr
,
107 unsigned long load_bias
,
108 unsigned long interp_load_addr
, int ibcs
)
112 elf_addr_t
*sp
, *csp
;
113 char *k_platform
, *u_platform
;
115 size_t platform_len
= 0;
118 * Get hold of platform and hardware capabilities masks for
119 * the machine we are running on. In some cases (Sparc),
120 * this info is impossible to get, in others (i386) it is
125 k_platform
= ELF_PLATFORM
;
128 platform_len
= strlen(k_platform
) + 1;
129 u_platform
= p
- platform_len
;
130 __copy_to_user(u_platform
, k_platform
, platform_len
);
135 * Force 16 byte _final_ alignment here for generality.
136 * Leave an extra 16 bytes free so that on the PowerPC we
137 * can move the aux table up to start on a 16-byte boundary.
139 sp
= (elf_addr_t
*)((~15UL & (unsigned long)(u_platform
)) - 16UL);
141 csp
-= ((exec
? DLINFO_ITEMS
*2 : 4) + (k_platform
? 2 : 0));
144 csp
-= (!ibcs
? 3 : 1); /* argc itself */
145 if ((unsigned long)csp
& 15UL)
146 sp
-= ((unsigned long)csp
& 15UL) / sizeof(*sp
);
149 * Put the ELF interpreter info on the stack
151 #define NEW_AUX_ENT(nr, id, val) \
152 __put_user ((id), sp+(nr*2)); \
153 __put_user ((val), sp+(nr*2+1)); \
156 NEW_AUX_ENT(0, AT_NULL
, 0);
159 NEW_AUX_ENT(0, AT_PLATFORM
, (elf_addr_t
)(unsigned long) u_platform
);
162 NEW_AUX_ENT(0, AT_HWCAP
, hwcap
);
167 NEW_AUX_ENT(0, AT_PHDR
, load_addr
+ exec
->e_phoff
);
168 NEW_AUX_ENT(1, AT_PHENT
, sizeof (struct elf_phdr
));
169 NEW_AUX_ENT(2, AT_PHNUM
, exec
->e_phnum
);
170 NEW_AUX_ENT(3, AT_PAGESZ
, ELF_EXEC_PAGESIZE
);
171 NEW_AUX_ENT(4, AT_BASE
, interp_load_addr
);
172 NEW_AUX_ENT(5, AT_FLAGS
, 0);
173 NEW_AUX_ENT(6, AT_ENTRY
, load_bias
+ exec
->e_entry
);
174 NEW_AUX_ENT(7, AT_UID
, (elf_addr_t
) current
->uid
);
175 NEW_AUX_ENT(8, AT_EUID
, (elf_addr_t
) current
->euid
);
176 NEW_AUX_ENT(9, AT_GID
, (elf_addr_t
) current
->gid
);
177 NEW_AUX_ENT(10, AT_EGID
, (elf_addr_t
) current
->egid
);
182 envp
= (elf_caddr_t
*) sp
;
184 argv
= (elf_caddr_t
*) sp
;
186 __put_user((elf_addr_t
)(unsigned long) envp
,--sp
);
187 __put_user((elf_addr_t
)(unsigned long) argv
,--sp
);
190 __put_user((elf_addr_t
)argc
,--sp
);
191 current
->mm
->arg_start
= (unsigned long) p
;
193 __put_user((elf_caddr_t
)(unsigned long)p
,argv
++);
196 __put_user(NULL
, argv
);
197 current
->mm
->arg_end
= current
->mm
->env_start
= (unsigned long) p
;
199 __put_user((elf_caddr_t
)(unsigned long)p
,envp
++);
202 __put_user(NULL
, envp
);
203 current
->mm
->env_end
= (unsigned long) p
;
208 /* This is much more generalized than the library routine read function,
209 so we keep this separate. Technically the library read function
210 is only provided so that we can read a.out libraries that have
213 static unsigned long load_elf_interp(struct elfhdr
* interp_elf_ex
,
214 struct dentry
* interpreter_dentry
,
215 unsigned long *interp_load_addr
)
218 struct elf_phdr
*elf_phdata
;
219 struct elf_phdr
*eppnt
;
220 unsigned long load_addr
= 0;
221 int load_addr_set
= 0;
222 unsigned long last_bss
= 0, elf_bss
= 0;
223 unsigned long error
= ~0UL;
227 /* First of all, some simple consistency checks */
228 if (interp_elf_ex
->e_type
!= ET_EXEC
&&
229 interp_elf_ex
->e_type
!= ET_DYN
)
231 if (!elf_check_arch(interp_elf_ex
->e_machine
))
233 if (!interpreter_dentry
->d_inode
->i_op
||
234 !interpreter_dentry
->d_inode
->i_op
->default_file_ops
->mmap
)
238 * If the size of this structure has changed, then punt, since
239 * we will be doing the wrong thing.
241 if (interp_elf_ex
->e_phentsize
!= sizeof(struct elf_phdr
))
244 /* Now read in all of the header information */
246 size
= sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
;
247 if (size
> ELF_EXEC_PAGESIZE
)
249 elf_phdata
= (struct elf_phdr
*) kmalloc(size
, GFP_KERNEL
);
253 retval
= read_exec(interpreter_dentry
, interp_elf_ex
->e_phoff
,
254 (char *) elf_phdata
, size
, 1);
260 elf_exec_fileno
= open_dentry(interpreter_dentry
, O_RDONLY
);
261 if (elf_exec_fileno
< 0)
263 file
= fget(elf_exec_fileno
);
266 for (i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
267 if (eppnt
->p_type
== PT_LOAD
) {
268 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
270 unsigned long vaddr
= 0;
271 unsigned long k
, map_addr
;
273 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
274 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
275 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
276 vaddr
= eppnt
->p_vaddr
;
277 if (interp_elf_ex
->e_type
== ET_EXEC
|| load_addr_set
) {
278 elf_type
|= MAP_FIXED
;
281 load_addr
= get_unmapped_area(0, eppnt
->p_filesz
+
282 ELF_PAGEOFFSET(vaddr
));
286 map_addr
= do_mmap(file
,
287 load_addr
+ ELF_PAGESTART(vaddr
),
288 eppnt
->p_filesz
+ ELF_PAGEOFFSET(eppnt
->p_vaddr
),
291 eppnt
->p_offset
- ELF_PAGEOFFSET(eppnt
->p_vaddr
));
292 if (map_addr
> -1024UL) /* Real error */
295 if (!load_addr_set
&& interp_elf_ex
->e_type
== ET_DYN
) {
296 load_addr
= map_addr
- ELF_PAGESTART(vaddr
);
301 * Find the end of the file mapping for this phdr, and keep
302 * track of the largest address we see for this.
304 k
= load_addr
+ eppnt
->p_vaddr
+ eppnt
->p_filesz
;
309 * Do the same thing for the memory mapping - between
310 * elf_bss and last_bss is the bss section.
312 k
= load_addr
+ eppnt
->p_memsz
+ eppnt
->p_vaddr
;
318 /* Now use mmap to map the library into memory. */
321 * Now fill out the bss section. First pad the last page up
322 * to the page boundary, and then perform a mmap to make sure
323 * that there are zero-mapped pages up to and including the
327 elf_bss
= ELF_PAGESTART(elf_bss
+ ELF_EXEC_PAGESIZE
- 1); /* What we have mapped so far */
329 /* Map the last of the bss segment */
330 if (last_bss
> elf_bss
)
331 do_mmap(NULL
, elf_bss
, last_bss
- elf_bss
,
332 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
333 MAP_FIXED
|MAP_PRIVATE
, 0);
335 *interp_load_addr
= load_addr
;
336 error
= ((unsigned long) interp_elf_ex
->e_entry
) + load_addr
;
340 sys_close(elf_exec_fileno
);
347 static unsigned long load_aout_interp(struct exec
* interp_ex
,
348 struct dentry
* interpreter_dentry
)
350 unsigned long text_data
, offset
, elf_entry
= ~0UL;
354 current
->mm
->end_code
= interp_ex
->a_text
;
355 text_data
= interp_ex
->a_text
+ interp_ex
->a_data
;
356 current
->mm
->end_data
= text_data
;
357 current
->mm
->brk
= interp_ex
->a_bss
+ text_data
;
359 switch (N_MAGIC(*interp_ex
)) {
366 offset
= N_TXTOFF(*interp_ex
);
367 addr
= (char *) N_TXTADDR(*interp_ex
);
373 do_mmap(NULL
, 0, text_data
,
374 PROT_READ
|PROT_WRITE
|PROT_EXEC
, MAP_FIXED
|MAP_PRIVATE
, 0);
375 retval
= read_exec(interpreter_dentry
, offset
, addr
, text_data
, 0);
378 flush_icache_range((unsigned long)addr
,
379 (unsigned long)addr
+ text_data
);
381 do_mmap(NULL
, ELF_PAGESTART(text_data
+ ELF_EXEC_PAGESIZE
- 1),
383 PROT_READ
|PROT_WRITE
|PROT_EXEC
, MAP_FIXED
|MAP_PRIVATE
, 0);
384 elf_entry
= interp_ex
->a_entry
;
391 * These are the functions used to load ELF style executables and shared
392 * libraries. There is no binary dependent code anywhere else.
395 #define INTERPRETER_NONE 0
396 #define INTERPRETER_AOUT 1
397 #define INTERPRETER_ELF 2
401 do_load_elf_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
)
404 struct dentry
*interpreter_dentry
= NULL
; /* to shut gcc up */
405 unsigned long load_addr
= 0, load_bias
;
406 int load_addr_set
= 0;
407 char * elf_interpreter
= NULL
;
408 unsigned int interpreter_type
= INTERPRETER_NONE
;
409 unsigned char ibcs2_interpreter
= 0;
412 struct elf_phdr
* elf_ppnt
, *elf_phdata
;
413 unsigned long elf_bss
, k
, elf_brk
;
416 unsigned long elf_entry
, interp_load_addr
= 0;
417 unsigned long start_code
, end_code
, end_data
;
418 struct elfhdr elf_ex
;
419 struct elfhdr interp_elf_ex
;
420 struct exec interp_ex
;
421 char passed_fileno
[6];
423 /* Get the exec-header */
424 elf_ex
= *((struct elfhdr
*) bprm
->buf
);
427 /* First of all, some simple consistency checks */
428 if (elf_ex
.e_ident
[0] != 0x7f ||
429 strncmp(&elf_ex
.e_ident
[1], "ELF", 3) != 0)
432 if (elf_ex
.e_type
!= ET_EXEC
&& elf_ex
.e_type
!= ET_DYN
)
434 if (!elf_check_arch(elf_ex
.e_machine
))
437 /* IRIX binaries handled elsewhere. */
438 if (elf_ex
.e_flags
& EF_MIPS_ARCH
) {
443 if (!bprm
->dentry
->d_inode
->i_op
||
444 !bprm
->dentry
->d_inode
->i_op
->default_file_ops
||
445 !bprm
->dentry
->d_inode
->i_op
->default_file_ops
->mmap
)
448 /* Now read in all of the header information */
451 size
= elf_ex
.e_phentsize
* elf_ex
.e_phnum
;
452 elf_phdata
= (struct elf_phdr
*) kmalloc(size
, GFP_KERNEL
);
456 retval
= read_exec(bprm
->dentry
, elf_ex
.e_phoff
,
457 (char *) elf_phdata
, size
, 1);
461 retval
= open_dentry(bprm
->dentry
, O_RDONLY
);
464 elf_exec_fileno
= retval
;
465 file
= fget(elf_exec_fileno
);
467 elf_ppnt
= elf_phdata
;
475 for (i
= 0; i
< elf_ex
.e_phnum
; i
++) {
476 if (elf_ppnt
->p_type
== PT_INTERP
) {
479 goto out_free_interp
;
481 /* This is the program interpreter used for
482 * shared libraries - for now assume that this
483 * is an a.out format binary
487 elf_interpreter
= (char *) kmalloc(elf_ppnt
->p_filesz
,
489 if (!elf_interpreter
)
492 retval
= read_exec(bprm
->dentry
, elf_ppnt
->p_offset
,
494 elf_ppnt
->p_filesz
, 1);
496 goto out_free_interp
;
497 /* If the program interpreter is one of these two,
498 * then assume an iBCS2 image. Otherwise assume
499 * a native linux image.
501 if (strcmp(elf_interpreter
,"/usr/lib/libc.so.1") == 0 ||
502 strcmp(elf_interpreter
,"/usr/lib/ld.so.1") == 0)
503 ibcs2_interpreter
= 1;
505 printk("Using ELF interpreter %s\n", elf_interpreter
);
507 old_fs
= get_fs(); /* This could probably be optimized */
510 if (ibcs2_interpreter
) {
511 unsigned long old_pers
= current
->personality
;
513 current
->personality
= PER_SVR4
;
514 interpreter_dentry
= open_namei(elf_interpreter
,
516 current
->personality
= old_pers
;
519 interpreter_dentry
= open_namei(elf_interpreter
,
522 retval
= PTR_ERR(interpreter_dentry
);
523 if (IS_ERR(interpreter_dentry
))
524 goto out_free_interp
;
525 retval
= permission(interpreter_dentry
->d_inode
, MAY_EXEC
);
527 goto out_free_dentry
;
528 retval
= read_exec(interpreter_dentry
, 0, bprm
->buf
, 128, 1);
530 goto out_free_dentry
;
532 /* Get the exec headers */
533 interp_ex
= *((struct exec
*) bprm
->buf
);
534 interp_elf_ex
= *((struct elfhdr
*) bprm
->buf
);
539 /* Some simple consistency checks for the interpreter */
540 if (elf_interpreter
) {
541 interpreter_type
= INTERPRETER_ELF
| INTERPRETER_AOUT
;
543 /* Now figure out which format our binary is */
544 if ((N_MAGIC(interp_ex
) != OMAGIC
) &&
545 (N_MAGIC(interp_ex
) != ZMAGIC
) &&
546 (N_MAGIC(interp_ex
) != QMAGIC
))
547 interpreter_type
= INTERPRETER_ELF
;
549 if (interp_elf_ex
.e_ident
[0] != 0x7f ||
550 strncmp(&interp_elf_ex
.e_ident
[1], "ELF", 3) != 0)
551 interpreter_type
&= ~INTERPRETER_ELF
;
554 if (!interpreter_type
)
555 goto out_free_dentry
;
557 /* Make sure only one type was selected */
558 if ((interpreter_type
& INTERPRETER_ELF
) &&
559 interpreter_type
!= INTERPRETER_ELF
) {
560 printk(KERN_WARNING
"ELF: Ambiguous type, using ELF\n");
561 interpreter_type
= INTERPRETER_ELF
;
565 /* OK, we are done with that, now set up the arg stuff,
566 and then start this sucker up */
568 if (!bprm
->sh_bang
) {
571 if (interpreter_type
== INTERPRETER_AOUT
) {
572 sprintf(passed_fileno
, "%d", elf_exec_fileno
);
573 passed_p
= passed_fileno
;
575 if (elf_interpreter
) {
576 bprm
->p
= copy_strings(1,&passed_p
,bprm
->page
,bprm
->p
,2);
582 goto out_free_dentry
;
585 /* Flush all traces of the currently running executable */
586 retval
= flush_old_exec(bprm
);
588 goto out_free_dentry
;
590 /* OK, This is the point of no return */
591 current
->mm
->end_data
= 0;
592 current
->mm
->end_code
= 0;
593 current
->mm
->mmap
= NULL
;
594 current
->flags
&= ~PF_FORKNOEXEC
;
595 elf_entry
= (unsigned long) elf_ex
.e_entry
;
597 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
598 may depend on the personality. */
599 SET_PERSONALITY(elf_ex
, ibcs2_interpreter
);
601 /* Do this so that we can load the interpreter, if need be. We will
602 change some of these later */
603 current
->mm
->rss
= 0;
604 bprm
->p
= setup_arg_pages(bprm
->p
, bprm
);
605 current
->mm
->start_stack
= bprm
->p
;
607 /* Try and get dynamic programs out of the way of the default mmap
608 base, as well as whatever program they might try to exec. This
609 is because the brk will follow the loader, and is not movable. */
611 load_bias
= ELF_PAGESTART(elf_ex
.e_type
==ET_DYN
? ELF_ET_DYN_BASE
: 0);
613 /* Now we do a little grungy work by mmaping the ELF image into
614 the correct location in memory. At this point, we assume that
615 the image should be loaded at fixed address, not at a variable
620 for(i
= 0, elf_ppnt
= elf_phdata
; i
< elf_ex
.e_phnum
; i
++, elf_ppnt
++) {
621 int elf_prot
= 0, elf_flags
;
624 if (elf_ppnt
->p_type
!= PT_LOAD
)
627 if (elf_ppnt
->p_flags
& PF_R
) elf_prot
|= PROT_READ
;
628 if (elf_ppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
629 if (elf_ppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
631 elf_flags
= MAP_PRIVATE
|MAP_DENYWRITE
|MAP_EXECUTABLE
;
633 vaddr
= elf_ppnt
->p_vaddr
;
634 if (elf_ex
.e_type
== ET_EXEC
|| load_addr_set
) {
635 elf_flags
|= MAP_FIXED
;
638 error
= do_mmap(file
, ELF_PAGESTART(load_bias
+ vaddr
),
639 (elf_ppnt
->p_filesz
+
640 ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)),
641 elf_prot
, elf_flags
, (elf_ppnt
->p_offset
-
642 ELF_PAGEOFFSET(elf_ppnt
->p_vaddr
)));
644 if (!load_addr_set
) {
646 load_addr
= (elf_ppnt
->p_vaddr
- elf_ppnt
->p_offset
);
647 if (elf_ex
.e_type
== ET_DYN
) {
649 ELF_PAGESTART(load_bias
+ vaddr
);
653 k
= elf_ppnt
->p_vaddr
;
654 if (k
< start_code
) start_code
= k
;
655 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_filesz
;
658 if ((elf_ppnt
->p_flags
& PF_X
) && end_code
< k
)
662 k
= elf_ppnt
->p_vaddr
+ elf_ppnt
->p_memsz
;
667 fput(file
); /* all done with the file */
669 elf_entry
+= load_bias
;
670 elf_bss
+= load_bias
;
671 elf_brk
+= load_bias
;
672 start_code
+= load_bias
;
673 end_code
+= load_bias
;
674 end_data
+= load_bias
;
676 if (elf_interpreter
) {
677 if (interpreter_type
== INTERPRETER_AOUT
)
678 elf_entry
= load_aout_interp(&interp_ex
,
681 elf_entry
= load_elf_interp(&interp_elf_ex
,
685 dput(interpreter_dentry
);
686 kfree(elf_interpreter
);
688 if (elf_entry
== ~0UL) {
689 printk(KERN_ERR
"Unable to load interpreter\n");
691 send_sig(SIGSEGV
, current
, 0);
698 if (interpreter_type
!= INTERPRETER_AOUT
)
699 sys_close(elf_exec_fileno
);
701 if (current
->exec_domain
&& current
->exec_domain
->module
)
702 __MOD_DEC_USE_COUNT(current
->exec_domain
->module
);
703 if (current
->binfmt
&& current
->binfmt
->module
)
704 __MOD_DEC_USE_COUNT(current
->binfmt
->module
);
705 current
->exec_domain
= lookup_exec_domain(current
->personality
);
706 current
->binfmt
= &elf_format
;
707 if (current
->exec_domain
&& current
->exec_domain
->module
)
708 __MOD_INC_USE_COUNT(current
->exec_domain
->module
);
709 if (current
->binfmt
&& current
->binfmt
->module
)
710 __MOD_INC_USE_COUNT(current
->binfmt
->module
);
712 #ifndef VM_STACK_FLAGS
713 current
->executable
= dget(bprm
->dentry
);
716 current
->flags
&= ~PF_FORKNOEXEC
;
717 bprm
->p
= (unsigned long)
718 create_elf_tables((char *)bprm
->p
,
721 (interpreter_type
== INTERPRETER_ELF
? &elf_ex
: NULL
),
722 load_addr
, load_bias
,
724 (interpreter_type
== INTERPRETER_AOUT
? 0 : 1));
725 /* N.B. passed_fileno might not be initialized? */
726 if (interpreter_type
== INTERPRETER_AOUT
)
727 current
->mm
->arg_start
+= strlen(passed_fileno
) + 1;
728 current
->mm
->start_brk
= current
->mm
->brk
= elf_brk
;
729 current
->mm
->end_code
= end_code
;
730 current
->mm
->start_code
= start_code
;
731 current
->mm
->end_data
= end_data
;
732 current
->mm
->start_stack
= bprm
->p
;
734 /* Calling set_brk effectively mmaps the pages that we need
735 * for the bss and break sections
737 set_brk(elf_bss
, elf_brk
);
742 printk("(start_brk) %x\n" , current
->mm
->start_brk
);
743 printk("(end_code) %x\n" , current
->mm
->end_code
);
744 printk("(start_code) %x\n" , current
->mm
->start_code
);
745 printk("(end_data) %x\n" , current
->mm
->end_data
);
746 printk("(start_stack) %x\n" , current
->mm
->start_stack
);
747 printk("(brk) %x\n" , current
->mm
->brk
);
750 if ( current
->personality
== PER_SVR4
)
752 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
753 and some applications "depend" upon this behavior.
754 Since we do not have the power to recompile these, we
755 emulate the SVr4 behavior. Sigh. */
756 /* N.B. Shouldn't the size here be PAGE_SIZE?? */
757 error
= do_mmap(NULL
, 0, 4096, PROT_READ
| PROT_EXEC
,
758 MAP_FIXED
| MAP_PRIVATE
, 0);
763 * The ABI may specify that certain registers be set up in special
764 * ways (on i386 %edx is the address of a DT_FINI function, for
765 * example. This macro performs whatever initialization to
766 * the regs structure is required.
771 start_thread(regs
, elf_entry
, bprm
->p
);
772 if (current
->flags
& PF_PTRACED
)
773 send_sig(SIGTRAP
, current
, 0);
780 dput(interpreter_dentry
);
783 kfree(elf_interpreter
);
786 sys_close(elf_exec_fileno
);
793 load_elf_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
)
798 retval
= do_load_elf_binary(bprm
, regs
);
803 /* This is really simpleminded and specialized - we are loading an
804 a.out library that is given an ELF header. */
807 do_load_elf_library(int fd
)
810 struct dentry
* dentry
;
811 struct inode
* inode
;
812 struct elf_phdr
*elf_phdata
;
813 unsigned long elf_bss
= 0, bss
, len
, k
;
814 int retval
, error
, i
, j
;
815 struct elfhdr elf_ex
;
820 if (!file
|| !file
->f_op
)
822 dentry
= file
->f_dentry
;
823 inode
= dentry
->d_inode
;
825 /* seek to the beginning of the file */
828 /* N.B. save current DS?? */
830 retval
= file
->f_op
->read(file
, (char *) &elf_ex
, sizeof(elf_ex
), &offset
);
832 if (retval
!= sizeof(elf_ex
))
835 if (elf_ex
.e_ident
[0] != 0x7f ||
836 strncmp(&elf_ex
.e_ident
[1], "ELF", 3) != 0)
839 /* First of all, some simple consistency checks */
840 if (elf_ex
.e_type
!= ET_EXEC
|| elf_ex
.e_phnum
> 2 ||
841 !elf_check_arch(elf_ex
.e_machine
) ||
842 (!inode
->i_op
|| !inode
->i_op
->default_file_ops
->mmap
))
845 /* Now read in all of the header information */
847 j
= sizeof(struct elf_phdr
) * elf_ex
.e_phnum
;
848 if (j
> ELF_EXEC_PAGESIZE
)
852 elf_phdata
= (struct elf_phdr
*) kmalloc(j
, GFP_KERNEL
);
856 /* N.B. check for error return?? */
857 retval
= read_exec(dentry
, elf_ex
.e_phoff
, (char *) elf_phdata
,
858 sizeof(struct elf_phdr
) * elf_ex
.e_phnum
, 1);
861 for (j
= 0, i
= 0; i
<elf_ex
.e_phnum
; i
++)
862 if ((elf_phdata
+ i
)->p_type
== PT_LOAD
) j
++;
866 while (elf_phdata
->p_type
!= PT_LOAD
) elf_phdata
++;
868 /* Now use mmap to map the library into memory. */
869 error
= do_mmap(file
,
870 ELF_PAGESTART(elf_phdata
->p_vaddr
),
871 (elf_phdata
->p_filesz
+
872 ELF_PAGEOFFSET(elf_phdata
->p_vaddr
)),
873 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
874 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
,
875 (elf_phdata
->p_offset
-
876 ELF_PAGEOFFSET(elf_phdata
->p_vaddr
)));
877 if (error
!= ELF_PAGESTART(elf_phdata
->p_vaddr
))
880 k
= elf_phdata
->p_vaddr
+ elf_phdata
->p_filesz
;
885 len
= ELF_PAGESTART(elf_phdata
->p_filesz
+ elf_phdata
->p_vaddr
+
886 ELF_EXEC_PAGESIZE
- 1);
887 bss
= elf_phdata
->p_memsz
+ elf_phdata
->p_vaddr
;
889 do_mmap(NULL
, len
, bss
- len
,
890 PROT_READ
|PROT_WRITE
|PROT_EXEC
,
891 MAP_FIXED
|MAP_PRIVATE
, 0);
902 static int load_elf_library(int fd
)
907 retval
= do_load_elf_library(fd
);
913 * Note that some platforms still use traditional core dumps and not
914 * the ELF core dump. Each platform can select it as appropriate.
916 #ifdef USE_ELF_CORE_DUMP
921 * Modelled on fs/exec.c:aout_core_dump()
922 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
925 * These are the only things you should do on a core-file: use only these
926 * functions to write out all the necessary info.
928 static int dump_write(struct file
*file
, const void *addr
, int nr
)
930 return file
->f_op
->write(file
, addr
, nr
, &file
->f_pos
) == nr
;
933 static int dump_seek(struct file
*file
, off_t off
)
935 if (file
->f_op
->llseek
) {
936 if (file
->f_op
->llseek(file
, off
, 0) != off
)
944 * Decide whether a segment is worth dumping; default is yes to be
945 * sure (missing info is worse than too much; etc).
946 * Personally I'd include everything, and use the coredump limit...
948 * I think we should skip something. But I am not sure how. H.J.
950 static inline int maydump(struct vm_area_struct
*vma
)
952 if (!(vma
->vm_flags
& (VM_READ
|VM_WRITE
|VM_EXEC
)))
955 /* Do not dump I/O mapped devices! -DaveM */
956 if(vma
->vm_flags
& VM_IO
)
959 if (vma
->vm_flags
& (VM_WRITE
|VM_GROWSUP
|VM_GROWSDOWN
))
961 if (vma
->vm_flags
& (VM_READ
|VM_EXEC
|VM_EXECUTABLE
|VM_SHARED
))
967 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
969 /* An ELF note in memory */
978 static int notesize(struct memelfnote
*en
)
982 sz
= sizeof(struct elf_note
);
983 sz
+= roundup(strlen(en
->name
), 4);
984 sz
+= roundup(en
->datasz
, 4);
992 static void dump_regs(const char *str
, elf_greg_t
*r
)
995 static const char *regs
[] = { "ebx", "ecx", "edx", "esi", "edi", "ebp",
996 "eax", "ds", "es", "fs", "gs",
997 "orig_eax", "eip", "cs",
998 "efl", "uesp", "ss"};
999 printk("Registers: %s\n", str
);
1001 for(i
= 0; i
< ELF_NGREG
; i
++)
1003 unsigned long val
= r
[i
];
1004 printk(" %-2d %-5s=%08lx %lu\n", i
, regs
[i
], val
, val
);
1009 #define DUMP_WRITE(addr, nr) \
1010 do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1011 #define DUMP_SEEK(off) \
1012 do { if (!dump_seek(file, (off))) return 0; } while(0)
1014 static int writenote(struct memelfnote
*men
, struct file
*file
)
1018 en
.n_namesz
= strlen(men
->name
);
1019 en
.n_descsz
= men
->datasz
;
1020 en
.n_type
= men
->type
;
1022 DUMP_WRITE(&en
, sizeof(en
));
1023 DUMP_WRITE(men
->name
, en
.n_namesz
);
1024 /* XXX - cast from long long to long to avoid need for libgcc.a */
1025 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1026 DUMP_WRITE(men
->data
, men
->datasz
);
1027 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1034 #define DUMP_WRITE(addr, nr) \
1035 if (!dump_write(file, (addr), (nr))) \
1036 goto close_coredump;
1037 #define DUMP_SEEK(off) \
1038 if (!dump_seek(file, (off))) \
1039 goto close_coredump;
1043 * This is a two-pass process; first we find the offsets of the bits,
1044 * and then they are actually written out. If we run out of core limit
1047 static int elf_core_dump(long signr
, struct pt_regs
* regs
)
1051 struct dentry
*dentry
;
1052 struct inode
*inode
;
1054 char corefile
[6+sizeof(current
->comm
)];
1058 struct vm_area_struct
*vma
;
1060 off_t offset
= 0, dataoff
;
1061 unsigned long limit
= current
->rlim
[RLIMIT_CORE
].rlim_cur
;
1063 struct memelfnote notes
[4];
1064 struct elf_prstatus prstatus
; /* NT_PRSTATUS */
1065 elf_fpregset_t fpu
; /* NT_PRFPREG */
1066 struct elf_prpsinfo psinfo
; /* NT_PRPSINFO */
1068 if (!current
->dumpable
||
1069 limit
< ELF_EXEC_PAGESIZE
||
1070 atomic_read(¤t
->mm
->count
) != 1)
1072 current
->dumpable
= 0;
1074 #ifndef CONFIG_BINFMT_ELF
1078 /* Count what's needed to dump, up to the limit of coredump size */
1081 for(vma
= current
->mm
->mmap
; vma
!= NULL
; vma
= vma
->vm_next
) {
1084 unsigned long sz
= vma
->vm_end
-vma
->vm_start
;
1086 if (size
+sz
>= limit
)
1095 printk("elf_core_dump: %d segs taking %d bytes\n", segs
, size
);
1099 memcpy(elf
.e_ident
, ELFMAG
, SELFMAG
);
1100 elf
.e_ident
[EI_CLASS
] = ELF_CLASS
;
1101 elf
.e_ident
[EI_DATA
] = ELF_DATA
;
1102 elf
.e_ident
[EI_VERSION
] = EV_CURRENT
;
1103 memset(elf
.e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1105 elf
.e_type
= ET_CORE
;
1106 elf
.e_machine
= ELF_ARCH
;
1107 elf
.e_version
= EV_CURRENT
;
1109 elf
.e_phoff
= sizeof(elf
);
1112 elf
.e_ehsize
= sizeof(elf
);
1113 elf
.e_phentsize
= sizeof(struct elf_phdr
);
1114 elf
.e_phnum
= segs
+1; /* Include notes */
1115 elf
.e_shentsize
= 0;
1122 memcpy(corefile
,"core.",5);
1124 memcpy(corefile
+5,current
->comm
,sizeof(current
->comm
));
1128 file
= filp_open(corefile
, O_CREAT
| 2 | O_TRUNC
| O_NOFOLLOW
, 0600);
1131 dentry
= file
->f_dentry
;
1132 inode
= dentry
->d_inode
;
1133 if (inode
->i_nlink
> 1)
1134 goto close_coredump
; /* multiple links - don't dump */
1136 if (!S_ISREG(inode
->i_mode
))
1137 goto close_coredump
;
1138 if (!inode
->i_op
|| !inode
->i_op
->default_file_ops
)
1139 goto close_coredump
;
1140 if (!file
->f_op
->write
)
1141 goto close_coredump
;
1144 current
->flags
|= PF_DUMPCORE
;
1146 DUMP_WRITE(&elf
, sizeof(elf
));
1147 offset
+= sizeof(elf
); /* Elf header */
1148 offset
+= (segs
+1) * sizeof(struct elf_phdr
); /* Program headers */
1151 * Set up the notes in similar form to SVR4 core dumps made
1152 * with info from their /proc.
1154 memset(&psinfo
, 0, sizeof(psinfo
));
1155 memset(&prstatus
, 0, sizeof(prstatus
));
1157 notes
[0].name
= "CORE";
1158 notes
[0].type
= NT_PRSTATUS
;
1159 notes
[0].datasz
= sizeof(prstatus
);
1160 notes
[0].data
= &prstatus
;
1161 prstatus
.pr_info
.si_signo
= prstatus
.pr_cursig
= signr
;
1162 prstatus
.pr_sigpend
= current
->signal
.sig
[0];
1163 prstatus
.pr_sighold
= current
->blocked
.sig
[0];
1164 psinfo
.pr_pid
= prstatus
.pr_pid
= current
->pid
;
1165 psinfo
.pr_ppid
= prstatus
.pr_ppid
= current
->p_pptr
->pid
;
1166 psinfo
.pr_pgrp
= prstatus
.pr_pgrp
= current
->pgrp
;
1167 psinfo
.pr_sid
= prstatus
.pr_sid
= current
->session
;
1168 prstatus
.pr_utime
.tv_sec
= CT_TO_SECS(current
->times
.tms_utime
);
1169 prstatus
.pr_utime
.tv_usec
= CT_TO_USECS(current
->times
.tms_utime
);
1170 prstatus
.pr_stime
.tv_sec
= CT_TO_SECS(current
->times
.tms_stime
);
1171 prstatus
.pr_stime
.tv_usec
= CT_TO_USECS(current
->times
.tms_stime
);
1172 prstatus
.pr_cutime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cutime
);
1173 prstatus
.pr_cutime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cutime
);
1174 prstatus
.pr_cstime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cstime
);
1175 prstatus
.pr_cstime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cstime
);
1178 * This transfers the registers from regs into the standard
1179 * coredump arrangement, whatever that is.
1181 #ifdef ELF_CORE_COPY_REGS
1182 ELF_CORE_COPY_REGS(prstatus
.pr_reg
, regs
)
1184 if (sizeof(elf_gregset_t
) != sizeof(struct pt_regs
))
1186 printk("sizeof(elf_gregset_t) (%ld) != sizeof(struct pt_regs) (%ld)\n",
1187 (long)sizeof(elf_gregset_t
), (long)sizeof(struct pt_regs
));
1190 *(struct pt_regs
*)&prstatus
.pr_reg
= *regs
;
1194 dump_regs("Passed in regs", (elf_greg_t
*)regs
);
1195 dump_regs("prstatus regs", (elf_greg_t
*)&prstatus
.pr_reg
);
1198 notes
[1].name
= "CORE";
1199 notes
[1].type
= NT_PRPSINFO
;
1200 notes
[1].datasz
= sizeof(psinfo
);
1201 notes
[1].data
= &psinfo
;
1202 i
= current
->state
? ffz(~current
->state
) + 1 : 0;
1203 psinfo
.pr_state
= i
;
1204 psinfo
.pr_sname
= (i
< 0 || i
> 5) ? '.' : "RSDZTD"[i
];
1205 psinfo
.pr_zomb
= psinfo
.pr_sname
== 'Z';
1206 psinfo
.pr_nice
= current
->priority
-15;
1207 psinfo
.pr_flag
= current
->flags
;
1208 psinfo
.pr_uid
= current
->uid
;
1209 psinfo
.pr_gid
= current
->gid
;
1215 len
= current
->mm
->arg_end
- current
->mm
->arg_start
;
1216 if (len
>= ELF_PRARGSZ
)
1217 len
= ELF_PRARGSZ
-1;
1218 copy_from_user(&psinfo
.pr_psargs
,
1219 (const char *)current
->mm
->arg_start
, len
);
1220 for(i
= 0; i
< len
; i
++)
1221 if (psinfo
.pr_psargs
[i
] == 0)
1222 psinfo
.pr_psargs
[i
] = ' ';
1223 psinfo
.pr_psargs
[len
] = 0;
1227 strncpy(psinfo
.pr_fname
, current
->comm
, sizeof(psinfo
.pr_fname
));
1229 notes
[2].name
= "CORE";
1230 notes
[2].type
= NT_TASKSTRUCT
;
1231 notes
[2].datasz
= sizeof(*current
);
1232 notes
[2].data
= current
;
1234 /* Try to dump the FPU. */
1235 prstatus
.pr_fpvalid
= dump_fpu (regs
, &fpu
);
1236 if (!prstatus
.pr_fpvalid
)
1242 notes
[3].name
= "CORE";
1243 notes
[3].type
= NT_PRFPREG
;
1244 notes
[3].datasz
= sizeof(fpu
);
1245 notes
[3].data
= &fpu
;
1248 /* Write notes phdr entry */
1250 struct elf_phdr phdr
;
1253 for(i
= 0; i
< numnote
; i
++)
1254 sz
+= notesize(¬es
[i
]);
1256 phdr
.p_type
= PT_NOTE
;
1257 phdr
.p_offset
= offset
;
1265 offset
+= phdr
.p_filesz
;
1266 DUMP_WRITE(&phdr
, sizeof(phdr
));
1269 /* Page-align dumped data */
1270 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1272 /* Write program headers for segments dump */
1273 for(vma
= current
->mm
->mmap
, i
= 0;
1274 i
< segs
&& vma
!= NULL
; vma
= vma
->vm_next
) {
1275 struct elf_phdr phdr
;
1280 sz
= vma
->vm_end
- vma
->vm_start
;
1282 phdr
.p_type
= PT_LOAD
;
1283 phdr
.p_offset
= offset
;
1284 phdr
.p_vaddr
= vma
->vm_start
;
1286 phdr
.p_filesz
= maydump(vma
) ? sz
: 0;
1288 offset
+= phdr
.p_filesz
;
1289 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1290 if (vma
->vm_flags
& VM_WRITE
) phdr
.p_flags
|= PF_W
;
1291 if (vma
->vm_flags
& VM_EXEC
) phdr
.p_flags
|= PF_X
;
1292 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1294 DUMP_WRITE(&phdr
, sizeof(phdr
));
1297 for(i
= 0; i
< numnote
; i
++)
1298 if (!writenote(¬es
[i
], file
))
1299 goto close_coredump
;
1305 for(i
= 0, vma
= current
->mm
->mmap
;
1306 i
< segs
&& vma
!= NULL
;
1307 vma
= vma
->vm_next
) {
1308 unsigned long addr
= vma
->vm_start
;
1309 unsigned long len
= vma
->vm_end
- vma
->vm_start
;
1315 printk("elf_core_dump: writing %08lx %lx\n", addr
, len
);
1317 DUMP_WRITE((void *)addr
, len
);
1320 if ((off_t
) file
->f_pos
!= offset
) {
1322 printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1323 (off_t
) file
->f_pos
, offset
);
1327 filp_close(file
, NULL
);
1331 #ifndef CONFIG_BINFMT_ELF
1336 #endif /* USE_ELF_CORE_DUMP */
1338 int __init
init_elf_binfmt(void)
1340 return register_binfmt(&elf_format
);
1345 int init_module(void)
1347 /* Install the COFF, ELF and XOUT loaders.
1348 * N.B. We *rely* on the table being the right size with the
1349 * right number of free slots...
1351 return init_elf_binfmt();
1355 void cleanup_module( void)
1357 /* Remove the COFF and ELF loaders. */
1358 unregister_binfmt(&elf_format
);