Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * This file is subject to the terms and conditions of the GNU General Public | |
3 | * License. See the file "COPYING" in the main directory of this archive | |
4 | * for more details. | |
5 | * | |
6 | * irixelf.c: Code to load IRIX ELF executables conforming to the MIPS ABI. | |
7 | * Based off of work by Eric Youngdale. | |
8 | * | |
9 | * Copyright (C) 1993 - 1994 Eric Youngdale <ericy@cais.com> | |
10 | * Copyright (C) 1996 - 2004 David S. Miller <dm@engr.sgi.com> | |
11 | * Copyright (C) 2004 Steven J. Hill <sjhill@realitydiluted.com> | |
12 | */ | |
13 | #include <linux/module.h> | |
14 | #include <linux/fs.h> | |
15 | #include <linux/stat.h> | |
16 | #include <linux/sched.h> | |
17 | #include <linux/mm.h> | |
18 | #include <linux/mman.h> | |
19 | #include <linux/a.out.h> | |
20 | #include <linux/errno.h> | |
21 | #include <linux/init.h> | |
22 | #include <linux/signal.h> | |
23 | #include <linux/binfmts.h> | |
24 | #include <linux/string.h> | |
25 | #include <linux/file.h> | |
26 | #include <linux/fcntl.h> | |
27 | #include <linux/ptrace.h> | |
28 | #include <linux/slab.h> | |
29 | #include <linux/shm.h> | |
30 | #include <linux/personality.h> | |
31 | #include <linux/elfcore.h> | |
32 | #include <linux/smp_lock.h> | |
33 | ||
34 | #include <asm/uaccess.h> | |
35 | #include <asm/mipsregs.h> | |
36 | #include <asm/prctl.h> | |
37 | ||
38 | #define DLINFO_ITEMS 12 | |
39 | ||
40 | #include <linux/elf.h> | |
41 | ||
42 | #undef DEBUG_ELF | |
43 | ||
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, | |
47 | struct file *file); | |
48 | ||
49 | static struct linux_binfmt irix_format = { | |
50 | NULL, THIS_MODULE, load_irix_binary, load_irix_library, | |
51 | irix_core_dump, PAGE_SIZE | |
52 | }; | |
53 | ||
54 | #ifndef elf_addr_t | |
55 | #define elf_addr_t unsigned long | |
56 | #endif | |
57 | ||
58 | #ifdef DEBUG_ELF | |
59 | /* Debugging routines. */ | |
60 | static char *get_elf_p_type(Elf32_Word p_type) | |
61 | { | |
62 | int i = (int) p_type; | |
63 | ||
64 | switch(i) { | |
65 | case PT_NULL: return("PT_NULL"); break; | |
66 | case PT_LOAD: return("PT_LOAD"); break; | |
67 | case PT_DYNAMIC: return("PT_DYNAMIC"); break; | |
68 | case PT_INTERP: return("PT_INTERP"); break; | |
69 | case PT_NOTE: return("PT_NOTE"); break; | |
70 | case PT_SHLIB: return("PT_SHLIB"); break; | |
71 | case PT_PHDR: return("PT_PHDR"); break; | |
72 | case PT_LOPROC: return("PT_LOPROC/REGINFO"); break; | |
73 | case PT_HIPROC: return("PT_HIPROC"); break; | |
74 | default: return("PT_BOGUS"); break; | |
75 | } | |
76 | } | |
77 | ||
78 | static void print_elfhdr(struct elfhdr *ehp) | |
79 | { | |
80 | int i; | |
81 | ||
82 | printk("ELFHDR: e_ident<"); | |
83 | for(i = 0; i < (EI_NIDENT - 1); i++) printk("%x ", ehp->e_ident[i]); | |
84 | printk("%x>\n", ehp->e_ident[i]); | |
85 | printk(" e_type[%04x] e_machine[%04x] e_version[%08lx]\n", | |
86 | (unsigned short) ehp->e_type, (unsigned short) ehp->e_machine, | |
87 | (unsigned long) ehp->e_version); | |
88 | printk(" e_entry[%08lx] e_phoff[%08lx] e_shoff[%08lx] " | |
89 | "e_flags[%08lx]\n", | |
90 | (unsigned long) ehp->e_entry, (unsigned long) ehp->e_phoff, | |
91 | (unsigned long) ehp->e_shoff, (unsigned long) ehp->e_flags); | |
92 | printk(" e_ehsize[%04x] e_phentsize[%04x] e_phnum[%04x]\n", | |
93 | (unsigned short) ehp->e_ehsize, (unsigned short) ehp->e_phentsize, | |
94 | (unsigned short) ehp->e_phnum); | |
95 | printk(" e_shentsize[%04x] e_shnum[%04x] e_shstrndx[%04x]\n", | |
96 | (unsigned short) ehp->e_shentsize, (unsigned short) ehp->e_shnum, | |
97 | (unsigned short) ehp->e_shstrndx); | |
98 | } | |
99 | ||
100 | static void print_phdr(int i, struct elf_phdr *ep) | |
101 | { | |
102 | printk("PHDR[%d]: p_type[%s] p_offset[%08lx] p_vaddr[%08lx] " | |
103 | "p_paddr[%08lx]\n", i, get_elf_p_type(ep->p_type), | |
104 | (unsigned long) ep->p_offset, (unsigned long) ep->p_vaddr, | |
105 | (unsigned long) ep->p_paddr); | |
106 | printk(" p_filesz[%08lx] p_memsz[%08lx] p_flags[%08lx] " | |
107 | "p_align[%08lx]\n", (unsigned long) ep->p_filesz, | |
108 | (unsigned long) ep->p_memsz, (unsigned long) ep->p_flags, | |
109 | (unsigned long) ep->p_align); | |
110 | } | |
111 | ||
112 | static void dump_phdrs(struct elf_phdr *ep, int pnum) | |
113 | { | |
114 | int i; | |
115 | ||
116 | for(i = 0; i < pnum; i++, ep++) { | |
117 | if((ep->p_type == PT_LOAD) || | |
118 | (ep->p_type == PT_INTERP) || | |
119 | (ep->p_type == PT_PHDR)) | |
120 | print_phdr(i, ep); | |
121 | } | |
122 | } | |
123 | #endif /* (DEBUG_ELF) */ | |
124 | ||
125 | static void set_brk(unsigned long start, unsigned long end) | |
126 | { | |
127 | start = PAGE_ALIGN(start); | |
128 | end = PAGE_ALIGN(end); | |
129 | if (end <= start) | |
130 | return; | |
131 | down_write(¤t->mm->mmap_sem); | |
132 | do_brk(start, end - start); | |
133 | up_write(¤t->mm->mmap_sem); | |
134 | } | |
135 | ||
136 | ||
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 | |
140 | * be in memory. | |
141 | */ | |
142 | static void padzero(unsigned long elf_bss) | |
143 | { | |
144 | unsigned long nbyte; | |
145 | ||
146 | nbyte = elf_bss & (PAGE_SIZE-1); | |
147 | if (nbyte) { | |
148 | nbyte = PAGE_SIZE - nbyte; | |
149 | clear_user((void *) elf_bss, nbyte); | |
150 | } | |
151 | } | |
152 | ||
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) | |
157 | { | |
158 | elf_addr_t *argv; | |
159 | elf_addr_t *envp; | |
160 | elf_addr_t *sp, *csp; | |
161 | ||
162 | #ifdef DEBUG_ELF | |
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); | |
166 | #endif | |
167 | sp = (elf_addr_t *) (~15UL & (unsigned long) p); | |
168 | csp = sp; | |
169 | csp -= exec ? DLINFO_ITEMS*2 : 2; | |
170 | csp -= envc+1; | |
171 | csp -= argc+1; | |
172 | csp -= 1; /* argc itself */ | |
173 | if ((unsigned long)csp & 15UL) { | |
174 | sp -= (16UL - ((unsigned long)csp & 15UL)) / sizeof(*sp); | |
175 | } | |
176 | ||
177 | /* | |
178 | * Put the ELF interpreter info on the stack | |
179 | */ | |
180 | #define NEW_AUX_ENT(nr, id, val) \ | |
181 | __put_user ((id), sp+(nr*2)); \ | |
182 | __put_user ((val), sp+(nr*2+1)); \ | |
183 | ||
184 | sp -= 2; | |
185 | NEW_AUX_ENT(0, AT_NULL, 0); | |
186 | ||
187 | if(exec) { | |
188 | sp -= 11*2; | |
189 | ||
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); | |
201 | } | |
202 | #undef NEW_AUX_ENT | |
203 | ||
204 | sp -= envc+1; | |
205 | envp = sp; | |
206 | sp -= argc+1; | |
207 | argv = sp; | |
208 | ||
209 | __put_user((elf_addr_t)argc,--sp); | |
210 | current->mm->arg_start = (unsigned long) p; | |
211 | while (argc-->0) { | |
212 | __put_user((unsigned long)p,argv++); | |
213 | p += strlen_user(p); | |
214 | } | |
215 | __put_user((unsigned long) NULL, argv); | |
216 | current->mm->arg_end = current->mm->env_start = (unsigned long) p; | |
217 | while (envc-->0) { | |
218 | __put_user((unsigned long)p,envp++); | |
219 | p += strlen_user(p); | |
220 | } | |
221 | __put_user((unsigned long) NULL, envp); | |
222 | current->mm->env_end = (unsigned long) p; | |
223 | return sp; | |
224 | } | |
225 | ||
226 | ||
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 | |
230 | * an ELF header. | |
231 | */ | |
232 | static unsigned int load_irix_interp(struct elfhdr * interp_elf_ex, | |
233 | struct file * interpreter, | |
234 | unsigned int *interp_load_addr) | |
235 | { | |
236 | struct elf_phdr *elf_phdata = NULL; | |
237 | struct elf_phdr *eppnt; | |
238 | unsigned int len; | |
239 | unsigned int load_addr; | |
240 | int elf_bss; | |
241 | int retval; | |
242 | unsigned int last_bss; | |
243 | int error; | |
244 | int i; | |
245 | unsigned int k; | |
246 | ||
247 | elf_bss = 0; | |
248 | last_bss = 0; | |
249 | error = load_addr = 0; | |
250 | ||
251 | #ifdef DEBUG_ELF | |
252 | print_elfhdr(interp_elf_ex); | |
253 | #endif | |
254 | ||
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); | |
261 | return 0xffffffff; | |
262 | } | |
263 | ||
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)); | |
268 | return 0xffffffff; | |
269 | } | |
270 | ||
271 | elf_phdata = kmalloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum, | |
272 | GFP_KERNEL); | |
273 | ||
274 | if(!elf_phdata) { | |
275 | printk("Cannot kmalloc phdata for IRIX interp.\n"); | |
276 | return 0xffffffff; | |
277 | } | |
278 | ||
279 | /* If the size of this structure has changed, then punt, since | |
280 | * we will be doing the wrong thing. | |
281 | */ | |
282 | if(interp_elf_ex->e_phentsize != 32) { | |
283 | printk("IRIX interp e_phentsize == %d != 32 ", | |
284 | interp_elf_ex->e_phentsize); | |
285 | kfree(elf_phdata); | |
286 | return 0xffffffff; | |
287 | } | |
288 | ||
289 | retval = kernel_read(interpreter, interp_elf_ex->e_phoff, | |
290 | (char *) elf_phdata, | |
291 | sizeof(struct elf_phdr) * interp_elf_ex->e_phnum); | |
292 | ||
293 | #ifdef DEBUG_ELF | |
294 | dump_phdrs(elf_phdata, interp_elf_ex->e_phnum); | |
295 | #endif | |
296 | ||
297 | eppnt = elf_phdata; | |
298 | for(i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) { | |
299 | if(eppnt->p_type == PT_LOAD) { | |
300 | int elf_type = MAP_PRIVATE | MAP_DENYWRITE; | |
301 | int elf_prot = 0; | |
302 | unsigned long vaddr = 0; | |
303 | if (eppnt->p_flags & PF_R) elf_prot = PROT_READ; | |
304 | if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE; | |
305 | if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC; | |
306 | elf_type |= MAP_FIXED; | |
307 | vaddr = eppnt->p_vaddr; | |
308 | ||
309 | #ifdef DEBUG_ELF | |
310 | printk("INTERP do_mmap(%p, %08lx, %08lx, %08lx, %08lx, %08lx) ", | |
311 | interpreter, vaddr, | |
312 | (unsigned long) (eppnt->p_filesz + (eppnt->p_vaddr & 0xfff)), | |
313 | (unsigned long) elf_prot, (unsigned long) elf_type, | |
314 | (unsigned long) (eppnt->p_offset & 0xfffff000)); | |
315 | #endif | |
316 | down_write(¤t->mm->mmap_sem); | |
317 | error = do_mmap(interpreter, vaddr, | |
318 | eppnt->p_filesz + (eppnt->p_vaddr & 0xfff), | |
319 | elf_prot, elf_type, | |
320 | eppnt->p_offset & 0xfffff000); | |
321 | up_write(¤t->mm->mmap_sem); | |
322 | ||
323 | if(error < 0 && error > -1024) { | |
324 | printk("Aieee IRIX interp mmap error=%d\n", error); | |
325 | break; /* Real error */ | |
326 | } | |
327 | #ifdef DEBUG_ELF | |
328 | printk("error=%08lx ", (unsigned long) error); | |
329 | #endif | |
330 | if(!load_addr && interp_elf_ex->e_type == ET_DYN) { | |
331 | load_addr = error; | |
332 | #ifdef DEBUG_ELF | |
333 | printk("load_addr = error "); | |
334 | #endif | |
335 | } | |
336 | ||
337 | /* Find the end of the file mapping for this phdr, and keep | |
338 | * track of the largest address we see for this. | |
339 | */ | |
340 | k = eppnt->p_vaddr + eppnt->p_filesz; | |
341 | if(k > elf_bss) elf_bss = k; | |
342 | ||
343 | /* Do the same thing for the memory mapping - between | |
344 | * elf_bss and last_bss is the bss section. | |
345 | */ | |
346 | k = eppnt->p_memsz + eppnt->p_vaddr; | |
347 | if(k > last_bss) last_bss = k; | |
348 | #ifdef DEBUG_ELF | |
349 | printk("\n"); | |
350 | #endif | |
351 | } | |
352 | } | |
353 | ||
354 | /* Now use mmap to map the library into memory. */ | |
355 | if(error < 0 && error > -1024) { | |
356 | #ifdef DEBUG_ELF | |
357 | printk("got error %d\n", error); | |
358 | #endif | |
359 | kfree(elf_phdata); | |
360 | return 0xffffffff; | |
361 | } | |
362 | ||
363 | /* Now fill out the bss section. First pad the last page up | |
364 | * to the page boundary, and then perform a mmap to make sure | |
365 | * that there are zero-mapped pages up to and including the | |
366 | * last bss page. | |
367 | */ | |
368 | #ifdef DEBUG_ELF | |
369 | printk("padzero(%08lx) ", (unsigned long) (elf_bss)); | |
370 | #endif | |
371 | padzero(elf_bss); | |
372 | len = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */ | |
373 | ||
374 | #ifdef DEBUG_ELF | |
375 | printk("last_bss[%08lx] len[%08lx]\n", (unsigned long) last_bss, | |
376 | (unsigned long) len); | |
377 | #endif | |
378 | ||
379 | /* Map the last of the bss segment */ | |
380 | if (last_bss > len) { | |
381 | down_write(¤t->mm->mmap_sem); | |
382 | do_brk(len, (last_bss - len)); | |
383 | up_write(¤t->mm->mmap_sem); | |
384 | } | |
385 | kfree(elf_phdata); | |
386 | ||
387 | *interp_load_addr = load_addr; | |
388 | return ((unsigned int) interp_elf_ex->e_entry); | |
389 | } | |
390 | ||
391 | /* Check sanity of IRIX elf executable header. */ | |
392 | static int verify_binary(struct elfhdr *ehp, struct linux_binprm *bprm) | |
393 | { | |
394 | if (memcmp(ehp->e_ident, ELFMAG, SELFMAG) != 0) | |
395 | return -ENOEXEC; | |
396 | ||
397 | /* First of all, some simple consistency checks */ | |
398 | if((ehp->e_type != ET_EXEC && ehp->e_type != ET_DYN) || | |
399 | !irix_elf_check_arch(ehp) || !bprm->file->f_op->mmap) { | |
400 | return -ENOEXEC; | |
401 | } | |
402 | ||
403 | /* Only support MIPS ARCH2 or greater IRIX binaries for now. */ | |
404 | if(!(ehp->e_flags & EF_MIPS_ARCH) && !(ehp->e_flags & 0x04)) { | |
405 | return -ENOEXEC; | |
406 | } | |
407 | ||
408 | /* XXX Don't support N32 or 64bit binaries yet because they can | |
409 | * XXX and do execute 64 bit instructions and expect all registers | |
410 | * XXX to be 64 bit as well. We need to make the kernel save | |
411 | * XXX all registers as 64bits on cpu's capable of this at | |
412 | * XXX exception time plus frob the XTLB exception vector. | |
413 | */ | |
414 | if((ehp->e_flags & 0x20)) { | |
415 | return -ENOEXEC; | |
416 | } | |
417 | ||
418 | return 0; /* It's ok. */ | |
419 | } | |
420 | ||
421 | #define IRIX_INTERP_PREFIX "/usr/gnemul/irix" | |
422 | ||
423 | /* Look for an IRIX ELF interpreter. */ | |
424 | static inline int look_for_irix_interpreter(char **name, | |
425 | struct file **interpreter, | |
426 | struct elfhdr *interp_elf_ex, | |
427 | struct elf_phdr *epp, | |
428 | struct linux_binprm *bprm, int pnum) | |
429 | { | |
430 | int i; | |
431 | int retval = -EINVAL; | |
432 | struct file *file = NULL; | |
433 | ||
434 | *name = NULL; | |
435 | for(i = 0; i < pnum; i++, epp++) { | |
436 | if (epp->p_type != PT_INTERP) | |
437 | continue; | |
438 | ||
439 | /* It is illegal to have two interpreters for one executable. */ | |
440 | if (*name != NULL) | |
441 | goto out; | |
442 | ||
443 | *name = kmalloc((epp->p_filesz + strlen(IRIX_INTERP_PREFIX)), | |
444 | GFP_KERNEL); | |
445 | if (!*name) | |
446 | return -ENOMEM; | |
447 | ||
448 | strcpy(*name, IRIX_INTERP_PREFIX); | |
449 | retval = kernel_read(bprm->file, epp->p_offset, (*name + 16), | |
450 | epp->p_filesz); | |
451 | if (retval < 0) | |
452 | goto out; | |
453 | ||
454 | file = open_exec(*name); | |
455 | if (IS_ERR(file)) { | |
456 | retval = PTR_ERR(file); | |
457 | goto out; | |
458 | } | |
459 | retval = kernel_read(file, 0, bprm->buf, 128); | |
460 | if (retval < 0) | |
461 | goto dput_and_out; | |
462 | ||
463 | *interp_elf_ex = *(struct elfhdr *) bprm->buf; | |
464 | } | |
465 | *interpreter = file; | |
466 | return 0; | |
467 | ||
468 | dput_and_out: | |
469 | fput(file); | |
470 | out: | |
471 | kfree(*name); | |
472 | return retval; | |
473 | } | |
474 | ||
475 | static inline int verify_irix_interpreter(struct elfhdr *ihp) | |
476 | { | |
477 | if (memcmp(ihp->e_ident, ELFMAG, SELFMAG) != 0) | |
478 | return -ELIBBAD; | |
479 | return 0; | |
480 | } | |
481 | ||
482 | #define EXEC_MAP_FLAGS (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE) | |
483 | ||
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, | |
488 | unsigned int *ebrk) | |
489 | { | |
490 | unsigned int tmp; | |
491 | int i, prot; | |
492 | ||
493 | for(i = 0; i < pnum; i++, epp++) { | |
494 | if(epp->p_type != PT_LOAD) | |
495 | continue; | |
496 | ||
497 | /* Map it. */ | |
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_write(¤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_write(¤t->mm->mmap_sem); | |
507 | ||
508 | /* Fixup location tracking vars. */ | |
509 | if((epp->p_vaddr & 0xfffff000) < *estack) | |
510 | *estack = (epp->p_vaddr & 0xfffff000); | |
511 | if(!*laddr) | |
512 | *laddr = epp->p_vaddr - epp->p_offset; | |
513 | if(epp->p_vaddr < *scode) | |
514 | *scode = epp->p_vaddr; | |
515 | ||
516 | tmp = epp->p_vaddr + epp->p_filesz; | |
517 | if(tmp > *ebss) | |
518 | *ebss = tmp; | |
519 | if((epp->p_flags & PF_X) && *ecode < tmp) | |
520 | *ecode = tmp; | |
521 | if(*edata < tmp) | |
522 | *edata = tmp; | |
523 | ||
524 | tmp = epp->p_vaddr + epp->p_memsz; | |
525 | if(tmp > *ebrk) | |
526 | *ebrk = tmp; | |
527 | } | |
528 | ||
529 | } | |
530 | ||
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) | |
535 | { | |
536 | int i; | |
537 | ||
538 | *eentry = 0xffffffff; | |
539 | for(i = 0; i < pnum; i++, epp++) { | |
540 | if(epp->p_type != PT_INTERP) | |
541 | continue; | |
542 | ||
543 | /* We should have fielded this error elsewhere... */ | |
544 | if(*eentry != 0xffffffff) | |
545 | return -1; | |
546 | ||
547 | set_fs(old_fs); | |
548 | *eentry = load_irix_interp(ihp, interp, iladdr); | |
549 | old_fs = get_fs(); | |
550 | set_fs(get_ds()); | |
551 | ||
552 | fput(interp); | |
553 | ||
554 | if (*eentry == 0xffffffff) | |
555 | return -1; | |
556 | } | |
557 | return 0; | |
558 | } | |
559 | ||
560 | /* | |
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 | |
563 | * structure | |
564 | */ | |
565 | void irix_map_prda_page (void) | |
566 | { | |
567 | unsigned long v; | |
568 | struct prda *pp; | |
569 | ||
570 | down_write(¤t->mm->mmap_sem); | |
571 | v = do_brk (PRDA_ADDRESS, PAGE_SIZE); | |
572 | up_write(¤t->mm->mmap_sem); | |
573 | ||
574 | if (v < 0) | |
575 | return; | |
576 | ||
577 | pp = (struct prda *) v; | |
578 | pp->prda_sys.t_pid = current->pid; | |
579 | pp->prda_sys.t_prid = read_c0_prid(); | |
580 | pp->prda_sys.t_rpid = current->pid; | |
581 | ||
582 | /* We leave the rest set to zero */ | |
583 | } | |
584 | ||
585 | ||
586 | ||
587 | /* These are the functions used to load ELF style executables and shared | |
588 | * libraries. There is no binary dependent code anywhere else. | |
589 | */ | |
590 | static int load_irix_binary(struct linux_binprm * bprm, struct pt_regs * regs) | |
591 | { | |
592 | struct elfhdr elf_ex, interp_elf_ex; | |
593 | struct file *interpreter; | |
594 | struct elf_phdr *elf_phdata, *elf_ihdr, *elf_ephdr; | |
595 | unsigned int load_addr, elf_bss, elf_brk; | |
596 | unsigned int elf_entry, interp_load_addr = 0; | |
597 | unsigned int start_code, end_code, end_data, elf_stack; | |
598 | int retval, has_interp, has_ephdr, size, i; | |
599 | char *elf_interpreter; | |
600 | mm_segment_t old_fs; | |
601 | ||
602 | load_addr = 0; | |
603 | has_interp = has_ephdr = 0; | |
604 | elf_ihdr = elf_ephdr = 0; | |
605 | elf_ex = *((struct elfhdr *) bprm->buf); | |
606 | retval = -ENOEXEC; | |
607 | ||
608 | if (verify_binary(&elf_ex, bprm)) | |
609 | goto out; | |
610 | ||
611 | #ifdef DEBUG_ELF | |
612 | print_elfhdr(&elf_ex); | |
613 | #endif | |
614 | ||
615 | /* Now read in all of the header information */ | |
616 | size = elf_ex.e_phentsize * elf_ex.e_phnum; | |
617 | if (size > 65536) | |
618 | goto out; | |
619 | elf_phdata = kmalloc(size, GFP_KERNEL); | |
620 | if (elf_phdata == NULL) { | |
621 | retval = -ENOMEM; | |
622 | goto out; | |
623 | } | |
624 | ||
625 | retval = kernel_read(bprm->file, elf_ex.e_phoff, (char *)elf_phdata, size); | |
626 | ||
627 | if (retval < 0) | |
628 | goto out_free_ph; | |
629 | ||
630 | #ifdef DEBUG_ELF | |
631 | dump_phdrs(elf_phdata, elf_ex.e_phnum); | |
632 | #endif | |
633 | ||
634 | /* Set some things for later. */ | |
635 | for(i = 0; i < elf_ex.e_phnum; i++) { | |
636 | switch(elf_phdata[i].p_type) { | |
637 | case PT_INTERP: | |
638 | has_interp = 1; | |
639 | elf_ihdr = &elf_phdata[i]; | |
640 | break; | |
641 | case PT_PHDR: | |
642 | has_ephdr = 1; | |
643 | elf_ephdr = &elf_phdata[i]; | |
644 | break; | |
645 | }; | |
646 | } | |
647 | #ifdef DEBUG_ELF | |
648 | printk("\n"); | |
649 | #endif | |
650 | ||
651 | elf_bss = 0; | |
652 | elf_brk = 0; | |
653 | ||
654 | elf_stack = 0xffffffff; | |
655 | elf_interpreter = NULL; | |
656 | start_code = 0xffffffff; | |
657 | end_code = 0; | |
658 | end_data = 0; | |
659 | ||
660 | retval = look_for_irix_interpreter(&elf_interpreter, | |
661 | &interpreter, | |
662 | &interp_elf_ex, elf_phdata, bprm, | |
663 | elf_ex.e_phnum); | |
664 | if (retval) | |
665 | goto out_free_file; | |
666 | ||
667 | if (elf_interpreter) { | |
668 | retval = verify_irix_interpreter(&interp_elf_ex); | |
669 | if(retval) | |
670 | goto out_free_interp; | |
671 | } | |
672 | ||
673 | /* OK, we are done with that, now set up the arg stuff, | |
674 | * and then start this sucker up. | |
675 | */ | |
676 | retval = -E2BIG; | |
677 | if (!bprm->sh_bang && !bprm->p) | |
678 | goto out_free_interp; | |
679 | ||
680 | /* Flush all traces of the currently running executable */ | |
681 | retval = flush_old_exec(bprm); | |
682 | if (retval) | |
683 | goto out_free_dentry; | |
684 | ||
685 | /* OK, This is the point of no return */ | |
686 | current->mm->end_data = 0; | |
687 | current->mm->end_code = 0; | |
688 | current->mm->mmap = NULL; | |
689 | current->flags &= ~PF_FORKNOEXEC; | |
690 | elf_entry = (unsigned int) elf_ex.e_entry; | |
691 | ||
692 | /* Do this so that we can load the interpreter, if need be. We will | |
693 | * change some of these later. | |
694 | */ | |
695 | set_mm_counter(current->mm, rss, 0); | |
696 | setup_arg_pages(bprm, STACK_TOP, EXSTACK_DEFAULT); | |
697 | current->mm->start_stack = bprm->p; | |
698 | ||
699 | /* At this point, we assume that the image should be loaded at | |
700 | * fixed address, not at a variable address. | |
701 | */ | |
702 | old_fs = get_fs(); | |
703 | set_fs(get_ds()); | |
704 | ||
705 | map_executable(bprm->file, elf_phdata, elf_ex.e_phnum, &elf_stack, | |
706 | &load_addr, &start_code, &elf_bss, &end_code, | |
707 | &end_data, &elf_brk); | |
708 | ||
709 | if(elf_interpreter) { | |
710 | retval = map_interpreter(elf_phdata, &interp_elf_ex, | |
711 | interpreter, &interp_load_addr, | |
712 | elf_ex.e_phnum, old_fs, &elf_entry); | |
713 | kfree(elf_interpreter); | |
714 | if(retval) { | |
715 | set_fs(old_fs); | |
716 | printk("Unable to load IRIX ELF interpreter\n"); | |
717 | send_sig(SIGSEGV, current, 0); | |
718 | retval = 0; | |
719 | goto out_free_file; | |
720 | } | |
721 | } | |
722 | ||
723 | set_fs(old_fs); | |
724 | ||
725 | kfree(elf_phdata); | |
726 | set_personality(PER_IRIX32); | |
727 | set_binfmt(&irix_format); | |
728 | compute_creds(bprm); | |
729 | current->flags &= ~PF_FORKNOEXEC; | |
730 | bprm->p = (unsigned long) | |
731 | create_irix_tables((char *)bprm->p, bprm->argc, bprm->envc, | |
732 | (elf_interpreter ? &elf_ex : NULL), | |
733 | load_addr, interp_load_addr, regs, elf_ephdr); | |
734 | current->mm->start_brk = current->mm->brk = elf_brk; | |
735 | current->mm->end_code = end_code; | |
736 | current->mm->start_code = start_code; | |
737 | current->mm->end_data = end_data; | |
738 | current->mm->start_stack = bprm->p; | |
739 | ||
740 | /* Calling set_brk effectively mmaps the pages that we need for the | |
741 | * bss and break sections. | |
742 | */ | |
743 | set_brk(elf_bss, elf_brk); | |
744 | ||
745 | /* | |
746 | * IRIX maps a page at 0x200000 which holds some system | |
747 | * information. Programs depend on this. | |
748 | */ | |
749 | irix_map_prda_page (); | |
750 | ||
751 | padzero(elf_bss); | |
752 | ||
753 | #ifdef DEBUG_ELF | |
754 | printk("(start_brk) %lx\n" , (long) current->mm->start_brk); | |
755 | printk("(end_code) %lx\n" , (long) current->mm->end_code); | |
756 | printk("(start_code) %lx\n" , (long) current->mm->start_code); | |
757 | printk("(end_data) %lx\n" , (long) current->mm->end_data); | |
758 | printk("(start_stack) %lx\n" , (long) current->mm->start_stack); | |
759 | printk("(brk) %lx\n" , (long) current->mm->brk); | |
760 | #endif | |
761 | ||
762 | #if 0 /* XXX No fucking way dude... */ | |
763 | /* Why this, you ask??? Well SVr4 maps page 0 as read-only, | |
764 | * and some applications "depend" upon this behavior. | |
765 | * Since we do not have the power to recompile these, we | |
766 | * emulate the SVr4 behavior. Sigh. | |
767 | */ | |
768 | down_write(¤t->mm->mmap_sem); | |
769 | (void) do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC, | |
770 | MAP_FIXED | MAP_PRIVATE, 0); | |
771 | up_write(¤t->mm->mmap_sem); | |
772 | #endif | |
773 | ||
774 | start_thread(regs, elf_entry, bprm->p); | |
775 | if (current->ptrace & PT_PTRACED) | |
776 | send_sig(SIGTRAP, current, 0); | |
777 | return 0; | |
778 | out: | |
779 | return retval; | |
780 | ||
781 | out_free_dentry: | |
782 | allow_write_access(interpreter); | |
783 | fput(interpreter); | |
784 | out_free_interp: | |
785 | if (elf_interpreter) | |
786 | kfree(elf_interpreter); | |
787 | out_free_file: | |
788 | out_free_ph: | |
789 | kfree (elf_phdata); | |
790 | goto out; | |
791 | } | |
792 | ||
793 | /* This is really simpleminded and specialized - we are loading an | |
794 | * a.out library that is given an ELF header. | |
795 | */ | |
796 | static int load_irix_library(struct file *file) | |
797 | { | |
798 | struct elfhdr elf_ex; | |
799 | struct elf_phdr *elf_phdata = NULL; | |
800 | unsigned int len = 0; | |
801 | int elf_bss = 0; | |
802 | int retval; | |
803 | unsigned int bss; | |
804 | int error; | |
805 | int i,j, k; | |
806 | ||
807 | error = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex)); | |
808 | if (error != sizeof(elf_ex)) | |
809 | return -ENOEXEC; | |
810 | ||
811 | if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0) | |
812 | return -ENOEXEC; | |
813 | ||
814 | /* First of all, some simple consistency checks. */ | |
815 | if(elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 || | |
816 | !irix_elf_check_arch(&elf_ex) || !file->f_op->mmap) | |
817 | return -ENOEXEC; | |
818 | ||
819 | /* Now read in all of the header information. */ | |
820 | if(sizeof(struct elf_phdr) * elf_ex.e_phnum > PAGE_SIZE) | |
821 | return -ENOEXEC; | |
822 | ||
823 | elf_phdata = kmalloc(sizeof(struct elf_phdr) * elf_ex.e_phnum, GFP_KERNEL); | |
824 | if (elf_phdata == NULL) | |
825 | return -ENOMEM; | |
826 | ||
827 | retval = kernel_read(file, elf_ex.e_phoff, (char *) elf_phdata, | |
828 | sizeof(struct elf_phdr) * elf_ex.e_phnum); | |
829 | ||
830 | j = 0; | |
831 | for(i=0; i<elf_ex.e_phnum; i++) | |
832 | if((elf_phdata + i)->p_type == PT_LOAD) j++; | |
833 | ||
834 | if(j != 1) { | |
835 | kfree(elf_phdata); | |
836 | return -ENOEXEC; | |
837 | } | |
838 | ||
839 | while(elf_phdata->p_type != PT_LOAD) elf_phdata++; | |
840 | ||
841 | /* Now use mmap to map the library into memory. */ | |
842 | down_write(¤t->mm->mmap_sem); | |
843 | error = do_mmap(file, | |
844 | elf_phdata->p_vaddr & 0xfffff000, | |
845 | elf_phdata->p_filesz + (elf_phdata->p_vaddr & 0xfff), | |
846 | PROT_READ | PROT_WRITE | PROT_EXEC, | |
847 | MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE, | |
848 | elf_phdata->p_offset & 0xfffff000); | |
849 | up_write(¤t->mm->mmap_sem); | |
850 | ||
851 | k = elf_phdata->p_vaddr + elf_phdata->p_filesz; | |
852 | if (k > elf_bss) elf_bss = k; | |
853 | ||
854 | if (error != (elf_phdata->p_vaddr & 0xfffff000)) { | |
855 | kfree(elf_phdata); | |
856 | return error; | |
857 | } | |
858 | ||
859 | padzero(elf_bss); | |
860 | ||
861 | len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000; | |
862 | bss = elf_phdata->p_memsz + elf_phdata->p_vaddr; | |
863 | if (bss > len) { | |
864 | down_write(¤t->mm->mmap_sem); | |
865 | do_brk(len, bss-len); | |
866 | up_write(¤t->mm->mmap_sem); | |
867 | } | |
868 | kfree(elf_phdata); | |
869 | return 0; | |
870 | } | |
871 | ||
872 | /* Called through irix_syssgi() to map an elf image given an FD, | |
873 | * a phdr ptr USER_PHDRP in userspace, and a count CNT telling how many | |
874 | * phdrs there are in the USER_PHDRP array. We return the vaddr the | |
875 | * first phdr was successfully mapped to. | |
876 | */ | |
877 | unsigned long irix_mapelf(int fd, struct elf_phdr *user_phdrp, int cnt) | |
878 | { | |
879 | struct elf_phdr *hp; | |
880 | struct file *filp; | |
881 | int i, retval; | |
882 | ||
883 | #ifdef DEBUG_ELF | |
884 | printk("irix_mapelf: fd[%d] user_phdrp[%p] cnt[%d]\n", | |
885 | fd, user_phdrp, cnt); | |
886 | #endif | |
887 | ||
888 | /* First get the verification out of the way. */ | |
889 | hp = user_phdrp; | |
890 | if (!access_ok(VERIFY_READ, hp, (sizeof(struct elf_phdr) * cnt))) { | |
891 | #ifdef DEBUG_ELF | |
892 | printk("irix_mapelf: access_ok fails!\n"); | |
893 | #endif | |
894 | return -EFAULT; | |
895 | } | |
896 | ||
897 | #ifdef DEBUG_ELF | |
898 | dump_phdrs(user_phdrp, cnt); | |
899 | #endif | |
900 | ||
901 | for(i = 0; i < cnt; i++, hp++) | |
902 | if(hp->p_type != PT_LOAD) { | |
903 | printk("irix_mapelf: One section is not PT_LOAD!\n"); | |
904 | return -ENOEXEC; | |
905 | } | |
906 | ||
907 | filp = fget(fd); | |
908 | if (!filp) | |
909 | return -EACCES; | |
910 | if(!filp->f_op) { | |
911 | printk("irix_mapelf: Bogon filp!\n"); | |
912 | fput(filp); | |
913 | return -EACCES; | |
914 | } | |
915 | ||
916 | hp = user_phdrp; | |
917 | for(i = 0; i < cnt; i++, hp++) { | |
918 | int prot; | |
919 | ||
920 | prot = (hp->p_flags & PF_R) ? PROT_READ : 0; | |
921 | prot |= (hp->p_flags & PF_W) ? PROT_WRITE : 0; | |
922 | prot |= (hp->p_flags & PF_X) ? PROT_EXEC : 0; | |
923 | down_write(¤t->mm->mmap_sem); | |
924 | retval = do_mmap(filp, (hp->p_vaddr & 0xfffff000), | |
925 | (hp->p_filesz + (hp->p_vaddr & 0xfff)), | |
926 | prot, (MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE), | |
927 | (hp->p_offset & 0xfffff000)); | |
928 | up_write(¤t->mm->mmap_sem); | |
929 | ||
930 | if(retval != (hp->p_vaddr & 0xfffff000)) { | |
931 | printk("irix_mapelf: do_mmap fails with %d!\n", retval); | |
932 | fput(filp); | |
933 | return retval; | |
934 | } | |
935 | } | |
936 | ||
937 | #ifdef DEBUG_ELF | |
938 | printk("irix_mapelf: Success, returning %08lx\n", | |
939 | (unsigned long) user_phdrp->p_vaddr); | |
940 | #endif | |
941 | fput(filp); | |
942 | return user_phdrp->p_vaddr; | |
943 | } | |
944 | ||
945 | /* | |
946 | * ELF core dumper | |
947 | * | |
948 | * Modelled on fs/exec.c:aout_core_dump() | |
949 | * Jeremy Fitzhardinge <jeremy@sw.oz.au> | |
950 | */ | |
951 | ||
952 | /* These are the only things you should do on a core-file: use only these | |
953 | * functions to write out all the necessary info. | |
954 | */ | |
955 | static int dump_write(struct file *file, const void *addr, int nr) | |
956 | { | |
957 | return file->f_op->write(file, addr, nr, &file->f_pos) == nr; | |
958 | } | |
959 | ||
960 | static int dump_seek(struct file *file, off_t off) | |
961 | { | |
962 | if (file->f_op->llseek) { | |
963 | if (file->f_op->llseek(file, off, 0) != off) | |
964 | return 0; | |
965 | } else | |
966 | file->f_pos = off; | |
967 | return 1; | |
968 | } | |
969 | ||
970 | /* Decide whether a segment is worth dumping; default is yes to be | |
971 | * sure (missing info is worse than too much; etc). | |
972 | * Personally I'd include everything, and use the coredump limit... | |
973 | * | |
974 | * I think we should skip something. But I am not sure how. H.J. | |
975 | */ | |
976 | static inline int maydump(struct vm_area_struct *vma) | |
977 | { | |
978 | if (!(vma->vm_flags & (VM_READ|VM_WRITE|VM_EXEC))) | |
979 | return 0; | |
980 | #if 1 | |
981 | if (vma->vm_flags & (VM_WRITE|VM_GROWSUP|VM_GROWSDOWN)) | |
982 | return 1; | |
983 | if (vma->vm_flags & (VM_READ|VM_EXEC|VM_EXECUTABLE|VM_SHARED)) | |
984 | return 0; | |
985 | #endif | |
986 | return 1; | |
987 | } | |
988 | ||
989 | #define roundup(x, y) ((((x)+((y)-1))/(y))*(y)) | |
990 | ||
991 | /* An ELF note in memory. */ | |
992 | struct memelfnote | |
993 | { | |
994 | const char *name; | |
995 | int type; | |
996 | unsigned int datasz; | |
997 | void *data; | |
998 | }; | |
999 | ||
1000 | static int notesize(struct memelfnote *en) | |
1001 | { | |
1002 | int sz; | |
1003 | ||
1004 | sz = sizeof(struct elf_note); | |
1005 | sz += roundup(strlen(en->name), 4); | |
1006 | sz += roundup(en->datasz, 4); | |
1007 | ||
1008 | return sz; | |
1009 | } | |
1010 | ||
1011 | /* #define DEBUG */ | |
1012 | ||
1013 | #define DUMP_WRITE(addr, nr) \ | |
1014 | if (!dump_write(file, (addr), (nr))) \ | |
1015 | goto end_coredump; | |
1016 | #define DUMP_SEEK(off) \ | |
1017 | if (!dump_seek(file, (off))) \ | |
1018 | goto end_coredump; | |
1019 | ||
1020 | static int writenote(struct memelfnote *men, struct file *file) | |
1021 | { | |
1022 | struct elf_note en; | |
1023 | ||
1024 | en.n_namesz = strlen(men->name); | |
1025 | en.n_descsz = men->datasz; | |
1026 | en.n_type = men->type; | |
1027 | ||
1028 | DUMP_WRITE(&en, sizeof(en)); | |
1029 | DUMP_WRITE(men->name, en.n_namesz); | |
1030 | /* XXX - cast from long long to long to avoid need for libgcc.a */ | |
1031 | DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */ | |
1032 | DUMP_WRITE(men->data, men->datasz); | |
1033 | DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */ | |
1034 | ||
1035 | return 1; | |
1036 | ||
1037 | end_coredump: | |
1038 | return 0; | |
1039 | } | |
1040 | #undef DUMP_WRITE | |
1041 | #undef DUMP_SEEK | |
1042 | ||
1043 | #define DUMP_WRITE(addr, nr) \ | |
1044 | if (!dump_write(file, (addr), (nr))) \ | |
1045 | goto end_coredump; | |
1046 | #define DUMP_SEEK(off) \ | |
1047 | if (!dump_seek(file, (off))) \ | |
1048 | goto end_coredump; | |
1049 | ||
1050 | /* Actual dumper. | |
1051 | * | |
1052 | * This is a two-pass process; first we find the offsets of the bits, | |
1053 | * and then they are actually written out. If we run out of core limit | |
1054 | * we just truncate. | |
1055 | */ | |
1056 | static int irix_core_dump(long signr, struct pt_regs * regs, struct file *file) | |
1057 | { | |
1058 | int has_dumped = 0; | |
1059 | mm_segment_t fs; | |
1060 | int segs; | |
1061 | int i; | |
1062 | size_t size; | |
1063 | struct vm_area_struct *vma; | |
1064 | struct elfhdr elf; | |
1065 | off_t offset = 0, dataoff; | |
1066 | int limit = current->signal->rlim[RLIMIT_CORE].rlim_cur; | |
1067 | int numnote = 4; | |
1068 | struct memelfnote notes[4]; | |
1069 | struct elf_prstatus prstatus; /* NT_PRSTATUS */ | |
1070 | elf_fpregset_t fpu; /* NT_PRFPREG */ | |
1071 | struct elf_prpsinfo psinfo; /* NT_PRPSINFO */ | |
1072 | ||
1073 | /* Count what's needed to dump, up to the limit of coredump size. */ | |
1074 | segs = 0; | |
1075 | size = 0; | |
1076 | for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) { | |
1077 | if (maydump(vma)) | |
1078 | { | |
1079 | int sz = vma->vm_end-vma->vm_start; | |
1080 | ||
1081 | if (size+sz >= limit) | |
1082 | break; | |
1083 | else | |
1084 | size += sz; | |
1085 | } | |
1086 | ||
1087 | segs++; | |
1088 | } | |
1089 | #ifdef DEBUG | |
1090 | printk("irix_core_dump: %d segs taking %d bytes\n", segs, size); | |
1091 | #endif | |
1092 | ||
1093 | /* Set up header. */ | |
1094 | memcpy(elf.e_ident, ELFMAG, SELFMAG); | |
1095 | elf.e_ident[EI_CLASS] = ELFCLASS32; | |
1096 | elf.e_ident[EI_DATA] = ELFDATA2LSB; | |
1097 | elf.e_ident[EI_VERSION] = EV_CURRENT; | |
1098 | elf.e_ident[EI_OSABI] = ELF_OSABI; | |
1099 | memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD); | |
1100 | ||
1101 | elf.e_type = ET_CORE; | |
1102 | elf.e_machine = ELF_ARCH; | |
1103 | elf.e_version = EV_CURRENT; | |
1104 | elf.e_entry = 0; | |
1105 | elf.e_phoff = sizeof(elf); | |
1106 | elf.e_shoff = 0; | |
1107 | elf.e_flags = 0; | |
1108 | elf.e_ehsize = sizeof(elf); | |
1109 | elf.e_phentsize = sizeof(struct elf_phdr); | |
1110 | elf.e_phnum = segs+1; /* Include notes. */ | |
1111 | elf.e_shentsize = 0; | |
1112 | elf.e_shnum = 0; | |
1113 | elf.e_shstrndx = 0; | |
1114 | ||
1115 | fs = get_fs(); | |
1116 | set_fs(KERNEL_DS); | |
1117 | ||
1118 | has_dumped = 1; | |
1119 | current->flags |= PF_DUMPCORE; | |
1120 | ||
1121 | DUMP_WRITE(&elf, sizeof(elf)); | |
1122 | offset += sizeof(elf); /* Elf header. */ | |
1123 | offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers. */ | |
1124 | ||
1125 | /* Set up the notes in similar form to SVR4 core dumps made | |
1126 | * with info from their /proc. | |
1127 | */ | |
1128 | memset(&psinfo, 0, sizeof(psinfo)); | |
1129 | memset(&prstatus, 0, sizeof(prstatus)); | |
1130 | ||
1131 | notes[0].name = "CORE"; | |
1132 | notes[0].type = NT_PRSTATUS; | |
1133 | notes[0].datasz = sizeof(prstatus); | |
1134 | notes[0].data = &prstatus; | |
1135 | prstatus.pr_info.si_signo = prstatus.pr_cursig = signr; | |
1136 | prstatus.pr_sigpend = current->pending.signal.sig[0]; | |
1137 | prstatus.pr_sighold = current->blocked.sig[0]; | |
1138 | psinfo.pr_pid = prstatus.pr_pid = current->pid; | |
1139 | psinfo.pr_ppid = prstatus.pr_ppid = current->parent->pid; | |
1140 | psinfo.pr_pgrp = prstatus.pr_pgrp = process_group(current); | |
1141 | psinfo.pr_sid = prstatus.pr_sid = current->signal->session; | |
1142 | if (current->pid == current->tgid) { | |
1143 | /* | |
1144 | * This is the record for the group leader. Add in the | |
1145 | * cumulative times of previous dead threads. This total | |
1146 | * won't include the time of each live thread whose state | |
1147 | * is included in the core dump. The final total reported | |
1148 | * to our parent process when it calls wait4 will include | |
1149 | * those sums as well as the little bit more time it takes | |
1150 | * this and each other thread to finish dying after the | |
1151 | * core dump synchronization phase. | |
1152 | */ | |
1153 | jiffies_to_timeval(current->utime + current->signal->utime, | |
1154 | &prstatus.pr_utime); | |
1155 | jiffies_to_timeval(current->stime + current->signal->stime, | |
1156 | &prstatus.pr_stime); | |
1157 | } else { | |
1158 | jiffies_to_timeval(current->utime, &prstatus.pr_utime); | |
1159 | jiffies_to_timeval(current->stime, &prstatus.pr_stime); | |
1160 | } | |
1161 | jiffies_to_timeval(current->signal->cutime, &prstatus.pr_cutime); | |
1162 | jiffies_to_timeval(current->signal->cstime, &prstatus.pr_cstime); | |
1163 | ||
1164 | if (sizeof(elf_gregset_t) != sizeof(struct pt_regs)) { | |
1165 | printk("sizeof(elf_gregset_t) (%d) != sizeof(struct pt_regs) " | |
1166 | "(%d)\n", sizeof(elf_gregset_t), sizeof(struct pt_regs)); | |
1167 | } else { | |
1168 | *(struct pt_regs *)&prstatus.pr_reg = *regs; | |
1169 | } | |
1170 | ||
1171 | notes[1].name = "CORE"; | |
1172 | notes[1].type = NT_PRPSINFO; | |
1173 | notes[1].datasz = sizeof(psinfo); | |
1174 | notes[1].data = &psinfo; | |
1175 | i = current->state ? ffz(~current->state) + 1 : 0; | |
1176 | psinfo.pr_state = i; | |
1177 | psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i]; | |
1178 | psinfo.pr_zomb = psinfo.pr_sname == 'Z'; | |
1179 | psinfo.pr_nice = task_nice(current); | |
1180 | psinfo.pr_flag = current->flags; | |
1181 | psinfo.pr_uid = current->uid; | |
1182 | psinfo.pr_gid = current->gid; | |
1183 | { | |
1184 | int i, len; | |
1185 | ||
1186 | set_fs(fs); | |
1187 | ||
1188 | len = current->mm->arg_end - current->mm->arg_start; | |
1189 | len = len >= ELF_PRARGSZ ? ELF_PRARGSZ : len; | |
1190 | copy_from_user(&psinfo.pr_psargs, | |
1191 | (const char *)current->mm->arg_start, len); | |
1192 | for(i = 0; i < len; i++) | |
1193 | if (psinfo.pr_psargs[i] == 0) | |
1194 | psinfo.pr_psargs[i] = ' '; | |
1195 | psinfo.pr_psargs[len] = 0; | |
1196 | ||
1197 | set_fs(KERNEL_DS); | |
1198 | } | |
1199 | strlcpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname)); | |
1200 | ||
1201 | notes[2].name = "CORE"; | |
1202 | notes[2].type = NT_TASKSTRUCT; | |
1203 | notes[2].datasz = sizeof(*current); | |
1204 | notes[2].data = current; | |
1205 | ||
1206 | /* Try to dump the FPU. */ | |
1207 | prstatus.pr_fpvalid = dump_fpu (regs, &fpu); | |
1208 | if (!prstatus.pr_fpvalid) { | |
1209 | numnote--; | |
1210 | } else { | |
1211 | notes[3].name = "CORE"; | |
1212 | notes[3].type = NT_PRFPREG; | |
1213 | notes[3].datasz = sizeof(fpu); | |
1214 | notes[3].data = &fpu; | |
1215 | } | |
1216 | ||
1217 | /* Write notes phdr entry. */ | |
1218 | { | |
1219 | struct elf_phdr phdr; | |
1220 | int sz = 0; | |
1221 | ||
1222 | for(i = 0; i < numnote; i++) | |
1223 | sz += notesize(¬es[i]); | |
1224 | ||
1225 | phdr.p_type = PT_NOTE; | |
1226 | phdr.p_offset = offset; | |
1227 | phdr.p_vaddr = 0; | |
1228 | phdr.p_paddr = 0; | |
1229 | phdr.p_filesz = sz; | |
1230 | phdr.p_memsz = 0; | |
1231 | phdr.p_flags = 0; | |
1232 | phdr.p_align = 0; | |
1233 | ||
1234 | offset += phdr.p_filesz; | |
1235 | DUMP_WRITE(&phdr, sizeof(phdr)); | |
1236 | } | |
1237 | ||
1238 | /* Page-align dumped data. */ | |
1239 | dataoff = offset = roundup(offset, PAGE_SIZE); | |
1240 | ||
1241 | /* Write program headers for segments dump. */ | |
1242 | for(vma = current->mm->mmap, i = 0; | |
1243 | i < segs && vma != NULL; vma = vma->vm_next) { | |
1244 | struct elf_phdr phdr; | |
1245 | size_t sz; | |
1246 | ||
1247 | i++; | |
1248 | ||
1249 | sz = vma->vm_end - vma->vm_start; | |
1250 | ||
1251 | phdr.p_type = PT_LOAD; | |
1252 | phdr.p_offset = offset; | |
1253 | phdr.p_vaddr = vma->vm_start; | |
1254 | phdr.p_paddr = 0; | |
1255 | phdr.p_filesz = maydump(vma) ? sz : 0; | |
1256 | phdr.p_memsz = sz; | |
1257 | offset += phdr.p_filesz; | |
1258 | phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0; | |
1259 | if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W; | |
1260 | if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X; | |
1261 | phdr.p_align = PAGE_SIZE; | |
1262 | ||
1263 | DUMP_WRITE(&phdr, sizeof(phdr)); | |
1264 | } | |
1265 | ||
1266 | for(i = 0; i < numnote; i++) | |
1267 | if (!writenote(¬es[i], file)) | |
1268 | goto end_coredump; | |
1269 | ||
1270 | set_fs(fs); | |
1271 | ||
1272 | DUMP_SEEK(dataoff); | |
1273 | ||
1274 | for(i = 0, vma = current->mm->mmap; | |
1275 | i < segs && vma != NULL; | |
1276 | vma = vma->vm_next) { | |
1277 | unsigned long addr = vma->vm_start; | |
1278 | unsigned long len = vma->vm_end - vma->vm_start; | |
1279 | ||
1280 | if (!maydump(vma)) | |
1281 | continue; | |
1282 | i++; | |
1283 | #ifdef DEBUG | |
1284 | printk("elf_core_dump: writing %08lx %lx\n", addr, len); | |
1285 | #endif | |
1286 | DUMP_WRITE((void *)addr, len); | |
1287 | } | |
1288 | ||
1289 | if ((off_t) file->f_pos != offset) { | |
1290 | /* Sanity check. */ | |
1291 | printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n", | |
1292 | (off_t) file->f_pos, offset); | |
1293 | } | |
1294 | ||
1295 | end_coredump: | |
1296 | set_fs(fs); | |
1297 | return has_dumped; | |
1298 | } | |
1299 | ||
1300 | static int __init init_irix_binfmt(void) | |
1301 | { | |
1302 | int init_inventory(void); | |
1303 | extern asmlinkage unsigned long sys_call_table; | |
1304 | extern asmlinkage unsigned long sys_call_table_irix5; | |
1305 | ||
1306 | init_inventory(); | |
1307 | ||
1308 | /* | |
1309 | * Copy the IRIX5 syscall table (8000 bytes) into the main syscall | |
1310 | * table. The IRIX5 calls are located by an offset of 8000 bytes | |
1311 | * from the beginning of the main table. | |
1312 | */ | |
1313 | memcpy((void *) ((unsigned long) &sys_call_table + 8000), | |
1314 | &sys_call_table_irix5, 8000); | |
1315 | ||
1316 | return register_binfmt(&irix_format); | |
1317 | } | |
1318 | ||
1319 | static void __exit exit_irix_binfmt(void) | |
1320 | { | |
1321 | /* Remove the IRIX ELF loaders. */ | |
1322 | unregister_binfmt(&irix_format); | |
1323 | } | |
1324 | ||
1325 | module_init(init_irix_binfmt) | |
1326 | module_exit(exit_irix_binfmt) |