[PATCH] elf: Always define elf_addr_t in linux/elf.h
[linux-2.6.git] / fs / binfmt_elf.c
1 /*
2  * linux/fs/binfmt_elf.c
3  *
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
7  * Tools".
8  *
9  * Copyright 1993, 1994: Eric Youngdale (ericy@cais.com).
10  */
11
12 #include <linux/module.h>
13 #include <linux/kernel.h>
14 #include <linux/fs.h>
15 #include <linux/stat.h>
16 #include <linux/time.h>
17 #include <linux/mm.h>
18 #include <linux/mman.h>
19 #include <linux/a.out.h>
20 #include <linux/errno.h>
21 #include <linux/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 <asm/uaccess.h>
43 #include <asm/param.h>
44 #include <asm/page.h>
45
46 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
47 static int load_elf_library(struct file *);
48 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);
49
50 /*
51  * If we don't support core dumping, then supply a NULL so we
52  * don't even try.
53  */
54 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
55 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file);
56 #else
57 #define elf_core_dump   NULL
58 #endif
59
60 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
61 #define ELF_MIN_ALIGN   ELF_EXEC_PAGESIZE
62 #else
63 #define ELF_MIN_ALIGN   PAGE_SIZE
64 #endif
65
66 #ifndef ELF_CORE_EFLAGS
67 #define ELF_CORE_EFLAGS 0
68 #endif
69
70 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
71 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
72 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
73
74 static struct linux_binfmt elf_format = {
75                 .module         = THIS_MODULE,
76                 .load_binary    = load_elf_binary,
77                 .load_shlib     = load_elf_library,
78                 .core_dump      = elf_core_dump,
79                 .min_coredump   = ELF_EXEC_PAGESIZE
80 };
81
82 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
83
84 static int set_brk(unsigned long start, unsigned long end)
85 {
86         start = ELF_PAGEALIGN(start);
87         end = ELF_PAGEALIGN(end);
88         if (end > start) {
89                 unsigned long addr;
90                 down_write(&current->mm->mmap_sem);
91                 addr = do_brk(start, end - start);
92                 up_write(&current->mm->mmap_sem);
93                 if (BAD_ADDR(addr))
94                         return addr;
95         }
96         current->mm->start_brk = current->mm->brk = end;
97         return 0;
98 }
99
100 /* We need to explicitly zero any fractional pages
101    after the data section (i.e. bss).  This would
102    contain the junk from the file that should not
103    be in memory
104  */
105 static int padzero(unsigned long elf_bss)
106 {
107         unsigned long nbyte;
108
109         nbyte = ELF_PAGEOFFSET(elf_bss);
110         if (nbyte) {
111                 nbyte = ELF_MIN_ALIGN - nbyte;
112                 if (clear_user((void __user *) elf_bss, nbyte))
113                         return -EFAULT;
114         }
115         return 0;
116 }
117
118 /* Let's use some macros to make this stack manipulation a litle clearer */
119 #ifdef CONFIG_STACK_GROWSUP
120 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
121 #define STACK_ROUND(sp, items) \
122         ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
123 #define STACK_ALLOC(sp, len) ({ \
124         elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
125         old_sp; })
126 #else
127 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
128 #define STACK_ROUND(sp, items) \
129         (((unsigned long) (sp - items)) &~ 15UL)
130 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
131 #endif
132
133 static int
134 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
135                 int interp_aout, unsigned long load_addr,
136                 unsigned long interp_load_addr)
137 {
138         unsigned long p = bprm->p;
139         int argc = bprm->argc;
140         int envc = bprm->envc;
141         elf_addr_t __user *argv;
142         elf_addr_t __user *envp;
143         elf_addr_t __user *sp;
144         elf_addr_t __user *u_platform;
145         const char *k_platform = ELF_PLATFORM;
146         int items;
147         elf_addr_t *elf_info;
148         int ei_index = 0;
149         struct task_struct *tsk = current;
150
151         /*
152          * If this architecture has a platform capability string, copy it
153          * to userspace.  In some cases (Sparc), this info is impossible
154          * for userspace to get any other way, in others (i386) it is
155          * merely difficult.
156          */
157         u_platform = NULL;
158         if (k_platform) {
159                 size_t len = strlen(k_platform) + 1;
160
161                 /*
162                  * In some cases (e.g. Hyper-Threading), we want to avoid L1
163                  * evictions by the processes running on the same package. One
164                  * thing we can do is to shuffle the initial stack for them.
165                  */
166
167                 p = arch_align_stack(p);
168
169                 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
170                 if (__copy_to_user(u_platform, k_platform, len))
171                         return -EFAULT;
172         }
173
174         /* Create the ELF interpreter info */
175         elf_info = (elf_addr_t *)current->mm->saved_auxv;
176 #define NEW_AUX_ENT(id, val) \
177         do { \
178                 elf_info[ei_index++] = id; \
179                 elf_info[ei_index++] = val; \
180         } while (0)
181
182 #ifdef ARCH_DLINFO
183         /* 
184          * ARCH_DLINFO must come first so PPC can do its special alignment of
185          * AUXV.
186          */
187         ARCH_DLINFO;
188 #endif
189         NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
190         NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
191         NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
192         NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
193         NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
194         NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
195         NEW_AUX_ENT(AT_BASE, interp_load_addr);
196         NEW_AUX_ENT(AT_FLAGS, 0);
197         NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
198         NEW_AUX_ENT(AT_UID, tsk->uid);
199         NEW_AUX_ENT(AT_EUID, tsk->euid);
200         NEW_AUX_ENT(AT_GID, tsk->gid);
201         NEW_AUX_ENT(AT_EGID, tsk->egid);
202         NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
203         if (k_platform) {
204                 NEW_AUX_ENT(AT_PLATFORM,
205                             (elf_addr_t)(unsigned long)u_platform);
206         }
207         if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
208                 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
209         }
210 #undef NEW_AUX_ENT
211         /* AT_NULL is zero; clear the rest too */
212         memset(&elf_info[ei_index], 0,
213                sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
214
215         /* And advance past the AT_NULL entry.  */
216         ei_index += 2;
217
218         sp = STACK_ADD(p, ei_index);
219
220         items = (argc + 1) + (envc + 1);
221         if (interp_aout) {
222                 items += 3; /* a.out interpreters require argv & envp too */
223         } else {
224                 items += 1; /* ELF interpreters only put argc on the stack */
225         }
226         bprm->p = STACK_ROUND(sp, items);
227
228         /* Point sp at the lowest address on the stack */
229 #ifdef CONFIG_STACK_GROWSUP
230         sp = (elf_addr_t __user *)bprm->p - items - ei_index;
231         bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
232 #else
233         sp = (elf_addr_t __user *)bprm->p;
234 #endif
235
236         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
237         if (__put_user(argc, sp++))
238                 return -EFAULT;
239         if (interp_aout) {
240                 argv = sp + 2;
241                 envp = argv + argc + 1;
242                 if (__put_user((elf_addr_t)(unsigned long)argv, sp++) ||
243                     __put_user((elf_addr_t)(unsigned long)envp, sp++))
244                         return -EFAULT;
245         } else {
246                 argv = sp;
247                 envp = argv + argc + 1;
248         }
249
250         /* Populate argv and envp */
251         p = current->mm->arg_end = current->mm->arg_start;
252         while (argc-- > 0) {
253                 size_t len;
254                 if (__put_user((elf_addr_t)p, argv++))
255                         return -EFAULT;
256                 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
257                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
258                         return 0;
259                 p += len;
260         }
261         if (__put_user(0, argv))
262                 return -EFAULT;
263         current->mm->arg_end = current->mm->env_start = p;
264         while (envc-- > 0) {
265                 size_t len;
266                 if (__put_user((elf_addr_t)p, envp++))
267                         return -EFAULT;
268                 len = strnlen_user((void __user *)p, PAGE_SIZE*MAX_ARG_PAGES);
269                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
270                         return 0;
271                 p += len;
272         }
273         if (__put_user(0, envp))
274                 return -EFAULT;
275         current->mm->env_end = p;
276
277         /* Put the elf_info on the stack in the right place.  */
278         sp = (elf_addr_t __user *)envp + 1;
279         if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
280                 return -EFAULT;
281         return 0;
282 }
283
284 #ifndef elf_map
285
286 static unsigned long elf_map(struct file *filep, unsigned long addr,
287                 struct elf_phdr *eppnt, int prot, int type)
288 {
289         unsigned long map_addr;
290         unsigned long pageoffset = ELF_PAGEOFFSET(eppnt->p_vaddr);
291
292         down_write(&current->mm->mmap_sem);
293         /* mmap() will return -EINVAL if given a zero size, but a
294          * segment with zero filesize is perfectly valid */
295         if (eppnt->p_filesz + pageoffset)
296                 map_addr = do_mmap(filep, ELF_PAGESTART(addr),
297                                    eppnt->p_filesz + pageoffset, prot, type,
298                                    eppnt->p_offset - pageoffset);
299         else
300                 map_addr = ELF_PAGESTART(addr);
301         up_write(&current->mm->mmap_sem);
302         return(map_addr);
303 }
304
305 #endif /* !elf_map */
306
307 /* This is much more generalized than the library routine read function,
308    so we keep this separate.  Technically the library read function
309    is only provided so that we can read a.out libraries that have
310    an ELF header */
311
312 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
313                 struct file *interpreter, unsigned long *interp_load_addr)
314 {
315         struct elf_phdr *elf_phdata;
316         struct elf_phdr *eppnt;
317         unsigned long load_addr = 0;
318         int load_addr_set = 0;
319         unsigned long last_bss = 0, elf_bss = 0;
320         unsigned long error = ~0UL;
321         int retval, i, size;
322
323         /* First of all, some simple consistency checks */
324         if (interp_elf_ex->e_type != ET_EXEC &&
325             interp_elf_ex->e_type != ET_DYN)
326                 goto out;
327         if (!elf_check_arch(interp_elf_ex))
328                 goto out;
329         if (!interpreter->f_op || !interpreter->f_op->mmap)
330                 goto out;
331
332         /*
333          * If the size of this structure has changed, then punt, since
334          * we will be doing the wrong thing.
335          */
336         if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
337                 goto out;
338         if (interp_elf_ex->e_phnum < 1 ||
339                 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
340                 goto out;
341
342         /* Now read in all of the header information */
343         size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
344         if (size > ELF_MIN_ALIGN)
345                 goto out;
346         elf_phdata = kmalloc(size, GFP_KERNEL);
347         if (!elf_phdata)
348                 goto out;
349
350         retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
351                              (char *)elf_phdata,size);
352         error = -EIO;
353         if (retval != size) {
354                 if (retval < 0)
355                         error = retval; 
356                 goto out_close;
357         }
358
359         eppnt = elf_phdata;
360         for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
361                 if (eppnt->p_type == PT_LOAD) {
362                         int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
363                         int elf_prot = 0;
364                         unsigned long vaddr = 0;
365                         unsigned long k, map_addr;
366
367                         if (eppnt->p_flags & PF_R)
368                                 elf_prot = PROT_READ;
369                         if (eppnt->p_flags & PF_W)
370                                 elf_prot |= PROT_WRITE;
371                         if (eppnt->p_flags & PF_X)
372                                 elf_prot |= PROT_EXEC;
373                         vaddr = eppnt->p_vaddr;
374                         if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
375                                 elf_type |= MAP_FIXED;
376
377                         map_addr = elf_map(interpreter, load_addr + vaddr,
378                                            eppnt, elf_prot, elf_type);
379                         error = map_addr;
380                         if (BAD_ADDR(map_addr))
381                                 goto out_close;
382
383                         if (!load_addr_set &&
384                             interp_elf_ex->e_type == ET_DYN) {
385                                 load_addr = map_addr - ELF_PAGESTART(vaddr);
386                                 load_addr_set = 1;
387                         }
388
389                         /*
390                          * Check to see if the section's size will overflow the
391                          * allowed task size. Note that p_filesz must always be
392                          * <= p_memsize so it's only necessary to check p_memsz.
393                          */
394                         k = load_addr + eppnt->p_vaddr;
395                         if (BAD_ADDR(k) ||
396                             eppnt->p_filesz > eppnt->p_memsz ||
397                             eppnt->p_memsz > TASK_SIZE ||
398                             TASK_SIZE - eppnt->p_memsz < k) {
399                                 error = -ENOMEM;
400                                 goto out_close;
401                         }
402
403                         /*
404                          * Find the end of the file mapping for this phdr, and
405                          * keep track of the largest address we see for this.
406                          */
407                         k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
408                         if (k > elf_bss)
409                                 elf_bss = k;
410
411                         /*
412                          * Do the same thing for the memory mapping - between
413                          * elf_bss and last_bss is the bss section.
414                          */
415                         k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
416                         if (k > last_bss)
417                                 last_bss = k;
418                 }
419         }
420
421         /*
422          * Now fill out the bss section.  First pad the last page up
423          * to the page boundary, and then perform a mmap to make sure
424          * that there are zero-mapped pages up to and including the 
425          * last bss page.
426          */
427         if (padzero(elf_bss)) {
428                 error = -EFAULT;
429                 goto out_close;
430         }
431
432         /* What we have mapped so far */
433         elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
434
435         /* Map the last of the bss segment */
436         if (last_bss > elf_bss) {
437                 down_write(&current->mm->mmap_sem);
438                 error = do_brk(elf_bss, last_bss - elf_bss);
439                 up_write(&current->mm->mmap_sem);
440                 if (BAD_ADDR(error))
441                         goto out_close;
442         }
443
444         *interp_load_addr = load_addr;
445         error = ((unsigned long)interp_elf_ex->e_entry) + load_addr;
446
447 out_close:
448         kfree(elf_phdata);
449 out:
450         return error;
451 }
452
453 static unsigned long load_aout_interp(struct exec *interp_ex,
454                 struct file *interpreter)
455 {
456         unsigned long text_data, elf_entry = ~0UL;
457         char __user * addr;
458         loff_t offset;
459
460         current->mm->end_code = interp_ex->a_text;
461         text_data = interp_ex->a_text + interp_ex->a_data;
462         current->mm->end_data = text_data;
463         current->mm->brk = interp_ex->a_bss + text_data;
464
465         switch (N_MAGIC(*interp_ex)) {
466         case OMAGIC:
467                 offset = 32;
468                 addr = (char __user *)0;
469                 break;
470         case ZMAGIC:
471         case QMAGIC:
472                 offset = N_TXTOFF(*interp_ex);
473                 addr = (char __user *)N_TXTADDR(*interp_ex);
474                 break;
475         default:
476                 goto out;
477         }
478
479         down_write(&current->mm->mmap_sem);     
480         do_brk(0, text_data);
481         up_write(&current->mm->mmap_sem);
482         if (!interpreter->f_op || !interpreter->f_op->read)
483                 goto out;
484         if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
485                 goto out;
486         flush_icache_range((unsigned long)addr,
487                            (unsigned long)addr + text_data);
488
489         down_write(&current->mm->mmap_sem);     
490         do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
491                 interp_ex->a_bss);
492         up_write(&current->mm->mmap_sem);
493         elf_entry = interp_ex->a_entry;
494
495 out:
496         return elf_entry;
497 }
498
499 /*
500  * These are the functions used to load ELF style executables and shared
501  * libraries.  There is no binary dependent code anywhere else.
502  */
503
504 #define INTERPRETER_NONE 0
505 #define INTERPRETER_AOUT 1
506 #define INTERPRETER_ELF 2
507
508 #ifndef STACK_RND_MASK
509 #define STACK_RND_MASK 0x7ff            /* with 4K pages 8MB of VA */
510 #endif
511
512 static unsigned long randomize_stack_top(unsigned long stack_top)
513 {
514         unsigned int random_variable = 0;
515
516         if ((current->flags & PF_RANDOMIZE) &&
517                 !(current->personality & ADDR_NO_RANDOMIZE)) {
518                 random_variable = get_random_int() & STACK_RND_MASK;
519                 random_variable <<= PAGE_SHIFT;
520         }
521 #ifdef CONFIG_STACK_GROWSUP
522         return PAGE_ALIGN(stack_top) + random_variable;
523 #else
524         return PAGE_ALIGN(stack_top) - random_variable;
525 #endif
526 }
527
528 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
529 {
530         struct file *interpreter = NULL; /* to shut gcc up */
531         unsigned long load_addr = 0, load_bias = 0;
532         int load_addr_set = 0;
533         char * elf_interpreter = NULL;
534         unsigned int interpreter_type = INTERPRETER_NONE;
535         unsigned char ibcs2_interpreter = 0;
536         unsigned long error;
537         struct elf_phdr *elf_ppnt, *elf_phdata;
538         unsigned long elf_bss, elf_brk;
539         int elf_exec_fileno;
540         int retval, i;
541         unsigned int size;
542         unsigned long elf_entry, interp_load_addr = 0;
543         unsigned long start_code, end_code, start_data, end_data;
544         unsigned long reloc_func_desc = 0;
545         char passed_fileno[6];
546         struct files_struct *files;
547         int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;
548         unsigned long def_flags = 0;
549         struct {
550                 struct elfhdr elf_ex;
551                 struct elfhdr interp_elf_ex;
552                 struct exec interp_ex;
553         } *loc;
554
555         loc = kmalloc(sizeof(*loc), GFP_KERNEL);
556         if (!loc) {
557                 retval = -ENOMEM;
558                 goto out_ret;
559         }
560         
561         /* Get the exec-header */
562         loc->elf_ex = *((struct elfhdr *)bprm->buf);
563
564         retval = -ENOEXEC;
565         /* First of all, some simple consistency checks */
566         if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
567                 goto out;
568
569         if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
570                 goto out;
571         if (!elf_check_arch(&loc->elf_ex))
572                 goto out;
573         if (!bprm->file->f_op||!bprm->file->f_op->mmap)
574                 goto out;
575
576         /* Now read in all of the header information */
577         if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
578                 goto out;
579         if (loc->elf_ex.e_phnum < 1 ||
580                 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
581                 goto out;
582         size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
583         retval = -ENOMEM;
584         elf_phdata = kmalloc(size, GFP_KERNEL);
585         if (!elf_phdata)
586                 goto out;
587
588         retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
589                              (char *)elf_phdata, size);
590         if (retval != size) {
591                 if (retval >= 0)
592                         retval = -EIO;
593                 goto out_free_ph;
594         }
595
596         files = current->files; /* Refcounted so ok */
597         retval = unshare_files();
598         if (retval < 0)
599                 goto out_free_ph;
600         if (files == current->files) {
601                 put_files_struct(files);
602                 files = NULL;
603         }
604
605         /* exec will make our files private anyway, but for the a.out
606            loader stuff we need to do it earlier */
607         retval = get_unused_fd();
608         if (retval < 0)
609                 goto out_free_fh;
610         get_file(bprm->file);
611         fd_install(elf_exec_fileno = retval, bprm->file);
612
613         elf_ppnt = elf_phdata;
614         elf_bss = 0;
615         elf_brk = 0;
616
617         start_code = ~0UL;
618         end_code = 0;
619         start_data = 0;
620         end_data = 0;
621
622         for (i = 0; i < loc->elf_ex.e_phnum; i++) {
623                 if (elf_ppnt->p_type == PT_INTERP) {
624                         /* This is the program interpreter used for
625                          * shared libraries - for now assume that this
626                          * is an a.out format binary
627                          */
628                         retval = -ENOEXEC;
629                         if (elf_ppnt->p_filesz > PATH_MAX || 
630                             elf_ppnt->p_filesz < 2)
631                                 goto out_free_file;
632
633                         retval = -ENOMEM;
634                         elf_interpreter = kmalloc(elf_ppnt->p_filesz,
635                                                   GFP_KERNEL);
636                         if (!elf_interpreter)
637                                 goto out_free_file;
638
639                         retval = kernel_read(bprm->file, elf_ppnt->p_offset,
640                                              elf_interpreter,
641                                              elf_ppnt->p_filesz);
642                         if (retval != elf_ppnt->p_filesz) {
643                                 if (retval >= 0)
644                                         retval = -EIO;
645                                 goto out_free_interp;
646                         }
647                         /* make sure path is NULL terminated */
648                         retval = -ENOEXEC;
649                         if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
650                                 goto out_free_interp;
651
652                         /* If the program interpreter is one of these two,
653                          * then assume an iBCS2 image. Otherwise assume
654                          * a native linux image.
655                          */
656                         if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
657                             strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
658                                 ibcs2_interpreter = 1;
659
660                         /*
661                          * The early SET_PERSONALITY here is so that the lookup
662                          * for the interpreter happens in the namespace of the 
663                          * to-be-execed image.  SET_PERSONALITY can select an
664                          * alternate root.
665                          *
666                          * However, SET_PERSONALITY is NOT allowed to switch
667                          * this task into the new images's memory mapping
668                          * policy - that is, TASK_SIZE must still evaluate to
669                          * that which is appropriate to the execing application.
670                          * This is because exit_mmap() needs to have TASK_SIZE
671                          * evaluate to the size of the old image.
672                          *
673                          * So if (say) a 64-bit application is execing a 32-bit
674                          * application it is the architecture's responsibility
675                          * to defer changing the value of TASK_SIZE until the
676                          * switch really is going to happen - do this in
677                          * flush_thread().      - akpm
678                          */
679                         SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
680
681                         interpreter = open_exec(elf_interpreter);
682                         retval = PTR_ERR(interpreter);
683                         if (IS_ERR(interpreter))
684                                 goto out_free_interp;
685                         retval = kernel_read(interpreter, 0, bprm->buf,
686                                              BINPRM_BUF_SIZE);
687                         if (retval != BINPRM_BUF_SIZE) {
688                                 if (retval >= 0)
689                                         retval = -EIO;
690                                 goto out_free_dentry;
691                         }
692
693                         /* Get the exec headers */
694                         loc->interp_ex = *((struct exec *)bprm->buf);
695                         loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
696                         break;
697                 }
698                 elf_ppnt++;
699         }
700
701         elf_ppnt = elf_phdata;
702         for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
703                 if (elf_ppnt->p_type == PT_GNU_STACK) {
704                         if (elf_ppnt->p_flags & PF_X)
705                                 executable_stack = EXSTACK_ENABLE_X;
706                         else
707                                 executable_stack = EXSTACK_DISABLE_X;
708                         break;
709                 }
710         have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);
711
712         /* Some simple consistency checks for the interpreter */
713         if (elf_interpreter) {
714                 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
715
716                 /* Now figure out which format our binary is */
717                 if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
718                     (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
719                     (N_MAGIC(loc->interp_ex) != QMAGIC))
720                         interpreter_type = INTERPRETER_ELF;
721
722                 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
723                         interpreter_type &= ~INTERPRETER_ELF;
724
725                 retval = -ELIBBAD;
726                 if (!interpreter_type)
727                         goto out_free_dentry;
728
729                 /* Make sure only one type was selected */
730                 if ((interpreter_type & INTERPRETER_ELF) &&
731                      interpreter_type != INTERPRETER_ELF) {
732                         // FIXME - ratelimit this before re-enabling
733                         // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
734                         interpreter_type = INTERPRETER_ELF;
735                 }
736                 /* Verify the interpreter has a valid arch */
737                 if ((interpreter_type == INTERPRETER_ELF) &&
738                     !elf_check_arch(&loc->interp_elf_ex))
739                         goto out_free_dentry;
740         } else {
741                 /* Executables without an interpreter also need a personality  */
742                 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
743         }
744
745         /* OK, we are done with that, now set up the arg stuff,
746            and then start this sucker up */
747         if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
748                 char *passed_p = passed_fileno;
749                 sprintf(passed_fileno, "%d", elf_exec_fileno);
750
751                 if (elf_interpreter) {
752                         retval = copy_strings_kernel(1, &passed_p, bprm);
753                         if (retval)
754                                 goto out_free_dentry; 
755                         bprm->argc++;
756                 }
757         }
758
759         /* Flush all traces of the currently running executable */
760         retval = flush_old_exec(bprm);
761         if (retval)
762                 goto out_free_dentry;
763
764         /* Discard our unneeded old files struct */
765         if (files) {
766                 put_files_struct(files);
767                 files = NULL;
768         }
769
770         /* OK, This is the point of no return */
771         current->mm->start_data = 0;
772         current->mm->end_data = 0;
773         current->mm->end_code = 0;
774         current->mm->mmap = NULL;
775         current->flags &= ~PF_FORKNOEXEC;
776         current->mm->def_flags = def_flags;
777
778         /* Do this immediately, since STACK_TOP as used in setup_arg_pages
779            may depend on the personality.  */
780         SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
781         if (elf_read_implies_exec(loc->elf_ex, executable_stack))
782                 current->personality |= READ_IMPLIES_EXEC;
783
784         if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
785                 current->flags |= PF_RANDOMIZE;
786         arch_pick_mmap_layout(current->mm);
787
788         /* Do this so that we can load the interpreter, if need be.  We will
789            change some of these later */
790         current->mm->free_area_cache = current->mm->mmap_base;
791         current->mm->cached_hole_size = 0;
792         retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
793                                  executable_stack);
794         if (retval < 0) {
795                 send_sig(SIGKILL, current, 0);
796                 goto out_free_dentry;
797         }
798         
799         current->mm->start_stack = bprm->p;
800
801         /* Now we do a little grungy work by mmaping the ELF image into
802            the correct location in memory.  At this point, we assume that
803            the image should be loaded at fixed address, not at a variable
804            address. */
805         for(i = 0, elf_ppnt = elf_phdata;
806             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
807                 int elf_prot = 0, elf_flags;
808                 unsigned long k, vaddr;
809
810                 if (elf_ppnt->p_type != PT_LOAD)
811                         continue;
812
813                 if (unlikely (elf_brk > elf_bss)) {
814                         unsigned long nbyte;
815                     
816                         /* There was a PT_LOAD segment with p_memsz > p_filesz
817                            before this one. Map anonymous pages, if needed,
818                            and clear the area.  */
819                         retval = set_brk (elf_bss + load_bias,
820                                           elf_brk + load_bias);
821                         if (retval) {
822                                 send_sig(SIGKILL, current, 0);
823                                 goto out_free_dentry;
824                         }
825                         nbyte = ELF_PAGEOFFSET(elf_bss);
826                         if (nbyte) {
827                                 nbyte = ELF_MIN_ALIGN - nbyte;
828                                 if (nbyte > elf_brk - elf_bss)
829                                         nbyte = elf_brk - elf_bss;
830                                 if (clear_user((void __user *)elf_bss +
831                                                         load_bias, nbyte)) {
832                                         /*
833                                          * This bss-zeroing can fail if the ELF
834                                          * file specifies odd protections. So
835                                          * we don't check the return value
836                                          */
837                                 }
838                         }
839                 }
840
841                 if (elf_ppnt->p_flags & PF_R)
842                         elf_prot |= PROT_READ;
843                 if (elf_ppnt->p_flags & PF_W)
844                         elf_prot |= PROT_WRITE;
845                 if (elf_ppnt->p_flags & PF_X)
846                         elf_prot |= PROT_EXEC;
847
848                 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
849
850                 vaddr = elf_ppnt->p_vaddr;
851                 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
852                         elf_flags |= MAP_FIXED;
853                 } else if (loc->elf_ex.e_type == ET_DYN) {
854                         /* Try and get dynamic programs out of the way of the
855                          * default mmap base, as well as whatever program they
856                          * might try to exec.  This is because the brk will
857                          * follow the loader, and is not movable.  */
858                         if (current->flags & PF_RANDOMIZE)
859                                 load_bias = randomize_range(0x10000,
860                                                             ELF_ET_DYN_BASE,
861                                                             0);
862                         else
863                                 load_bias = ELF_ET_DYN_BASE;
864                         load_bias = ELF_PAGESTART(load_bias - vaddr);
865                 }
866
867                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
868                                 elf_prot, elf_flags);
869                 if (BAD_ADDR(error)) {
870                         send_sig(SIGKILL, current, 0);
871                         goto out_free_dentry;
872                 }
873
874                 if (!load_addr_set) {
875                         load_addr_set = 1;
876                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
877                         if (loc->elf_ex.e_type == ET_DYN) {
878                                 load_bias += error -
879                                              ELF_PAGESTART(load_bias + vaddr);
880                                 load_addr += load_bias;
881                                 reloc_func_desc = load_bias;
882                         }
883                 }
884                 k = elf_ppnt->p_vaddr;
885                 if (k < start_code)
886                         start_code = k;
887                 if (start_data < k)
888                         start_data = k;
889
890                 /*
891                  * Check to see if the section's size will overflow the
892                  * allowed task size. Note that p_filesz must always be
893                  * <= p_memsz so it is only necessary to check p_memsz.
894                  */
895                 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
896                     elf_ppnt->p_memsz > TASK_SIZE ||
897                     TASK_SIZE - elf_ppnt->p_memsz < k) {
898                         /* set_brk can never work. Avoid overflows. */
899                         send_sig(SIGKILL, current, 0);
900                         goto out_free_dentry;
901                 }
902
903                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
904
905                 if (k > elf_bss)
906                         elf_bss = k;
907                 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
908                         end_code = k;
909                 if (end_data < k)
910                         end_data = k;
911                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
912                 if (k > elf_brk)
913                         elf_brk = k;
914         }
915
916         loc->elf_ex.e_entry += load_bias;
917         elf_bss += load_bias;
918         elf_brk += load_bias;
919         start_code += load_bias;
920         end_code += load_bias;
921         start_data += load_bias;
922         end_data += load_bias;
923
924         /* Calling set_brk effectively mmaps the pages that we need
925          * for the bss and break sections.  We must do this before
926          * mapping in the interpreter, to make sure it doesn't wind
927          * up getting placed where the bss needs to go.
928          */
929         retval = set_brk(elf_bss, elf_brk);
930         if (retval) {
931                 send_sig(SIGKILL, current, 0);
932                 goto out_free_dentry;
933         }
934         if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
935                 send_sig(SIGSEGV, current, 0);
936                 retval = -EFAULT; /* Nobody gets to see this, but.. */
937                 goto out_free_dentry;
938         }
939
940         if (elf_interpreter) {
941                 if (interpreter_type == INTERPRETER_AOUT)
942                         elf_entry = load_aout_interp(&loc->interp_ex,
943                                                      interpreter);
944                 else
945                         elf_entry = load_elf_interp(&loc->interp_elf_ex,
946                                                     interpreter,
947                                                     &interp_load_addr);
948                 if (BAD_ADDR(elf_entry)) {
949                         force_sig(SIGSEGV, current);
950                         retval = IS_ERR((void *)elf_entry) ?
951                                         (int)elf_entry : -EINVAL;
952                         goto out_free_dentry;
953                 }
954                 reloc_func_desc = interp_load_addr;
955
956                 allow_write_access(interpreter);
957                 fput(interpreter);
958                 kfree(elf_interpreter);
959         } else {
960                 elf_entry = loc->elf_ex.e_entry;
961                 if (BAD_ADDR(elf_entry)) {
962                         force_sig(SIGSEGV, current);
963                         retval = -EINVAL;
964                         goto out_free_dentry;
965                 }
966         }
967
968         kfree(elf_phdata);
969
970         if (interpreter_type != INTERPRETER_AOUT)
971                 sys_close(elf_exec_fileno);
972
973         set_binfmt(&elf_format);
974
975 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
976         retval = arch_setup_additional_pages(bprm, executable_stack);
977         if (retval < 0) {
978                 send_sig(SIGKILL, current, 0);
979                 goto out;
980         }
981 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
982
983         compute_creds(bprm);
984         current->flags &= ~PF_FORKNOEXEC;
985         create_elf_tables(bprm, &loc->elf_ex,
986                           (interpreter_type == INTERPRETER_AOUT),
987                           load_addr, interp_load_addr);
988         /* N.B. passed_fileno might not be initialized? */
989         if (interpreter_type == INTERPRETER_AOUT)
990                 current->mm->arg_start += strlen(passed_fileno) + 1;
991         current->mm->end_code = end_code;
992         current->mm->start_code = start_code;
993         current->mm->start_data = start_data;
994         current->mm->end_data = end_data;
995         current->mm->start_stack = bprm->p;
996
997         if (current->personality & MMAP_PAGE_ZERO) {
998                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
999                    and some applications "depend" upon this behavior.
1000                    Since we do not have the power to recompile these, we
1001                    emulate the SVr4 behavior. Sigh. */
1002                 down_write(&current->mm->mmap_sem);
1003                 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
1004                                 MAP_FIXED | MAP_PRIVATE, 0);
1005                 up_write(&current->mm->mmap_sem);
1006         }
1007
1008 #ifdef ELF_PLAT_INIT
1009         /*
1010          * The ABI may specify that certain registers be set up in special
1011          * ways (on i386 %edx is the address of a DT_FINI function, for
1012          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
1013          * that the e_entry field is the address of the function descriptor
1014          * for the startup routine, rather than the address of the startup
1015          * routine itself.  This macro performs whatever initialization to
1016          * the regs structure is required as well as any relocations to the
1017          * function descriptor entries when executing dynamically links apps.
1018          */
1019         ELF_PLAT_INIT(regs, reloc_func_desc);
1020 #endif
1021
1022         start_thread(regs, elf_entry, bprm->p);
1023         if (unlikely(current->ptrace & PT_PTRACED)) {
1024                 if (current->ptrace & PT_TRACE_EXEC)
1025                         ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
1026                 else
1027                         send_sig(SIGTRAP, current, 0);
1028         }
1029         retval = 0;
1030 out:
1031         kfree(loc);
1032 out_ret:
1033         return retval;
1034
1035         /* error cleanup */
1036 out_free_dentry:
1037         allow_write_access(interpreter);
1038         if (interpreter)
1039                 fput(interpreter);
1040 out_free_interp:
1041         kfree(elf_interpreter);
1042 out_free_file:
1043         sys_close(elf_exec_fileno);
1044 out_free_fh:
1045         if (files)
1046                 reset_files_struct(current, files);
1047 out_free_ph:
1048         kfree(elf_phdata);
1049         goto out;
1050 }
1051
1052 /* This is really simpleminded and specialized - we are loading an
1053    a.out library that is given an ELF header. */
1054 static int load_elf_library(struct file *file)
1055 {
1056         struct elf_phdr *elf_phdata;
1057         struct elf_phdr *eppnt;
1058         unsigned long elf_bss, bss, len;
1059         int retval, error, i, j;
1060         struct elfhdr elf_ex;
1061
1062         error = -ENOEXEC;
1063         retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
1064         if (retval != sizeof(elf_ex))
1065                 goto out;
1066
1067         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1068                 goto out;
1069
1070         /* First of all, some simple consistency checks */
1071         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1072             !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1073                 goto out;
1074
1075         /* Now read in all of the header information */
1076
1077         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1078         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1079
1080         error = -ENOMEM;
1081         elf_phdata = kmalloc(j, GFP_KERNEL);
1082         if (!elf_phdata)
1083                 goto out;
1084
1085         eppnt = elf_phdata;
1086         error = -ENOEXEC;
1087         retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1088         if (retval != j)
1089                 goto out_free_ph;
1090
1091         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1092                 if ((eppnt + i)->p_type == PT_LOAD)
1093                         j++;
1094         if (j != 1)
1095                 goto out_free_ph;
1096
1097         while (eppnt->p_type != PT_LOAD)
1098                 eppnt++;
1099
1100         /* Now use mmap to map the library into memory. */
1101         down_write(&current->mm->mmap_sem);
1102         error = do_mmap(file,
1103                         ELF_PAGESTART(eppnt->p_vaddr),
1104                         (eppnt->p_filesz +
1105                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
1106                         PROT_READ | PROT_WRITE | PROT_EXEC,
1107                         MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1108                         (eppnt->p_offset -
1109                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
1110         up_write(&current->mm->mmap_sem);
1111         if (error != ELF_PAGESTART(eppnt->p_vaddr))
1112                 goto out_free_ph;
1113
1114         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1115         if (padzero(elf_bss)) {
1116                 error = -EFAULT;
1117                 goto out_free_ph;
1118         }
1119
1120         len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1121                             ELF_MIN_ALIGN - 1);
1122         bss = eppnt->p_memsz + eppnt->p_vaddr;
1123         if (bss > len) {
1124                 down_write(&current->mm->mmap_sem);
1125                 do_brk(len, bss - len);
1126                 up_write(&current->mm->mmap_sem);
1127         }
1128         error = 0;
1129
1130 out_free_ph:
1131         kfree(elf_phdata);
1132 out:
1133         return error;
1134 }
1135
1136 /*
1137  * Note that some platforms still use traditional core dumps and not
1138  * the ELF core dump.  Each platform can select it as appropriate.
1139  */
1140 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1141
1142 /*
1143  * ELF core dumper
1144  *
1145  * Modelled on fs/exec.c:aout_core_dump()
1146  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1147  */
1148 /*
1149  * These are the only things you should do on a core-file: use only these
1150  * functions to write out all the necessary info.
1151  */
1152 static int dump_write(struct file *file, const void *addr, int nr)
1153 {
1154         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1155 }
1156
1157 static int dump_seek(struct file *file, loff_t off)
1158 {
1159         if (file->f_op->llseek && file->f_op->llseek != no_llseek) {
1160                 if (file->f_op->llseek(file, off, SEEK_CUR) < 0)
1161                         return 0;
1162         } else {
1163                 char *buf = (char *)get_zeroed_page(GFP_KERNEL);
1164                 if (!buf)
1165                         return 0;
1166                 while (off > 0) {
1167                         unsigned long n = off;
1168                         if (n > PAGE_SIZE)
1169                                 n = PAGE_SIZE;
1170                         if (!dump_write(file, buf, n))
1171                                 return 0;
1172                         off -= n;
1173                 }
1174                 free_page((unsigned long)buf);
1175         }
1176         return 1;
1177 }
1178
1179 /*
1180  * Decide whether a segment is worth dumping; default is yes to be
1181  * sure (missing info is worse than too much; etc).
1182  * Personally I'd include everything, and use the coredump limit...
1183  *
1184  * I think we should skip something. But I am not sure how. H.J.
1185  */
1186 static int maydump(struct vm_area_struct *vma)
1187 {
1188         /* Do not dump I/O mapped devices or special mappings */
1189         if (vma->vm_flags & (VM_IO | VM_RESERVED))
1190                 return 0;
1191
1192         /* Dump shared memory only if mapped from an anonymous file. */
1193         if (vma->vm_flags & VM_SHARED)
1194                 return vma->vm_file->f_dentry->d_inode->i_nlink == 0;
1195
1196         /* If it hasn't been written to, don't write it out */
1197         if (!vma->anon_vma)
1198                 return 0;
1199
1200         return 1;
1201 }
1202
1203 /* An ELF note in memory */
1204 struct memelfnote
1205 {
1206         const char *name;
1207         int type;
1208         unsigned int datasz;
1209         void *data;
1210 };
1211
1212 static int notesize(struct memelfnote *en)
1213 {
1214         int sz;
1215
1216         sz = sizeof(struct elf_note);
1217         sz += roundup(strlen(en->name) + 1, 4);
1218         sz += roundup(en->datasz, 4);
1219
1220         return sz;
1221 }
1222
1223 #define DUMP_WRITE(addr, nr, foffset)   \
1224         do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
1225
1226 static int alignfile(struct file *file, loff_t *foffset)
1227 {
1228         static const char buf[4] = { 0, };
1229         DUMP_WRITE(buf, roundup(*foffset, 4) - *foffset, foffset);
1230         return 1;
1231 }
1232
1233 static int writenote(struct memelfnote *men, struct file *file,
1234                         loff_t *foffset)
1235 {
1236         struct elf_note en;
1237         en.n_namesz = strlen(men->name) + 1;
1238         en.n_descsz = men->datasz;
1239         en.n_type = men->type;
1240
1241         DUMP_WRITE(&en, sizeof(en), foffset);
1242         DUMP_WRITE(men->name, en.n_namesz, foffset);
1243         if (!alignfile(file, foffset))
1244                 return 0;
1245         DUMP_WRITE(men->data, men->datasz, foffset);
1246         if (!alignfile(file, foffset))
1247                 return 0;
1248
1249         return 1;
1250 }
1251 #undef DUMP_WRITE
1252
1253 #define DUMP_WRITE(addr, nr)    \
1254         if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1255                 goto end_coredump;
1256 #define DUMP_SEEK(off)  \
1257         if (!dump_seek(file, (off))) \
1258                 goto end_coredump;
1259
1260 static void fill_elf_header(struct elfhdr *elf, int segs)
1261 {
1262         memcpy(elf->e_ident, ELFMAG, SELFMAG);
1263         elf->e_ident[EI_CLASS] = ELF_CLASS;
1264         elf->e_ident[EI_DATA] = ELF_DATA;
1265         elf->e_ident[EI_VERSION] = EV_CURRENT;
1266         elf->e_ident[EI_OSABI] = ELF_OSABI;
1267         memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1268
1269         elf->e_type = ET_CORE;
1270         elf->e_machine = ELF_ARCH;
1271         elf->e_version = EV_CURRENT;
1272         elf->e_entry = 0;
1273         elf->e_phoff = sizeof(struct elfhdr);
1274         elf->e_shoff = 0;
1275         elf->e_flags = ELF_CORE_EFLAGS;
1276         elf->e_ehsize = sizeof(struct elfhdr);
1277         elf->e_phentsize = sizeof(struct elf_phdr);
1278         elf->e_phnum = segs;
1279         elf->e_shentsize = 0;
1280         elf->e_shnum = 0;
1281         elf->e_shstrndx = 0;
1282         return;
1283 }
1284
1285 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1286 {
1287         phdr->p_type = PT_NOTE;
1288         phdr->p_offset = offset;
1289         phdr->p_vaddr = 0;
1290         phdr->p_paddr = 0;
1291         phdr->p_filesz = sz;
1292         phdr->p_memsz = 0;
1293         phdr->p_flags = 0;
1294         phdr->p_align = 0;
1295         return;
1296 }
1297
1298 static void fill_note(struct memelfnote *note, const char *name, int type, 
1299                 unsigned int sz, void *data)
1300 {
1301         note->name = name;
1302         note->type = type;
1303         note->datasz = sz;
1304         note->data = data;
1305         return;
1306 }
1307
1308 /*
1309  * fill up all the fields in prstatus from the given task struct, except
1310  * registers which need to be filled up separately.
1311  */
1312 static void fill_prstatus(struct elf_prstatus *prstatus,
1313                 struct task_struct *p, long signr)
1314 {
1315         prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1316         prstatus->pr_sigpend = p->pending.signal.sig[0];
1317         prstatus->pr_sighold = p->blocked.sig[0];
1318         prstatus->pr_pid = p->pid;
1319         prstatus->pr_ppid = p->parent->pid;
1320         prstatus->pr_pgrp = process_group(p);
1321         prstatus->pr_sid = p->signal->session;
1322         if (thread_group_leader(p)) {
1323                 /*
1324                  * This is the record for the group leader.  Add in the
1325                  * cumulative times of previous dead threads.  This total
1326                  * won't include the time of each live thread whose state
1327                  * is included in the core dump.  The final total reported
1328                  * to our parent process when it calls wait4 will include
1329                  * those sums as well as the little bit more time it takes
1330                  * this and each other thread to finish dying after the
1331                  * core dump synchronization phase.
1332                  */
1333                 cputime_to_timeval(cputime_add(p->utime, p->signal->utime),
1334                                    &prstatus->pr_utime);
1335                 cputime_to_timeval(cputime_add(p->stime, p->signal->stime),
1336                                    &prstatus->pr_stime);
1337         } else {
1338                 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1339                 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1340         }
1341         cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1342         cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1343 }
1344
1345 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1346                        struct mm_struct *mm)
1347 {
1348         unsigned int i, len;
1349         
1350         /* first copy the parameters from user space */
1351         memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1352
1353         len = mm->arg_end - mm->arg_start;
1354         if (len >= ELF_PRARGSZ)
1355                 len = ELF_PRARGSZ-1;
1356         if (copy_from_user(&psinfo->pr_psargs,
1357                            (const char __user *)mm->arg_start, len))
1358                 return -EFAULT;
1359         for(i = 0; i < len; i++)
1360                 if (psinfo->pr_psargs[i] == 0)
1361                         psinfo->pr_psargs[i] = ' ';
1362         psinfo->pr_psargs[len] = 0;
1363
1364         psinfo->pr_pid = p->pid;
1365         psinfo->pr_ppid = p->parent->pid;
1366         psinfo->pr_pgrp = process_group(p);
1367         psinfo->pr_sid = p->signal->session;
1368
1369         i = p->state ? ffz(~p->state) + 1 : 0;
1370         psinfo->pr_state = i;
1371         psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1372         psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1373         psinfo->pr_nice = task_nice(p);
1374         psinfo->pr_flag = p->flags;
1375         SET_UID(psinfo->pr_uid, p->uid);
1376         SET_GID(psinfo->pr_gid, p->gid);
1377         strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1378         
1379         return 0;
1380 }
1381
1382 /* Here is the structure in which status of each thread is captured. */
1383 struct elf_thread_status
1384 {
1385         struct list_head list;
1386         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1387         elf_fpregset_t fpu;             /* NT_PRFPREG */
1388         struct task_struct *thread;
1389 #ifdef ELF_CORE_COPY_XFPREGS
1390         elf_fpxregset_t xfpu;           /* NT_PRXFPREG */
1391 #endif
1392         struct memelfnote notes[3];
1393         int num_notes;
1394 };
1395
1396 /*
1397  * In order to add the specific thread information for the elf file format,
1398  * we need to keep a linked list of every threads pr_status and then create
1399  * a single section for them in the final core file.
1400  */
1401 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1402 {
1403         int sz = 0;
1404         struct task_struct *p = t->thread;
1405         t->num_notes = 0;
1406
1407         fill_prstatus(&t->prstatus, p, signr);
1408         elf_core_copy_task_regs(p, &t->prstatus.pr_reg);        
1409         
1410         fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1411                   &(t->prstatus));
1412         t->num_notes++;
1413         sz += notesize(&t->notes[0]);
1414
1415         if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1416                                                                 &t->fpu))) {
1417                 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1418                           &(t->fpu));
1419                 t->num_notes++;
1420                 sz += notesize(&t->notes[1]);
1421         }
1422
1423 #ifdef ELF_CORE_COPY_XFPREGS
1424         if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1425                 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu),
1426                           &t->xfpu);
1427                 t->num_notes++;
1428                 sz += notesize(&t->notes[2]);
1429         }
1430 #endif  
1431         return sz;
1432 }
1433
1434 /*
1435  * Actual dumper
1436  *
1437  * This is a two-pass process; first we find the offsets of the bits,
1438  * and then they are actually written out.  If we run out of core limit
1439  * we just truncate.
1440  */
1441 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file)
1442 {
1443 #define NUM_NOTES       6
1444         int has_dumped = 0;
1445         mm_segment_t fs;
1446         int segs;
1447         size_t size = 0;
1448         int i;
1449         struct vm_area_struct *vma;
1450         struct elfhdr *elf = NULL;
1451         loff_t offset = 0, dataoff, foffset;
1452         unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
1453         int numnote;
1454         struct memelfnote *notes = NULL;
1455         struct elf_prstatus *prstatus = NULL;   /* NT_PRSTATUS */
1456         struct elf_prpsinfo *psinfo = NULL;     /* NT_PRPSINFO */
1457         struct task_struct *g, *p;
1458         LIST_HEAD(thread_list);
1459         struct list_head *t;
1460         elf_fpregset_t *fpu = NULL;
1461 #ifdef ELF_CORE_COPY_XFPREGS
1462         elf_fpxregset_t *xfpu = NULL;
1463 #endif
1464         int thread_status_size = 0;
1465         elf_addr_t *auxv;
1466
1467         /*
1468          * We no longer stop all VM operations.
1469          * 
1470          * This is because those proceses that could possibly change map_count
1471          * or the mmap / vma pages are now blocked in do_exit on current
1472          * finishing this core dump.
1473          *
1474          * Only ptrace can touch these memory addresses, but it doesn't change
1475          * the map_count or the pages allocated. So no possibility of crashing
1476          * exists while dumping the mm->vm_next areas to the core file.
1477          */
1478   
1479         /* alloc memory for large data structures: too large to be on stack */
1480         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1481         if (!elf)
1482                 goto cleanup;
1483         prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1484         if (!prstatus)
1485                 goto cleanup;
1486         psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1487         if (!psinfo)
1488                 goto cleanup;
1489         notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1490         if (!notes)
1491                 goto cleanup;
1492         fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1493         if (!fpu)
1494                 goto cleanup;
1495 #ifdef ELF_CORE_COPY_XFPREGS
1496         xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1497         if (!xfpu)
1498                 goto cleanup;
1499 #endif
1500
1501         if (signr) {
1502                 struct elf_thread_status *tmp;
1503                 rcu_read_lock();
1504                 do_each_thread(g,p)
1505                         if (current->mm == p->mm && current != p) {
1506                                 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
1507                                 if (!tmp) {
1508                                         rcu_read_unlock();
1509                                         goto cleanup;
1510                                 }
1511                                 tmp->thread = p;
1512                                 list_add(&tmp->list, &thread_list);
1513                         }
1514                 while_each_thread(g,p);
1515                 rcu_read_unlock();
1516                 list_for_each(t, &thread_list) {
1517                         struct elf_thread_status *tmp;
1518                         int sz;
1519
1520                         tmp = list_entry(t, struct elf_thread_status, list);
1521                         sz = elf_dump_thread_status(signr, tmp);
1522                         thread_status_size += sz;
1523                 }
1524         }
1525         /* now collect the dump for the current */
1526         memset(prstatus, 0, sizeof(*prstatus));
1527         fill_prstatus(prstatus, current, signr);
1528         elf_core_copy_regs(&prstatus->pr_reg, regs);
1529         
1530         segs = current->mm->map_count;
1531 #ifdef ELF_CORE_EXTRA_PHDRS
1532         segs += ELF_CORE_EXTRA_PHDRS;
1533 #endif
1534
1535         /* Set up header */
1536         fill_elf_header(elf, segs + 1); /* including notes section */
1537
1538         has_dumped = 1;
1539         current->flags |= PF_DUMPCORE;
1540
1541         /*
1542          * Set up the notes in similar form to SVR4 core dumps made
1543          * with info from their /proc.
1544          */
1545
1546         fill_note(notes + 0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1547         fill_psinfo(psinfo, current->group_leader, current->mm);
1548         fill_note(notes + 1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1549         
1550         numnote = 2;
1551
1552         auxv = (elf_addr_t *)current->mm->saved_auxv;
1553
1554         i = 0;
1555         do
1556                 i += 2;
1557         while (auxv[i - 2] != AT_NULL);
1558         fill_note(&notes[numnote++], "CORE", NT_AUXV,
1559                   i * sizeof(elf_addr_t), auxv);
1560
1561         /* Try to dump the FPU. */
1562         if ((prstatus->pr_fpvalid =
1563              elf_core_copy_task_fpregs(current, regs, fpu)))
1564                 fill_note(notes + numnote++,
1565                           "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1566 #ifdef ELF_CORE_COPY_XFPREGS
1567         if (elf_core_copy_task_xfpregs(current, xfpu))
1568                 fill_note(notes + numnote++,
1569                           "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1570 #endif  
1571   
1572         fs = get_fs();
1573         set_fs(KERNEL_DS);
1574
1575         DUMP_WRITE(elf, sizeof(*elf));
1576         offset += sizeof(*elf);                         /* Elf header */
1577         offset += (segs + 1) * sizeof(struct elf_phdr); /* Program headers */
1578         foffset = offset;
1579
1580         /* Write notes phdr entry */
1581         {
1582                 struct elf_phdr phdr;
1583                 int sz = 0;
1584
1585                 for (i = 0; i < numnote; i++)
1586                         sz += notesize(notes + i);
1587                 
1588                 sz += thread_status_size;
1589
1590 #ifdef ELF_CORE_WRITE_EXTRA_NOTES
1591                 sz += ELF_CORE_EXTRA_NOTES_SIZE;
1592 #endif
1593
1594                 fill_elf_note_phdr(&phdr, sz, offset);
1595                 offset += sz;
1596                 DUMP_WRITE(&phdr, sizeof(phdr));
1597         }
1598
1599         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1600
1601         /* Write program headers for segments dump */
1602         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1603                 struct elf_phdr phdr;
1604                 size_t sz;
1605
1606                 sz = vma->vm_end - vma->vm_start;
1607
1608                 phdr.p_type = PT_LOAD;
1609                 phdr.p_offset = offset;
1610                 phdr.p_vaddr = vma->vm_start;
1611                 phdr.p_paddr = 0;
1612                 phdr.p_filesz = maydump(vma) ? sz : 0;
1613                 phdr.p_memsz = sz;
1614                 offset += phdr.p_filesz;
1615                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1616                 if (vma->vm_flags & VM_WRITE)
1617                         phdr.p_flags |= PF_W;
1618                 if (vma->vm_flags & VM_EXEC)
1619                         phdr.p_flags |= PF_X;
1620                 phdr.p_align = ELF_EXEC_PAGESIZE;
1621
1622                 DUMP_WRITE(&phdr, sizeof(phdr));
1623         }
1624
1625 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1626         ELF_CORE_WRITE_EXTRA_PHDRS;
1627 #endif
1628
1629         /* write out the notes section */
1630         for (i = 0; i < numnote; i++)
1631                 if (!writenote(notes + i, file, &foffset))
1632                         goto end_coredump;
1633
1634 #ifdef ELF_CORE_WRITE_EXTRA_NOTES
1635         ELF_CORE_WRITE_EXTRA_NOTES;
1636 #endif
1637
1638         /* write out the thread status notes section */
1639         list_for_each(t, &thread_list) {
1640                 struct elf_thread_status *tmp =
1641                                 list_entry(t, struct elf_thread_status, list);
1642
1643                 for (i = 0; i < tmp->num_notes; i++)
1644                         if (!writenote(&tmp->notes[i], file, &foffset))
1645                                 goto end_coredump;
1646         }
1647
1648         /* Align to page */
1649         DUMP_SEEK(dataoff - foffset);
1650
1651         for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1652                 unsigned long addr;
1653
1654                 if (!maydump(vma))
1655                         continue;
1656
1657                 for (addr = vma->vm_start;
1658                      addr < vma->vm_end;
1659                      addr += PAGE_SIZE) {
1660                         struct page *page;
1661                         struct vm_area_struct *vma;
1662
1663                         if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1664                                                 &page, &vma) <= 0) {
1665                                 DUMP_SEEK(PAGE_SIZE);
1666                         } else {
1667                                 if (page == ZERO_PAGE(addr)) {
1668                                         DUMP_SEEK(PAGE_SIZE);
1669                                 } else {
1670                                         void *kaddr;
1671                                         flush_cache_page(vma, addr,
1672                                                          page_to_pfn(page));
1673                                         kaddr = kmap(page);
1674                                         if ((size += PAGE_SIZE) > limit ||
1675                                             !dump_write(file, kaddr,
1676                                             PAGE_SIZE)) {
1677                                                 kunmap(page);
1678                                                 page_cache_release(page);
1679                                                 goto end_coredump;
1680                                         }
1681                                         kunmap(page);
1682                                 }
1683                                 page_cache_release(page);
1684                         }
1685                 }
1686         }
1687
1688 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1689         ELF_CORE_WRITE_EXTRA_DATA;
1690 #endif
1691
1692 end_coredump:
1693         set_fs(fs);
1694
1695 cleanup:
1696         while (!list_empty(&thread_list)) {
1697                 struct list_head *tmp = thread_list.next;
1698                 list_del(tmp);
1699                 kfree(list_entry(tmp, struct elf_thread_status, list));
1700         }
1701
1702         kfree(elf);
1703         kfree(prstatus);
1704         kfree(psinfo);
1705         kfree(notes);
1706         kfree(fpu);
1707 #ifdef ELF_CORE_COPY_XFPREGS
1708         kfree(xfpu);
1709 #endif
1710         return has_dumped;
1711 #undef NUM_NOTES
1712 }
1713
1714 #endif          /* USE_ELF_CORE_DUMP */
1715
1716 static int __init init_elf_binfmt(void)
1717 {
1718         return register_binfmt(&elf_format);
1719 }
1720
1721 static void __exit exit_elf_binfmt(void)
1722 {
1723         /* Remove the COFF and ELF loaders. */
1724         unregister_binfmt(&elf_format);
1725 }
1726
1727 core_initcall(init_elf_binfmt);
1728 module_exit(exit_elf_binfmt);
1729 MODULE_LICENSE("GPL");