2 * irixelf.c: Code to load IRIX ELF executables which conform to
5 * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
7 * Based upon work which is:
8 * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
11 #include <linux/module.h>
14 #include <linux/stat.h>
15 #include <linux/sched.h>
17 #include <linux/mman.h>
18 #include <linux/a.out.h>
19 #include <linux/errno.h>
20 #include <linux/init.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/smp_lock.h>
33 #include <asm/uaccess.h>
34 #include <asm/pgalloc.h>
35 #include <asm/mipsregs.h>
36 #include <asm/prctl.h>
38 #define DLINFO_ITEMS 12
40 #include <linux/elf.h>
44 static int load_irix_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
);
45 static int load_irix_library(struct file
*);
46 static int irix_core_dump(long signr
, struct pt_regs
* regs
,
48 extern int dump_fpu (elf_fpregset_t
*);
50 static struct linux_binfmt irix_format
= {
51 NULL
, THIS_MODULE
, load_irix_binary
, load_irix_library
,
52 irix_core_dump
, PAGE_SIZE
56 #define elf_addr_t unsigned long
57 #define elf_caddr_t char *
61 /* Debugging routines. */
62 static char *get_elf_p_type(Elf32_Word p_type
)
67 case PT_NULL
: return("PT_NULL"); break;
68 case PT_LOAD
: return("PT_LOAD"); break;
69 case PT_DYNAMIC
: return("PT_DYNAMIC"); break;
70 case PT_INTERP
: return("PT_INTERP"); break;
71 case PT_NOTE
: return("PT_NOTE"); break;
72 case PT_SHLIB
: return("PT_SHLIB"); break;
73 case PT_PHDR
: return("PT_PHDR"); break;
74 case PT_LOPROC
: return("PT_LOPROC/REGINFO"); break;
75 case PT_HIPROC
: return("PT_HIPROC"); break;
76 default: return("PT_BOGUS"); break;
80 static void print_elfhdr(struct elfhdr
*ehp
)
84 printk("ELFHDR: e_ident<");
85 for(i
= 0; i
< (EI_NIDENT
- 1); i
++) printk("%x ", ehp
->e_ident
[i
]);
86 printk("%x>\n", ehp
->e_ident
[i
]);
87 printk(" e_type[%04x] e_machine[%04x] e_version[%08lx]\n",
88 (unsigned short) ehp
->e_type
, (unsigned short) ehp
->e_machine
,
89 (unsigned long) ehp
->e_version
);
90 printk(" e_entry[%08lx] e_phoff[%08lx] e_shoff[%08lx] "
92 (unsigned long) ehp
->e_entry
, (unsigned long) ehp
->e_phoff
,
93 (unsigned long) ehp
->e_shoff
, (unsigned long) ehp
->e_flags
);
94 printk(" e_ehsize[%04x] e_phentsize[%04x] e_phnum[%04x]\n",
95 (unsigned short) ehp
->e_ehsize
, (unsigned short) ehp
->e_phentsize
,
96 (unsigned short) ehp
->e_phnum
);
97 printk(" e_shentsize[%04x] e_shnum[%04x] e_shstrndx[%04x]\n",
98 (unsigned short) ehp
->e_shentsize
, (unsigned short) ehp
->e_shnum
,
99 (unsigned short) ehp
->e_shstrndx
);
102 static void print_phdr(int i
, struct elf_phdr
*ep
)
104 printk("PHDR[%d]: p_type[%s] p_offset[%08lx] p_vaddr[%08lx] "
105 "p_paddr[%08lx]\n", i
, get_elf_p_type(ep
->p_type
),
106 (unsigned long) ep
->p_offset
, (unsigned long) ep
->p_vaddr
,
107 (unsigned long) ep
->p_paddr
);
108 printk(" p_filesz[%08lx] p_memsz[%08lx] p_flags[%08lx] "
109 "p_align[%08lx]\n", (unsigned long) ep
->p_filesz
,
110 (unsigned long) ep
->p_memsz
, (unsigned long) ep
->p_flags
,
111 (unsigned long) ep
->p_align
);
114 static void dump_phdrs(struct elf_phdr
*ep
, int pnum
)
118 for(i
= 0; i
< pnum
; i
++, ep
++) {
119 if((ep
->p_type
== PT_LOAD
) ||
120 (ep
->p_type
== PT_INTERP
) ||
121 (ep
->p_type
== PT_PHDR
))
125 #endif /* (DEBUG_ELF) */
127 static void set_brk(unsigned long start
, unsigned long end
)
129 start
= PAGE_ALIGN(start
);
130 end
= PAGE_ALIGN(end
);
133 do_brk(start
, end
- start
);
137 /* We need to explicitly zero any fractional pages
138 * after the data section (i.e. bss). This would
139 * contain the junk from the file that should not
142 static void padzero(unsigned long elf_bss
)
146 nbyte
= elf_bss
& (PAGE_SIZE
-1);
148 nbyte
= PAGE_SIZE
- nbyte
;
149 clear_user((void *) elf_bss
, nbyte
);
153 unsigned long * create_irix_tables(char * p
, int argc
, int envc
,
154 struct elfhdr
* exec
, unsigned int load_addr
,
155 unsigned int interp_load_addr
,
156 struct pt_regs
*regs
, struct elf_phdr
*ephdr
)
160 elf_addr_t
*sp
, *csp
;
163 printk("create_irix_tables: p[%p] argc[%d] envc[%d] "
164 "load_addr[%08x] interp_load_addr[%08x]\n",
165 p
, argc
, envc
, load_addr
, interp_load_addr
);
167 sp
= (elf_addr_t
*) (~15UL & (unsigned long) p
);
169 csp
-= exec
? DLINFO_ITEMS
*2 : 2;
172 csp
-= 1; /* argc itself */
173 if ((unsigned long)csp
& 15UL) {
174 sp
-= (16UL - ((unsigned long)csp
& 15UL)) / sizeof(*sp
);
178 * Put the ELF interpreter info on the stack
180 #define NEW_AUX_ENT(nr, id, val) \
181 __put_user ((id), sp+(nr*2)); \
182 __put_user ((val), sp+(nr*2+1)); \
185 NEW_AUX_ENT(0, AT_NULL
, 0);
190 NEW_AUX_ENT (0, AT_PHDR
, load_addr
+ exec
->e_phoff
);
191 NEW_AUX_ENT (1, AT_PHENT
, sizeof (struct elf_phdr
));
192 NEW_AUX_ENT (2, AT_PHNUM
, exec
->e_phnum
);
193 NEW_AUX_ENT (3, AT_PAGESZ
, ELF_EXEC_PAGESIZE
);
194 NEW_AUX_ENT (4, AT_BASE
, interp_load_addr
);
195 NEW_AUX_ENT (5, AT_FLAGS
, 0);
196 NEW_AUX_ENT (6, AT_ENTRY
, (elf_addr_t
) exec
->e_entry
);
197 NEW_AUX_ENT (7, AT_UID
, (elf_addr_t
) current
->uid
);
198 NEW_AUX_ENT (8, AT_EUID
, (elf_addr_t
) current
->euid
);
199 NEW_AUX_ENT (9, AT_GID
, (elf_addr_t
) current
->gid
);
200 NEW_AUX_ENT (10, AT_EGID
, (elf_addr_t
) current
->egid
);
205 envp
= (elf_caddr_t
*) sp
;
207 argv
= (elf_caddr_t
*) sp
;
209 __put_user((elf_addr_t
)argc
,--sp
);
210 current
->mm
->arg_start
= (unsigned long) p
;
212 __put_user((elf_caddr_t
)(unsigned long)p
,argv
++);
215 __put_user(NULL
, argv
);
216 current
->mm
->arg_end
= current
->mm
->env_start
= (unsigned long) p
;
218 __put_user((elf_caddr_t
)(unsigned long)p
,envp
++);
221 __put_user(NULL
, envp
);
222 current
->mm
->env_end
= (unsigned long) p
;
227 /* This is much more generalized than the library routine read function,
228 * so we keep this separate. Technically the library read function
229 * is only provided so that we can read a.out libraries that have
232 static unsigned int load_irix_interp(struct elfhdr
* interp_elf_ex
,
233 struct file
* interpreter
,
234 unsigned int *interp_load_addr
)
236 struct elf_phdr
*elf_phdata
= NULL
;
237 struct elf_phdr
*eppnt
;
239 unsigned int load_addr
;
242 unsigned int last_bss
;
249 error
= load_addr
= 0;
252 print_elfhdr(interp_elf_ex
);
255 /* First of all, some simple consistency checks */
256 if ((interp_elf_ex
->e_type
!= ET_EXEC
&&
257 interp_elf_ex
->e_type
!= ET_DYN
) ||
258 !irix_elf_check_arch(interp_elf_ex
) ||
259 !interpreter
->f_op
->mmap
) {
260 printk("IRIX interp has bad e_type %d\n", interp_elf_ex
->e_type
);
264 /* Now read in all of the header information */
265 if(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
> PAGE_SIZE
) {
266 printk("IRIX interp header bigger than a page (%d)\n",
267 (sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
));
271 elf_phdata
= (struct elf_phdr
*)
272 kmalloc(sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
,
276 printk("Cannot kmalloc phdata for IRIX interp.\n");
280 /* If the size of this structure has changed, then punt, since
281 * we will be doing the wrong thing.
283 if(interp_elf_ex
->e_phentsize
!= 32) {
284 printk("IRIX interp e_phentsize == %d != 32 ",
285 interp_elf_ex
->e_phentsize
);
290 retval
= kernel_read(interpreter
, interp_elf_ex
->e_phoff
,
292 sizeof(struct elf_phdr
) * interp_elf_ex
->e_phnum
);
295 dump_phdrs(elf_phdata
, interp_elf_ex
->e_phnum
);
299 for(i
=0; i
<interp_elf_ex
->e_phnum
; i
++, eppnt
++) {
300 if(eppnt
->p_type
== PT_LOAD
) {
301 int elf_type
= MAP_PRIVATE
| MAP_DENYWRITE
;
303 unsigned long vaddr
= 0;
304 if (eppnt
->p_flags
& PF_R
) elf_prot
= PROT_READ
;
305 if (eppnt
->p_flags
& PF_W
) elf_prot
|= PROT_WRITE
;
306 if (eppnt
->p_flags
& PF_X
) elf_prot
|= PROT_EXEC
;
307 elf_type
|= MAP_FIXED
;
308 vaddr
= eppnt
->p_vaddr
;
311 printk("INTERP do_mmap(%p, %08lx, %08lx, %08lx, %08lx, %08lx) ",
313 (unsigned long) (eppnt
->p_filesz
+ (eppnt
->p_vaddr
& 0xfff)),
314 (unsigned long) elf_prot
, (unsigned long) elf_type
,
315 (unsigned long) (eppnt
->p_offset
& 0xfffff000));
317 down(¤t
->mm
->mmap_sem
);
318 error
= do_mmap(interpreter
, vaddr
,
319 eppnt
->p_filesz
+ (eppnt
->p_vaddr
& 0xfff),
321 eppnt
->p_offset
& 0xfffff000);
322 up(¤t
->mm
->mmap_sem
);
324 if(error
< 0 && error
> -1024) {
325 printk("Aieee IRIX interp mmap error=%d\n", error
);
326 break; /* Real error */
329 printk("error=%08lx ", (unsigned long) error
);
331 if(!load_addr
&& interp_elf_ex
->e_type
== ET_DYN
) {
334 printk("load_addr = error ");
338 /* Find the end of the file mapping for this phdr, and keep
339 * track of the largest address we see for this.
341 k
= eppnt
->p_vaddr
+ eppnt
->p_filesz
;
342 if(k
> elf_bss
) elf_bss
= k
;
344 /* Do the same thing for the memory mapping - between
345 * elf_bss and last_bss is the bss section.
347 k
= eppnt
->p_memsz
+ eppnt
->p_vaddr
;
348 if(k
> last_bss
) last_bss
= k
;
355 /* Now use mmap to map the library into memory. */
356 if(error
< 0 && error
> -1024) {
358 printk("got error %d\n", error
);
364 /* Now fill out the bss section. First pad the last page up
365 * to the page boundary, and then perform a mmap to make sure
366 * that there are zero-mapped pages up to and including the
370 printk("padzero(%08lx) ", (unsigned long) (elf_bss
));
373 len
= (elf_bss
+ 0xfff) & 0xfffff000; /* What we have mapped so far */
376 printk("last_bss[%08lx] len[%08lx]\n", (unsigned long) last_bss
,
377 (unsigned long) len
);
380 /* Map the last of the bss segment */
381 if (last_bss
> len
) {
382 do_brk(len
, (last_bss
- len
));
386 *interp_load_addr
= load_addr
;
387 return ((unsigned int) interp_elf_ex
->e_entry
);
390 /* Check sanity of IRIX elf executable header. */
391 static int verify_binary(struct elfhdr
*ehp
, struct linux_binprm
*bprm
)
393 if (memcmp(ehp
->e_ident
, ELFMAG
, SELFMAG
) != 0)
396 /* First of all, some simple consistency checks */
397 if((ehp
->e_type
!= ET_EXEC
&& ehp
->e_type
!= ET_DYN
) ||
398 !irix_elf_check_arch(ehp
) || !bprm
->file
->f_op
->mmap
) {
402 /* Only support MIPS ARCH2 or greater IRIX binaries for now. */
403 if(!(ehp
->e_flags
& EF_MIPS_ARCH
) && !(ehp
->e_flags
& 0x04)) {
407 /* XXX Don't support N32 or 64bit binaries yet because they can
408 * XXX and do execute 64 bit instructions and expect all registers
409 * XXX to be 64 bit as well. We need to make the kernel save
410 * XXX all registers as 64bits on cpu's capable of this at
411 * XXX exception time plus frob the XTLB exception vector.
413 if((ehp
->e_flags
& 0x20)) {
417 return 0; /* It's ok. */
420 #define IRIX_INTERP_PREFIX "/usr/gnemul/irix"
422 /* Look for an IRIX ELF interpreter. */
423 static inline int look_for_irix_interpreter(char **name
,
424 struct file
**interpreter
,
425 struct elfhdr
*interp_elf_ex
,
426 struct elf_phdr
*epp
,
427 struct linux_binprm
*bprm
, int pnum
)
430 int retval
= -EINVAL
;
431 struct file
*file
= NULL
;
434 for(i
= 0; i
< pnum
; i
++, epp
++) {
435 if (epp
->p_type
!= PT_INTERP
)
438 /* It is illegal to have two interpreters for one executable. */
442 *name
= (char *) kmalloc((epp
->p_filesz
+
443 strlen(IRIX_INTERP_PREFIX
)),
448 strcpy(*name
, IRIX_INTERP_PREFIX
);
449 retval
= kernel_read(bprm
->file
, epp
->p_offset
, (*name
+ 16),
454 file
= open_exec(*name
);
456 retval
= PTR_ERR(file
);
459 retval
= kernel_read(file
, 0, bprm
->buf
, 128);
463 *interp_elf_ex
= *(struct elfhdr
*) bprm
->buf
;
475 static inline int verify_irix_interpreter(struct elfhdr
*ihp
)
477 if (memcmp(ihp
->e_ident
, ELFMAG
, SELFMAG
) != 0)
482 #define EXEC_MAP_FLAGS (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE)
484 static inline void map_executable(struct file
*fp
, struct elf_phdr
*epp
, int pnum
,
485 unsigned int *estack
, unsigned int *laddr
,
486 unsigned int *scode
, unsigned int *ebss
,
487 unsigned int *ecode
, unsigned int *edata
,
493 for(i
= 0; i
< pnum
; i
++, epp
++) {
494 if(epp
->p_type
!= PT_LOAD
)
498 prot
= (epp
->p_flags
& PF_R
) ? PROT_READ
: 0;
499 prot
|= (epp
->p_flags
& PF_W
) ? PROT_WRITE
: 0;
500 prot
|= (epp
->p_flags
& PF_X
) ? PROT_EXEC
: 0;
501 down(¤t
->mm
->mmap_sem
);
502 (void) do_mmap(fp
, (epp
->p_vaddr
& 0xfffff000),
503 (epp
->p_filesz
+ (epp
->p_vaddr
& 0xfff)),
504 prot
, EXEC_MAP_FLAGS
,
505 (epp
->p_offset
& 0xfffff000));
506 up(¤t
->mm
->mmap_sem
);
508 /* Fixup location tracking vars. */
509 if((epp
->p_vaddr
& 0xfffff000) < *estack
)
510 *estack
= (epp
->p_vaddr
& 0xfffff000);
512 *laddr
= epp
->p_vaddr
- epp
->p_offset
;
513 if(epp
->p_vaddr
< *scode
)
514 *scode
= epp
->p_vaddr
;
516 tmp
= epp
->p_vaddr
+ epp
->p_filesz
;
519 if((epp
->p_flags
& PF_X
) && *ecode
< tmp
)
524 tmp
= epp
->p_vaddr
+ epp
->p_memsz
;
531 static inline int map_interpreter(struct elf_phdr
*epp
, struct elfhdr
*ihp
,
532 struct file
*interp
, unsigned int *iladdr
,
533 int pnum
, mm_segment_t old_fs
,
534 unsigned int *eentry
)
538 *eentry
= 0xffffffff;
539 for(i
= 0; i
< pnum
; i
++, epp
++) {
540 if(epp
->p_type
!= PT_INTERP
)
543 /* We should have fielded this error elsewhere... */
544 if(*eentry
!= 0xffffffff)
548 *eentry
= load_irix_interp(ihp
, interp
, iladdr
);
554 if (*eentry
== 0xffffffff)
561 * IRIX maps a page at 0x200000 that holds information about the
562 * process and the system, here we map the page and fill the
565 void irix_map_prda_page (void)
570 v
= do_brk (PRDA_ADDRESS
, PAGE_SIZE
);
575 pp
= (struct prda
*) v
;
576 pp
->prda_sys
.t_pid
= current
->pid
;
577 pp
->prda_sys
.t_prid
= read_32bit_cp0_register (CP0_PRID
);
578 pp
->prda_sys
.t_rpid
= current
->pid
;
580 /* We leave the rest set to zero */
585 /* These are the functions used to load ELF style executables and shared
586 * libraries. There is no binary dependent code anywhere else.
588 static int load_irix_binary(struct linux_binprm
* bprm
, struct pt_regs
* regs
)
590 struct elfhdr elf_ex
, interp_elf_ex
;
591 struct file
*interpreter
;
592 struct elf_phdr
*elf_phdata
, *elf_ihdr
, *elf_ephdr
;
593 unsigned int load_addr
, elf_bss
, elf_brk
;
594 unsigned int elf_entry
, interp_load_addr
= 0;
595 unsigned int start_code
, end_code
, end_data
, elf_stack
;
596 int retval
, has_interp
, has_ephdr
, size
, i
;
597 char *elf_interpreter
;
601 has_interp
= has_ephdr
= 0;
602 elf_ihdr
= elf_ephdr
= 0;
603 elf_ex
= *((struct elfhdr
*) bprm
->buf
);
606 if (verify_binary(&elf_ex
, bprm
))
610 print_elfhdr(&elf_ex
);
613 /* Now read in all of the header information */
614 size
= elf_ex
.e_phentsize
* elf_ex
.e_phnum
;
617 elf_phdata
= (struct elf_phdr
*) kmalloc(size
, GFP_KERNEL
);
618 if (elf_phdata
== NULL
) {
623 retval
= kernel_read(bprm
->file
, elf_ex
.e_phoff
, (char *)elf_phdata
, size
);
628 dump_phdrs(elf_phdata
, elf_ex
.e_phnum
);
631 /* Set some things for later. */
632 for(i
= 0; i
< elf_ex
.e_phnum
; i
++) {
633 switch(elf_phdata
[i
].p_type
) {
636 elf_ihdr
= &elf_phdata
[i
];
640 elf_ephdr
= &elf_phdata
[i
];
651 elf_stack
= 0xffffffff;
652 elf_interpreter
= NULL
;
653 start_code
= 0xffffffff;
657 retval
= look_for_irix_interpreter(&elf_interpreter
,
659 &interp_elf_ex
, elf_phdata
, bprm
,
664 if (elf_interpreter
) {
665 retval
= verify_irix_interpreter(&interp_elf_ex
);
667 goto out_free_interp
;
670 /* OK, we are done with that, now set up the arg stuff,
671 * and then start this sucker up.
674 if (!bprm
->sh_bang
&& !bprm
->p
)
675 goto out_free_interp
;
677 /* Flush all traces of the currently running executable */
678 retval
= flush_old_exec(bprm
);
680 goto out_free_dentry
;
682 /* OK, This is the point of no return */
683 current
->mm
->end_data
= 0;
684 current
->mm
->end_code
= 0;
685 current
->mm
->mmap
= NULL
;
686 current
->flags
&= ~PF_FORKNOEXEC
;
687 elf_entry
= (unsigned int) elf_ex
.e_entry
;
689 /* Do this so that we can load the interpreter, if need be. We will
690 * change some of these later.
692 current
->mm
->rss
= 0;
693 setup_arg_pages(bprm
);
694 current
->mm
->start_stack
= bprm
->p
;
696 /* At this point, we assume that the image should be loaded at
697 * fixed address, not at a variable address.
702 map_executable(bprm
->file
, elf_phdata
, elf_ex
.e_phnum
, &elf_stack
,
703 &load_addr
, &start_code
, &elf_bss
, &end_code
,
704 &end_data
, &elf_brk
);
706 if(elf_interpreter
) {
707 retval
= map_interpreter(elf_phdata
, &interp_elf_ex
,
708 interpreter
, &interp_load_addr
,
709 elf_ex
.e_phnum
, old_fs
, &elf_entry
);
710 kfree(elf_interpreter
);
713 printk("Unable to load IRIX ELF interpreter\n");
714 send_sig(SIGSEGV
, current
, 0);
723 set_personality(PER_IRIX32
);
724 set_binfmt(&irix_format
);
726 current
->flags
&= ~PF_FORKNOEXEC
;
727 bprm
->p
= (unsigned long)
728 create_irix_tables((char *)bprm
->p
, bprm
->argc
, bprm
->envc
,
729 (elf_interpreter
? &elf_ex
: NULL
),
730 load_addr
, interp_load_addr
, regs
, elf_ephdr
);
731 current
->mm
->start_brk
= current
->mm
->brk
= elf_brk
;
732 current
->mm
->end_code
= end_code
;
733 current
->mm
->start_code
= start_code
;
734 current
->mm
->end_data
= end_data
;
735 current
->mm
->start_stack
= bprm
->p
;
737 /* Calling set_brk effectively mmaps the pages that we need for the
738 * bss and break sections.
740 set_brk(elf_bss
, elf_brk
);
743 * IRIX maps a page at 0x200000 which holds some system
744 * information. Programs depend on this.
746 irix_map_prda_page ();
751 printk("(start_brk) %lx\n" , (long) current
->mm
->start_brk
);
752 printk("(end_code) %lx\n" , (long) current
->mm
->end_code
);
753 printk("(start_code) %lx\n" , (long) current
->mm
->start_code
);
754 printk("(end_data) %lx\n" , (long) current
->mm
->end_data
);
755 printk("(start_stack) %lx\n" , (long) current
->mm
->start_stack
);
756 printk("(brk) %lx\n" , (long) current
->mm
->brk
);
759 #if 0 /* XXX No fucking way dude... */
760 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
761 * and some applications "depend" upon this behavior.
762 * Since we do not have the power to recompile these, we
763 * emulate the SVr4 behavior. Sigh.
765 down(¤t
->mm
->mmap_sem
);
766 (void) do_mmap(NULL
, 0, 4096, PROT_READ
| PROT_EXEC
,
767 MAP_FIXED
| MAP_PRIVATE
, 0);
768 up(¤t
->mm
->mmap_sem
);
771 start_thread(regs
, elf_entry
, bprm
->p
);
772 if (current
->ptrace
& PT_PTRACED
)
773 send_sig(SIGTRAP
, current
, 0);
779 allow_write_access(interpreter
);
783 kfree(elf_interpreter
);
790 /* This is really simpleminded and specialized - we are loading an
791 * a.out library that is given an ELF header.
793 static int load_irix_library(struct file
*file
)
795 struct elfhdr elf_ex
;
796 struct elf_phdr
*elf_phdata
= NULL
;
797 unsigned int len
= 0;
804 error
= kernel_read(file
, 0, (char *) &elf_ex
, sizeof(elf_ex
));
805 if (error
!= sizeof(elf_ex
))
808 if (memcmp(elf_ex
.e_ident
, ELFMAG
, SELFMAG
) != 0)
811 /* First of all, some simple consistency checks. */
812 if(elf_ex
.e_type
!= ET_EXEC
|| elf_ex
.e_phnum
> 2 ||
813 !irix_elf_check_arch(&elf_ex
) || !file
->f_op
->mmap
)
816 /* Now read in all of the header information. */
817 if(sizeof(struct elf_phdr
) * elf_ex
.e_phnum
> PAGE_SIZE
)
820 elf_phdata
= (struct elf_phdr
*)
821 kmalloc(sizeof(struct elf_phdr
) * elf_ex
.e_phnum
, GFP_KERNEL
);
822 if (elf_phdata
== NULL
)
825 retval
= kernel_read(file
, elf_ex
.e_phoff
, (char *) elf_phdata
,
826 sizeof(struct elf_phdr
) * elf_ex
.e_phnum
);
829 for(i
=0; i
<elf_ex
.e_phnum
; i
++)
830 if((elf_phdata
+ i
)->p_type
== PT_LOAD
) j
++;
837 while(elf_phdata
->p_type
!= PT_LOAD
) elf_phdata
++;
839 /* Now use mmap to map the library into memory. */
840 down(¤t
->mm
->mmap_sem
);
841 error
= do_mmap(file
,
842 elf_phdata
->p_vaddr
& 0xfffff000,
843 elf_phdata
->p_filesz
+ (elf_phdata
->p_vaddr
& 0xfff),
844 PROT_READ
| PROT_WRITE
| PROT_EXEC
,
845 MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
,
846 elf_phdata
->p_offset
& 0xfffff000);
847 up(¤t
->mm
->mmap_sem
);
849 k
= elf_phdata
->p_vaddr
+ elf_phdata
->p_filesz
;
850 if (k
> elf_bss
) elf_bss
= k
;
852 if (error
!= (elf_phdata
->p_vaddr
& 0xfffff000)) {
859 len
= (elf_phdata
->p_filesz
+ elf_phdata
->p_vaddr
+ 0xfff) & 0xfffff000;
860 bss
= elf_phdata
->p_memsz
+ elf_phdata
->p_vaddr
;
862 do_brk(len
, bss
-len
);
867 /* Called through irix_syssgi() to map an elf image given an FD,
868 * a phdr ptr USER_PHDRP in userspace, and a count CNT telling how many
869 * phdrs there are in the USER_PHDRP array. We return the vaddr the
870 * first phdr was successfully mapped to.
872 unsigned long irix_mapelf(int fd
, struct elf_phdr
*user_phdrp
, int cnt
)
879 printk("irix_mapelf: fd[%d] user_phdrp[%p] cnt[%d]\n",
880 fd
, user_phdrp
, cnt
);
883 /* First get the verification out of the way. */
885 retval
= verify_area(VERIFY_READ
, hp
, (sizeof(struct elf_phdr
) * cnt
));
888 printk("irix_mapelf: verify_area fails!\n");
894 dump_phdrs(user_phdrp
, cnt
);
897 for(i
= 0; i
< cnt
; i
++, hp
++)
898 if(hp
->p_type
!= PT_LOAD
) {
899 printk("irix_mapelf: One section is not PT_LOAD!\n");
907 printk("irix_mapelf: Bogon filp!\n");
913 for(i
= 0; i
< cnt
; i
++, hp
++) {
916 prot
= (hp
->p_flags
& PF_R
) ? PROT_READ
: 0;
917 prot
|= (hp
->p_flags
& PF_W
) ? PROT_WRITE
: 0;
918 prot
|= (hp
->p_flags
& PF_X
) ? PROT_EXEC
: 0;
919 down(¤t
->mm
->mmap_sem
);
920 retval
= do_mmap(filp
, (hp
->p_vaddr
& 0xfffff000),
921 (hp
->p_filesz
+ (hp
->p_vaddr
& 0xfff)),
922 prot
, (MAP_FIXED
| MAP_PRIVATE
| MAP_DENYWRITE
),
923 (hp
->p_offset
& 0xfffff000));
924 up(¤t
->mm
->mmap_sem
);
926 if(retval
!= (hp
->p_vaddr
& 0xfffff000)) {
927 printk("irix_mapelf: do_mmap fails with %d!\n", retval
);
934 printk("irix_mapelf: Success, returning %08lx\n", user_phdrp
->p_vaddr
);
937 return user_phdrp
->p_vaddr
;
943 * Modelled on fs/exec.c:aout_core_dump()
944 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
947 /* These are the only things you should do on a core-file: use only these
948 * functions to write out all the necessary info.
950 static int dump_write(struct file
*file
, const void *addr
, int nr
)
952 return file
->f_op
->write(file
, addr
, nr
, &file
->f_pos
) == nr
;
955 static int dump_seek(struct file
*file
, off_t off
)
957 if (file
->f_op
->llseek
) {
958 if (file
->f_op
->llseek(file
, off
, 0) != off
)
965 /* Decide whether a segment is worth dumping; default is yes to be
966 * sure (missing info is worse than too much; etc).
967 * Personally I'd include everything, and use the coredump limit...
969 * I think we should skip something. But I am not sure how. H.J.
971 static inline int maydump(struct vm_area_struct
*vma
)
973 if (!(vma
->vm_flags
& (VM_READ
|VM_WRITE
|VM_EXEC
)))
976 if (vma
->vm_flags
& (VM_WRITE
|VM_GROWSUP
|VM_GROWSDOWN
))
978 if (vma
->vm_flags
& (VM_READ
|VM_EXEC
|VM_EXECUTABLE
|VM_SHARED
))
984 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
986 /* An ELF note in memory. */
995 static int notesize(struct memelfnote
*en
)
999 sz
= sizeof(struct elf_note
);
1000 sz
+= roundup(strlen(en
->name
), 4);
1001 sz
+= roundup(en
->datasz
, 4);
1008 #define DUMP_WRITE(addr, nr) \
1009 if (!dump_write(file, (addr), (nr))) \
1011 #define DUMP_SEEK(off) \
1012 if (!dump_seek(file, (off))) \
1015 static int writenote(struct memelfnote
*men
, struct file
*file
)
1019 en
.n_namesz
= strlen(men
->name
);
1020 en
.n_descsz
= men
->datasz
;
1021 en
.n_type
= men
->type
;
1023 DUMP_WRITE(&en
, sizeof(en
));
1024 DUMP_WRITE(men
->name
, en
.n_namesz
);
1025 /* XXX - cast from long long to long to avoid need for libgcc.a */
1026 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1027 DUMP_WRITE(men
->data
, men
->datasz
);
1028 DUMP_SEEK(roundup((unsigned long)file
->f_pos
, 4)); /* XXX */
1038 #define DUMP_WRITE(addr, nr) \
1039 if (!dump_write(file, (addr), (nr))) \
1041 #define DUMP_SEEK(off) \
1042 if (!dump_seek(file, (off))) \
1047 * This is a two-pass process; first we find the offsets of the bits,
1048 * and then they are actually written out. If we run out of core limit
1051 static int irix_core_dump(long signr
, struct pt_regs
* regs
, struct file
*file
)
1058 struct vm_area_struct
*vma
;
1060 off_t offset
= 0, dataoff
;
1061 int 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 /* Count what's needed to dump, up to the limit of coredump size. */
1071 for(vma
= current
->mm
->mmap
; vma
!= NULL
; vma
= vma
->vm_next
) {
1074 int sz
= vma
->vm_end
-vma
->vm_start
;
1076 if (size
+sz
>= limit
)
1085 printk("irix_core_dump: %d segs taking %d bytes\n", segs
, size
);
1088 /* Set up header. */
1089 memcpy(elf
.e_ident
, ELFMAG
, SELFMAG
);
1090 elf
.e_ident
[EI_CLASS
] = ELFCLASS32
;
1091 elf
.e_ident
[EI_DATA
] = ELFDATA2LSB
;
1092 elf
.e_ident
[EI_VERSION
] = EV_CURRENT
;
1093 memset(elf
.e_ident
+EI_PAD
, 0, EI_NIDENT
-EI_PAD
);
1095 elf
.e_type
= ET_CORE
;
1096 elf
.e_machine
= ELF_ARCH
;
1097 elf
.e_version
= EV_CURRENT
;
1099 elf
.e_phoff
= sizeof(elf
);
1102 elf
.e_ehsize
= sizeof(elf
);
1103 elf
.e_phentsize
= sizeof(struct elf_phdr
);
1104 elf
.e_phnum
= segs
+1; /* Include notes. */
1105 elf
.e_shentsize
= 0;
1113 current
->flags
|= PF_DUMPCORE
;
1115 DUMP_WRITE(&elf
, sizeof(elf
));
1116 offset
+= sizeof(elf
); /* Elf header. */
1117 offset
+= (segs
+1) * sizeof(struct elf_phdr
); /* Program headers. */
1119 /* Set up the notes in similar form to SVR4 core dumps made
1120 * with info from their /proc.
1122 memset(&psinfo
, 0, sizeof(psinfo
));
1123 memset(&prstatus
, 0, sizeof(prstatus
));
1125 notes
[0].name
= "CORE";
1126 notes
[0].type
= NT_PRSTATUS
;
1127 notes
[0].datasz
= sizeof(prstatus
);
1128 notes
[0].data
= &prstatus
;
1129 prstatus
.pr_info
.si_signo
= prstatus
.pr_cursig
= signr
;
1130 prstatus
.pr_sigpend
= current
->signal
.sig
[0];
1131 prstatus
.pr_sighold
= current
->blocked
.sig
[0];
1132 psinfo
.pr_pid
= prstatus
.pr_pid
= current
->pid
;
1133 psinfo
.pr_ppid
= prstatus
.pr_ppid
= current
->p_pptr
->pid
;
1134 psinfo
.pr_pgrp
= prstatus
.pr_pgrp
= current
->pgrp
;
1135 psinfo
.pr_sid
= prstatus
.pr_sid
= current
->session
;
1136 prstatus
.pr_utime
.tv_sec
= CT_TO_SECS(current
->times
.tms_utime
);
1137 prstatus
.pr_utime
.tv_usec
= CT_TO_USECS(current
->times
.tms_utime
);
1138 prstatus
.pr_stime
.tv_sec
= CT_TO_SECS(current
->times
.tms_stime
);
1139 prstatus
.pr_stime
.tv_usec
= CT_TO_USECS(current
->times
.tms_stime
);
1140 prstatus
.pr_cutime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cutime
);
1141 prstatus
.pr_cutime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cutime
);
1142 prstatus
.pr_cstime
.tv_sec
= CT_TO_SECS(current
->times
.tms_cstime
);
1143 prstatus
.pr_cstime
.tv_usec
= CT_TO_USECS(current
->times
.tms_cstime
);
1144 if (sizeof(elf_gregset_t
) != sizeof(struct pt_regs
)) {
1145 printk("sizeof(elf_gregset_t) (%d) != sizeof(struct pt_regs) "
1146 "(%d)\n", sizeof(elf_gregset_t
), sizeof(struct pt_regs
));
1148 *(struct pt_regs
*)&prstatus
.pr_reg
= *regs
;
1151 notes
[1].name
= "CORE";
1152 notes
[1].type
= NT_PRPSINFO
;
1153 notes
[1].datasz
= sizeof(psinfo
);
1154 notes
[1].data
= &psinfo
;
1155 i
= current
->state
? ffz(~current
->state
) + 1 : 0;
1156 psinfo
.pr_state
= i
;
1157 psinfo
.pr_sname
= (i
< 0 || i
> 5) ? '.' : "RSDZTD"[i
];
1158 psinfo
.pr_zomb
= psinfo
.pr_sname
== 'Z';
1159 psinfo
.pr_nice
= current
->nice
;
1160 psinfo
.pr_flag
= current
->flags
;
1161 psinfo
.pr_uid
= current
->uid
;
1162 psinfo
.pr_gid
= current
->gid
;
1168 len
= current
->mm
->arg_end
- current
->mm
->arg_start
;
1169 len
= len
>= ELF_PRARGSZ
? ELF_PRARGSZ
: len
;
1170 copy_from_user(&psinfo
.pr_psargs
,
1171 (const char *)current
->mm
->arg_start
, len
);
1172 for(i
= 0; i
< len
; i
++)
1173 if (psinfo
.pr_psargs
[i
] == 0)
1174 psinfo
.pr_psargs
[i
] = ' ';
1175 psinfo
.pr_psargs
[len
] = 0;
1179 strncpy(psinfo
.pr_fname
, current
->comm
, sizeof(psinfo
.pr_fname
));
1181 notes
[2].name
= "CORE";
1182 notes
[2].type
= NT_TASKSTRUCT
;
1183 notes
[2].datasz
= sizeof(*current
);
1184 notes
[2].data
= current
;
1186 /* Try to dump the FPU. */
1187 prstatus
.pr_fpvalid
= dump_fpu (&fpu
);
1188 if (!prstatus
.pr_fpvalid
) {
1191 notes
[3].name
= "CORE";
1192 notes
[3].type
= NT_PRFPREG
;
1193 notes
[3].datasz
= sizeof(fpu
);
1194 notes
[3].data
= &fpu
;
1197 /* Write notes phdr entry. */
1199 struct elf_phdr phdr
;
1202 for(i
= 0; i
< numnote
; i
++)
1203 sz
+= notesize(¬es
[i
]);
1205 phdr
.p_type
= PT_NOTE
;
1206 phdr
.p_offset
= offset
;
1214 offset
+= phdr
.p_filesz
;
1215 DUMP_WRITE(&phdr
, sizeof(phdr
));
1218 /* Page-align dumped data. */
1219 dataoff
= offset
= roundup(offset
, PAGE_SIZE
);
1221 /* Write program headers for segments dump. */
1222 for(vma
= current
->mm
->mmap
, i
= 0;
1223 i
< segs
&& vma
!= NULL
; vma
= vma
->vm_next
) {
1224 struct elf_phdr phdr
;
1229 sz
= vma
->vm_end
- vma
->vm_start
;
1231 phdr
.p_type
= PT_LOAD
;
1232 phdr
.p_offset
= offset
;
1233 phdr
.p_vaddr
= vma
->vm_start
;
1235 phdr
.p_filesz
= maydump(vma
) ? sz
: 0;
1237 offset
+= phdr
.p_filesz
;
1238 phdr
.p_flags
= vma
->vm_flags
& VM_READ
? PF_R
: 0;
1239 if (vma
->vm_flags
& VM_WRITE
) phdr
.p_flags
|= PF_W
;
1240 if (vma
->vm_flags
& VM_EXEC
) phdr
.p_flags
|= PF_X
;
1241 phdr
.p_align
= PAGE_SIZE
;
1243 DUMP_WRITE(&phdr
, sizeof(phdr
));
1246 for(i
= 0; i
< numnote
; i
++)
1247 if (!writenote(¬es
[i
], file
))
1254 for(i
= 0, vma
= current
->mm
->mmap
;
1255 i
< segs
&& vma
!= NULL
;
1256 vma
= vma
->vm_next
) {
1257 unsigned long addr
= vma
->vm_start
;
1258 unsigned long len
= vma
->vm_end
- vma
->vm_start
;
1264 printk("elf_core_dump: writing %08lx %lx\n", addr
, len
);
1266 DUMP_WRITE((void *)addr
, len
);
1269 if ((off_t
) file
->f_pos
!= offset
) {
1271 printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1272 (off_t
) file
->f_pos
, offset
);
1280 static int __init
init_irix_binfmt(void)
1282 return register_binfmt(&irix_format
);
1285 static void __exit
exit_irix_binfmt(void)
1287 /* Remove the IRIX ELF loaders. */
1288 unregister_binfmt(&irix_format
);
1291 module_init(init_irix_binfmt
)
1292 module_exit(exit_irix_binfmt
)