Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/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 
 14 #include <linux/fs.h>
 15 #include <linux/stat.h>
 16 #include <linux/sched.h>
 17 #include <linux/mm.h>
 18 #include <linux/mman.h>
 19 #include <linux/a.out.h>
 20 #include <linux/errno.h>
 21 #include <linux/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_lock.h>
 34 #include <linux/compiler.h>
 35 #include <linux/highmem.h>
 36 
 37 #include <asm/uaccess.h>
 38 #include <asm/param.h>
 39 #include <asm/pgalloc.h>
 40 
 41 #define DLINFO_ITEMS 13
 42 
 43 #include <linux/elf.h>
 44 
 45 static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs);
 46 static int load_elf_library(struct file*);
 47 static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int);
 48 extern int dump_fpu (struct pt_regs *, elf_fpregset_t *);
 49 extern void dump_thread(struct pt_regs *, struct user *);
 50 
 51 #ifndef elf_addr_t
 52 #define elf_addr_t unsigned long
 53 #define elf_caddr_t char *
 54 #endif
 55 
 56 /*
 57  * If we don't support core dumping, then supply a NULL so we
 58  * don't even try.
 59  */
 60 #ifdef USE_ELF_CORE_DUMP
 61 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file);
 62 #else
 63 #define elf_core_dump   NULL
 64 #endif
 65 
 66 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
 67 # define ELF_MIN_ALIGN  ELF_EXEC_PAGESIZE
 68 #else
 69 # define ELF_MIN_ALIGN  PAGE_SIZE
 70 #endif
 71 
 72 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
 73 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
 74 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
 75 
 76 static struct linux_binfmt elf_format = {
 77         NULL, THIS_MODULE, load_elf_binary, load_elf_library, elf_core_dump, ELF_EXEC_PAGESIZE
 78 };
 79 
 80 #define BAD_ADDR(x)     ((unsigned long)(x) >= TASK_SIZE)
 81 
 82 static int set_brk(unsigned long start, unsigned long end)
 83 {
 84         start = ELF_PAGEALIGN(start);
 85         end = ELF_PAGEALIGN(end);
 86         if (end > start) {
 87                 unsigned long addr;
 88                 down_write(&current->mm->mmap_sem);
 89                 addr = do_brk(start, end - start);
 90                 up_write(&current->mm->mmap_sem);
 91                 if (BAD_ADDR(addr))
 92                         return addr;
 93         }
 94         current->mm->start_brk = current->mm->brk = end;
 95         return 0;
 96 }
 97 
 98 
 99 /* We need to explicitly zero any fractional pages
100    after the data section (i.e. bss).  This would
101    contain the junk from the file that should not
102    be in memory */
103 
104 
105 static void 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                 clear_user((void *) elf_bss, nbyte);
113         }
114 }
115 
116 static elf_addr_t * 
117 create_elf_tables(char *p, int argc, int envc,
118                   struct elfhdr * exec,
119                   unsigned long load_addr,
120                   unsigned long load_bias,
121                   unsigned long interp_load_addr, int ibcs)
122 {
123         elf_caddr_t *argv;
124         elf_caddr_t *envp;
125         elf_addr_t *sp, *csp;
126         char *k_platform, *u_platform;
127         long hwcap;
128         size_t platform_len = 0;
129         size_t len;
130 
131         /*
132          * Get hold of platform and hardware capabilities masks for
133          * the machine we are running on.  In some cases (Sparc), 
134          * this info is impossible to get, in others (i386) it is
135          * merely difficult.
136          */
137 
138         hwcap = ELF_HWCAP;
139         k_platform = ELF_PLATFORM;
140 
141         if (k_platform) {
142                 platform_len = strlen(k_platform) + 1;
143                 u_platform = p - platform_len;
144                 __copy_to_user(u_platform, k_platform, platform_len);
145         } else
146                 u_platform = p;
147 
148 #if defined(__i386__) && defined(CONFIG_SMP)
149         /*
150          * In some cases (e.g. Hyper-Threading), we want to avoid L1 evictions
151          * by the processes running on the same package. One thing we can do
152          * is to shuffle the initial stack for them.
153          *
154          * The conditionals here are unneeded, but kept in to make the
155          * code behaviour the same as pre change unless we have hyperthreaded
156          * processors. This keeps Mr Marcelo Person happier but should be
157          * removed for 2.5
158          */
159          
160         if(smp_num_siblings > 1)
161                 u_platform = u_platform - ((current->pid % 64) << 7);
162 #endif  
163 
164         /*
165          * Force 16 byte _final_ alignment here for generality.
166          */
167         sp = (elf_addr_t *)(~15UL & (unsigned long)(u_platform));
168         csp = sp;
169         csp -= (1+DLINFO_ITEMS)*2 + (k_platform ? 2 : 0);
170 #ifdef DLINFO_ARCH_ITEMS
171         csp -= DLINFO_ARCH_ITEMS*2;
172 #endif
173         csp -= envc+1;
174         csp -= argc+1;
175         csp -= (!ibcs ? 3 : 1); /* argc itself */
176         if ((unsigned long)csp & 15UL)
177                 sp -= ((unsigned long)csp & 15UL) / sizeof(*sp);
178 
179         /*
180          * Put the ELF interpreter info on the stack
181          */
182 #define NEW_AUX_ENT(nr, id, val) \
183           __put_user ((id), sp+(nr*2)); \
184           __put_user ((val), sp+(nr*2+1)); \
185 
186         sp -= 2;
187         NEW_AUX_ENT(0, AT_NULL, 0);
188         if (k_platform) {
189                 sp -= 2;
190                 NEW_AUX_ENT(0, AT_PLATFORM, (elf_addr_t)(unsigned long) u_platform);
191         }
192         sp -= DLINFO_ITEMS*2;
193         NEW_AUX_ENT( 0, AT_HWCAP, hwcap);
194         NEW_AUX_ENT( 1, AT_PAGESZ, ELF_EXEC_PAGESIZE);
195         NEW_AUX_ENT( 2, AT_CLKTCK, CLOCKS_PER_SEC);
196         NEW_AUX_ENT( 3, AT_PHDR, load_addr + exec->e_phoff);
197         NEW_AUX_ENT( 4, AT_PHENT, sizeof (struct elf_phdr));
198         NEW_AUX_ENT( 5, AT_PHNUM, exec->e_phnum);
199         NEW_AUX_ENT( 6, AT_BASE, interp_load_addr);
200         NEW_AUX_ENT( 7, AT_FLAGS, 0);
201         NEW_AUX_ENT( 8, AT_ENTRY, load_bias + exec->e_entry);
202         NEW_AUX_ENT( 9, AT_UID, (elf_addr_t) current->uid);
203         NEW_AUX_ENT(10, AT_EUID, (elf_addr_t) current->euid);
204         NEW_AUX_ENT(11, AT_GID, (elf_addr_t) current->gid);
205         NEW_AUX_ENT(12, AT_EGID, (elf_addr_t) current->egid);
206 #ifdef ARCH_DLINFO
207         /* 
208          * ARCH_DLINFO must come last so platform specific code can enforce
209          * special alignment requirements on the AUXV if necessary (eg. PPC).
210          */
211         ARCH_DLINFO;
212 #endif
213 #undef NEW_AUX_ENT
214 
215         sp -= envc+1;
216         envp = (elf_caddr_t *) sp;
217         sp -= argc+1;
218         argv = (elf_caddr_t *) sp;
219         if (!ibcs) {
220                 __put_user((elf_addr_t)(unsigned long) envp,--sp);
221                 __put_user((elf_addr_t)(unsigned long) argv,--sp);
222         }
223 
224         __put_user((elf_addr_t)argc,--sp);
225         current->mm->arg_start = current->mm->arg_end = (unsigned long) p;
226         while (argc-->0) {
227                 __put_user((elf_caddr_t)(unsigned long)p,argv++);
228                 len = strnlen_user(p, PAGE_SIZE*MAX_ARG_PAGES);
229                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
230                         return NULL;
231                 p += len;
232         }
233         __put_user(NULL, argv);
234         current->mm->arg_end = current->mm->env_start = (unsigned long) p;
235         while (envc-->0) {
236                 __put_user((elf_caddr_t)(unsigned long)p,envp++);
237                 len = strnlen_user(p, PAGE_SIZE*MAX_ARG_PAGES);
238                 if (!len || len > PAGE_SIZE*MAX_ARG_PAGES)
239                         return NULL;
240                 p += len;
241         }
242         __put_user(NULL, envp);
243         current->mm->env_end = (unsigned long) p;
244         return sp;
245 }
246 
247 #ifndef elf_map
248 
249 static inline unsigned long
250 elf_map (struct file *filep, unsigned long addr, struct elf_phdr *eppnt, int prot, int type)
251 {
252         unsigned long map_addr;
253 
254         down_write(&current->mm->mmap_sem);
255         map_addr = do_mmap(filep, ELF_PAGESTART(addr),
256                            eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr), prot, type,
257                            eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr));
258         up_write(&current->mm->mmap_sem);
259         return(map_addr);
260 }
261 
262 #endif /* !elf_map */
263 
264 /* This is much more generalized than the library routine read function,
265    so we keep this separate.  Technically the library read function
266    is only provided so that we can read a.out libraries that have
267    an ELF header */
268 
269 static unsigned long load_elf_interp(struct elfhdr * interp_elf_ex,
270                                      struct file * interpreter,
271                                      unsigned long *interp_load_addr)
272 {
273         struct elf_phdr *elf_phdata;
274         struct elf_phdr *eppnt;
275         unsigned long load_addr = 0;
276         int load_addr_set = 0;
277         unsigned long last_bss = 0, elf_bss = 0;
278         unsigned long error = ~0UL;
279         int retval, i, size;
280 
281         /* First of all, some simple consistency checks */
282         if (interp_elf_ex->e_type != ET_EXEC &&
283             interp_elf_ex->e_type != ET_DYN)
284                 goto out;
285         if (!elf_check_arch(interp_elf_ex))
286                 goto out;
287         if (!interpreter->f_op || !interpreter->f_op->mmap)
288                 goto out;
289 
290         /*
291          * If the size of this structure has changed, then punt, since
292          * we will be doing the wrong thing.
293          */
294         if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
295                 goto out;
296 
297         if (interp_elf_ex->e_phnum < 1 ||
298             interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
299                 goto out;
300 
301         /* Now read in all of the header information */
302 
303         size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
304         if (size > ELF_MIN_ALIGN)
305                 goto out;
306         elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
307         if (!elf_phdata)
308                 goto out;
309 
310         retval = kernel_read(interpreter,interp_elf_ex->e_phoff,(char *)elf_phdata,size);
311         error = -EIO;
312         if (retval != size) {
313                 if (retval < 0)
314                         error = retval; 
315                 goto out_close;
316         }
317 
318         eppnt = elf_phdata;
319         for (i=0; i<interp_elf_ex->e_phnum; i++, eppnt++) {
320           if (eppnt->p_type == PT_LOAD) {
321             int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
322             int elf_prot = 0;
323             unsigned long vaddr = 0;
324             unsigned long k, map_addr;
325 
326             if (eppnt->p_flags & PF_R) elf_prot =  PROT_READ;
327             if (eppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
328             if (eppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
329             vaddr = eppnt->p_vaddr;
330             if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
331                 elf_type |= MAP_FIXED;
332 
333             map_addr = elf_map(interpreter, load_addr + vaddr, eppnt, elf_prot, elf_type);
334             if (BAD_ADDR(map_addr))
335                 goto out_close;
336 
337             if (!load_addr_set && interp_elf_ex->e_type == ET_DYN) {
338                 load_addr = map_addr - ELF_PAGESTART(vaddr);
339                 load_addr_set = 1;
340             }
341 
342             /*
343              * Check to see if the section's size will overflow the
344              * allowed task size. Note that p_filesz must always be
345              * <= p_memsize so it is only necessary to check p_memsz.
346              */
347             k = load_addr + eppnt->p_vaddr;
348             if (BAD_ADDR(k) || eppnt->p_filesz > eppnt->p_memsz ||
349                 eppnt->p_memsz > TASK_SIZE || TASK_SIZE - eppnt->p_memsz < k) {
350                 error = -ENOMEM;
351                 goto out_close;
352             }
353 
354             /*
355              * Find the end of the file mapping for this phdr, and keep
356              * track of the largest address we see for this.
357              */
358             k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
359             if (k > elf_bss)
360                 elf_bss = k;
361 
362             /*
363              * Do the same thing for the memory mapping - between
364              * elf_bss and last_bss is the bss section.
365              */
366             k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
367             if (k > last_bss)
368                 last_bss = k;
369           }
370         }
371 
372         /* Now use mmap to map the library into memory. */
373 
374         /*
375          * Now fill out the bss section.  First pad the last page up
376          * to the page boundary, and then perform a mmap to make sure
377          * that there are zero-mapped pages up to and including the 
378          * last bss page.
379          */
380         padzero(elf_bss);
381         elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);   /* What we have mapped so far */
382 
383         /* Map the last of the bss segment */
384         if (last_bss > elf_bss) {
385                 down_write(&current->mm->mmap_sem);
386                 error = do_brk(elf_bss, last_bss - elf_bss);
387                 up_write(&current->mm->mmap_sem);
388                 if (BAD_ADDR(error))
389                         goto out_close;
390         }
391 
392         *interp_load_addr = load_addr;
393         /*
394          * XXX: is everything deallocated properly if this happens
395          * to be ~0UL (that is, we succeeded, but the header is broken
396          * and thus the caller will think that we failed)? We'd better
397          * switch to out-of-band error reporting.
398          */
399         error = ((unsigned long) interp_elf_ex->e_entry) + load_addr;
400 
401 out_close:
402         kfree(elf_phdata);
403 out:
404         return error;
405 }
406 
407 static unsigned long load_aout_interp(struct exec * interp_ex,
408                              struct file * interpreter)
409 {
410         unsigned long text_data, elf_entry = ~0UL;
411         char * addr;
412         loff_t offset;
413 
414         current->mm->end_code = interp_ex->a_text;
415         text_data = interp_ex->a_text + interp_ex->a_data;
416         current->mm->end_data = text_data;
417         current->mm->brk = interp_ex->a_bss + text_data;
418 
419         switch (N_MAGIC(*interp_ex)) {
420         case OMAGIC:
421                 offset = 32;
422                 addr = (char *) 0;
423                 break;
424         case ZMAGIC:
425         case QMAGIC:
426                 offset = N_TXTOFF(*interp_ex);
427                 addr = (char *) N_TXTADDR(*interp_ex);
428                 break;
429         default:
430                 goto out;
431         }
432 
433         down_write(&current->mm->mmap_sem);
434         do_brk(0, text_data);
435         up_write(&current->mm->mmap_sem);
436 
437         if (!interpreter->f_op || !interpreter->f_op->read)
438                 goto out;
439         if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
440                 goto out;
441         flush_icache_range((unsigned long)addr,
442                            (unsigned long)addr + text_data);
443 
444         down_write(&current->mm->mmap_sem);
445         do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
446                 interp_ex->a_bss);
447         up_write(&current->mm->mmap_sem);
448 
449         elf_entry = interp_ex->a_entry;
450 
451 out:
452         return elf_entry;
453 }
454 
455 /*
456  * These are the functions used to load ELF style executables and shared
457  * libraries.  There is no binary dependent code anywhere else.
458  */
459 
460 #define INTERPRETER_NONE 0
461 #define INTERPRETER_AOUT 1
462 #define INTERPRETER_ELF 2
463 
464 
465 static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
466 {
467         struct file *interpreter = NULL; /* to shut gcc up */
468         unsigned long load_addr = 0, load_bias = 0;
469         int load_addr_set = 0;
470         char * elf_interpreter = NULL;
471         unsigned int interpreter_type = INTERPRETER_NONE;
472         unsigned char ibcs2_interpreter = 0;
473         unsigned long error;
474         struct elf_phdr * elf_ppnt, *elf_phdata;
475         unsigned long elf_bss, k, elf_brk;
476         int elf_exec_fileno;
477         int retval, i;
478         unsigned int size;
479         unsigned long elf_entry, interp_load_addr = 0;
480         unsigned long start_code, end_code, start_data, end_data;
481         unsigned long reloc_func_desc = 0;
482         struct elfhdr elf_ex;
483         struct elfhdr interp_elf_ex;
484         struct exec interp_ex;
485         char passed_fileno[6];
486         struct files_struct *files;
487         
488         /* Get the exec-header */
489         elf_ex = *((struct elfhdr *) bprm->buf);
490 
491         retval = -ENOEXEC;
492         /* First of all, some simple consistency checks */
493         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
494                 goto out;
495 
496         if (elf_ex.e_type != ET_EXEC && elf_ex.e_type != ET_DYN)
497                 goto out;
498         if (!elf_check_arch(&elf_ex))
499                 goto out;
500         if (!bprm->file->f_op||!bprm->file->f_op->mmap)
501                 goto out;
502 
503         /* Now read in all of the header information */
504 
505         if (elf_ex.e_phentsize != sizeof(struct elf_phdr))
506                 goto out;
507         if (elf_ex.e_phnum < 1 ||
508             elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
509                 goto out;
510         size = elf_ex.e_phnum * sizeof(struct elf_phdr);
511         retval = -ENOMEM;
512         elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
513         if (!elf_phdata)
514                 goto out;
515 
516         retval = kernel_read(bprm->file, elf_ex.e_phoff, (char *) elf_phdata, size);
517         if (retval != size) {
518                 if (retval >= 0)
519                         retval = -EIO;
520                 goto out_free_ph;
521         }
522 
523         files = current->files;         /* Refcounted so ok */
524         retval = unshare_files();
525         if (retval < 0)
526                 goto out_free_ph;
527         if (files == current->files) {
528                 put_files_struct(files);
529                 files = NULL;
530         }
531 
532         /* exec will make our files private anyway, but for the a.out
533            loader stuff we need to do it earlier */
534            
535         retval = get_unused_fd();
536         if (retval < 0)
537                 goto out_free_fh;
538         get_file(bprm->file);
539         fd_install(elf_exec_fileno = retval, bprm->file);
540 
541         elf_ppnt = elf_phdata;
542         elf_bss = 0;
543         elf_brk = 0;
544 
545         start_code = ~0UL;
546         end_code = 0;
547         start_data = 0;
548         end_data = 0;
549 
550         for (i = 0; i < elf_ex.e_phnum; i++) {
551                 if (elf_ppnt->p_type == PT_INTERP) {
552                         /* This is the program interpreter used for
553                          * shared libraries - for now assume that this
554                          * is an a.out format binary
555                          */
556 
557                         retval = -ENOEXEC;
558                         if (elf_ppnt->p_filesz > PATH_MAX || 
559                             elf_ppnt->p_filesz < 2)
560                                 goto out_free_file;
561 
562                         retval = -ENOMEM;
563                         elf_interpreter = (char *) kmalloc(elf_ppnt->p_filesz,
564                                                            GFP_KERNEL);
565                         if (!elf_interpreter)
566                                 goto out_free_file;
567 
568                         retval = kernel_read(bprm->file, elf_ppnt->p_offset,
569                                            elf_interpreter,
570                                            elf_ppnt->p_filesz);
571                         if (retval != elf_ppnt->p_filesz) {
572                                 if (retval >= 0)
573                                         retval = -EIO;
574                                 goto out_free_interp;
575                         }
576                         /* make sure path is NULL terminated */
577                         retval = -ENOEXEC;
578                         if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
579                                 goto out_free_interp;
580 
581                         /* If the program interpreter is one of these two,
582                          * then assume an iBCS2 image. Otherwise assume
583                          * a native linux image.
584                          */
585                         if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
586                             strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
587                                 ibcs2_interpreter = 1;
588 #if 0
589                         printk("Using ELF interpreter %s\n", elf_interpreter);
590 #endif
591 
592                         SET_PERSONALITY(elf_ex, ibcs2_interpreter);
593 
594                         interpreter = open_exec(elf_interpreter);
595                         retval = PTR_ERR(interpreter);
596                         if (IS_ERR(interpreter))
597                                 goto out_free_interp;
598                         retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);
599                         if (retval != BINPRM_BUF_SIZE) {
600                                 if (retval >= 0)
601                                         retval = -EIO;
602                                 goto out_free_dentry;
603                         }
604 
605                         /* Get the exec headers */
606                         interp_ex = *((struct exec *) bprm->buf);
607                         interp_elf_ex = *((struct elfhdr *) bprm->buf);
608                         break;
609                 }
610                 elf_ppnt++;
611         }
612 
613         /* Some simple consistency checks for the interpreter */
614         if (elf_interpreter) {
615                 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
616 
617                 /* Now figure out which format our binary is */
618                 if ((N_MAGIC(interp_ex) != OMAGIC) &&
619                     (N_MAGIC(interp_ex) != ZMAGIC) &&
620                     (N_MAGIC(interp_ex) != QMAGIC))
621                         interpreter_type = INTERPRETER_ELF;
622 
623                 if (memcmp(interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
624                         interpreter_type &= ~INTERPRETER_ELF;
625 
626                 retval = -ELIBBAD;
627                 if (!interpreter_type)
628                         goto out_free_dentry;
629 
630                 /* Make sure only one type was selected */
631                 if ((interpreter_type & INTERPRETER_ELF) &&
632                      interpreter_type != INTERPRETER_ELF) {
633                         // FIXME - ratelimit this before re-enabling
634                         // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
635                         interpreter_type = INTERPRETER_ELF;
636                 }
637                 /* Verify the interpreter has a valid arch */
638                 if ((interpreter_type == INTERPRETER_ELF) &&
639                     !elf_check_arch(&interp_elf_ex))
640                         goto out_free_dentry;
641         } else {
642                 /* Executables without an interpreter also need a personality  */
643                 SET_PERSONALITY(elf_ex, ibcs2_interpreter);
644         }
645 
646         if (BAD_ADDR(elf_ex.e_entry)) {
647                 retval = -ENOEXEC;
648                 goto out_free_dentry;
649         }
650 
651         /* OK, we are done with that, now set up the arg stuff,
652            and then start this sucker up */
653 
654         if (!bprm->sh_bang) {
655                 char * passed_p;
656 
657                 if (interpreter_type == INTERPRETER_AOUT) {
658                   sprintf(passed_fileno, "%d", elf_exec_fileno);
659                   passed_p = passed_fileno;
660 
661                   if (elf_interpreter) {
662                     retval = copy_strings_kernel(1,&passed_p,bprm);
663                         if (retval)
664                                 goto out_free_dentry; 
665                     bprm->argc++;
666                   }
667                 }
668         }
669 
670         /* Flush all traces of the currently running executable */
671         retval = flush_old_exec(bprm);
672         if (retval)
673                 goto out_free_dentry;
674 
675         /* Discard our unneeded old files struct */
676         if (files) {
677                 steal_locks(files);
678                 put_files_struct(files);
679                 files = NULL;
680         }
681 
682         /* OK, This is the point of no return */
683         current->mm->start_data = 0;
684         current->mm->end_data = 0;
685         current->mm->end_code = 0;
686         current->mm->mmap = NULL;
687         current->flags &= ~PF_FORKNOEXEC;
688         elf_entry = (unsigned long) elf_ex.e_entry;
689 
690         /* Do this so that we can load the interpreter, if need be.  We will
691            change some of these later */
692         current->mm->rss = 0;
693         retval = setup_arg_pages(bprm);
694         if (retval < 0) {
695                 send_sig(SIGKILL, current, 0);
696                 return retval;
697         }
698         
699         current->mm->start_stack = bprm->p;
700 
701         /* Now we do a little grungy work by mmaping the ELF image into
702            the correct location in memory.  At this point, we assume that
703            the image should be loaded at fixed address, not at a variable
704            address. */
705 
706         for(i = 0, elf_ppnt = elf_phdata; i < elf_ex.e_phnum; i++, elf_ppnt++) {
707                 int elf_prot = 0, elf_flags;
708                 unsigned long vaddr;
709 
710                 if (elf_ppnt->p_type != PT_LOAD)
711                         continue;
712 
713                 if (unlikely (elf_brk > elf_bss)) {
714                         unsigned long nbyte;
715                     
716                         /* There was a PT_LOAD segment with p_memsz > p_filesz
717                            before this one. Map anonymous pages, if needed,
718                            and clear the area.  */
719                         retval = set_brk (elf_bss + load_bias,
720                                           elf_brk + load_bias);
721                         if (retval) {
722                                 send_sig(SIGKILL, current, 0);
723                                 goto out_free_dentry;
724                         }
725                         nbyte = ELF_PAGEOFFSET(elf_bss);
726                         if (nbyte) {
727                                 nbyte = ELF_MIN_ALIGN - nbyte;
728                                 if (nbyte > elf_brk - elf_bss)
729                                         nbyte = elf_brk - elf_bss;
730                                 clear_user((void *) elf_bss + load_bias, nbyte);
731                         }
732                 }
733 
734                 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
735                 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
736                 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
737 
738                 elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
739 
740                 vaddr = elf_ppnt->p_vaddr;
741                 if (elf_ex.e_type == ET_EXEC || load_addr_set) {
742                         elf_flags |= MAP_FIXED;
743                 } else if (elf_ex.e_type == ET_DYN) {
744                         /* Try and get dynamic programs out of the way of the default mmap
745                            base, as well as whatever program they might try to exec.  This
746                            is because the brk will follow the loader, and is not movable.  */
747                         load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
748                 }
749 
750                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);
751                 if (BAD_ADDR(error)) {
752                         send_sig(SIGKILL, current, 0);
753                         goto out_free_dentry;
754                 }
755 
756                 if (!load_addr_set) {
757                         load_addr_set = 1;
758                         load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
759                         if (elf_ex.e_type == ET_DYN) {
760                                 load_bias += error -
761                                              ELF_PAGESTART(load_bias + vaddr);
762                                 load_addr += load_bias;
763                                 reloc_func_desc = load_addr;
764                         }
765                 }
766                 k = elf_ppnt->p_vaddr;
767                 if (k < start_code) start_code = k;
768                 if (start_data < k) start_data = k;
769 
770                 /*
771                  * Check to see if the section's size will overflow the
772                  * allowed task size. Note that p_filesz must always be
773                  * <= p_memsz so it is only necessary to check p_memsz.
774                  */
775                 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
776                     elf_ppnt->p_memsz > TASK_SIZE ||
777                     TASK_SIZE - elf_ppnt->p_memsz < k) {
778                         /* set_brk can never work.  Avoid overflows.  */
779                         send_sig(SIGKILL, current, 0);
780                         goto out_free_dentry;
781                 }
782 
783                 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
784 
785                 if (k > elf_bss)
786                         elf_bss = k;
787                 if ((elf_ppnt->p_flags & PF_X) && end_code <  k)
788                         end_code = k;
789                 if (end_data < k)
790                         end_data = k;
791                 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
792                 if (k > elf_brk)
793                         elf_brk = k;
794         }
795 
796         elf_entry += load_bias;
797         elf_bss += load_bias;
798         elf_brk += load_bias;
799         start_code += load_bias;
800         end_code += load_bias;
801         start_data += load_bias;
802         end_data += load_bias;
803 
804         /* Calling set_brk effectively mmaps the pages that we need
805          * for the bss and break sections.  We must do this before
806          * mapping in the interpreter, to make sure it doesn't wind
807          * up getting placed where the bss needs to go.
808          */
809         retval = set_brk(elf_bss, elf_brk);
810         if (retval) {
811                 send_sig(SIGKILL, current, 0);
812                 goto out_free_dentry;
813         }
814         padzero(elf_bss);
815 
816         if (elf_interpreter) {
817                 if (interpreter_type == INTERPRETER_AOUT)
818                         elf_entry = load_aout_interp(&interp_ex,
819                                                      interpreter);
820                 else
821                         elf_entry = load_elf_interp(&interp_elf_ex,
822                                                     interpreter,
823                                                     &interp_load_addr);
824                 if (BAD_ADDR(elf_entry)) {
825                         // FIXME - ratelimit this before re-enabling
826                         // printk(KERN_ERR "Unable to load interpreter %.128s\n",
827                         //        elf_interpreter);
828 
829                         force_sig(SIGSEGV, current);
830                         retval = IS_ERR((void *)elf_entry) ?
831                                         (int)elf_entry : -EINVAL;
832                         goto out_free_dentry;
833                 }
834                 reloc_func_desc = interp_load_addr;
835 
836                 allow_write_access(interpreter);
837                 fput(interpreter);
838                 kfree(elf_interpreter);
839         } else {
840                 if (BAD_ADDR(elf_entry)) {
841                         force_sig(SIGSEGV, current);
842                         retval = -EINVAL;
843                         goto out_free_dentry;
844                 }
845         }
846 
847         kfree(elf_phdata);
848 
849         if (interpreter_type != INTERPRETER_AOUT)
850                 sys_close(elf_exec_fileno);
851 
852         set_binfmt(&elf_format);
853 
854         compute_creds(bprm);
855         current->flags &= ~PF_FORKNOEXEC;
856         bprm->p = (unsigned long)
857           create_elf_tables((char *)bprm->p,
858                         bprm->argc,
859                         bprm->envc,
860                         &elf_ex,
861                         load_addr, load_bias,
862                         interp_load_addr,
863                         (interpreter_type == INTERPRETER_AOUT ? 0 : 1));
864         /* N.B. passed_fileno might not be initialized? */
865         if (interpreter_type == INTERPRETER_AOUT)
866                 current->mm->arg_start += strlen(passed_fileno) + 1;
867         current->mm->start_brk = current->mm->brk = elf_brk;
868         current->mm->end_code = end_code;
869         current->mm->start_code = start_code;
870         current->mm->start_data = start_data;
871         current->mm->end_data = end_data;
872         current->mm->start_stack = bprm->p;
873 
874 #if 0
875         printk("(start_brk) %lx\n" , (long) current->mm->start_brk);
876         printk("(end_code) %lx\n" , (long) current->mm->end_code);
877         printk("(start_code) %lx\n" , (long) current->mm->start_code);
878         printk("(start_data) %lx\n" , (long) current->mm->start_data);
879         printk("(end_data) %lx\n" , (long) current->mm->end_data);
880         printk("(start_stack) %lx\n" , (long) current->mm->start_stack);
881         printk("(brk) %lx\n" , (long) current->mm->brk);
882 #endif
883 
884         if (current->personality & MMAP_PAGE_ZERO) {
885                 /* Why this, you ask???  Well SVr4 maps page 0 as read-only,
886                    and some applications "depend" upon this behavior.
887                    Since we do not have the power to recompile these, we
888                    emulate the SVr4 behavior.  Sigh.  */
889                 /* N.B. Shouldn't the size here be PAGE_SIZE?? */
890                 down_write(&current->mm->mmap_sem);
891                 error = do_mmap(NULL, 0, 4096, PROT_READ | PROT_EXEC,
892                                 MAP_FIXED | MAP_PRIVATE, 0);
893                 up_write(&current->mm->mmap_sem);
894         }
895 
896 #ifdef ELF_PLAT_INIT
897         /*
898          * The ABI may specify that certain registers be set up in special
899          * ways (on i386 %edx is the address of a DT_FINI function, for
900          * example.  In addition, it may also specify (eg, PowerPC64 ELF)
901          * that the e_entry field is the address of the function descriptor
902          * for the startup routine, rather than the address of the startup
903          * routine itself.  This macro performs whatever initialization to
904          * the regs structure is required as well as any relocations to the
905          * function descriptor entries when executing dynamically linked apps.
906          */
907         ELF_PLAT_INIT(regs, reloc_func_desc);
908 #endif
909 
910         start_thread(regs, elf_entry, bprm->p);
911         if (current->ptrace & PT_PTRACED)
912                 send_sig(SIGTRAP, current, 0);
913         retval = 0;
914 out:
915         return retval;
916 
917         /* error cleanup */
918 out_free_dentry:
919         allow_write_access(interpreter);
920         if (interpreter)
921                 fput(interpreter);
922 out_free_interp:
923         if (elf_interpreter)
924                 kfree(elf_interpreter);
925 out_free_file:
926         sys_close(elf_exec_fileno);
927 out_free_fh:
928         if (files) {
929                 put_files_struct(current->files);
930                 current->files = files;
931         }
932 out_free_ph:
933         kfree(elf_phdata);
934         goto out;
935 }
936 
937 /* This is really simpleminded and specialized - we are loading an
938    a.out library that is given an ELF header. */
939 
940 static int load_elf_library(struct file *file)
941 {
942         struct elf_phdr *elf_phdata;
943         struct elf_phdr *eppnt;
944         unsigned long elf_bss, bss, len;
945         int retval, error, i, j;
946         struct elfhdr elf_ex;
947 
948         error = -ENOEXEC;
949         retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
950         if (retval != sizeof(elf_ex))
951                 goto out;
952 
953         if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
954                 goto out;
955 
956         /* First of all, some simple consistency checks */
957         if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
958            !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
959                 goto out;
960 
961         /* Now read in all of the header information */
962 
963         j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
964         /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
965 
966         error = -ENOMEM;
967         elf_phdata = kmalloc(j, GFP_KERNEL);
968         if (!elf_phdata)
969                 goto out;
970 
971         eppnt = elf_phdata;
972         error = -ENOEXEC;
973         retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
974         if (retval != j)
975                 goto out_free_ph;
976 
977         for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
978                 if ((eppnt + i)->p_type == PT_LOAD) j++;
979         if (j != 1)
980                 goto out_free_ph;
981 
982         while (eppnt->p_type != PT_LOAD) 
983                 eppnt++;
984 
985         /* Now use mmap to map the library into memory. */
986         down_write(&current->mm->mmap_sem);
987         error = do_mmap(file,
988                         ELF_PAGESTART(eppnt->p_vaddr),
989                         (eppnt->p_filesz +
990                          ELF_PAGEOFFSET(eppnt->p_vaddr)),
991                         PROT_READ | PROT_WRITE | PROT_EXEC,
992                         MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
993                         (eppnt->p_offset -
994                          ELF_PAGEOFFSET(eppnt->p_vaddr)));
995         up_write(&current->mm->mmap_sem);
996         if (error != ELF_PAGESTART(eppnt->p_vaddr))
997                 goto out_free_ph;
998 
999         elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1000         padzero(elf_bss);
1001 
1002         len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);
1003         bss = eppnt->p_memsz + eppnt->p_vaddr;
1004         if (bss > len) {
1005                 down_write(&current->mm->mmap_sem);
1006                 do_brk(len, bss - len);
1007                 up_write(&current->mm->mmap_sem);
1008         }
1009         error = 0;
1010 
1011 out_free_ph:
1012         kfree(elf_phdata);
1013 out:
1014         return error;
1015 }
1016 
1017 /*
1018  * Note that some platforms still use traditional core dumps and not
1019  * the ELF core dump.  Each platform can select it as appropriate.
1020  */
1021 #ifdef USE_ELF_CORE_DUMP
1022 
1023 /*
1024  * ELF core dumper
1025  *
1026  * Modelled on fs/exec.c:aout_core_dump()
1027  * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1028  */
1029 /*
1030  * These are the only things you should do on a core-file: use only these
1031  * functions to write out all the necessary info.
1032  */
1033 static int dump_write(struct file *file, const void *addr, int nr)
1034 {
1035         return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1036 }
1037 
1038 static int dump_seek(struct file *file, off_t off)
1039 {
1040         if (file->f_op->llseek) {
1041                 if (file->f_op->llseek(file, off, 0) != off)
1042                         return 0;
1043         } else
1044                 file->f_pos = off;
1045         return 1;
1046 }
1047 
1048 /*
1049  * Decide whether a segment is worth dumping; default is yes to be
1050  * sure (missing info is worse than too much; etc).
1051  * Personally I'd include everything, and use the coredump limit...
1052  *
1053  * I think we should skip something. But I am not sure how. H.J.
1054  */
1055 static inline int maydump(struct vm_area_struct *vma)
1056 {
1057         /*
1058          * If we may not read the contents, don't allow us to dump
1059          * them either. "dump_write()" can't handle it anyway.
1060          */
1061         if (!(vma->vm_flags & VM_READ))
1062                 return 0;
1063 
1064         /* Do not dump I/O mapped devices! -DaveM */
1065         if (vma->vm_flags & VM_IO)
1066                 return 0;
1067 #if 1
1068         if (vma->vm_flags & (VM_WRITE|VM_GROWSUP|VM_GROWSDOWN))
1069                 return 1;
1070         if (vma->vm_flags & (VM_READ|VM_EXEC|VM_EXECUTABLE|VM_SHARED))
1071                 return 0;
1072 #endif
1073         return 1;
1074 }
1075 
1076 #define roundup(x, y)  ((((x)+((y)-1))/(y))*(y))
1077 
1078 /* An ELF note in memory */
1079 struct memelfnote
1080 {
1081         const char *name;
1082         int type;
1083         unsigned int datasz;
1084         void *data;
1085 };
1086 
1087 static int notesize(struct memelfnote *en)
1088 {
1089         int sz;
1090 
1091         sz = sizeof(struct elf_note);
1092         sz += roundup(strlen(en->name), 4);
1093         sz += roundup(en->datasz, 4);
1094 
1095         return sz;
1096 }
1097 
1098 /* #define DEBUG */
1099 
1100 #ifdef DEBUG
1101 static void dump_regs(const char *str, elf_greg_t *r)
1102 {
1103         int i;
1104         static const char *regs[] = { "ebx", "ecx", "edx", "esi", "edi", "ebp",
1105                                               "eax", "ds", "es", "fs", "gs",
1106                                               "orig_eax", "eip", "cs",
1107                                               "efl", "uesp", "ss"};
1108         printk("Registers: %s\n", str);
1109 
1110         for(i = 0; i < ELF_NGREG; i++)
1111         {
1112                 unsigned long val = r[i];
1113                 printk("   %-2d %-5s=%08lx %lu\n", i, regs[i], val, val);
1114         }
1115 }
1116 #endif
1117 
1118 #define DUMP_WRITE(addr, nr)    \
1119         do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1120 #define DUMP_SEEK(off)  \
1121         do { if (!dump_seek(file, (off))) return 0; } while(0)
1122 
1123 static int writenote(struct memelfnote *men, struct file *file)
1124 {
1125         struct elf_note en;
1126 
1127         en.n_namesz = strlen(men->name);
1128         en.n_descsz = men->datasz;
1129         en.n_type = men->type;
1130 
1131         DUMP_WRITE(&en, sizeof(en));
1132         DUMP_WRITE(men->name, en.n_namesz);
1133         /* XXX - cast from long long to long to avoid need for libgcc.a */
1134         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1135         DUMP_WRITE(men->data, men->datasz);
1136         DUMP_SEEK(roundup((unsigned long)file->f_pos, 4));      /* XXX */
1137 
1138         return 1;
1139 }
1140 #undef DUMP_WRITE
1141 #undef DUMP_SEEK
1142 
1143 #define DUMP_WRITE(addr, nr)    \
1144         if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1145                 goto end_coredump;
1146 #define DUMP_SEEK(off)  \
1147         if (!dump_seek(file, (off))) \
1148                 goto end_coredump;
1149 /*
1150  * Actual dumper
1151  *
1152  * This is a two-pass process; first we find the offsets of the bits,
1153  * and then they are actually written out.  If we run out of core limit
1154  * we just truncate.
1155  */
1156 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
1157 {
1158         int has_dumped = 0;
1159         mm_segment_t fs;
1160         int segs;
1161         size_t size = 0;
1162         int i;
1163         struct vm_area_struct *vma;
1164         struct elfhdr elf;
1165         off_t offset = 0, dataoff;
1166         unsigned long limit = current->rlim[RLIMIT_CORE].rlim_cur;
1167         int numnote = 4;
1168         struct memelfnote notes[4];
1169         struct elf_prstatus prstatus;   /* NT_PRSTATUS */
1170         elf_fpregset_t fpu;             /* NT_PRFPREG */
1171         struct elf_prpsinfo psinfo;     /* NT_PRPSINFO */
1172 
1173         /* first copy the parameters from user space */
1174         memset(&psinfo, 0, sizeof(psinfo));
1175         {
1176                 unsigned int i, len;
1177 
1178                 len = current->mm->arg_end - current->mm->arg_start;
1179                 if (len >= ELF_PRARGSZ)
1180                         len = ELF_PRARGSZ-1;
1181                 copy_from_user(&psinfo.pr_psargs,
1182                               (const char *)current->mm->arg_start, len);
1183                 for(i = 0; i < len; i++)
1184                         if (psinfo.pr_psargs[i] == 0)
1185                                 psinfo.pr_psargs[i] = ' ';
1186                 psinfo.pr_psargs[len] = 0;
1187 
1188         }
1189 
1190         memset(&prstatus, 0, sizeof(prstatus));
1191         /*
1192          * This transfers the registers from regs into the standard
1193          * coredump arrangement, whatever that is.
1194          */
1195 #ifdef ELF_CORE_COPY_REGS
1196         ELF_CORE_COPY_REGS(prstatus.pr_reg, regs)
1197 #else
1198         if (sizeof(elf_gregset_t) != sizeof(struct pt_regs))
1199         {
1200                 printk("sizeof(elf_gregset_t) (%ld) != sizeof(struct pt_regs) (%ld)\n",
1201                         (long)sizeof(elf_gregset_t), (long)sizeof(struct pt_regs));
1202         }
1203         else
1204                 *(struct pt_regs *)&prstatus.pr_reg = *regs;
1205 #endif
1206 
1207         /* now stop all vm operations */
1208         down_write(&current->mm->mmap_sem);
1209         segs = current->mm->map_count;
1210 
1211 #ifdef DEBUG
1212         printk("elf_core_dump: %d segs %lu limit\n", segs, limit);
1213 #endif
1214 
1215         /* Set up header */
1216         memcpy(elf.e_ident, ELFMAG, SELFMAG);
1217         elf.e_ident[EI_CLASS] = ELF_CLASS;
1218         elf.e_ident[EI_DATA] = ELF_DATA;
1219         elf.e_ident[EI_VERSION] = EV_CURRENT;
1220         memset(elf.e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1221 
1222         elf.e_type = ET_CORE;
1223         elf.e_machine = ELF_ARCH;
1224         elf.e_version = EV_CURRENT;
1225         elf.e_entry = 0;
1226         elf.e_phoff = sizeof(elf);
1227         elf.e_shoff = 0;
1228         elf.e_flags = 0;
1229         elf.e_ehsize = sizeof(elf);
1230         elf.e_phentsize = sizeof(struct elf_phdr);
1231         elf.e_phnum = segs+1;           /* Include notes */
1232         elf.e_shentsize = 0;
1233         elf.e_shnum = 0;
1234         elf.e_shstrndx = 0;
1235 
1236         fs = get_fs();
1237         set_fs(KERNEL_DS);
1238 
1239         has_dumped = 1;
1240         current->flags |= PF_DUMPCORE;
1241 
1242         DUMP_WRITE(&elf, sizeof(elf));
1243         offset += sizeof(elf);                          /* Elf header */
1244         offset += (segs+1) * sizeof(struct elf_phdr);   /* Program headers */
1245 
1246         /*
1247          * Set up the notes in similar form to SVR4 core dumps made
1248          * with info from their /proc.
1249          */
1250 
1251         notes[0].name = "CORE";
1252         notes[0].type = NT_PRSTATUS;
1253         notes[0].datasz = sizeof(prstatus);
1254         notes[0].data = &prstatus;
1255         prstatus.pr_info.si_signo = prstatus.pr_cursig = signr;
1256         prstatus.pr_sigpend = current->pending.signal.sig[0];
1257         prstatus.pr_sighold = current->blocked.sig[0];
1258         psinfo.pr_pid = prstatus.pr_pid = current->pid;
1259         psinfo.pr_ppid = prstatus.pr_ppid = current->p_pptr->pid;
1260         psinfo.pr_pgrp = prstatus.pr_pgrp = current->pgrp;
1261         psinfo.pr_sid = prstatus.pr_sid = current->session;
1262         prstatus.pr_utime.tv_sec = CT_TO_SECS(current->times.tms_utime);
1263         prstatus.pr_utime.tv_usec = CT_TO_USECS(current->times.tms_utime);
1264         prstatus.pr_stime.tv_sec = CT_TO_SECS(current->times.tms_stime);
1265         prstatus.pr_stime.tv_usec = CT_TO_USECS(current->times.tms_stime);
1266         prstatus.pr_cutime.tv_sec = CT_TO_SECS(current->times.tms_cutime);
1267         prstatus.pr_cutime.tv_usec = CT_TO_USECS(current->times.tms_cutime);
1268         prstatus.pr_cstime.tv_sec = CT_TO_SECS(current->times.tms_cstime);
1269         prstatus.pr_cstime.tv_usec = CT_TO_USECS(current->times.tms_cstime);
1270 
1271 #ifdef DEBUG
1272         dump_regs("Passed in regs", (elf_greg_t *)regs);
1273         dump_regs("prstatus regs", (elf_greg_t *)&prstatus.pr_reg);
1274 #endif
1275 
1276         notes[1].name = "CORE";
1277         notes[1].type = NT_PRPSINFO;
1278         notes[1].datasz = sizeof(psinfo);
1279         notes[1].data = &psinfo;
1280         i = current->state ? ffz(~current->state) + 1 : 0;
1281         psinfo.pr_state = i;
1282         psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i];
1283         psinfo.pr_zomb = psinfo.pr_sname == 'Z';
1284         psinfo.pr_nice = current->nice;
1285         psinfo.pr_flag = current->flags;
1286         psinfo.pr_uid = NEW_TO_OLD_UID(current->uid);
1287         psinfo.pr_gid = NEW_TO_OLD_GID(current->gid);
1288         strncpy(psinfo.pr_fname, current->comm, sizeof(psinfo.pr_fname));
1289 
1290         notes[2].name = "CORE";
1291         notes[2].type = NT_TASKSTRUCT;
1292         notes[2].datasz = sizeof(*current);
1293         notes[2].data = current;
1294 
1295         /* Try to dump the FPU. */
1296         prstatus.pr_fpvalid = dump_fpu (regs, &fpu);
1297         if (!prstatus.pr_fpvalid)
1298         {
1299                 numnote--;
1300         }
1301         else
1302         {
1303                 notes[3].name = "CORE";
1304                 notes[3].type = NT_PRFPREG;
1305                 notes[3].datasz = sizeof(fpu);
1306                 notes[3].data = &fpu;
1307         }
1308         
1309         /* Write notes phdr entry */
1310         {
1311                 struct elf_phdr phdr;
1312                 int sz = 0;
1313 
1314                 for(i = 0; i < numnote; i++)
1315                         sz += notesize(&notes[i]);
1316 
1317                 phdr.p_type = PT_NOTE;
1318                 phdr.p_offset = offset;
1319                 phdr.p_vaddr = 0;
1320                 phdr.p_paddr = 0;
1321                 phdr.p_filesz = sz;
1322                 phdr.p_memsz = 0;
1323                 phdr.p_flags = 0;
1324                 phdr.p_align = 0;
1325 
1326                 offset += phdr.p_filesz;
1327                 DUMP_WRITE(&phdr, sizeof(phdr));
1328         }
1329 
1330         /* Page-align dumped data */
1331         dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1332 
1333         /* Write program headers for segments dump */
1334         for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1335                 struct elf_phdr phdr;
1336                 size_t sz;
1337 
1338                 sz = vma->vm_end - vma->vm_start;
1339 
1340                 phdr.p_type = PT_LOAD;
1341                 phdr.p_offset = offset;
1342                 phdr.p_vaddr = vma->vm_start;
1343                 phdr.p_paddr = 0;
1344                 phdr.p_filesz = maydump(vma) ? sz : 0;
1345                 phdr.p_memsz = sz;
1346                 offset += phdr.p_filesz;
1347                 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1348                 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
1349                 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
1350                 phdr.p_align = ELF_EXEC_PAGESIZE;
1351 
1352                 DUMP_WRITE(&phdr, sizeof(phdr));
1353         }
1354 
1355         for(i = 0; i < numnote; i++)
1356                 if (!writenote(&notes[i], file))
1357                         goto end_coredump;
1358 
1359         DUMP_SEEK(dataoff);
1360 
1361         for(vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1362                 unsigned long addr;
1363 
1364                 if (!maydump(vma))
1365                         continue;
1366 
1367 #ifdef DEBUG
1368                 printk("elf_core_dump: writing %08lx-%08lx\n", vma->vm_start, vma->vm_end);
1369 #endif
1370 
1371                 for (addr = vma->vm_start;
1372                      addr < vma->vm_end;
1373                      addr += PAGE_SIZE) {
1374                         struct page* page;
1375                         struct vm_area_struct *vma;
1376 
1377                         if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1378                                                 &page, &vma) <= 0) {
1379                                 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1380                         } else {
1381                                 if (page == ZERO_PAGE(addr)) {
1382                                         DUMP_SEEK (file->f_pos + PAGE_SIZE);
1383                                 } else {
1384                                         void *kaddr;
1385                                         flush_cache_page(vma, addr);
1386                                         kaddr = kmap(page);
1387                                         DUMP_WRITE(kaddr, PAGE_SIZE);
1388                                         flush_page_to_ram(page);
1389                                         kunmap(page);
1390                                 }
1391                                 put_page(page);
1392                         }
1393                 }
1394         }
1395 
1396         if ((off_t) file->f_pos != offset) {
1397                 /* Sanity check */
1398                 printk("elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1399                        (off_t) file->f_pos, offset);
1400         }
1401 
1402  end_coredump:
1403         set_fs(fs);
1404         up_write(&current->mm->mmap_sem);
1405         return has_dumped;
1406 }
1407 #endif          /* USE_ELF_CORE_DUMP */
1408 
1409 static int __init init_elf_binfmt(void)
1410 {
1411         return register_binfmt(&elf_format);
1412 }
1413 
1414 static void __exit exit_elf_binfmt(void)
1415 {
1416         /* Remove the COFF and ELF loaders. */
1417         unregister_binfmt(&elf_format);
1418 }
1419 
1420 module_init(init_elf_binfmt)
1421 module_exit(exit_elf_binfmt)
1422 MODULE_LICENSE("GPL");
1423 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us