开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
irixelf.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：33k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

irixelf.c：源码内容
  1. /*
  2.  * irixelf.c: Code to load IRIX ELF executables which conform to
  3.  *            the MIPS ABI.
  4.  *
  5.  * Copyright (C) 1996 David S. Miller (dm@engr.sgi.com)
  6.  *
  7.  * Based upon work which is:
  8.  * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
  9.  */
  11. #include <linux/module.h>
  13. #include <linux/fs.h>
  14. #include <linux/stat.h>
  15. #include <linux/sched.h>
  16. #include <linux/mm.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/slab.h>
  27. #include <linux/shm.h>
  28. #include <linux/personality.h>
  29. #include <linux/elfcore.h>
  30. #include <linux/smp_lock.h>
  32. #include <asm/uaccess.h>
  33. #include <asm/pgalloc.h>
  34. #include <asm/ptrace.h>
  35. #include <asm/mipsregs.h>
  36. #include <asm/prctl.h>
  38. #define DLINFO_ITEMS 12
  40. #include <linux/elf.h>
  42. #undef DEBUG_ELF
  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. 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
  53. };
  55. #ifndef elf_addr_t
  56. #define elf_addr_t unsigned long
  57. #define elf_caddr_t char *
  58. #endif
  60. #ifdef DEBUG_ELF
  61. /* Debugging routines. */
  62. static char *get_elf_p_type(Elf32_Word p_type)
  63. {
  64. int i = (int) p_type;
  66. switch(i) {
  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;
  77. }
  78. }
  80. static void print_elfhdr(struct elfhdr *ehp)
  81. {
  82. int i;
  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] "
  91.        "e_flags[%08lx]n",
  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);
  100. }
  102. static void print_phdr(int i, struct elf_phdr *ep)
  103. {
  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);
  112. }
  114. static void dump_phdrs(struct elf_phdr *ep, int pnum)
  115. {
  116. int i;
  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))
  122. print_phdr(i, ep);
  123. }
  124. }
  125. #endif /* (DEBUG_ELF) */
  127. static void set_brk(unsigned long start, unsigned long end)
  128. {
  129. start = PAGE_ALIGN(start);
  130. end = PAGE_ALIGN(end);
  131. if (end <= start)
  132. return;
  133. do_brk(start, end - start);
  134. }
  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;
  146. nbyte = elf_bss & (PAGE_SIZE-1);
  147. if (nbyte) {
  148. nbyte = PAGE_SIZE - nbyte;
  149. clear_user((void *) elf_bss, nbyte);
  150. }
  151. }
  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_caddr_t *argv;
  159. elf_caddr_t *envp;
  160. elf_addr_t *sp, *csp;
  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. }
  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)); 
  184. sp -= 2;
  185. NEW_AUX_ENT(0, AT_NULL, 0);
  187. if(exec) {
  188. sp -= 11*2;
  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
  204. sp -= envc+1;
  205. envp = (elf_caddr_t *) sp;
  206. sp -= argc+1;
  207. argv = (elf_caddr_t *) sp;
  209. __put_user((elf_addr_t)argc,--sp);
  210. current->mm->arg_start = (unsigned long) p;
  211. while (argc-->0) {
  212. __put_user((elf_caddr_t)(unsigned long)p,argv++);
  213. p += strlen_user(p);
  214. }
  215. __put_user(NULL, argv);
  216. current->mm->arg_end = current->mm->env_start = (unsigned long) p;
  217. while (envc-->0) {
  218. __put_user((elf_caddr_t)(unsigned long)p,envp++);
  219. p += strlen_user(p);
  220. }
  221. __put_user(NULL, envp);
  222. current->mm->env_end = (unsigned long) p;
  223. return sp;
  224. }
  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;
  247. elf_bss = 0;
  248. last_bss = 0;
  249. error = load_addr = 0;
  251. #ifdef DEBUG_ELF
  252. print_elfhdr(interp_elf_ex);
  253. #endif
  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 %dn", interp_elf_ex->e_type);
  261. return 0xffffffff;
  262. }
  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. }
  271. elf_phdata =  (struct elf_phdr *)
  272. kmalloc(sizeof(struct elf_phdr) * interp_elf_ex->e_phnum,
  273. GFP_KERNEL);
  275. if(!elf_phdata) {
  276.           printk("Cannot kmalloc phdata for IRIX interp.n");
  277.   return 0xffffffff;
  278. }
  280. /* If the size of this structure has changed, then punt, since
  281.  * we will be doing the wrong thing.
  282.  */
  283. if(interp_elf_ex->e_phentsize != 32) {
  284. printk("IRIX interp e_phentsize == %d != 32 ",
  285.        interp_elf_ex->e_phentsize);
  286. kfree(elf_phdata);
  287. return 0xffffffff;
  288. }
  290. retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
  291.    (char *) elf_phdata,
  292.    sizeof(struct elf_phdr) * interp_elf_ex->e_phnum);
  294. #ifdef DEBUG_ELF
  295. dump_phdrs(elf_phdata, interp_elf_ex->e_phnum);
  296. #endif
  298. eppnt = elf_phdata;
  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;
  302.     int elf_prot = 0;
  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;
  310. #ifdef DEBUG_ELF
  311.     printk("INTERP do_mmap(%p, %08lx, %08lx, %08lx, %08lx, %08lx) ",
  312.    interpreter, vaddr,
  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));
  316. #endif
  317.     down_write(&current->mm->mmap_sem);
  318.     error = do_mmap(interpreter, vaddr,
  319.     eppnt->p_filesz + (eppnt->p_vaddr & 0xfff),
  320.     elf_prot, elf_type,
  321.     eppnt->p_offset & 0xfffff000);
  322.     up_write(&current->mm->mmap_sem);
  324.     if(error < 0 && error > -1024) {
  325.     printk("Aieee IRIX interp mmap error=%dn", error);
  326.     break;  /* Real error */
  327.     }
  328. #ifdef DEBUG_ELF
  329.     printk("error=%08lx ", (unsigned long) error);
  330. #endif
  331.     if(!load_addr && interp_elf_ex->e_type == ET_DYN) {
  332.       load_addr = error;
  333. #ifdef DEBUG_ELF
  334.               printk("load_addr = error ");
  335. #endif
  336.     }
  338.     /* Find the end of the file  mapping for this phdr, and keep
  339.      * track of the largest address we see for this.
  340.      */
  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.
  346.      */
  347.     k = eppnt->p_memsz + eppnt->p_vaddr;
  348.     if(k > last_bss) last_bss = k;
  349. #ifdef DEBUG_ELF
  350.     printk("n");
  351. #endif
  352.   }
  353. }
  355. /* Now use mmap to map the library into memory. */
  356. if(error < 0 && error > -1024) {
  357. #ifdef DEBUG_ELF
  358. printk("got error %dn", error);
  359. #endif
  360. kfree(elf_phdata);
  361. return 0xffffffff;
  362. }
  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
  367.  * last bss page.
  368.  */
  369. #ifdef DEBUG_ELF
  370. printk("padzero(%08lx) ", (unsigned long) (elf_bss));
  371. #endif
  372. padzero(elf_bss);
  373. len = (elf_bss + 0xfff) & 0xfffff000; /* What we have mapped so far */
  375. #ifdef DEBUG_ELF
  376. printk("last_bss[%08lx] len[%08lx]n", (unsigned long) last_bss,
  377.        (unsigned long) len);
  378. #endif
  380. /* Map the last of the bss segment */
  381. if (last_bss > len) {
  382. do_brk(len, (last_bss - len));
  383. }
  384. kfree(elf_phdata);
  386. *interp_load_addr = load_addr;
  387. return ((unsigned int) interp_elf_ex->e_entry);
  388. }
  390. /* Check sanity of IRIX elf executable header. */
  391. static int verify_binary(struct elfhdr *ehp, struct linux_binprm *bprm)
  392. {
  393. if (memcmp(ehp->e_ident, ELFMAG, SELFMAG) != 0)
  394. return -ENOEXEC;
  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) {
  399. return -ENOEXEC;
  400. }
  402. /* Only support MIPS ARCH2 or greater IRIX binaries for now. */
  403. if(!(ehp->e_flags & EF_MIPS_ARCH) && !(ehp->e_flags & 0x04)) {
  404. return -ENOEXEC;
  405. }
  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.
  412.  */
  413. if((ehp->e_flags & 0x20)) {
  414. return -ENOEXEC;
  415. }
  417. return 0; /* It's ok. */
  418. }
  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)
  428. {
  429. int i;
  430. int retval = -EINVAL;
  431. struct file *file = NULL;
  433. *name = NULL;
  434. for(i = 0; i < pnum; i++, epp++) {
  435. if (epp->p_type != PT_INTERP)
  436. continue;
  438. /* It is illegal to have two interpreters for one executable. */
  439. if (*name != NULL)
  440. goto out;
  442. *name = (char *) kmalloc((epp->p_filesz +
  443.   strlen(IRIX_INTERP_PREFIX)),
  444.  GFP_KERNEL);
  445. if (!*name)
  446. return -ENOMEM;
  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;
  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;
  463. *interp_elf_ex = *(struct elfhdr *) bprm->buf;
  464. }
  465. *interpreter = file;
  466. return 0;
  468. dput_and_out:
  469. fput(file);
  470. out:
  471. kfree(*name);
  472. return retval;
  473. }
  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. }
  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,
  488.   unsigned int *ebrk)
  489. {
  490. unsigned int tmp;
  491. int i, prot;
  493. for(i = 0; i < pnum; i++, epp++) {
  494. if(epp->p_type != PT_LOAD)
  495. continue;
  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(&current->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(&current->mm->mmap_sem);
  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;
  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;
  524. tmp = epp->p_vaddr + epp->p_memsz;
  525. if(tmp > *ebrk)
  526. *ebrk = tmp;
  527. }
  529. }
  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;
  538. *eentry = 0xffffffff;
  539. for(i = 0; i < pnum; i++, epp++) {
  540. if(epp->p_type != PT_INTERP)
  541. continue;
  543. /* We should have fielded this error elsewhere... */
  544. if(*eentry != 0xffffffff)
  545. return -1;
  547. set_fs(old_fs);
  548. *eentry = load_irix_interp(ihp, interp, iladdr);
  549. old_fs = get_fs();
  550. set_fs(get_ds());
  552. fput(interp);
  554. if (*eentry == 0xffffffff)
  555. return -1;
  556. }
  557. return 0;
  558. }
  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;
  570. v =  do_brk (PRDA_ADDRESS, PAGE_SIZE);
  572. if (v < 0)
  573. return;
  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 */
  581. }
  585. /* These are the functions used to load ELF style executables and shared
  586.  * libraries.  There is no binary dependent code anywhere else.
  587.  */
  588. static int load_irix_binary(struct linux_binprm * bprm, struct pt_regs * regs)
  589. {
  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;
  598. mm_segment_t old_fs;
  600. load_addr = 0;
  601. has_interp = has_ephdr = 0;
  602. elf_ihdr = elf_ephdr = 0;
  603. elf_ex = *((struct elfhdr *) bprm->buf);
  604. retval = -ENOEXEC;
  606. if (verify_binary(&elf_ex, bprm))
  607. goto out;
  609. #ifdef DEBUG_ELF
  610. print_elfhdr(&elf_ex);
  611. #endif
  613. /* Now read in all of the header information */
  614. size = elf_ex.e_phentsize * elf_ex.e_phnum;
  615. if (size > 65536)
  616. goto out;
  617. elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
  618. if (elf_phdata == NULL) {
  619. retval = -ENOMEM;
  620. goto out;
  621. }
  623. retval = kernel_read(bprm->file, elf_ex.e_phoff, (char *)elf_phdata, size);
  624. if (retval < 0)
  625. goto out_free_ph;
  627. #ifdef DEBUG_ELF
  628. dump_phdrs(elf_phdata, elf_ex.e_phnum);
  629. #endif
  631. /* Set some things for later. */
  632. for(i = 0; i < elf_ex.e_phnum; i++) {
  633. switch(elf_phdata[i].p_type) {
  634. case PT_INTERP:
  635. has_interp = 1;
  636. elf_ihdr = &elf_phdata[i];
  637. break;
  638. case PT_PHDR:
  639. has_ephdr = 1;
  640. elf_ephdr = &elf_phdata[i];
  641. break;
  642. };
  643. }
  644. #ifdef DEBUG_ELF
  645. printk("n");
  646. #endif
  648. elf_bss = 0;
  649. elf_brk = 0;
  651. elf_stack = 0xffffffff;
  652. elf_interpreter = NULL;
  653. start_code = 0xffffffff;
  654. end_code = 0;
  655. end_data = 0;
  657. retval = look_for_irix_interpreter(&elf_interpreter,
  658.                                    &interpreter,
  659.    &interp_elf_ex, elf_phdata, bprm,
  660.    elf_ex.e_phnum);
  661. if (retval)
  662. goto out_free_file;
  664. if (elf_interpreter) {
  665. retval = verify_irix_interpreter(&interp_elf_ex);
  666. if(retval)
  667. goto out_free_interp;
  668. }
  670. /* OK, we are done with that, now set up the arg stuff,
  671.  * and then start this sucker up.
  672.  */
  673. retval = -E2BIG;
  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);
  679. if (retval)
  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.
  691.  */
  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.
  698.  */
  699. old_fs = get_fs();
  700. set_fs(get_ds());
  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);
  711. if(retval) {
  712. set_fs(old_fs);
  713. printk("Unable to load IRIX ELF interpretern");
  714. send_sig(SIGSEGV, current, 0);
  715. retval = 0;
  716. goto out_free_file;
  717. }
  718. }
  720. set_fs(old_fs);
  722. kfree(elf_phdata);
  723. set_personality(PER_IRIX32);
  724. set_binfmt(&irix_format);
  725. compute_creds(bprm);
  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.
  739.  */
  740. set_brk(elf_bss, elf_brk);
  742. /*
  743.  * IRIX maps a page at 0x200000 which holds some system
  744.  * information.  Programs depend on this.
  745.  */
  746. irix_map_prda_page ();
  748. padzero(elf_bss);
  750. #ifdef DEBUG_ELF
  751. printk("(start_brk) %lxn" , (long) current->mm->start_brk);
  752. printk("(end_code) %lxn" , (long) current->mm->end_code);
  753. printk("(start_code) %lxn" , (long) current->mm->start_code);
  754. printk("(end_data) %lxn" , (long) current->mm->end_data);
  755. printk("(start_stack) %lxn" , (long) current->mm->start_stack);
  756. printk("(brk) %lxn" , (long) current->mm->brk);
  757. #endif
  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.
  764.  */
  765. down_write(&current->mm->mmap_sem);
  766. (void) do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
  767.        MAP_FIXED | MAP_PRIVATE, 0);
  768. up_write(&current->mm->mmap_sem);
  769. #endif
  771. start_thread(regs, elf_entry, bprm->p);
  772. if (current->ptrace & PT_PTRACED)
  773. send_sig(SIGTRAP, current, 0);
  774. return 0;
  775. out:
  776. return retval;
  778. out_free_dentry:
  779. allow_write_access(interpreter);
  780. fput(interpreter);
  781. out_free_interp:
  782. if (elf_interpreter)
  783. kfree(elf_interpreter);
  784. out_free_file:
  785. out_free_ph:
  786. kfree (elf_phdata);
  787. goto out;
  788. }
  790. /* This is really simpleminded and specialized - we are loading an
  791.  * a.out library that is given an ELF header.
  792.  */
  793. static int load_irix_library(struct file *file)
  794. {
  795. struct elfhdr elf_ex;
  796. struct elf_phdr *elf_phdata  =  NULL;
  797. unsigned int len = 0;
  798. int elf_bss = 0;
  799. int retval;
  800. unsigned int bss;
  801. int error;
  802. int i,j, k;
  804. error = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
  805. if (error != sizeof(elf_ex))
  806. return -ENOEXEC;
  808. if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
  809. return -ENOEXEC;
  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)
  814. return -ENOEXEC;
  816. /* Now read in all of the header information. */
  817. if(sizeof(struct elf_phdr) * elf_ex.e_phnum > PAGE_SIZE)
  818. return -ENOEXEC;
  820. elf_phdata =  (struct elf_phdr *)
  821. kmalloc(sizeof(struct elf_phdr) * elf_ex.e_phnum, GFP_KERNEL);
  822. if (elf_phdata == NULL)
  823. return -ENOMEM;
  825. retval = kernel_read(file, elf_ex.e_phoff, (char *) elf_phdata,
  826.    sizeof(struct elf_phdr) * elf_ex.e_phnum);
  828. j = 0;
  829. for(i=0; i<elf_ex.e_phnum; i++)
  830. if((elf_phdata + i)->p_type == PT_LOAD) j++;
  832. if(j != 1)  {
  833. kfree(elf_phdata);
  834. return -ENOEXEC;
  835. }
  837. while(elf_phdata->p_type != PT_LOAD) elf_phdata++;
  839. /* Now use mmap to map the library into memory. */
  840. down_write(&current->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_write(&current->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)) {
  853. kfree(elf_phdata);
  854. return error;
  855. }
  857. padzero(elf_bss);
  859. len = (elf_phdata->p_filesz + elf_phdata->p_vaddr+ 0xfff) & 0xfffff000;
  860. bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
  861. if (bss > len)
  862.   do_brk(len, bss-len);
  863. kfree(elf_phdata);
  864. return 0;
  865. }
  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.
  871.  */
  872. unsigned long irix_mapelf(int fd, struct elf_phdr *user_phdrp, int cnt)
  873. {
  874. struct elf_phdr *hp;
  875. struct file *filp;
  876. int i, retval;
  878. #ifdef DEBUG_ELF
  879. printk("irix_mapelf: fd[%d] user_phdrp[%p] cnt[%d]n",
  880.        fd, user_phdrp, cnt);
  881. #endif
  883. /* First get the verification out of the way. */
  884. hp = user_phdrp;
  885. retval = verify_area(VERIFY_READ, hp, (sizeof(struct elf_phdr) * cnt));
  886. if(retval) {
  887. #ifdef DEBUG_ELF
  888. printk("irix_mapelf: verify_area fails!n");
  889. #endif
  890. return retval;
  891. }
  893. #ifdef DEBUG_ELF
  894. dump_phdrs(user_phdrp, cnt);
  895. #endif
  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");
  900. return -ENOEXEC;
  901. }
  903. filp = fget(fd);
  904. if (!filp)
  905. return -EACCES;
  906. if(!filp->f_op) {
  907. printk("irix_mapelf: Bogon filp!n");
  908. fput(filp);
  909. return -EACCES;
  910. }
  912. hp = user_phdrp;
  913. for(i = 0; i < cnt; i++, hp++) {
  914. int prot;
  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_write(&current->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_write(&current->mm->mmap_sem);
  926. if(retval != (hp->p_vaddr & 0xfffff000)) {
  927. printk("irix_mapelf: do_mmap fails with %d!n", retval);
  928. fput(filp);
  929. return retval;
  930. }
  931. }
  933. #ifdef DEBUG_ELF
  934. printk("irix_mapelf: Success, returning %08lxn", user_phdrp->p_vaddr);
  935. #endif
  936. fput(filp);
  937. return user_phdrp->p_vaddr;
  938. }
  940. /*
  941.  * ELF core dumper
  942.  *
  943.  * Modelled on fs/exec.c:aout_core_dump()
  944.  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
  945.  */
  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.
  949.  */
  950. static int dump_write(struct file *file, const void *addr, int nr)
  951. {
  952. return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
  953. }
  955. static int dump_seek(struct file *file, off_t off)
  956. {
  957. if (file->f_op->llseek) {
  958. if (file->f_op->llseek(file, off, 0) != off)
  959. return 0;
  960. } else
  961. file->f_pos = off;
  962. return 1;
  963. }
  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...
  968.  *
  969.  * I think we should skip something. But I am not sure how. H.J.
  970.  */
  971. static inline int maydump(struct vm_area_struct *vma)
  972. {
  973. if (!(vma->vm_flags & (VM_READ|VM_WRITE|VM_EXEC)))
  974. return 0;
  975. #if 1
  976. if (vma->vm_flags & (VM_WRITE|VM_GROWSUP|VM_GROWSDOWN))
  977. return 1;
  978. if (vma->vm_flags & (VM_READ|VM_EXEC|VM_EXECUTABLE|VM_SHARED))
  979. return 0;
  980. #endif
  981. return 1;
  982. }
  984. #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
  986. /* An ELF note in memory. */
  987. struct memelfnote
  988. {
  989. const char *name;
  990. int type;
  991. unsigned int datasz;
  992. void *data;
  993. };
  995. static int notesize(struct memelfnote *en)
  996. {
  997. int sz;
  999. sz = sizeof(struct elf_note);
  1000. sz += roundup(strlen(en->name), 4);
  1001. sz += roundup(en->datasz, 4);
  1003. return sz;
  1004. }
  1006. /* #define DEBUG */
  1008. #define DUMP_WRITE(addr, nr)
  1009. if (!dump_write(file, (addr), (nr))) 
  1010. goto end_coredump;
  1011. #define DUMP_SEEK(off)
  1012. if (!dump_seek(file, (off))) 
  1013. goto end_coredump;
  1015. static int writenote(struct memelfnote *men, struct file *file)
  1016. {
  1017. struct elf_note en;
  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 */
  1030. return 1;
  1032. end_coredump:
  1033. return 0;
  1034. }
  1035. #undef DUMP_WRITE
  1036. #undef DUMP_SEEK
  1038. #define DUMP_WRITE(addr, nr)
  1039. if (!dump_write(file, (addr), (nr))) 
  1040. goto end_coredump;
  1041. #define DUMP_SEEK(off)
  1042. if (!dump_seek(file, (off))) 
  1043. goto end_coredump;
  1045. /* Actual dumper.
  1046.  *
  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
  1049.  * we just truncate.
  1050.  */
  1051. static int irix_core_dump(long signr, struct pt_regs * regs, struct file *file)
  1052. {
  1053. int has_dumped = 0;
  1054. mm_segment_t fs;
  1055. int segs;
  1056. int i;
  1057. size_t size;
  1058. struct vm_area_struct *vma;
  1059. struct elfhdr elf;
  1060. off_t offset = 0, dataoff;
  1061. int limit = current->rlim[RLIMIT_CORE].rlim_cur;
  1062. int numnote = 4;
  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. */
  1069. segs = 0;
  1070. size = 0;
  1071. for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
  1072. if (maydump(vma))
  1073. {
  1074. int sz = vma->vm_end-vma->vm_start;
  1076. if (size+sz >= limit)
  1077. break;
  1078. else
  1079. size += sz;
  1080. }
  1082. segs++;
  1083. }
  1084. #ifdef DEBUG
  1085. printk("irix_core_dump: %d segs taking %d bytesn", segs, size);
  1086. #endif
  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;
  1098. elf.e_entry = 0;
  1099. elf.e_phoff = sizeof(elf);
  1100. elf.e_shoff = 0;
  1101. elf.e_flags = 0;
  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;
  1106. elf.e_shnum = 0;
  1107. elf.e_shstrndx = 0;
  1109. fs = get_fs();
  1110. set_fs(KERNEL_DS);
  1112. has_dumped = 1;
  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.
  1121.  */
  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->pending.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));
  1147. } else {
  1148. *(struct pt_regs *)&prstatus.pr_reg = *regs;
  1149. }
  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;
  1163. {
  1164. int i, len;
  1166. set_fs(fs);
  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;
  1177. set_fs(KERNEL_DS);
  1178. }
  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) {
  1189. numnote--;
  1190. } else {
  1191. notes[3].name = "CORE";
  1192. notes[3].type = NT_PRFPREG;
  1193. notes[3].datasz = sizeof(fpu);
  1194. notes[3].data = &fpu;
  1195. }
  1197. /* Write notes phdr entry. */
  1198. {
  1199. struct elf_phdr phdr;
  1200. int sz = 0;
  1202. for(i = 0; i < numnote; i++)
  1203. sz += notesize(&notes[i]);
  1205. phdr.p_type = PT_NOTE;
  1206. phdr.p_offset = offset;
  1207. phdr.p_vaddr = 0;
  1208. phdr.p_paddr = 0;
  1209. phdr.p_filesz = sz;
  1210. phdr.p_memsz = 0;
  1211. phdr.p_flags = 0;
  1212. phdr.p_align = 0;
  1214. offset += phdr.p_filesz;
  1215. DUMP_WRITE(&phdr, sizeof(phdr));
  1216. }
  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;
  1225. size_t sz;
  1227. i++;
  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;
  1234. phdr.p_paddr = 0;
  1235. phdr.p_filesz = maydump(vma) ? sz : 0;
  1236. phdr.p_memsz = sz;
  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));
  1244. }
  1246. for(i = 0; i < numnote; i++)
  1247. if (!writenote(&notes[i], file))
  1248. goto end_coredump;
  1250. set_fs(fs);
  1252. DUMP_SEEK(dataoff);
  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;
  1260. if (!maydump(vma))
  1261. continue;
  1262. i++;
  1263. #ifdef DEBUG
  1264. printk("elf_core_dump: writing %08lx %lxn", addr, len);
  1265. #endif
  1266. DUMP_WRITE((void *)addr, len);
  1267. }
  1269. if ((off_t) file->f_pos != offset) {
  1270. /* Sanity check. */
  1271. printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)n",
  1272.        (off_t) file->f_pos, offset);
  1273. }
  1275. end_coredump:
  1276. set_fs(fs);
  1277. return has_dumped;
  1278. }
  1280. static int __init init_irix_binfmt(void)
  1281. {
  1282. return register_binfmt(&irix_format);
  1283. }
  1285. static void __exit exit_irix_binfmt(void)
  1286. {
  1287. /* Remove the IRIX ELF loaders. */
  1288. unregister_binfmt(&irix_format);
  1289. }
  1291. module_init(init_irix_binfmt)
  1292. module_exit(exit_irix_binfmt)