fs/binfmt_elf.c
7656 /*
7657 * linux/fs/binfmt_elf.c
7658 *
7659 * These are the functions used to load ELF format
7660 * executables as used on SVr4 machines. Information on
7661 * the format may be found in the book "UNIX SYSTEM V
7662 * RELEASE 4 Programmers Guide: Ansi C and Programming
7663 * Support Tools".
7664 *
7665 * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
7666 */
7667
7668 #include <linux/module.h>
7669
7670 #include <linux/fs.h>
7671 #include <linux/stat.h>
7672 #include <linux/sched.h>
7673 #include <linux/mm.h>
7674 #include <linux/mman.h>
7675 #include <linux/a.out.h>
7676 #include <linux/errno.h>
7677 #include <linux/signal.h>
7678 #include <linux/binfmts.h>
7679 #include <linux/string.h>
7680 #include <linux/file.h>
7681 #include <linux/fcntl.h>
7682 #include <linux/ptrace.h>
7683 #include <linux/malloc.h>
7684 #include <linux/shm.h>
7685 #include <linux/personality.h>
7686 #include <linux/elfcore.h>
7687 #include <linux/init.h>
7688
7689 #include <asm/uaccess.h>
7690 #include <asm/pgtable.h>
7691
7692 #include <linux/config.h>
7693
7694 #define DLINFO_ITEMS 13
7695
7696 #include <linux/elf.h>
7697
7698 static int load_elf_binary(struct linux_binprm * bprm,
7699 struct pt_regs * regs);
7700 static int load_elf_library(int fd);
7701 extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
7702 extern void dump_thread(struct pt_regs *, struct user *);
7703
7704 #ifndef elf_addr_t
7705 #define elf_addr_t unsigned long
7706 #define elf_caddr_t char *
7707 #endif
7708
7709 /* If we don't support core dumping, then supply a NULL
7710 * so we don't even try. */
7711 #ifdef USE_ELF_CORE_DUMP
7712 static int elf_core_dump(long signr,
7713 struct pt_regs * regs);
7714 #else
7715 #define elf_core_dump NULL
7716 #endif
7717
7718 #define ELF_PAGESTART(_v) \
7719 ((_v) & ~(unsigned long)(ELF_EXEC_PAGESIZE-1))
7720 #define ELF_PAGEOFFSET(_v) \
7721 ((_v) & (ELF_EXEC_PAGESIZE-1))
7722 #define ELF_PAGEALIGN(_v) \
7723 (((_v) + ELF_EXEC_PAGESIZE - 1) & \
7724 ~(ELF_EXEC_PAGESIZE - 1))
7725
7726 static struct linux_binfmt elf_format = {
7727 #ifndef MODULE
7728 NULL, NULL,
7729 load_elf_binary, load_elf_library, elf_core_dump
7730 #else
7731 NULL, &__this_module,
7732 load_elf_binary, load_elf_library, elf_core_dump
7733 #endif
7734 };
7735
7736 static void set_brk(unsigned long start,
7737 unsigned long end)
7738 {
7739 start = ELF_PAGEALIGN(start);
7740 end = ELF_PAGEALIGN(end);
7741 if (end <= start)
7742 return;
7743 do_mmap(NULL, start, end - start,
7744 PROT_READ | PROT_WRITE | PROT_EXEC,
7745 MAP_FIXED | MAP_PRIVATE, 0);
7746 }
7747
7748
7749 /* We need to explicitly zero any fractional pages
7750 after the data section (i.e. bss). This would
7751 contain the junk from the file that should not
7752 be in memory */
7753
7754
7755 static void padzero(unsigned long elf_bss)
7756 {
7757 unsigned long nbyte;
7758
7759 nbyte = ELF_PAGEOFFSET(elf_bss);
7760 if (nbyte) {
7761 nbyte = ELF_EXEC_PAGESIZE - nbyte;
7762 clear_user((void *) elf_bss, nbyte);
7763 }
7764 }
7765
7766 static elf_addr_t *
7767 create_elf_tables(char *p, int argc, int envc,
7768 struct elfhdr * exec,
7769 unsigned long load_addr,
7770 unsigned long load_bias,
7771 unsigned long interp_load_addr, int ibcs)
7772 {
7773 elf_caddr_t *argv;
7774 elf_caddr_t *envp;
7775 elf_addr_t *sp, *csp;
7776 char *k_platform, *u_platform;
7777 long hwcap;
7778 size_t platform_len = 0;
7779
7780 /* Get hold of platform and hardware capabilities masks
7781 * for the machine we are running on. In some cases
7782 * (Sparc), this info is impossible to get, in others
7783 * (i386) it is merely difficult. */
7784 hwcap = ELF_HWCAP;
7785 k_platform = ELF_PLATFORM;
7786
7787 if (k_platform) {
7788 platform_len = strlen(k_platform) + 1;
7789 u_platform = p - platform_len;
7790 __copy_to_user(u_platform, k_platform, platform_len);
7791 } else
7792 u_platform = p;
7793
7794 /* Force 16 byte _final_ alignment here for generality.
7795 * Leave an extra 16 bytes free so that on the PowerPC
7796 * we can move the aux table up to start on a 16-byte
7797 * boundary. */
7798 sp = (elf_addr_t *)
7799 ((~15UL & (unsigned long)(u_platform)) - 16UL);
7800 csp = sp;
7801 csp -= ((exec ? DLINFO_ITEMS*2 : 4) +
7802 (k_platform ? 2 : 0));
7803 csp -= envc+1;
7804 csp -= argc+1;
7805 csp -= (!ibcs ? 3 : 1); /* argc itself */
7806 if ((unsigned long)csp & 15UL)
7807 sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
7808
7809 /* Put the ELF interpreter info on the stack */
7810 #define NEW_AUX_ENT(nr, id, val) \
7811 __put_user ((id), sp+(nr*2)); \
7812 __put_user ((val), sp+(nr*2+1)); \
7813
7814 sp -= 2;
7815 NEW_AUX_ENT(0, AT_NULL, 0);
7816 if (k_platform) {
7817 sp -= 2;
7818 NEW_AUX_ENT(0, AT_PLATFORM,
7819 (elf_addr_t)(unsigned long) u_platform);
7820 }
7821 sp -= 2;
7822 NEW_AUX_ENT(0, AT_HWCAP, hwcap);
7823
7824 if (exec) {
7825 sp -= 11*2;
7826
7827 NEW_AUX_ENT(0, AT_PHDR, load_addr + exec->e_phoff);
7828 NEW_AUX_ENT(1, AT_PHENT, sizeof (struct elf_phdr));
7829 NEW_AUX_ENT(2, AT_PHNUM, exec->e_phnum);
7830 NEW_AUX_ENT(3, AT_PAGESZ, ELF_EXEC_PAGESIZE);
7831 NEW_AUX_ENT(4, AT_BASE, interp_load_addr);
7832 NEW_AUX_ENT(5, AT_FLAGS, 0);
7833 NEW_AUX_ENT(6, AT_ENTRY, load_bias + exec->e_entry);
7834 NEW_AUX_ENT(7, AT_UID, (elf_addr_t) current->uid);
7835 NEW_AUX_ENT(8, AT_EUID, (elf_addr_t) current->euid);
7836 NEW_AUX_ENT(9, AT_GID, (elf_addr_t) current->gid);
7837 NEW_AUX_ENT(10, AT_EGID, (elf_addr_t) current->egid);
7838 }
7839 #undef NEW_AUX_ENT
7840
7841 sp -= envc+1;
7842 envp = (elf_caddr_t *) sp;
7843 sp -= argc+1;
7844 argv = (elf_caddr_t *) sp;
7845 if (!ibcs) {
7846 __put_user((elf_addr_t)(unsigned long) envp,--sp);
7847 __put_user((elf_addr_t)(unsigned long) argv,--sp);
7848 }
7849
7850 __put_user((elf_addr_t)argc,--sp);
7851 current->mm->arg_start = (unsigned long) p;
7852 while (argc-->0) {
7853 __put_user((elf_caddr_t)(unsigned long)p,argv++);
7854 p += strlen_user(p);
7855 }
7856 __put_user(NULL, argv);
7857 current->mm->arg_end =
7858 current->mm->env_start = (unsigned long) p;
7859 while (envc-->0) {
7860 __put_user((elf_caddr_t)(unsigned long)p,envp++);
7861 p += strlen_user(p);
7862 }
7863 __put_user(NULL, envp);
7864 current->mm->env_end = (unsigned long) p;
7865 return sp;
7866 }
7867
7868
7869 /* This is much more generalized than the library routine
7870 read function, so we keep this separate. Technically
7871 the library read function is only provided so that we
7872 can read a.out libraries that have an ELF header */
7873
7874 static unsigned long load_elf_interp(
7875 struct elfhdr * interp_elf_ex,
7876 struct dentry * interpreter_dentry,
7877 unsigned long *interp_load_addr)
7878 {
7879 struct file * file;
7880 struct elf_phdr *elf_phdata;
7881 struct elf_phdr *eppnt;
7882 unsigned long load_addr = 0;
7883 int load_addr_set = 0;
7884 unsigned long last_bss = 0, elf_bss = 0;
7885 unsigned long error = ~0UL;
7886 int elf_exec_fileno;
7887 int retval, i, size;
7888
7889 /* First of all, some simple consistency checks */
7890 if (interp_elf_ex->e_type != ET_EXEC &&
7891 interp_elf_ex->e_type != ET_DYN)
7892 goto out;
7893 if (!elf_check_arch(interp_elf_ex->e_machine))
7894 goto out;
7895 if (!interpreter_dentry->d_inode->i_op ||
7896 !interpreter_dentry->d_inode->i_op->
7897 default_file_ops->mmap)
7898 goto out;
7899
7900 /* If the size of this structure has changed, then
7901 * punt, since we will be doing the wrong thing. */
7902 if (interp_elf_ex->e_phentsize !=
7903 sizeof(struct elf_phdr))
7904 goto out;
7905
7906 /* Now read in all of the header information */
7907
7908 size = sizeof(struct elf_phdr) *interp_elf_ex->e_phnum;
7909 if (size > ELF_EXEC_PAGESIZE)
7910 goto out;
7911 elf_phdata =
7912 (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
7913 if (!elf_phdata)
7914 goto out;
7915
7916 retval = read_exec(interpreter_dentry,
7917 interp_elf_ex->e_phoff,
7918 (char *) elf_phdata, size, 1);
7919 error = retval;
7920 if (retval < 0)
7921 goto out_free;
7922
7923 error = ~0UL;
7924 elf_exec_fileno = open_dentry(interpreter_dentry,
7925 O_RDONLY);
7926 if (elf_exec_fileno < 0)
7927 goto out_free;
7928 file = fget(elf_exec_fileno);
7929
7930 eppnt = elf_phdata;
7931 for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
7932 if (eppnt->p_type == PT_LOAD) {
7933 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
7934 int elf_prot = 0;
7935 unsigned long vaddr = 0;
7936 unsigned long k, map_addr;
7937
7938 if (eppnt->p_flags & PF_R) elf_prot = PROT_READ;
7939 if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
7940 if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
7941 vaddr = eppnt->p_vaddr;
7942 if (interp_elf_ex->e_type == ET_EXEC ||
7943 load_addr_set) {
7944 elf_type |= MAP_FIXED;
7945 #ifdef __sparc__
7946 } else {
7947 load_addr = get_unmapped_area(0, eppnt->p_filesz +
7948 ELF_PAGEOFFSET(vaddr));
7949 #endif
7950 }
7951
7952 map_addr = do_mmap(file,
7953 load_addr + ELF_PAGESTART(vaddr),
7954 eppnt->p_filesz +
7955 ELF_PAGEOFFSET(eppnt->p_vaddr),
7956 elf_prot,
7957 elf_type,
7958 eppnt->p_offset -
7959 ELF_PAGEOFFSET(eppnt->p_vaddr));
7960 if (map_addr > -1024UL) /* Real error */
7961 goto out_close;
7962
7963 if (!load_addr_set &&
7964 interp_elf_ex->e_type == ET_DYN) {
7965 load_addr = map_addr - ELF_PAGESTART(vaddr);
7966 load_addr_set = 1;
7967 }
7968
7969 /* Find the end of the file mapping for this phdr,
7970 * and keep track of the largest address we see for
7971 * this. */
7972 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
7973 if (k > elf_bss)
7974 elf_bss = k;
7975
7976 /* Do the same thing for the memory mapping -
7977 * between elf_bss and last_bss is the bss section.
7978 */
7979 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
7980 if (k > last_bss)
7981 last_bss = k;
7982 }
7983 }
7984
7985 /* Now use mmap to map the library into memory. */
7986
7987 /* Now fill out the bss section. First pad the last
7988 * page up to the page boundary, and then perform a
7989 * mmap to make sure that there are zero-mapped pages
7990 * up to and including the last bss page. */
7991 padzero(elf_bss);
7992 /* What we have mapped so far */
7993 elf_bss = ELF_PAGESTART(elf_bss +
7994 ELF_EXEC_PAGESIZE - 1);
7995
7996 /* Map the last of the bss segment */
7997 if (last_bss > elf_bss)
7998 do_mmap(NULL, elf_bss, last_bss - elf_bss,
7999 PROT_READ|PROT_WRITE|PROT_EXEC,
8000 MAP_FIXED|MAP_PRIVATE, 0);
8001
8002 *interp_load_addr = load_addr;
8003 error =
8004 ((unsigned long) interp_elf_ex->e_entry) + load_addr;
8005
8006 out_close:
8007 fput(file);
8008 sys_close(elf_exec_fileno);
8009 out_free:
8010 kfree(elf_phdata);
8011 out:
8012 return error;
8013 }
8014
8015 static unsigned long load_aout_interp(
8016 struct exec * interp_ex,
8017 struct dentry * interpreter_dentry)
8018 {
8019 unsigned long text_data, offset, elf_entry = ~0UL;
8020 char * addr;
8021 int retval;
8022
8023 current->mm->end_code = interp_ex->a_text;
8024 text_data = interp_ex->a_text + interp_ex->a_data;
8025 current->mm->end_data = text_data;
8026 current->mm->brk = interp_ex->a_bss + text_data;
8027
8028 switch (N_MAGIC(*interp_ex)) {
8029 case OMAGIC:
8030 offset = 32;
8031 addr = (char *) 0;
8032 break;
8033 case ZMAGIC:
8034 case QMAGIC:
8035 offset = N_TXTOFF(*interp_ex);
8036 addr = (char *) N_TXTADDR(*interp_ex);
8037 break;
8038 default:
8039 goto out;
8040 }
8041
8042 do_mmap(NULL, 0, text_data,
8043 PROT_READ|PROT_WRITE|PROT_EXEC,
8044 MAP_FIXED|MAP_PRIVATE, 0);
8045 retval = read_exec(interpreter_dentry, offset, addr,
8046 text_data, 0);
8047 if (retval < 0)
8048 goto out;
8049 flush_icache_range((unsigned long)addr,
8050 (unsigned long)addr + text_data);
8051
8052 do_mmap(NULL,
8053 ELF_PAGESTART(text_data + ELF_EXEC_PAGESIZE-1),
8054 interp_ex->a_bss,
8055 PROT_READ|PROT_WRITE|PROT_EXEC,
8056 MAP_FIXED|MAP_PRIVATE, 0);
8057 elf_entry = interp_ex->a_entry;
8058
8059 out:
8060 return elf_entry;
8061 }
8062
8063 /* These are the functions used to load ELF style
8064 * executables and shared libraries. There is no binary
8065 * dependent code anywhere else. */
8066
8067 #define INTERPRETER_NONE 0
8068 #define INTERPRETER_AOUT 1
8069 #define INTERPRETER_ELF 2
8070
8071
8072 static inline int
8073 do_load_elf_binary(struct linux_binprm * bprm,
8074 struct pt_regs * regs)
8075 {
8076 struct file * file;
8077 struct dentry *interpreter_dentry = NULL;
8078 unsigned long load_addr = 0, load_bias;
8079 int load_addr_set = 0;
8080 char * elf_interpreter = NULL;
8081 unsigned int interpreter_type = INTERPRETER_NONE;
8082 unsigned char ibcs2_interpreter = 0;
8083 mm_segment_t old_fs;
8084 unsigned long error;
8085 struct elf_phdr * elf_ppnt, *elf_phdata;
8086 unsigned long elf_bss, k, elf_brk;
8087 int elf_exec_fileno;
8088 int retval, size, i;
8089 unsigned long elf_entry, interp_load_addr = 0;
8090 unsigned long start_code, end_code, end_data;
8091 struct elfhdr elf_ex;
8092 struct elfhdr interp_elf_ex;
8093 struct exec interp_ex;
8094 char passed_fileno[6];
8095
8096 /* Get the exec-header */
8097 elf_ex = *((struct elfhdr *) bprm->buf);
8098
8099 retval = -ENOEXEC;
8100 /* First of all, some simple consistency checks */
8101 if (elf_ex.e_ident[0] != 0x7f ||
8102 strncmp(&elf_ex.e_ident[1], "ELF", 3) != 0)
8103 goto out;
8104
8105 if (elf_ex.e_type != ET_EXEC &&
8106 elf_ex.e_type != ET_DYN)
8107 goto out;
8108 if (!elf_check_arch(elf_ex.e_machine))
8109 goto out;
8110 #ifdef __mips__
8111 /* IRIX binaries handled elsewhere. */
8112 if (elf_ex.e_flags & EF_MIPS_ARCH) {
8113 retval = -ENOEXEC;
8114 goto out;
8115 }
8116 #endif
8117 if (!bprm->dentry->d_inode->i_op ||
8118 !bprm->dentry->d_inode->i_op->default_file_ops ||
8119 !bprm->dentry->d_inode->i_op->default_file_ops->
8120 mmap)
8121 goto out;
8122
8123 /* Now read in all of the header information */
8124
8125 retval = -ENOMEM;
8126 size = elf_ex.e_phentsize * elf_ex.e_phnum;
8127 elf_phdata =
8128 (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
8129 if (!elf_phdata)
8130 goto out;
8131
8132 retval = read_exec(bprm->dentry, elf_ex.e_phoff,
8133 (char *) elf_phdata, size, 1);
8134 if (retval < 0)
8135 goto out_free_ph;
8136
8137 retval = open_dentry(bprm->dentry, O_RDONLY);
8138 if (retval < 0)
8139 goto out_free_ph;
8140 elf_exec_fileno = retval;
8141 file = fget(elf_exec_fileno);
8142
8143 elf_ppnt = elf_phdata;
8144 elf_bss = 0;
8145 elf_brk = 0;
8146
8147 start_code = ~0UL;
8148 end_code = 0;
8149 end_data = 0;
8150
8151 for (i = 0; i < elf_ex.e_phnum; i++) {
8152 if (elf_ppnt->p_type == PT_INTERP) {
8153 retval = -EINVAL;
8154 if (elf_interpreter)
8155 goto out_free_interp;
8156
8157 /* This is the program interpreter used for
8158 * shared libraries - for now assume that this
8159 * is an a.out format binary
8160 */
8161
8162 retval = -ENOMEM;
8163 elf_interpreter =
8164 (char *) kmalloc(elf_ppnt->p_filesz, GFP_KERNEL);
8165 if (!elf_interpreter)
8166 goto out_free_file;
8167
8168 retval = read_exec(bprm->dentry,
8169 elf_ppnt->p_offset,
8170 elf_interpreter,
8171 elf_ppnt->p_filesz, 1);
8172 if (retval < 0)
8173 goto out_free_interp;
8174 /* If the program interpreter is one of these two,
8175 * then assume an iBCS2 image. Otherwise assume
8176 * a native linux image.
8177 */
8178 if (!strcmp(elf_interpreter,"/usr/lib/libc.so.1")
8179 || !strcmp(elf_interpreter,"/usr/lib/ld.so.1"))
8180 ibcs2_interpreter = 1;
8181 #if 0
8182 printk("Using ELF interpreter %s\n",
8183 elf_interpreter);
8184 #endif
8185 old_fs = get_fs(); /* Could probably be optimized*/
8186 set_fs(get_ds());
8187 #ifdef __sparc__
8188 if (ibcs2_interpreter) {
8189 unsigned long old_pers = current->personality;
8190
8191 current->personality = PER_SVR4;
8192 interpreter_dentry = open_namei(elf_interpreter,
8193 0, 0);
8194 current->personality = old_pers;
8195 } else
8196 #endif
8197 interpreter_dentry = open_namei(elf_interpreter,
8198 0, 0);
8199 set_fs(old_fs);
8200 retval = PTR_ERR(interpreter_dentry);
8201 if (IS_ERR(interpreter_dentry))
8202 goto out_free_interp;
8203 retval = permission(interpreter_dentry->d_inode,
8204 MAY_EXEC);
8205 if (retval < 0)
8206 goto out_free_dentry;
8207 retval = read_exec(interpreter_dentry, 0,
8208 bprm->buf, 128, 1);
8209 if (retval < 0)
8210 goto out_free_dentry;
8211
8212 /* Get the exec headers */
8213 interp_ex = *((struct exec *) bprm->buf);
8214 interp_elf_ex = *((struct elfhdr *) bprm->buf);
8215 }
8216 elf_ppnt++;
8217 }
8218
8219 /* Some simple consistency checks for the interpreter*/
8220 if (elf_interpreter) {
8221 interpreter_type = INTERPRETER_ELF|INTERPRETER_AOUT;
8222
8223 /* Now figure out which format our binary is */
8224 if ((N_MAGIC(interp_ex) != OMAGIC) &&
8225 (N_MAGIC(interp_ex) != ZMAGIC) &&
8226 (N_MAGIC(interp_ex) != QMAGIC))
8227 interpreter_type = INTERPRETER_ELF;
8228
8229 if (interp_elf_ex.e_ident[0] != 0x7f ||
8230 strncmp(&interp_elf_ex.e_ident[1], "ELF", 3))
8231 interpreter_type &= ~INTERPRETER_ELF;
8232
8233 retval = -ELIBBAD;
8234 if (!interpreter_type)
8235 goto out_free_dentry;
8236
8237 /* Make sure only one type was selected */
8238 if ((interpreter_type & INTERPRETER_ELF) &&
8239 interpreter_type != INTERPRETER_ELF) {
8240 printk(KERN_WARNING
8241 "ELF: Ambiguous type, using ELF\n");
8242 interpreter_type = INTERPRETER_ELF;
8243 }
8244 }
8245
8246 /* OK, we are done with that, now set up the arg stuff,
8247 and then start this sucker up */
8248
8249 if (!bprm->sh_bang) {
8250 char * passed_p;
8251
8252 if (interpreter_type == INTERPRETER_AOUT) {
8253 sprintf(passed_fileno, "%d", elf_exec_fileno);
8254 passed_p = passed_fileno;
8255
8256 if (elf_interpreter) {
8257 bprm->p = copy_strings(1, &passed_p, bprm->page,
8258 bprm->p, 2);
8259 bprm->argc++;
8260 }
8261 }
8262 retval = -E2BIG;
8263 if (!bprm->p)
8264 goto out_free_dentry;
8265 }
8266
8267 /* Flush all traces of the currently running exe */
8268 retval = flush_old_exec(bprm);
8269 if (retval)
8270 goto out_free_dentry;
8271
8272 /* OK, This is the point of no return */
8273 current->mm->end_data = 0;
8274 current->mm->end_code = 0;
8275 current->mm->mmap = NULL;
8276 current->flags &= ~PF_FORKNOEXEC;
8277 elf_entry = (unsigned long) elf_ex.e_entry;
8278
8279 /* Do this immediately, since STACK_TOP as used in
8280 setup_arg_pages may depend on the personality. */
8281 SET_PERSONALITY(elf_ex, ibcs2_interpreter);
8282
8283 /* Do this so that we can load the interpreter, if need
8284 be. We will change some of these later */
8285 current->mm->rss = 0;
8286 bprm->p = setup_arg_pages(bprm->p, bprm);
8287 current->mm->start_stack = bprm->p;
8288
8289 /* Try and get dynamic programs out of the way of the
8290 default mmap base, as well as whatever program they
8291 might try to exec. This is because the brk will
8292 follow the loader, and is not movable. */
8293
8294 load_bias = ELF_PAGESTART(elf_ex.e_type == ET_DYN
8295 ? ELF_ET_DYN_BASE : 0);
8296
8297 /* Now we do a little grungy work by mmaping the ELF
8298 image into the correct location in memory. At this
8299 point, we assume that the image should be loaded at
8300 fixed address, not at a variable address. */
8301
8302 old_fs = get_fs();
8303 set_fs(get_ds());
8304 for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum;
8305 i++, elf_ppnt++) {
8306 int elf_prot = 0, elf_flags;
8307 unsigned long vaddr;
8308
8309 if (elf_ppnt->p_type != PT_LOAD)
8310 continue;
8311
8312 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
8313 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
8314 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
8315
8316 elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
8317
8318 vaddr = elf_ppnt->p_vaddr;
8319 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
8320 elf_flags |= MAP_FIXED;
8321 }
8322
8323 error = do_mmap(file,
8324 ELF_PAGESTART(load_bias + vaddr),
8325 (elf_ppnt->p_filesz +
8326 ELF_PAGEOFFSET(elf_ppnt->p_vaddr)),
8327 elf_prot, elf_flags, (elf_ppnt->p_offset -
8328 ELF_PAGEOFFSET(elf_ppnt->p_vaddr)));
8329
8330 if (!load_addr_set) {
8331 load_addr_set = 1;
8332 load_addr =
8333 (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
8334 if (elf_ex.e_type == ET_DYN) {
8335 load_bias += error -
8336 ELF_PAGESTART(load_bias + vaddr);
8337 load_addr += error;
8338 }
8339 }
8340 k = elf_ppnt->p_vaddr;
8341 if (k < start_code) start_code = k;
8342 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
8343 if (k > elf_bss)
8344 elf_bss = k;
8345 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
8346 end_code = k;
8347 if (end_data < k)
8348 end_data = k;
8349 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
8350 if (k > elf_brk)
8351 elf_brk = k;
8352 }
8353 set_fs(old_fs);
8354 fput(file); /* all done with the file */
8355
8356 elf_entry += load_bias;
8357 elf_bss += load_bias;
8358 elf_brk += load_bias;
8359 start_code += load_bias;
8360 end_code += load_bias;
8361 end_data += load_bias;
8362
8363 if (elf_interpreter) {
8364 if (interpreter_type == INTERPRETER_AOUT)
8365 elf_entry = load_aout_interp(&interp_ex,
8366 interpreter_dentry);
8367 else
8368 elf_entry = load_elf_interp(&interp_elf_ex,
8369 interpreter_dentry,
8370 &interp_load_addr);
8371
8372 dput(interpreter_dentry);
8373 kfree(elf_interpreter);
8374
8375 if (elf_entry == ~0UL) {
8376 printk(KERN_ERR "Unable to load interpreter\n");
8377 kfree(elf_phdata);
8378 send_sig(SIGSEGV, current, 0);
8379 return 0;
8380 }
8381 }
8382
8383 kfree(elf_phdata);
8384
8385 if (interpreter_type != INTERPRETER_AOUT)
8386 sys_close(elf_exec_fileno);
8387
8388 if (current->exec_domain &&
8389 current->exec_domain->module)
8390 __MOD_DEC_USE_COUNT(current->exec_domain->module);
8391 if (current->binfmt && current->binfmt->module)
8392 __MOD_DEC_USE_COUNT(current->binfmt->module);
8393 current->exec_domain =
8394 lookup_exec_domain(current->personality);
8395 current->binfmt = &elf_format;
8396 if (current->exec_domain &&
8397 current->exec_domain->module)
8398 __MOD_INC_USE_COUNT(current->exec_domain->module);
8399 if (current->binfmt && current->binfmt->module)
8400 __MOD_INC_USE_COUNT(current->binfmt->module);
8401
8402 #ifndef VM_STACK_FLAGS
8403 current->executable = dget(bprm->dentry);
8404 #endif
8405 compute_creds(bprm);
8406 current->flags &= ~PF_FORKNOEXEC;
8407 bprm->p = (unsigned long)
8408 create_elf_tables((char *)bprm->p,
8409 bprm->argc,
8410 bprm->envc,
8411 (interpreter_type == INTERPRETER_ELF
8412 ? &elf_ex : NULL),
8413 load_addr, load_bias,
8414 interp_load_addr,
8415 (interpreter_type == INTERPRETER_AOUT ? 0 : 1));
8416 /* N.B. passed_fileno might not be initialized? */
8417 if (interpreter_type == INTERPRETER_AOUT)
8418 current->mm->arg_start += strlen(passed_fileno) + 1;
8419 current->mm->start_brk = current->mm->brk = elf_brk;
8420 current->mm->end_code = end_code;
8421 current->mm->start_code = start_code;
8422 current->mm->end_data = end_data;
8423 current->mm->start_stack = bprm->p;
8424
8425 /* Calling set_brk effectively mmaps the pages that we
8426 * need for the bss and break sections */
8427 set_brk(elf_bss, elf_brk);
8428
8429 padzero(elf_bss);
8430
8431 #if 0
8432 printk("(start_brk) %x\n" , current->mm->start_brk);
8433 printk("(end_code) %x\n" , current->mm->end_code);
8434 printk("(start_code) %x\n" , current->mm->start_code);
8435 printk("(end_data) %x\n" , current->mm->end_data);
8436 printk("(start_stack) %x\n", current->mm->start_stack);
8437 printk("(brk) %x\n" , current->mm->brk);
8438 #endif
8439
8440 if ( current->personality == PER_SVR4 )
8441 {
8442 /* Why this, you ask??? Well SVr4 maps page 0 as
8443 read-only, and some applications "depend" upon
8444 this behavior. Since we do not have the power to
8445 recompile these, we emulate the SVr4 behavior.
8446 Sigh. */
8447 /* N.B. Shouldn't the size here be PAGE_SIZE?? */
8448 error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
8449 MAP_FIXED | MAP_PRIVATE, 0);
8450 }
8451
8452 #ifdef ELF_PLAT_INIT
8453 /* The ABI may specify that certain registers be set up
8454 * in special ways (on i386 %edx is the address of a
8455 * DT_FINI function, for example. This macro performs
8456 * whatever initialization to the regs structure is
8457 * required. */
8458 ELF_PLAT_INIT(regs);
8459 #endif
8460
8461 start_thread(regs, elf_entry, bprm->p);
8462 if (current->flags & PF_PTRACED)
8463 send_sig(SIGTRAP, current, 0);
8464 retval = 0;
8465 out:
8466 return retval;
8467
8468 /* error cleanup */
8469 out_free_dentry:
8470 dput(interpreter_dentry);
8471 out_free_interp:
8472 if (elf_interpreter)
8473 kfree(elf_interpreter);
8474 out_free_file:
8475 fput(file);
8476 sys_close(elf_exec_fileno);
8477 out_free_ph:
8478 kfree(elf_phdata);
8479 goto out;
8480 }
8481
8482 static int
8483 load_elf_binary(struct linux_binprm * bprm,
8484 struct pt_regs * regs)
8485 {
8486 int retval;
8487
8488 MOD_INC_USE_COUNT;
8489 retval = do_load_elf_binary(bprm, regs);
8490 MOD_DEC_USE_COUNT;
8491 return retval;
8492 }
8493
8494 /* This is really simpleminded and specialized - we are
8495 loading an a.out library that is given an ELF
8496 header. */
8497
8498 static inline int
8499 do_load_elf_library(int fd)
8500 {
8501 struct file * file;
8502 struct dentry * dentry;
8503 struct inode * inode;
8504 struct elf_phdr *elf_phdata;
8505 unsigned long elf_bss = 0, bss, len, k;
8506 int retval, error, i, j;
8507 struct elfhdr elf_ex;
8508 loff_t offset = 0;
8509
8510 error = -EACCES;
8511 file = fget(fd);
8512 if (!file || !file->f_op)
8513 goto out;
8514 dentry = file->f_dentry;
8515 inode = dentry->d_inode;
8516
8517 /* seek to the beginning of the file */
8518 error = -ENOEXEC;
8519
8520 /* N.B. save current DS?? */
8521 set_fs(KERNEL_DS);
8522 retval = file->f_op->read(file, (char *) &elf_ex,
8523 sizeof(elf_ex), &offset);
8524 set_fs(USER_DS);
8525 if (retval != sizeof(elf_ex))
8526 goto out_putf;
8527
8528 if (elf_ex.e_ident[0] != 0x7f ||
8529 strncmp(&elf_ex.e_ident[1], "ELF", 3) != 0)
8530 goto out_putf;
8531
8532 /* First of all, some simple consistency checks */
8533 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
8534 !elf_check_arch(elf_ex.e_machine) ||
8535 (!inode->i_op ||
8536 !inode->i_op->default_file_ops->mmap))
8537 goto out_putf;
8538
8539 /* Now read in all of the header information */
8540
8541 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
8542 if (j > ELF_EXEC_PAGESIZE)
8543 goto out_putf;
8544
8545 error = -ENOMEM;
8546 elf_phdata = (struct elf_phdr *) kmalloc(j,GFP_KERNEL);
8547 if (!elf_phdata)
8548 goto out_putf;
8549
8550 /* N.B. check for error return?? */
8551 retval = read_exec(dentry, elf_ex.e_phoff,
8552 (char *) elf_phdata,
8553 sizeof(struct elf_phdr) * elf_ex.e_phnum, 1);
8554
8555 error = -ENOEXEC;
8556 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
8557 if ((elf_phdata + i)->p_type == PT_LOAD) j++;
8558 if (j != 1)
8559 goto out_free_ph;
8560
8561 while (elf_phdata->p_type != PT_LOAD) elf_phdata++;
8562
8563 /* Now use mmap to map the library into memory. */
8564 error = do_mmap(file,
8565 ELF_PAGESTART(elf_phdata->p_vaddr),
8566 (elf_phdata->p_filesz +
8567 ELF_PAGEOFFSET(elf_phdata->p_vaddr)),
8568 PROT_READ | PROT_WRITE | PROT_EXEC,
8569 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
8570 (elf_phdata->p_offset -
8571 ELF_PAGEOFFSET(elf_phdata->p_vaddr)));
8572 if (error != ELF_PAGESTART(elf_phdata->p_vaddr))
8573 goto out_free_ph;
8574
8575 k = elf_phdata->p_vaddr + elf_phdata->p_filesz;
8576 if (k > elf_bss)
8577 elf_bss = k;
8578 padzero(elf_bss);
8579
8580 len = ELF_PAGESTART(elf_phdata->p_filesz +
8581 elf_phdata->p_vaddr +
8582 ELF_EXEC_PAGESIZE - 1);
8583 bss = elf_phdata->p_memsz + elf_phdata->p_vaddr;
8584 if (bss > len)
8585 do_mmap(NULL, len, bss - len,
8586 PROT_READ|PROT_WRITE|PROT_EXEC,
8587 MAP_FIXED|MAP_PRIVATE, 0);
8588 error = 0;
8589
8590 out_free_ph:
8591 kfree(elf_phdata);
8592 out_putf:
8593 fput(file);
8594 out:
8595 return error;
8596 }
8597
8598 static int load_elf_library(int fd)
8599 {
8600 int retval;
8601
8602 MOD_INC_USE_COUNT;
8603 retval = do_load_elf_library(fd);
8604 MOD_DEC_USE_COUNT;
8605 return retval;
8606 }
8607
8608 /* Note that some platforms still use traditional core
8609 * dumps and not the ELF core dump. Each platform can
8610 * select it as appropriate. */
8611 #ifdef USE_ELF_CORE_DUMP
8612
8613 /* ELF core dumper
8614 *
8615 * Modelled on fs/exec.c:aout_core_dump()
8616 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
8617 */
8618 /* These are the only things you should do on a
8619 * core-file: use only these functions to write out all
8620 * the necessary info. */
8621 static int dump_write(struct file *file,
8622 const void *addr, int nr)
8623 {
8624 return file->f_op->write(file, addr, nr, &file->f_pos)
8625 == nr;
8626 }
8627
8628 static int dump_seek(struct file *file, off_t off)
8629 {
8630 if (file->f_op->llseek) {
8631 if (file->f_op->llseek(file, off, 0) != off)
8632 return 0;
8633 } else
8634 file->f_pos = off;
8635 return 1;
8636 }
8637
8638 /* Decide whether a segment is worth dumping; default is
8639 * yes to be sure (missing info is worse than too much;
8640 * etc). Personally I'd include everything, and use the
8641 * coredump limit...
8642 *
8643 * I think we should skip something. But I am not sure
8644 * how. H.J. */
8645 static inline int maydump(struct vm_area_struct *vma)
8646 {
8647 if (!(vma->vm_flags & (VM_READ|VM_WRITE|VM_EXEC)))
8648 return 0;
8649
8650 /* Do not dump I/O mapped devices! -DaveM */
8651 if(vma->vm_flags & VM_IO)
8652 return 0;
8653 #if 1
8654 if (vma->vm_flags & (VM_WRITE|VM_GROWSUP|VM_GROWSDOWN))
8655 return 1;
8656 if (vma->vm_flags & (VM_READ|VM_EXEC|VM_EXECUTABLE|
8657 VM_SHARED))
8658 return 0;
8659 #endif
8660 return 1;
8661 }
8662
8663 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
8664
8665 /* An ELF note in memory */
8666 struct memelfnote
8667 {
8668 const char *name;
8669 int type;
8670 unsigned int datasz;
8671 void *data;
8672 };
8673
8674 static int notesize(struct memelfnote *en)
8675 {
8676 int sz;
8677
8678 sz = sizeof(struct elf_note);
8679 sz += roundup(strlen(en->name), 4);
8680 sz += roundup(en->datasz, 4);
8681
8682 return sz;
8683 }
8684
8685 /* #define DEBUG */
8686
8687 #ifdef DEBUG
8688 static void dump_regs(const char *str, elf_greg_t *r)
8689 {
8690 int i;
8691 static const char *regs[] = {
8692 "ebx", "ecx", "edx", "esi", "edi", "ebp",
8693 "eax", "ds", "es", "fs", "gs",
8694 "orig_eax", "eip", "cs",
8695 "efl", "uesp", "ss"};
8696 printk("Registers: %s\n", str);
8697
8698 for(i = 0; i < ELF_NGREG; i++)
8699 {
8700 unsigned long val = r[i];
8701 printk(" %-2d %-5s=%08lx %lu\n",
8702 i, regs[i], val, val);
8703 }
8704 }
8705 #endif
8706
8707 #define DUMP_WRITE(addr, nr) \
8708 do { if (!dump_write(file, (addr), (nr))) return 0; } \
8709 while(0)
8710 #define DUMP_SEEK(off) \
8711 do { if (!dump_seek(file, (off))) return 0; } while(0)
8712
8713 static int writenote(struct memelfnote *men,
8714 struct file *file)
8715 {
8716 struct elf_note en;
8717
8718 en.n_namesz = strlen(men->name);
8719 en.n_descsz = men->datasz;
8720 en.n_type = men->type;
8721
8722 DUMP_WRITE(&en, sizeof(en));
8723 DUMP_WRITE(men->name, en.n_namesz);
8724 /* XXX - cast from long long to long to avoid need for
8725 * libgcc.a */
8726 /* XXX */
8727 DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));
8728 DUMP_WRITE(men->data, men->datasz);
8729 /* XXX */
8730 DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));
8731
8732 return 1;
8733 }
8734 #undef DUMP_WRITE
8735 #undef DUMP_SEEK
8736
8737 #define DUMP_WRITE(addr, nr) \
8738 if (!dump_write(&file, (addr), (nr))) \
8739 goto close_coredump;
8740 #define DUMP_SEEK(off) \
8741 if (!dump_seek(&file, (off))) \
8742 goto close_coredump;
8743 /* Actual dumper
8744 *
8745 * This is a two-pass process; first we find the offsets
8746 * of the bits, and then they are actually written out.
8747 * If we run out of core limit we just truncate. */
8748 static int elf_core_dump(long signr,
8749 struct pt_regs * regs)
8750 {
8751 int has_dumped = 0;
8752 struct file file;
8753 struct dentry *dentry;
8754 struct inode *inode;
8755 mm_segment_t fs;
8756 char corefile[6+sizeof(current->comm)];
8757 int segs;
8758 int i;
8759 size_t size;
8760 struct vm_area_struct *vma;
8761 struct elfhdr elf;
8762 off_t offset = 0, dataoff;
8763 unsigned long limit =
8764 current->rlim[RLIMIT_CORE].rlim_cur;
8765 int numnote = 4;
8766 struct memelfnote notes[4];
8767 struct elf_prstatus prstatus; /* NT_PRSTATUS */
8768 elf_fpregset_t fpu; /* NT_PRFPREG */
8769 struct elf_prpsinfo psinfo; /* NT_PRPSINFO */
8770
8771 if (!current->dumpable ||
8772 limit < ELF_EXEC_PAGESIZE ||
8773 atomic_read(¤t->mm->count) != 1)
8774 return 0;
8775 current->dumpable = 0;
8776
8777 #ifndef CONFIG_BINFMT_ELF
8778 MOD_INC_USE_COUNT;
8779 #endif
8780
8781 /* Count what's needed to dump, up to the limit of
8782 * coredump size */
8783 segs = 0;
8784 size = 0;
8785 for(vma = current->mm->mmap; vma != NULL;
8786 vma = vma->vm_next) {
8787 if (maydump(vma))
8788 {
8789 unsigned long sz = vma->vm_end-vma->vm_start;
8790
8791 if (size+sz >= limit)
8792 break;
8793 else
8794 size += sz;
8795 }
8796
8797 segs++;
8798 }
8799 #ifdef DEBUG
8800 printk("elf_core_dump: %d segs taking %d bytes\n",
8801 segs, size);
8802 #endif
8803
8804 /* Set up header */
8805 memcpy(elf.e_ident, ELFMAG, SELFMAG);
8806 elf.e_ident[EI_CLASS] = ELF_CLASS;
8807 elf.e_ident[EI_DATA] = ELF_DATA;
8808 elf.e_ident[EI_VERSION] = EV_CURRENT;
8809 memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
8810
8811 elf.e_type = ET_CORE;
8812 elf.e_machine = ELF_ARCH;
8813 elf.e_version = EV_CURRENT;
8814 elf.e_entry = 0;
8815 elf.e_phoff = sizeof(elf);
8816 elf.e_shoff = 0;
8817 elf.e_flags = 0;
8818 elf.e_ehsize = sizeof(elf);
8819 elf.e_phentsize = sizeof(struct elf_phdr);
8820 elf.e_phnum = segs+1; /* Include notes */
8821 elf.e_shentsize = 0;
8822 elf.e_shnum = 0;
8823 elf.e_shstrndx = 0;
8824
8825 fs = get_fs();
8826 set_fs(KERNEL_DS);
8827 memcpy(corefile,"core.",5);
8828 #if 0
8829 memcpy(corefile+5,current->comm,sizeof(current->comm));
8830 #else
8831 corefile[4] = '\0';
8832 #endif
8833 dentry = open_namei(corefile,
8834 O_CREAT | 2 | O_TRUNC | O_NOFOLLOW, 0600);
8835 if (IS_ERR(dentry)) {
8836 dentry = NULL;
8837 goto end_coredump;
8838 }
8839 inode = dentry->d_inode;
8840
8841 if(inode->i_nlink > 1)
8842 goto end_coredump; /* multiple links - don't dump */
8843
8844 if (!S_ISREG(inode->i_mode))
8845 goto end_coredump;
8846 if (!inode->i_op || !inode->i_op->default_file_ops)
8847 goto end_coredump;
8848 if (init_private_file(&file, dentry, 3))
8849 goto end_coredump;
8850 if (!file.f_op->write)
8851 goto close_coredump;
8852 has_dumped = 1;
8853 current->flags |= PF_DUMPCORE;
8854
8855 DUMP_WRITE(&elf, sizeof(elf));
8856 offset += sizeof(elf); /* Elf header */
8857 /* Program headers */
8858 offset += (segs+1) * sizeof(struct elf_phdr);
8859
8860 /* Set up the notes in similar form to SVR4 core dumps
8861 * made with info from their /proc. */
8862 memset(&psinfo, 0, sizeof(psinfo));
8863 memset(&prstatus, 0, sizeof(prstatus));
8864
8865 notes[0].name = "CORE";
8866 notes[0].type = NT_PRSTATUS;
8867 notes[0].datasz = sizeof(prstatus);
8868 notes[0].data = &prstatus;
8869 prstatus.pr_info.si_signo = prstatus.pr_cursig = signr;
8870 prstatus.pr_sigpend = current->signal.sig[0];
8871 prstatus.pr_sighold = current->blocked.sig[0];
8872 psinfo.pr_pid = prstatus.pr_pid = current->pid;
8873 psinfo.pr_ppid = prstatus.pr_ppid =
8874 current->p_pptr->pid;
8875 psinfo.pr_pgrp = prstatus.pr_pgrp = current->pgrp;
8876 psinfo.pr_sid = prstatus.pr_sid = current->session;
8877 prstatus.pr_utime.tv_sec =
8878 CT_TO_SECS(current->times.tms_utime);
8879 prstatus.pr_utime.tv_usec =
8880 CT_TO_USECS(current->times.tms_utime);
8881 prstatus.pr_stime.tv_sec =
8882 CT_TO_SECS(current->times.tms_stime);
8883 prstatus.pr_stime.tv_usec =
8884 CT_TO_USECS(current->times.tms_stime);
8885 prstatus.pr_cutime.tv_sec =
8886 CT_TO_SECS(current->times.tms_cutime);
8887 prstatus.pr_cutime.tv_usec =
8888 CT_TO_USECS(current->times.tms_cutime);
8889 prstatus.pr_cstime.tv_sec =
8890 CT_TO_SECS(current->times.tms_cstime);
8891 prstatus.pr_cstime.tv_usec =
8892 CT_TO_USECS(current->times.tms_cstime);
8893
8894 /* This transfers the registers from regs into the
8895 * standard coredump arrangement, whatever that is. */
8896 #ifdef ELF_CORE_COPY_REGS
8897 ELF_CORE_COPY_REGS(prstatus.pr_reg, regs)
8898 #else
8899 if (sizeof(elf_gregset_t) != sizeof(struct pt_regs))
8900 {
8901 printk("sizeof(elf_gregset_t) (%ld) != "
8902 "sizeof(struct pt_regs) (%ld)\n",
8903 (long)sizeof(elf_gregset_t),
8904 (long)sizeof(struct pt_regs));
8905 }
8906 else
8907 *(struct pt_regs *)&prstatus.pr_reg = *regs;
8908 #endif
8909
8910 #ifdef DEBUG
8911 dump_regs("Passed in regs", (elf_greg_t *)regs);
8912 dump_regs("prstatus regs",
8913 (elf_greg_t *)&prstatus.pr_reg);
8914 #endif
8915
8916 notes[1].name = "CORE";
8917 notes[1].type = NT_PRPSINFO;
8918 notes[1].datasz = sizeof(psinfo);
8919 notes[1].data = &psinfo;
8920 i = current->state ? ffz(~current->state) + 1 : 0;
8921 psinfo.pr_state = i;
8922 psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i];
8923 psinfo.pr_zomb = psinfo.pr_sname == 'Z';
8924 psinfo.pr_nice = current->priority-15;
8925 psinfo.pr_flag = current->flags;
8926 psinfo.pr_uid = current->uid;
8927 psinfo.pr_gid = current->gid;
8928 {
8929 int i, len;
8930
8931 set_fs(fs);
8932
8933 len = current->mm->arg_end - current->mm->arg_start;
8934 if (len >= ELF_PRARGSZ)
8935 len = ELF_PRARGSZ-1;
8936 copy_from_user(&psinfo.pr_psargs,
8937 (const char *)current->mm->arg_start, len);
8938 for(i = 0; i < len; i++)
8939 if (psinfo.pr_psargs[i] == 0)
8940 psinfo.pr_psargs[i] = ' ';
8941 psinfo.pr_psargs[len] = 0;
8942
8943 set_fs(KERNEL_DS);
8944 }
8945 strncpy(psinfo.pr_fname, current->comm,
8946 sizeof(psinfo.pr_fname));
8947
8948 notes[2].name = "CORE";
8949 notes[2].type = NT_TASKSTRUCT;
8950 notes[2].datasz = sizeof(*current);
8951 notes[2].data = current;
8952
8953 /* Try to dump the FPU. */
8954 prstatus.pr_fpvalid = dump_fpu (regs, &fpu);
8955 if (!prstatus.pr_fpvalid)
8956 {
8957 numnote--;
8958 }
8959 else
8960 {
8961 notes[3].name = "CORE";
8962 notes[3].type = NT_PRFPREG;
8963 notes[3].datasz = sizeof(fpu);
8964 notes[3].data = &fpu;
8965 }
8966
8967 /* Write notes phdr entry */
8968 {
8969 struct elf_phdr phdr;
8970 int sz = 0;
8971
8972 for(i = 0; i < numnote; i++)
8973 sz += notesize(¬es[i]);
8974
8975 phdr.p_type = PT_NOTE;
8976 phdr.p_offset = offset;
8977 phdr.p_vaddr = 0;
8978 phdr.p_paddr = 0;
8979 phdr.p_filesz = sz;
8980 phdr.p_memsz = 0;
8981 phdr.p_flags = 0;
8982 phdr.p_align = 0;
8983
8984 offset += phdr.p_filesz;
8985 DUMP_WRITE(&phdr, sizeof(phdr));
8986 }
8987
8988 /* Page-align dumped data */
8989 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
8990
8991 /* Write program headers for segments dump */
8992 for(vma = current->mm->mmap, i = 0;
8993 i < segs && vma != NULL; vma = vma->vm_next) {
8994 struct elf_phdr phdr;
8995 size_t sz;
8996
8997 i++;
8998
8999 sz = vma->vm_end - vma->vm_start;
9000
9001 phdr.p_type = PT_LOAD;
9002 phdr.p_offset = offset;
9003 phdr.p_vaddr = vma->vm_start;
9004 phdr.p_paddr = 0;
9005 phdr.p_filesz = maydump(vma) ? sz : 0;
9006 phdr.p_memsz = sz;
9007 offset += phdr.p_filesz;
9008 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
9009 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
9010 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
9011 phdr.p_align = ELF_EXEC_PAGESIZE;
9012
9013 DUMP_WRITE(&phdr, sizeof(phdr));
9014 }
9015
9016 for(i = 0; i < numnote; i++)
9017 if (!writenote(¬es[i], &file))
9018 goto close_coredump;
9019
9020 set_fs(fs);
9021
9022 DUMP_SEEK(dataoff);
9023
9024 for(i = 0, vma = current->mm->mmap;
9025 i < segs && vma != NULL;
9026 vma = vma->vm_next) {
9027 unsigned long addr = vma->vm_start;
9028 unsigned long len = vma->vm_end - vma->vm_start;
9029
9030 i++;
9031 if (!maydump(vma))
9032 continue;
9033 #ifdef DEBUG
9034 printk("elf_core_dump: writing %08lx %lx\n",
9035 addr, len);
9036 #endif
9037 DUMP_WRITE((void *)addr, len);
9038 }
9039
9040 if ((off_t) file.f_pos != offset) {
9041 /* Sanity check */
9042 printk("elf_core_dump: file.f_pos (%ld) != "
9043 "offset (%ld)\n",
9044 (off_t) file.f_pos, offset);
9045 }
9046
9047 close_coredump:
9048 if (file.f_op->release)
9049 file.f_op->release(inode,&file);
9050
9051 end_coredump:
9052 set_fs(fs);
9053 dput(dentry);
9054 #ifndef CONFIG_BINFMT_ELF
9055 MOD_DEC_USE_COUNT;
9056 #endif
9057 return has_dumped;
9058 }
9059 #endif /* USE_ELF_CORE_DUMP */
9060
9061 int __init init_elf_binfmt(void)
9062 {
9063 return register_binfmt(&elf_format);
9064 }
9065
9066 #ifdef MODULE
9067
9068 int init_module(void)
9069 {
9070 /* Install the COFF, ELF and XOUT loaders. N.B. We
9071 * *rely* on the table being the right size with the
9072 * right number of free slots... */
9073 return init_elf_binfmt();
9074 }
9075
9076
9077 void cleanup_module( void)
9078 {
9079 /* Remove the COFF and ELF loaders. */
9080 unregister_binfmt(&elf_format);
9081 }
9082 #endif
Сайт управляется системой
uCoz