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