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;
1121 memcpy(corefile
,"core.",5);
1123 memcpy(corefile
+5,current
->comm
,sizeof(current
->comm
));
1127 dentry
= open_namei(corefile
, O_CREAT
| 2 | O_TRUNC
| O_NOFOLLOW
, 0600);
1128 if (IS_ERR(dentry
)) {
1132 inode
= dentry
->d_inode
;
1134 if(inode
->i_nlink
> 1)
1135 goto end_coredump
; /* multiple links - don't dump */
1137 if (!S_ISREG(inode
->i_mode
))
1139 if (!inode
->i_op
|| !inode
->i_op
->default_file_ops
)
1141 if (init_private_file(&file
, dentry
, 3))
1143 if (!file
.f_op
->write
)
1144 goto close_coredump
;
1146 current
->flags
|= PF_DUMPCORE
;
1148 DUMP_WRITE(&elf
, sizeof(elf
));
1149 offset
+= sizeof(elf
); /* Elf header */
1150 offset
+= (segs
+1) * sizeof(struct elf_phdr
); /* Program headers */
1153 * Set up the notes in similar form to SVR4 core dumps made
1154 * with info from their /proc.
1156 memset(&psinfo
, 0, sizeof(psinfo
));
1157 memset(&prstatus
, 0, sizeof(prstatus
));
1159 notes
[0].name
= "CORE";
1160 notes
[0].type
= NT_PRSTATUS
;
1161 notes
[0].datasz
= sizeof(prstatus
);
1162 notes
[0].data
= &prstatus
;
1163 prstatus
.pr_info
.si_signo
= prstatus
.pr_cursig
= signr
;
1164 prstatus
.pr_sigpend
= current
->signal
.sig
[0];
1165 prstatus
.pr_sighold
= current
->blocked
.sig
[0];
1166 psinfo
.pr_pid
= prstatus
.pr_pid
= current
->pid
;
1167 psinfo
.pr_ppid
= prstatus
.pr_ppid
= current
->p_pptr
->pid
;
1168 psinfo
.pr_pgrp
= prstatus
.pr_pgrp
= current
->pgrp
;
1169 psinfo
.pr_sid
= prstatus
.pr_sid
= current
->session
;
1170 prstatus
.pr_utime
.tv_sec
= CT_TO_SECS(current
->times
.tms_utime
);
1171 prstatus
.pr_utime
.tv_usec
= CT_TO_USECS(current
->times
.tms_utime
);
1172 prstatus
.pr_stime
.tv_sec
= CT_TO_SECS(current
->times
.tms_stime
);
1173 prstatus
.pr_stime
.tv_usec
= CT_TO_USECS(current
->times
.tms_stime
);
1174 prstatus
.pr_cutime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cutime
);
1175 prstatus
.pr_cutime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cutime
);
1176 prstatus
.pr_cstime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cstime
);
1177 prstatus
.pr_cstime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cstime
);
1180 * This transfers the registers from regs into the standard
1181 * coredump arrangement, whatever that is.
1183 #ifdef ELF_CORE_COPY_REGS
1184 ELF_CORE_COPY_REGS(prstatus
.pr_reg
, regs
)
1186 if (sizeof(elf_gregset_t
) != sizeof(struct pt_regs
))
1188 printk("sizeof(elf_gregset_t) (%ld) != sizeof(struct pt_regs) (%ld)\n",
1189 (long)sizeof(elf_gregset_t
), (long)sizeof(struct pt_regs
));
1192 *(struct pt_regs
*)&prstatus
.pr_reg
= *regs
;
1196 dump_regs("Passed in regs", (elf_greg_t
*)regs
);
1197 dump_regs("prstatus regs", (elf_greg_t
*)&prstatus
.pr_reg
);
1200 notes
[1].name
= "CORE";
1201 notes
[1].type
= NT_PRPSINFO
;
1202 notes
[1].datasz
= sizeof(psinfo
);
1203 notes
[1].data
= &psinfo
;
1204 i
= current
->state
? ffz(~current
->state
) + 1 : 0;
1205 psinfo
.pr_state
= i
;
1206 psinfo
.pr_sname
= (i
< 0 || i
> 5) ? '.' : "RSDZTD"[i
];
1207 psinfo
.pr_zomb
= psinfo
.pr_sname
== 'Z';
1208 psinfo
.pr_nice
= current
->priority
-15;
1209 psinfo
.pr_flag
= current
->flags
;
1210 psinfo
.pr_uid
= current
->uid
;
1211 psinfo
.pr_gid
= current
->gid
;
1217 len
= current
->mm
->arg_end
- current
->mm
->arg_start
;
1218 if (len
>= ELF_PRARGSZ
)
1219 len
= ELF_PRARGSZ
-1;
1220 copy_from_user(&psinfo
.pr_psargs
,
1221 (const char *)current
->mm
->arg_start
, len
);
1222 for(i
= 0; i
< len
; i
++)
1223 if (psinfo
.pr_psargs
[i
] == 0)
1224 psinfo
.pr_psargs
[i
] = ' ';
1225 psinfo
.pr_psargs
[len
] = 0;
1229 strncpy(psinfo
.pr_fname
, current
->comm
, sizeof(psinfo
.pr_fname
));
1231 notes
[2].name
= "CORE";
1232 notes
[2].type
= NT_TASKSTRUCT
;
1233 notes
[2].datasz
= sizeof(*current
);
1234 notes
[2].data
= current
;
1236 /* Try to dump the FPU. */
1237 prstatus
.pr_fpvalid
= dump_fpu (regs
, &fpu
);
1238 if (!prstatus
.pr_fpvalid
)
1244 notes
[3].name
= "CORE";
1245 notes
[3].type
= NT_PRFPREG
;
1246 notes
[3].datasz
= sizeof(fpu
);
1247 notes
[3].data
= &fpu
;
1250 /* Write notes phdr entry */
1252 struct elf_phdr phdr
;
1255 for(i
= 0; i
< numnote
; i
++)
1256 sz
+= notesize(¬es
[i
]);
1258 phdr
.p_type
= PT_NOTE
;
1259 phdr
.p_offset
= offset
;
1267 offset
+= phdr
.p_filesz
;
1268 DUMP_WRITE(&phdr
, sizeof(phdr
));
1271 /* Page-align dumped data */
1272 dataoff
= offset
= roundup(offset
, ELF_EXEC_PAGESIZE
);
1274 /* Write program headers for segments dump */
1275 for(vma
= current
->mm
->mmap
, i
= 0;
1276 i
< segs
&& vma
!= NULL
; vma
= vma
->vm_next
) {
1277 struct elf_phdr phdr
;
1282 sz
= vma
->vm_end
- vma
->vm_start
;
1284 phdr
.p_type
= PT_LOAD
;
1285 phdr
.p_offset
= offset
;
1286 phdr
.p_vaddr
= vma
->vm_start
;
1288 phdr
.p_filesz
= maydump(vma
) ? sz
: 0;
1290 offset
+= phdr
.p_filesz
;
1291 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1292 if (vma
->vm_flags
& VM_WRITE
) phdr
.p_flags
|= PF_W
;
1293 if (vma
->vm_flags
& VM_EXEC
) phdr
.p_flags
|= PF_X
;
1294 phdr
.p_align
= ELF_EXEC_PAGESIZE
;
1296 DUMP_WRITE(&phdr
, sizeof(phdr
));
1299 for(i
= 0; i
< numnote
; i
++)
1300 if (!writenote(¬es
[i
], &file
))
1301 goto close_coredump
;
1307 for(i
= 0, vma
= current
->mm
->mmap
;
1308 i
< segs
&& vma
!= NULL
;
1309 vma
= vma
->vm_next
) {
1310 unsigned long addr
= vma
->vm_start
;
1311 unsigned long len
= vma
->vm_end
- vma
->vm_start
;
1317 printk("elf_core_dump: writing %08lx %lx\n", addr
, len
);
1319 DUMP_WRITE((void *)addr
, len
);
1322 if ((off_t
) file
.f_pos
!= offset
) {
1324 printk("elf_core_dump: file.f_pos (%ld) != offset (%ld)\n",
1325 (off_t
) file
.f_pos
, offset
);
1329 if (file
.f_op
->release
)
1330 file
.f_op
->release(inode
,&file
);
1335 #ifndef CONFIG_BINFMT_ELF
1340 #endif /* USE_ELF_CORE_DUMP */
1342 int __init
init_elf_binfmt(void)
1344 return register_binfmt(&elf_format
);
1349 int init_module(void)
1351 /* Install the COFF, ELF and XOUT loaders.
1352 * N.B. We *rely* on the table being the right size with the
1353 * right number of free slots...
1355 return init_elf_binfmt();
1359 void cleanup_module( void)
1361 /* Remove the COFF and ELF loaders. */
1362 unregister_binfmt(&elf_format
);