2 * linux/fs/binfmt_elf.c
4 * These are the functions used to load ELF format executables as used
5 * on SVr4 machines. Information on the format may be found in the book
6 * "UNIX SYSTEM V RELEASE 4 Programmers Guide: Ansi C and Programming Support
9 * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
12 #include <linux/module.h>
13 #include <linux/kernel.h>
15 #include <linux/stat.h>
16 #include <linux/time.h>
18 #include <linux/mman.h>
19 #include <linux/a.out.h>
20 #include <linux/errno.h>
21 #include <linux/signal.h>
22 #include <linux/binfmts.h>
23 #include <linux/string.h>
24 #include <linux/file.h>
25 #include <linux/fcntl.h>
26 #include <linux/ptrace.h>
27 #include <linux/slab.h>
28 #include <linux/shm.h>
29 #include <linux/personality.h>
30 #include <linux/elfcore.h>
31 #include <linux/init.h>
32 #include <linux/highuid.h>
33 #include <linux/smp.h>
34 #include <linux/smp_lock.h>
35 #include <linux/compiler.h>
36 #include <linux/highmem.h>
37 #include <linux/pagemap.h>
38 #include <linux/security.h>
39 #include <linux/syscalls.h>
40 #include <linux/random.h>
41 #include <linux/elf.h>
42 #include <linux/vs_memory.h>
43 #include <asm/uaccess.h>
44 #include <asm/param.h>
47 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
48 static int load_elf_library(struct file *);
49 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int, unsigned long);
52 * If we don't support core dumping, then supply a NULL so we
55 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
56 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file);
58 #define elf_core_dump NULL
61 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
62 #define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
64 #define ELF_MIN_ALIGN PAGE_SIZE
67 #ifndef ELF_CORE_EFLAGS
68 #define ELF_CORE_EFLAGS 0
71 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
72 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
73 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
75 static struct linux_binfmt elf_format = {
76 .module = THIS_MODULE,
77 .load_binary = load_elf_binary,
78 .load_shlib = load_elf_library,
79 .core_dump = elf_core_dump,
80 .min_coredump = ELF_EXEC_PAGESIZE,
84 #define BAD_ADDR(x) ((unsigned long)(x) >= PAGE_MASK)
86 static int set_brk(unsigned long start, unsigned long end)
88 start = ELF_PAGEALIGN(start);
89 end = ELF_PAGEALIGN(end);
92 down_write(¤t->mm->mmap_sem);
93 addr = do_brk(start, end - start);
94 up_write(¤t->mm->mmap_sem);
98 current->mm->start_brk = current->mm->brk = end;
102 /* We need to explicitly zero any fractional pages
103 after the data section (i.e. bss). This would
104 contain the junk from the file that should not
107 static int padzero(unsigned long elf_bss)
111 nbyte = ELF_PAGEOFFSET(elf_bss);
113 nbyte = ELF_MIN_ALIGN - nbyte;
114 if (clear_user((void __user *) elf_bss, nbyte))
120 /* Let's use some macros to make this stack manipulation a litle clearer */
121 #ifdef CONFIG_STACK_GROWSUP
122 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
123 #define STACK_ROUND(sp, items) \
124 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
125 #define STACK_ALLOC(sp, len) ({ \
126 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
129 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
130 #define STACK_ROUND(sp, items) \
131 (((unsigned long) (sp - items)) &~ 15UL)
132 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
136 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
137 int interp_aout, unsigned long load_addr,
138 unsigned long interp_load_addr)
140 unsigned long p = bprm->p;
141 int argc = bprm->argc;
142 int envc = bprm->envc;
143 elf_addr_t __user *argv;
144 elf_addr_t __user *envp;
145 elf_addr_t __user *sp;
146 elf_addr_t __user *u_platform;
147 const char *k_platform = ELF_PLATFORM;
149 elf_addr_t *elf_info;
151 struct task_struct *tsk = current;
154 * If this architecture has a platform capability string, copy it
155 * to userspace. In some cases (Sparc), this info is impossible
156 * for userspace to get any other way, in others (i386) it is
161 size_t len = strlen(k_platform) + 1;
164 * In some cases (e.g. Hyper-Threading), we want to avoid L1
165 * evictions by the processes running on the same package. One
166 * thing we can do is to shuffle the initial stack for them.
169 p = arch_align_stack(p);
171 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
172 if (__copy_to_user(u_platform, k_platform, len))
176 /* Create the ELF interpreter info */
177 elf_info = (elf_addr_t *)current->mm->saved_auxv;
178 #define NEW_AUX_ENT(id, val) \
180 elf_info[ei_index++] = id; \
181 elf_info[ei_index++] = val; \
186 * ARCH_DLINFO must come first so PPC can do its special alignment of
191 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
192 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
193 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
194 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
195 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
196 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
197 NEW_AUX_ENT(AT_BASE, interp_load_addr);
198 NEW_AUX_ENT(AT_FLAGS, 0);
199 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
200 NEW_AUX_ENT(AT_UID, tsk->uid);
201 NEW_AUX_ENT(AT_EUID, tsk->euid);
202 NEW_AUX_ENT(AT_GID, tsk->gid);
203 NEW_AUX_ENT(AT_EGID, tsk->egid);
204 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
206 NEW_AUX_ENT(AT_PLATFORM,
207 (elf_addr_t)(unsigned long)u_platform);
209 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
210 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
213 /* AT_NULL is zero; clear the rest too */
214 memset(&elf_info[ei_index], 0,
215 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
217 /* And advance past the AT_NULL entry. */
220 sp = STACK_ADD(p, ei_index);
222 items = (argc + 1) + (envc + 1);
224 items += 3; /* a.out interpreters require argv & envp too */
226 items += 1; /* ELF interpreters only put argc on the stack */
228 bprm->p = STACK_ROUND(sp, items);
230 /* Point sp at the lowest address on the stack */
231 #ifdef CONFIG_STACK_GROWSUP
232 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
233 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
235 sp = (elf_addr_t __user *)bprm->p;
238 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
239 if (__put_user(argc, sp++))
243 envp = argv + argc + 1;
244 if (__put_user((elf_addr_t)(unsigned long)argv, sp++) ||
245 __put_user((elf_addr_t)(unsigned long)envp, sp++))
249 envp = argv + argc + 1;
252 /* Populate argv and envp */
253 p = current->mm->arg_end = current->mm->arg_start;
256 if (__put_user((elf_addr_t)p, argv++))
258 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
259 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
263 if (__put_user(0, argv))
265 current->mm->arg_end = current->mm->env_start = p;
268 if (__put_user((elf_addr_t)p, envp++))
270 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
271 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
275 if (__put_user(0, envp))
277 current->mm->env_end = p;
279 /* Put the elf_info on the stack in the right place. */
280 sp = (elf_addr_t __user *)envp + 1;
281 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
288 static unsigned long elf_map(struct file *filep, unsigned long addr,
289 struct elf_phdr *eppnt, int prot, int type,
290 unsigned long total_size)
292 unsigned long map_addr;
293 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
294 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
296 addr = ELF_PAGESTART(addr);
297 size = ELF_PAGEALIGN(size);
299 /* mmap() will return -EINVAL if given a zero size, but a
300 * segment with zero filesize is perfectly valid */
304 down_write(¤t->mm->mmap_sem);
306 * total_size is the size of the ELF (interpreter) image.
307 * The _first_ mmap needs to know the full size, otherwise
308 * randomization might put this image into an overlapping
309 * position with the ELF binary image. (since size < total_size)
310 * So we first map the 'big' image - and unmap the remainder at
311 * the end. (which unmap is needed for ELF images with holes.)
314 total_size = ELF_PAGEALIGN(total_size);
315 map_addr = do_mmap(filep, addr, total_size, prot, type, off);
316 if (!BAD_ADDR(map_addr))
317 do_munmap(current->mm, map_addr+size, total_size-size);
319 map_addr = do_mmap(filep, addr, size, prot, type, off);
321 up_write(¤t->mm->mmap_sem);
325 #endif /* !elf_map */
327 static inline unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
329 int i, first_idx = -1, last_idx = -1;
331 for (i = 0; i < nr; i++)
332 if (cmds[i].p_type == PT_LOAD) {
341 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
342 ELF_PAGESTART(cmds[first_idx].p_vaddr);
346 /* This is much more generalized than the library routine read function,
347 so we keep this separate. Technically the library read function
348 is only provided so that we can read a.out libraries that have
351 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
352 struct file *interpreter, unsigned long *interp_map_addr,
353 unsigned long no_base)
355 struct elf_phdr *elf_phdata;
356 struct elf_phdr *eppnt;
357 unsigned long load_addr = 0;
358 int load_addr_set = 0;
359 unsigned long last_bss = 0, elf_bss = 0;
360 unsigned long error = ~0UL;
361 unsigned long total_size;
364 /* First of all, some simple consistency checks */
365 if (interp_elf_ex->e_type != ET_EXEC &&
366 interp_elf_ex->e_type != ET_DYN)
368 if (!elf_check_arch(interp_elf_ex))
370 if (!interpreter->f_op || !interpreter->f_op->mmap)
374 * If the size of this structure has changed, then punt, since
375 * we will be doing the wrong thing.
377 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
379 if (interp_elf_ex->e_phnum < 1 ||
380 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
383 /* Now read in all of the header information */
384 size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
385 if (size > ELF_MIN_ALIGN)
387 elf_phdata = kmalloc(size, GFP_KERNEL);
391 retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
392 (char *)elf_phdata,size);
394 if (retval != size) {
400 total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
405 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
406 if (eppnt->p_type == PT_LOAD) {
407 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
409 unsigned long vaddr = 0;
410 unsigned long k, map_addr;
412 if (eppnt->p_flags & PF_R)
413 elf_prot = PROT_READ;
414 if (eppnt->p_flags & PF_W)
415 elf_prot |= PROT_WRITE;
416 if (eppnt->p_flags & PF_X)
417 elf_prot |= PROT_EXEC;
418 vaddr = eppnt->p_vaddr;
419 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
420 elf_type |= MAP_FIXED;
421 else if (no_base && interp_elf_ex->e_type == ET_DYN)
424 map_addr = elf_map(interpreter, load_addr + vaddr,
425 eppnt, elf_prot, elf_type, total_size);
427 if (!*interp_map_addr)
428 *interp_map_addr = map_addr;
430 if (BAD_ADDR(map_addr))
433 if (!load_addr_set &&
434 interp_elf_ex->e_type == ET_DYN) {
435 load_addr = map_addr - ELF_PAGESTART(vaddr);
440 * Check to see if the section's size will overflow the
441 * allowed task size. Note that p_filesz must always be
442 * <= p_memsize so it's only necessary to check p_memsz.
444 k = load_addr + eppnt->p_vaddr;
446 eppnt->p_filesz > eppnt->p_memsz ||
447 eppnt->p_memsz > TASK_SIZE ||
448 TASK_SIZE - eppnt->p_memsz < k) {
454 * Find the end of the file mapping for this phdr, and
455 * keep track of the largest address we see for this.
457 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
462 * Do the same thing for the memory mapping - between
463 * elf_bss and last_bss is the bss section.
465 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
472 * Now fill out the bss section. First pad the last page up
473 * to the page boundary, and then perform a mmap to make sure
474 * that there are zero-mapped pages up to and including the
477 if (padzero(elf_bss)) {
482 /* What we have mapped so far */
483 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
485 /* Map the last of the bss segment */
486 if (last_bss > elf_bss) {
487 down_write(¤t->mm->mmap_sem);
488 error = do_brk(elf_bss, last_bss - elf_bss);
489 up_write(¤t->mm->mmap_sem);
502 static unsigned long load_aout_interp(struct exec *interp_ex,
503 struct file *interpreter)
505 unsigned long text_data, elf_entry = ~0UL;
509 current->mm->end_code = interp_ex->a_text;
510 text_data = interp_ex->a_text + interp_ex->a_data;
511 current->mm->end_data = text_data;
512 current->mm->brk = interp_ex->a_bss + text_data;
514 switch (N_MAGIC(*interp_ex)) {
517 addr = (char __user *)0;
521 offset = N_TXTOFF(*interp_ex);
522 addr = (char __user *)N_TXTADDR(*interp_ex);
528 down_write(¤t->mm->mmap_sem);
529 do_brk(0, text_data);
530 up_write(¤t->mm->mmap_sem);
531 if (!interpreter->f_op || !interpreter->f_op->read)
533 if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
535 flush_icache_range((unsigned long)addr,
536 (unsigned long)addr + text_data);
538 down_write(¤t->mm->mmap_sem);
539 do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
541 up_write(¤t->mm->mmap_sem);
542 elf_entry = interp_ex->a_entry;
549 * These are the functions used to load ELF style executables and shared
550 * libraries. There is no binary dependent code anywhere else.
553 #define INTERPRETER_NONE 0
554 #define INTERPRETER_AOUT 1
555 #define INTERPRETER_ELF 2
557 #ifndef STACK_RND_MASK
558 #define STACK_RND_MASK 0x7ff /* with 4K pages 8MB of VA */
561 static unsigned long randomize_stack_top(unsigned long stack_top)
563 unsigned int random_variable = 0;
565 if ((current->flags & PF_RANDOMIZE) &&
566 !(current->personality & ADDR_NO_RANDOMIZE)) {
567 random_variable = get_random_int() & STACK_RND_MASK;
568 random_variable <<= PAGE_SHIFT;
570 #ifdef CONFIG_STACK_GROWSUP
571 return PAGE_ALIGN(stack_top) + random_variable;
573 return PAGE_ALIGN(stack_top) - random_variable;
577 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
579 struct file *interpreter = NULL; /* to shut gcc up */
580 unsigned long load_addr = 0, load_bias = 0;
581 int load_addr_set = 0;
582 char * elf_interpreter = NULL;
583 unsigned int interpreter_type = INTERPRETER_NONE;
584 unsigned char ibcs2_interpreter = 0;
586 struct elf_phdr *elf_ppnt, *elf_phdata;
587 unsigned long elf_bss, elf_brk;
591 unsigned long elf_entry, interp_load_addr = 0, interp_map_addr = 0;
592 unsigned long start_code, end_code, start_data, end_data;
593 unsigned long reloc_func_desc = 0;
594 char passed_fileno[6];
595 struct files_struct *files;
596 int executable_stack;
597 unsigned long def_flags = 0;
599 struct elfhdr elf_ex;
600 struct elfhdr interp_elf_ex;
601 struct exec interp_ex;
604 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
610 /* Get the exec-header */
611 loc->elf_ex = *((struct elfhdr *)bprm->buf);
614 /* First of all, some simple consistency checks */
615 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
618 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
620 if (!elf_check_arch(&loc->elf_ex))
622 if (!bprm->file->f_op||!bprm->file->f_op->mmap)
625 /* Now read in all of the header information */
626 if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
628 if (loc->elf_ex.e_phnum < 1 ||
629 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
631 size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
633 elf_phdata = kmalloc(size, GFP_KERNEL);
637 retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
638 (char *)elf_phdata, size);
639 if (retval != size) {
645 files = current->files; /* Refcounted so ok */
646 retval = unshare_files();
649 if (files == current->files) {
650 put_files_struct(files);
654 /* exec will make our files private anyway, but for the a.out
655 loader stuff we need to do it earlier */
656 retval = get_unused_fd();
659 get_file(bprm->file);
660 fd_install(elf_exec_fileno = retval, bprm->file);
662 elf_ppnt = elf_phdata;
671 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
672 if (elf_ppnt->p_type == PT_INTERP) {
673 /* This is the program interpreter used for
674 * shared libraries - for now assume that this
675 * is an a.out format binary
678 if (elf_ppnt->p_filesz > PATH_MAX ||
679 elf_ppnt->p_filesz < 2)
683 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
685 if (!elf_interpreter)
688 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
691 if (retval != elf_ppnt->p_filesz) {
694 goto out_free_interp;
696 /* make sure path is NULL terminated */
698 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
699 goto out_free_interp;
701 /* If the program interpreter is one of these two,
702 * then assume an iBCS2 image. Otherwise assume
703 * a native linux image.
705 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
706 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
707 ibcs2_interpreter = 1;
710 * The early SET_PERSONALITY here is so that the lookup
711 * for the interpreter happens in the namespace of the
712 * to-be-execed image. SET_PERSONALITY can select an
715 * However, SET_PERSONALITY is NOT allowed to switch
716 * this task into the new images's memory mapping
717 * policy - that is, TASK_SIZE must still evaluate to
718 * that which is appropriate to the execing application.
719 * This is because exit_mmap() needs to have TASK_SIZE
720 * evaluate to the size of the old image.
722 * So if (say) a 64-bit application is execing a 32-bit
723 * application it is the architecture's responsibility
724 * to defer changing the value of TASK_SIZE until the
725 * switch really is going to happen - do this in
726 * flush_thread(). - akpm
728 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
730 interpreter = open_exec(elf_interpreter);
731 retval = PTR_ERR(interpreter);
732 if (IS_ERR(interpreter))
733 goto out_free_interp;
736 * If the binary is not readable then enforce
737 * mm->dumpable = 0 regardless of the interpreter's
740 if (file_permission(interpreter, MAY_READ) < 0)
741 bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
743 retval = kernel_read(interpreter, 0, bprm->buf,
745 if (retval != BINPRM_BUF_SIZE) {
748 goto out_free_dentry;
751 /* Get the exec headers */
752 loc->interp_ex = *((struct exec *)bprm->buf);
753 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
759 elf_ppnt = elf_phdata;
760 executable_stack = EXSTACK_DEFAULT;
762 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
763 if (elf_ppnt->p_type == PT_GNU_STACK) {
764 if (elf_ppnt->p_flags & PF_X)
765 executable_stack = EXSTACK_ENABLE_X;
767 executable_stack = EXSTACK_DISABLE_X;
771 if (current->personality == PER_LINUX && (exec_shield & 2)) {
772 executable_stack = EXSTACK_DISABLE_X;
773 current->flags |= PF_RANDOMIZE;
776 /* Some simple consistency checks for the interpreter */
777 if (elf_interpreter) {
778 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
780 /* Now figure out which format our binary is */
781 if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
782 (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
783 (N_MAGIC(loc->interp_ex) != QMAGIC))
784 interpreter_type = INTERPRETER_ELF;
786 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
787 interpreter_type &= ~INTERPRETER_ELF;
790 if (!interpreter_type)
791 goto out_free_dentry;
793 /* Make sure only one type was selected */
794 if ((interpreter_type & INTERPRETER_ELF) &&
795 interpreter_type != INTERPRETER_ELF) {
796 // FIXME - ratelimit this before re-enabling
797 // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
798 interpreter_type = INTERPRETER_ELF;
800 /* Verify the interpreter has a valid arch */
801 if ((interpreter_type == INTERPRETER_ELF) &&
802 !elf_check_arch(&loc->interp_elf_ex))
803 goto out_free_dentry;
805 /* Executables without an interpreter also need a personality */
806 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
809 /* OK, we are done with that, now set up the arg stuff,
810 and then start this sucker up */
811 if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
812 char *passed_p = passed_fileno;
813 sprintf(passed_fileno, "%d", elf_exec_fileno);
815 if (elf_interpreter) {
816 retval = copy_strings_kernel(1, &passed_p, bprm);
818 goto out_free_dentry;
823 /* Flush all traces of the currently running executable */
824 retval = flush_old_exec(bprm);
826 goto out_free_dentry;
830 * Turn off the CS limit completely if exec-shield disabled or
833 if (!exec_shield || executable_stack != EXSTACK_DISABLE_X || nx_enabled)
834 arch_add_exec_range(current->mm, -1);
837 /* Discard our unneeded old files struct */
839 put_files_struct(files);
843 /* OK, This is the point of no return */
844 current->mm->start_data = 0;
845 current->mm->end_data = 0;
846 current->mm->end_code = 0;
847 current->mm->mmap = NULL;
848 current->flags &= ~PF_FORKNOEXEC;
849 current->mm->def_flags = def_flags;
851 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
852 may depend on the personality. */
853 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
854 if (!(exec_shield & 2) &&
855 elf_read_implies_exec(loc->elf_ex, executable_stack))
856 current->personality |= READ_IMPLIES_EXEC;
858 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
859 current->flags |= PF_RANDOMIZE;
860 arch_pick_mmap_layout(current->mm);
862 /* Do this so that we can load the interpreter, if need be. We will
863 change some of these later */
864 current->mm->free_area_cache = current->mm->mmap_base;
865 current->mm->cached_hole_size = 0;
866 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
869 send_sig(SIGKILL, current, 0);
870 goto out_free_dentry;
873 current->mm->start_stack = bprm->p;
875 /* Now we do a little grungy work by mmaping the ELF image into
876 the correct location in memory.
878 for(i = 0, elf_ppnt = elf_phdata;
879 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
880 int elf_prot = 0, elf_flags;
881 unsigned long k, vaddr;
883 if (elf_ppnt->p_type != PT_LOAD)
886 if (unlikely (elf_brk > elf_bss)) {
889 /* There was a PT_LOAD segment with p_memsz > p_filesz
890 before this one. Map anonymous pages, if needed,
891 and clear the area. */
892 retval = set_brk (elf_bss + load_bias,
893 elf_brk + load_bias);
895 send_sig(SIGKILL, current, 0);
896 goto out_free_dentry;
898 nbyte = ELF_PAGEOFFSET(elf_bss);
900 nbyte = ELF_MIN_ALIGN - nbyte;
901 if (nbyte > elf_brk - elf_bss)
902 nbyte = elf_brk - elf_bss;
903 if (clear_user((void __user *)elf_bss +
906 * This bss-zeroing can fail if the ELF
907 * file specifies odd protections. So
908 * we don't check the return value
914 if (elf_ppnt->p_flags & PF_R)
915 elf_prot |= PROT_READ;
916 if (elf_ppnt->p_flags & PF_W)
917 elf_prot |= PROT_WRITE;
918 if (elf_ppnt->p_flags & PF_X)
919 elf_prot |= PROT_EXEC;
921 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
923 vaddr = elf_ppnt->p_vaddr;
924 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
925 elf_flags |= MAP_FIXED;
926 } else if (loc->elf_ex.e_type == ET_DYN) {
927 /* Try and get dynamic programs out of the way of the
928 * default mmap base, as well as whatever program they
929 * might try to exec. This is because the brk will
930 * follow the loader, and is not movable. */
931 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
934 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
935 elf_prot, elf_flags, 0);
936 if (BAD_ADDR(error)) {
937 send_sig(SIGKILL, current, 0);
938 goto out_free_dentry;
941 if (!load_addr_set) {
943 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
944 if (loc->elf_ex.e_type == ET_DYN) {
946 ELF_PAGESTART(load_bias + vaddr);
947 load_addr += load_bias;
948 reloc_func_desc = load_bias;
951 k = elf_ppnt->p_vaddr;
958 * Check to see if the section's size will overflow the
959 * allowed task size. Note that p_filesz must always be
960 * <= p_memsz so it is only necessary to check p_memsz.
962 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
963 elf_ppnt->p_memsz > TASK_SIZE ||
964 TASK_SIZE - elf_ppnt->p_memsz < k) {
965 /* set_brk can never work. Avoid overflows. */
966 send_sig(SIGKILL, current, 0);
967 goto out_free_dentry;
970 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
974 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
978 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
983 loc->elf_ex.e_entry += load_bias;
984 elf_bss += load_bias;
985 elf_brk += load_bias;
986 start_code += load_bias;
987 end_code += load_bias;
988 start_data += load_bias;
989 end_data += load_bias;
991 /* Calling set_brk effectively mmaps the pages that we need
992 * for the bss and break sections. We must do this before
993 * mapping in the interpreter, to make sure it doesn't wind
994 * up getting placed where the bss needs to go.
996 retval = set_brk(elf_bss, elf_brk);
998 send_sig(SIGKILL, current, 0);
999 goto out_free_dentry;
1001 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
1002 send_sig(SIGSEGV, current, 0);
1003 retval = -EFAULT; /* Nobody gets to see this, but.. */
1004 goto out_free_dentry;
1007 if (elf_interpreter) {
1008 if (interpreter_type == INTERPRETER_AOUT)
1009 elf_entry = load_aout_interp(&loc->interp_ex,
1012 elf_entry = load_elf_interp(&loc->interp_elf_ex,
1016 if (!BAD_ADDR(elf_entry)) {
1017 /* load_elf_interp() returns relocation adjustment */
1018 interp_load_addr = elf_entry;
1019 elf_entry += loc->interp_elf_ex.e_entry;
1022 if (BAD_ADDR(elf_entry)) {
1023 force_sig(SIGSEGV, current);
1024 retval = IS_ERR((void *)elf_entry) ?
1025 (int)elf_entry : -EINVAL;
1026 goto out_free_dentry;
1028 reloc_func_desc = interp_load_addr;
1030 allow_write_access(interpreter);
1032 kfree(elf_interpreter);
1034 elf_entry = loc->elf_ex.e_entry;
1035 if (BAD_ADDR(elf_entry)) {
1036 force_sig(SIGSEGV, current);
1038 goto out_free_dentry;
1042 if (interpreter_type != INTERPRETER_AOUT)
1043 sys_close(elf_exec_fileno);
1045 set_binfmt(&elf_format);
1047 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
1048 retval = arch_setup_additional_pages(bprm, executable_stack,
1049 start_code, interp_map_addr);
1051 send_sig(SIGKILL, current, 0);
1054 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
1058 compute_creds(bprm);
1059 current->flags &= ~PF_FORKNOEXEC;
1060 create_elf_tables(bprm, &loc->elf_ex,
1061 (interpreter_type == INTERPRETER_AOUT),
1062 load_addr, interp_load_addr);
1063 /* N.B. passed_fileno might not be initialized? */
1064 if (interpreter_type == INTERPRETER_AOUT)
1065 current->mm->arg_start += strlen(passed_fileno) + 1;
1066 current->mm->end_code = end_code;
1067 current->mm->start_code = start_code;
1068 current->mm->start_data = start_data;
1069 current->mm->end_data = end_data;
1070 current->mm->start_stack = bprm->p;
1072 #ifdef __HAVE_ARCH_RANDOMIZE_BRK
1073 if (current->flags & PF_RANDOMIZE)
1074 randomize_brk(elf_brk);
1076 if (current->personality & MMAP_PAGE_ZERO) {
1077 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
1078 and some applications "depend" upon this behavior.
1079 Since we do not have the power to recompile these, we
1080 emulate the SVr4 behavior. Sigh. */
1081 down_write(¤t->mm->mmap_sem);
1082 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1083 MAP_FIXED | MAP_PRIVATE, 0);
1084 up_write(¤t->mm->mmap_sem);
1087 #ifdef ELF_PLAT_INIT
1089 * The ABI may specify that certain registers be set up in special
1090 * ways (on i386 %edx is the address of a DT_FINI function, for
1091 * example. In addition, it may also specify (eg, PowerPC64 ELF)
1092 * that the e_entry field is the address of the function descriptor
1093 * for the startup routine, rather than the address of the startup
1094 * routine itself. This macro performs whatever initialization to
1095 * the regs structure is required as well as any relocations to the
1096 * function descriptor entries when executing dynamically links apps.
1098 ELF_PLAT_INIT(regs, reloc_func_desc);
1101 start_thread(regs, elf_entry, bprm->p);
1110 allow_write_access(interpreter);
1114 kfree(elf_interpreter);
1116 sys_close(elf_exec_fileno);
1119 reset_files_struct(current, files);
1125 /* This is really simpleminded and specialized - we are loading an
1126 a.out library that is given an ELF header. */
1127 static int load_elf_library(struct file *file)
1129 struct elf_phdr *elf_phdata;
1130 struct elf_phdr *eppnt;
1131 unsigned long elf_bss, bss, len;
1132 int retval, error, i, j;
1133 struct elfhdr elf_ex;
1136 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
1137 if (retval != sizeof(elf_ex))
1140 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1143 /* First of all, some simple consistency checks */
1144 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1145 !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1148 /* Now read in all of the header information */
1150 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1151 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1154 elf_phdata = kmalloc(j, GFP_KERNEL);
1160 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1164 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1165 if ((eppnt + i)->p_type == PT_LOAD)
1170 while (eppnt->p_type != PT_LOAD)
1173 /* Now use mmap to map the library into memory. */
1174 down_write(¤t->mm->mmap_sem);
1175 error = do_mmap(file,
1176 ELF_PAGESTART(eppnt->p_vaddr),
1178 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1179 PROT_READ | PROT_WRITE | PROT_EXEC,
1180 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1182 ELF_PAGEOFFSET(eppnt->p_vaddr)));
1183 up_write(¤t->mm->mmap_sem);
1184 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1187 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1188 if (padzero(elf_bss)) {
1193 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1195 bss = eppnt->p_memsz + eppnt->p_vaddr;
1197 down_write(¤t->mm->mmap_sem);
1198 do_brk(len, bss - len);
1199 up_write(¤t->mm->mmap_sem);
1210 * Note that some platforms still use traditional core dumps and not
1211 * the ELF core dump. Each platform can select it as appropriate.
1213 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1218 * Modelled on fs/exec.c:aout_core_dump()
1219 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1222 * These are the only things you should do on a core-file: use only these
1223 * functions to write out all the necessary info.
1225 static int dump_write(struct file *file, const void *addr, int nr)
1227 return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1230 static int dump_seek(struct file *file, loff_t off)
1232 if (file->f_op->llseek && file->f_op->llseek != no_llseek) {
1233 if (file->f_op->llseek(file, off, SEEK_CUR) < 0)
1236 char *buf = (char *)get_zeroed_page(GFP_KERNEL);
1240 unsigned long n = off;
1243 if (!dump_write(file, buf, n))
1247 free_page((unsigned long)buf);
1253 * Decide whether a segment is worth dumping; default is yes to be
1254 * sure (missing info is worse than too much; etc).
1255 * Personally I'd include everything, and use the coredump limit...
1257 * I think we should skip something. But I am not sure how. H.J.
1259 static int maydump(struct vm_area_struct *vma)
1261 /* The vma can be set up to tell us the answer directly. */
1262 if (vma->vm_flags & VM_ALWAYSDUMP)
1265 /* Do not dump I/O mapped devices or special mappings */
1266 if (vma->vm_flags & (VM_IO | VM_RESERVED))
1269 /* Dump shared memory only if mapped from an anonymous file. */
1270 if (vma->vm_flags & VM_SHARED)
1271 return vma->vm_file->f_path.dentry->d_inode->i_nlink == 0;
1273 /* If it hasn't been written to, don't write it out */
1280 /* An ELF note in memory */
1285 unsigned int datasz;
1289 static int notesize(struct memelfnote *en)
1293 sz = sizeof(struct elf_note);
1294 sz += roundup(strlen(en->name) + 1, 4);
1295 sz += roundup(en->datasz, 4);
1300 #define DUMP_WRITE(addr, nr, foffset) \
1301 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
1303 static int alignfile(struct file *file, loff_t *foffset)
1305 static const char buf[4] = { 0, };
1306 DUMP_WRITE(buf, roundup(*foffset, 4) - *foffset, foffset);
1310 static int writenote(struct memelfnote *men, struct file *file,
1314 en.n_namesz = strlen(men->name) + 1;
1315 en.n_descsz = men->datasz;
1316 en.n_type = men->type;
1318 DUMP_WRITE(&en, sizeof(en), foffset);
1319 DUMP_WRITE(men->name, en.n_namesz, foffset);
1320 if (!alignfile(file, foffset))
1322 DUMP_WRITE(men->data, men->datasz, foffset);
1323 if (!alignfile(file, foffset))
1330 #define DUMP_WRITE(addr, nr) \
1331 if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1333 #define DUMP_SEEK(off) \
1334 if (!dump_seek(file, (off))) \
1337 static void fill_elf_header(struct elfhdr *elf, int segs)
1339 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1340 elf->e_ident[EI_CLASS] = ELF_CLASS;
1341 elf->e_ident[EI_DATA] = ELF_DATA;
1342 elf->e_ident[EI_VERSION] = EV_CURRENT;
1343 elf->e_ident[EI_OSABI] = ELF_OSABI;
1344 memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1346 elf->e_type = ET_CORE;
1347 elf->e_machine = ELF_ARCH;
1348 elf->e_version = EV_CURRENT;
1350 elf->e_phoff = sizeof(struct elfhdr);
1352 elf->e_flags = ELF_CORE_EFLAGS;
1353 elf->e_ehsize = sizeof(struct elfhdr);
1354 elf->e_phentsize = sizeof(struct elf_phdr);
1355 elf->e_phnum = segs;
1356 elf->e_shentsize = 0;
1358 elf->e_shstrndx = 0;
1362 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1364 phdr->p_type = PT_NOTE;
1365 phdr->p_offset = offset;
1368 phdr->p_filesz = sz;
1375 static void fill_note(struct memelfnote *note, const char *name, int type,
1376 unsigned int sz, void *data)
1386 * fill up all the fields in prstatus from the given task struct, except
1387 * registers which need to be filled up separately.
1389 static void fill_prstatus(struct elf_prstatus *prstatus,
1390 struct task_struct *p, long signr)
1392 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1393 prstatus->pr_sigpend = p->pending.signal.sig[0];
1394 prstatus->pr_sighold = p->blocked.sig[0];
1395 prstatus->pr_pid = p->pid;
1396 prstatus->pr_ppid = p->parent->pid;
1397 prstatus->pr_pgrp = process_group(p);
1398 prstatus->pr_sid = process_session(p);
1399 if (thread_group_leader(p)) {
1401 * This is the record for the group leader. Add in the
1402 * cumulative times of previous dead threads. This total
1403 * won't include the time of each live thread whose state
1404 * is included in the core dump. The final total reported
1405 * to our parent process when it calls wait4 will include
1406 * those sums as well as the little bit more time it takes
1407 * this and each other thread to finish dying after the
1408 * core dump synchronization phase.
1410 cputime_to_timeval(cputime_add(p->utime, p->signal->utime),
1411 &prstatus->pr_utime);
1412 cputime_to_timeval(cputime_add(p->stime, p->signal->stime),
1413 &prstatus->pr_stime);
1415 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1416 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1418 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1419 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1422 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1423 struct mm_struct *mm)
1425 unsigned int i, len;
1427 /* first copy the parameters from user space */
1428 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1430 len = mm->arg_end - mm->arg_start;
1431 if (len >= ELF_PRARGSZ)
1432 len = ELF_PRARGSZ-1;
1433 if (copy_from_user(&psinfo->pr_psargs,
1434 (const char __user *)mm->arg_start, len))
1436 for(i = 0; i < len; i++)
1437 if (psinfo->pr_psargs[i] == 0)
1438 psinfo->pr_psargs[i] = ' ';
1439 psinfo->pr_psargs[len] = 0;
1441 psinfo->pr_pid = p->pid;
1442 psinfo->pr_ppid = p->parent->pid;
1443 psinfo->pr_pgrp = process_group(p);
1444 psinfo->pr_sid = process_session(p);
1446 i = p->state ? ffz(~p->state) + 1 : 0;
1447 psinfo->pr_state = i;
1448 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1449 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1450 psinfo->pr_nice = task_nice(p);
1451 psinfo->pr_flag = p->flags;
1452 SET_UID(psinfo->pr_uid, p->uid);
1453 SET_GID(psinfo->pr_gid, p->gid);
1454 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1459 /* Here is the structure in which status of each thread is captured. */
1460 struct elf_thread_status
1462 struct list_head list;
1463 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1464 elf_fpregset_t fpu; /* NT_PRFPREG */
1465 struct task_struct *thread;
1466 #ifdef ELF_CORE_COPY_XFPREGS
1467 elf_fpxregset_t xfpu; /* NT_PRXFPREG */
1469 struct memelfnote notes[3];
1474 * In order to add the specific thread information for the elf file format,
1475 * we need to keep a linked list of every threads pr_status and then create
1476 * a single section for them in the final core file.
1478 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1481 struct task_struct *p = t->thread;
1484 fill_prstatus(&t->prstatus, p, signr);
1485 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1487 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1490 sz += notesize(&t->notes[0]);
1492 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1494 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1497 sz += notesize(&t->notes[1]);
1500 #ifdef ELF_CORE_COPY_XFPREGS
1501 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1502 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu),
1505 sz += notesize(&t->notes[2]);
1511 static struct vm_area_struct *first_vma(struct task_struct *tsk,
1512 struct vm_area_struct *gate_vma)
1514 struct vm_area_struct *ret = tsk->mm->mmap;
1521 * Helper function for iterating across a vma list. It ensures that the caller
1522 * will visit `gate_vma' prior to terminating the search.
1524 static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
1525 struct vm_area_struct *gate_vma)
1527 struct vm_area_struct *ret;
1529 ret = this_vma->vm_next;
1532 if (this_vma == gate_vma)
1540 * This is a two-pass process; first we find the offsets of the bits,
1541 * and then they are actually written out. If we run out of core limit
1544 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
1552 struct vm_area_struct *vma, *gate_vma;
1553 struct elfhdr *elf = NULL;
1554 loff_t offset = 0, dataoff, foffset;
1555 unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
1557 struct memelfnote *notes = NULL;
1558 struct elf_prstatus *prstatus = NULL; /* NT_PRSTATUS */
1559 struct elf_prpsinfo *psinfo = NULL; /* NT_PRPSINFO */
1560 struct task_struct *g, *p;
1561 LIST_HEAD(thread_list);
1562 struct list_head *t;
1563 elf_fpregset_t *fpu = NULL;
1564 #ifdef ELF_CORE_COPY_XFPREGS
1565 elf_fpxregset_t *xfpu = NULL;
1567 int thread_status_size = 0;
1571 * We no longer stop all VM operations.
1573 * This is because those proceses that could possibly change map_count
1574 * or the mmap / vma pages are now blocked in do_exit on current
1575 * finishing this core dump.
1577 * Only ptrace can touch these memory addresses, but it doesn't change
1578 * the map_count or the pages allocated. So no possibility of crashing
1579 * exists while dumping the mm->vm_next areas to the core file.
1582 /* alloc memory for large data structures: too large to be on stack */
1583 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1586 prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1589 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1592 notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1595 fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1598 #ifdef ELF_CORE_COPY_XFPREGS
1599 xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1605 struct elf_thread_status *tmp;
1608 if (current->mm == p->mm && current != p) {
1609 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
1615 list_add(&tmp->list, &thread_list);
1617 while_each_thread(g,p);
1619 list_for_each(t, &thread_list) {
1620 struct elf_thread_status *tmp;
1623 tmp = list_entry(t, struct elf_thread_status, list);
1624 sz = elf_dump_thread_status(signr, tmp);
1625 thread_status_size += sz;
1628 /* now collect the dump for the current */
1629 memset(prstatus, 0, sizeof(*prstatus));
1630 fill_prstatus(prstatus, current, signr);
1631 elf_core_copy_regs(&prstatus->pr_reg, regs);
1633 segs = current->mm->map_count;
1634 #ifdef ELF_CORE_EXTRA_PHDRS
1635 segs += ELF_CORE_EXTRA_PHDRS;
1638 gate_vma = get_gate_vma(current);
1639 if (gate_vma != NULL)
1643 fill_elf_header(elf, segs + 1); /* including notes section */
1646 current->flags |= PF_DUMPCORE;
1649 * Set up the notes in similar form to SVR4 core dumps made
1650 * with info from their /proc.
1653 fill_note(notes + 0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1654 fill_psinfo(psinfo, current->group_leader, current->mm);
1655 fill_note(notes + 1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1659 auxv = (elf_addr_t *)current->mm->saved_auxv;
1664 while (auxv[i - 2] != AT_NULL);
1665 fill_note(¬es[numnote++], "CORE", NT_AUXV,
1666 i * sizeof(elf_addr_t), auxv);
1668 /* Try to dump the FPU. */
1669 if ((prstatus->pr_fpvalid =
1670 elf_core_copy_task_fpregs(current, regs, fpu)))
1671 fill_note(notes + numnote++,
1672 "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1673 #ifdef ELF_CORE_COPY_XFPREGS
1674 if (elf_core_copy_task_xfpregs(current, xfpu))
1675 fill_note(notes + numnote++,
1676 "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1682 DUMP_WRITE(elf, sizeof(*elf));
1683 offset += sizeof(*elf); /* Elf header */
1684 offset += (segs + 1) * sizeof(struct elf_phdr); /* Program headers */
1687 /* Write notes phdr entry */
1689 struct elf_phdr phdr;
1692 for (i = 0; i < numnote; i++)
1693 sz += notesize(notes + i);
1695 sz += thread_status_size;
1697 #ifdef ELF_CORE_WRITE_EXTRA_NOTES
1698 sz += ELF_CORE_EXTRA_NOTES_SIZE;
1701 fill_elf_note_phdr(&phdr, sz, offset);
1703 DUMP_WRITE(&phdr, sizeof(phdr));
1706 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1708 /* Write program headers for segments dump */
1709 for (vma = first_vma(current, gate_vma); vma != NULL;
1710 vma = next_vma(vma, gate_vma)) {
1711 struct elf_phdr phdr;
1714 sz = vma->vm_end - vma->vm_start;
1716 phdr.p_type = PT_LOAD;
1717 phdr.p_offset = offset;
1718 phdr.p_vaddr = vma->vm_start;
1720 phdr.p_filesz = maydump(vma) ? sz : 0;
1722 offset += phdr.p_filesz;
1723 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1724 if (vma->vm_flags & VM_WRITE)
1725 phdr.p_flags |= PF_W;
1726 if (vma->vm_flags & VM_EXEC)
1727 phdr.p_flags |= PF_X;
1728 phdr.p_align = ELF_EXEC_PAGESIZE;
1730 DUMP_WRITE(&phdr, sizeof(phdr));
1733 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1734 ELF_CORE_WRITE_EXTRA_PHDRS;
1737 /* write out the notes section */
1738 for (i = 0; i < numnote; i++)
1739 if (!writenote(notes + i, file, &foffset))
1742 #ifdef ELF_CORE_WRITE_EXTRA_NOTES
1743 ELF_CORE_WRITE_EXTRA_NOTES;
1746 /* write out the thread status notes section */
1747 list_for_each(t, &thread_list) {
1748 struct elf_thread_status *tmp =
1749 list_entry(t, struct elf_thread_status, list);
1751 for (i = 0; i < tmp->num_notes; i++)
1752 if (!writenote(&tmp->notes[i], file, &foffset))
1757 DUMP_SEEK(dataoff - foffset);
1759 for (vma = first_vma(current, gate_vma); vma != NULL;
1760 vma = next_vma(vma, gate_vma)) {
1766 for (addr = vma->vm_start;
1768 addr += PAGE_SIZE) {
1770 struct vm_area_struct *vma;
1772 if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1773 &page, &vma) <= 0) {
1774 DUMP_SEEK(PAGE_SIZE);
1776 if (page == ZERO_PAGE(addr)) {
1777 if (!dump_seek(file, PAGE_SIZE)) {
1778 page_cache_release(page);
1783 flush_cache_page(vma, addr,
1786 if ((size += PAGE_SIZE) > limit ||
1787 !dump_write(file, kaddr,
1790 page_cache_release(page);
1795 page_cache_release(page);
1800 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1801 ELF_CORE_WRITE_EXTRA_DATA;
1808 while (!list_empty(&thread_list)) {
1809 struct list_head *tmp = thread_list.next;
1811 kfree(list_entry(tmp, struct elf_thread_status, list));
1819 #ifdef ELF_CORE_COPY_XFPREGS
1826 #endif /* USE_ELF_CORE_DUMP */
1828 static int __init init_elf_binfmt(void)
1830 return register_binfmt(&elf_format);
1833 static void __exit exit_elf_binfmt(void)
1835 /* Remove the COFF and ELF loaders. */
1836 unregister_binfmt(&elf_format);
1839 core_initcall(init_elf_binfmt);
1840 module_exit(exit_elf_binfmt);
1841 MODULE_LICENSE("GPL");