?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] fix update_mmu_cache in fremap.c
[linux-2.6.22.y-op.git] / fs / binfmt_elf.c
blob8a04216e8b4d37856bec43d273f24b45cadc138e
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 (k > TASK_SIZE || 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 #ifndef STACK_RND_MASK
504 #define STACK_RND_MASK 0x7ff /* with 4K pages 8MB of VA */
505 #endif
506
507 static unsigned long randomize_stack_top(unsigned long stack_top)
508 {
509 unsigned int random_variable = 0;
510
511 if (current->flags & PF_RANDOMIZE) {
512 random_variable = get_random_int() & STACK_RND_MASK;
513 random_variable <<= PAGE_SHIFT;
514 }
515 #ifdef CONFIG_STACK_GROWSUP
516 return PAGE_ALIGN(stack_top) + random_variable;
517 #else
518 return PAGE_ALIGN(stack_top) - random_variable;
519 #endif
520 }
521
522 static int load_elf_binary(struct linux_binprm * bprm, struct pt_regs * regs)
523 {
524 struct file *interpreter = NULL; /* to shut gcc up */
525 unsigned long load_addr = 0, load_bias = 0;
526 int load_addr_set = 0;
527 char * elf_interpreter = NULL;
528 unsigned int interpreter_type = INTERPRETER_NONE;
529 unsigned char ibcs2_interpreter = 0;
530 unsigned long error;
531 struct elf_phdr * elf_ppnt, *elf_phdata;
532 unsigned long elf_bss, elf_brk;
533 int elf_exec_fileno;
534 int retval, i;
535 unsigned int size;
536 unsigned long elf_entry, interp_load_addr = 0;
537 unsigned long start_code, end_code, start_data, end_data;
538 unsigned long reloc_func_desc = 0;
539 char passed_fileno[6];
540 struct files_struct *files;
541 int have_pt_gnu_stack, executable_stack = EXSTACK_DEFAULT;
542 unsigned long def_flags = 0;
543 struct {
544 struct elfhdr elf_ex;
545 struct elfhdr interp_elf_ex;
546 struct exec interp_ex;
547 } *loc;
548
549 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
550 if (!loc) {
551 retval = -ENOMEM;
552 goto out_ret;
553 }
554
555 /* Get the exec-header */
556 loc->elf_ex = *((struct elfhdr *) bprm->buf);
557
558 retval = -ENOEXEC;
559 /* First of all, some simple consistency checks */
560 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
561 goto out;
562
563 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
564 goto out;
565 if (!elf_check_arch(&loc->elf_ex))
566 goto out;
567 if (!bprm->file->f_op||!bprm->file->f_op->mmap)
568 goto out;
569
570 /* Now read in all of the header information */
571
572 if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
573 goto out;
574 if (loc->elf_ex.e_phnum < 1 ||
575 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
576 goto out;
577 size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
578 retval = -ENOMEM;
579 elf_phdata = (struct elf_phdr *) kmalloc(size, GFP_KERNEL);
580 if (!elf_phdata)
581 goto out;
582
583 retval = kernel_read(bprm->file, loc->elf_ex.e_phoff, (char *) elf_phdata, size);
584 if (retval != size) {
585 if (retval >= 0)
586 retval = -EIO;
587 goto out_free_ph;
588 }
589
590 files = current->files; /* Refcounted so ok */
591 retval = unshare_files();
592 if (retval < 0)
593 goto out_free_ph;
594 if (files == current->files) {
595 put_files_struct(files);
596 files = NULL;
597 }
598
599 /* exec will make our files private anyway, but for the a.out
600 loader stuff we need to do it earlier */
601
602 retval = get_unused_fd();
603 if (retval < 0)
604 goto out_free_fh;
605 get_file(bprm->file);
606 fd_install(elf_exec_fileno = retval, bprm->file);
607
608 elf_ppnt = elf_phdata;
609 elf_bss = 0;
610 elf_brk = 0;
611
612 start_code = ~0UL;
613 end_code = 0;
614 start_data = 0;
615 end_data = 0;
616
617 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
618 if (elf_ppnt->p_type == PT_INTERP) {
619 /* This is the program interpreter used for
620 * shared libraries - for now assume that this
621 * is an a.out format binary
622 */
623
624 retval = -ENOEXEC;
625 if (elf_ppnt->p_filesz > PATH_MAX ||
626 elf_ppnt->p_filesz < 2)
627 goto out_free_file;
628
629 retval = -ENOMEM;
630 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
631 GFP_KERNEL);
632 if (!elf_interpreter)
633 goto out_free_file;
634
635 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
636 elf_interpreter,
637 elf_ppnt->p_filesz);
638 if (retval != elf_ppnt->p_filesz) {
639 if (retval >= 0)
640 retval = -EIO;
641 goto out_free_interp;
642 }
643 /* make sure path is NULL terminated */
644 retval = -ENOEXEC;
645 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
646 goto out_free_interp;
647
648 /* If the program interpreter is one of these two,
649 * then assume an iBCS2 image. Otherwise assume
650 * a native linux image.
651 */
652 if (strcmp(elf_interpreter,"/usr/lib/libc.so.1") == 0 ||
653 strcmp(elf_interpreter,"/usr/lib/ld.so.1") == 0)
654 ibcs2_interpreter = 1;
655
656 /*
657 * The early SET_PERSONALITY here is so that the lookup
658 * for the interpreter happens in the namespace of the
659 * to-be-execed image. SET_PERSONALITY can select an
660 * alternate root.
661 *
662 * However, SET_PERSONALITY is NOT allowed to switch
663 * this task into the new images's memory mapping
664 * policy - that is, TASK_SIZE must still evaluate to
665 * that which is appropriate to the execing application.
666 * This is because exit_mmap() needs to have TASK_SIZE
667 * evaluate to the size of the old image.
668 *
669 * So if (say) a 64-bit application is execing a 32-bit
670 * application it is the architecture's responsibility
671 * to defer changing the value of TASK_SIZE until the
672 * switch really is going to happen - do this in
673 * flush_thread(). - akpm
674 */
675 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
676
677 interpreter = open_exec(elf_interpreter);
678 retval = PTR_ERR(interpreter);
679 if (IS_ERR(interpreter))
680 goto out_free_interp;
681 retval = kernel_read(interpreter, 0, bprm->buf, BINPRM_BUF_SIZE);
682 if (retval != BINPRM_BUF_SIZE) {
683 if (retval >= 0)
684 retval = -EIO;
685 goto out_free_dentry;
686 }
687
688 /* Get the exec headers */
689 loc->interp_ex = *((struct exec *) bprm->buf);
690 loc->interp_elf_ex = *((struct elfhdr *) bprm->buf);
691 break;
692 }
693 elf_ppnt++;
694 }
695
696 elf_ppnt = elf_phdata;
697 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
698 if (elf_ppnt->p_type == PT_GNU_STACK) {
699 if (elf_ppnt->p_flags & PF_X)
700 executable_stack = EXSTACK_ENABLE_X;
701 else
702 executable_stack = EXSTACK_DISABLE_X;
703 break;
704 }
705 have_pt_gnu_stack = (i < loc->elf_ex.e_phnum);
706
707 /* Some simple consistency checks for the interpreter */
708 if (elf_interpreter) {
709 interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
710
711 /* Now figure out which format our binary is */
712 if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
713 (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
714 (N_MAGIC(loc->interp_ex) != QMAGIC))
715 interpreter_type = INTERPRETER_ELF;
716
717 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
718 interpreter_type &= ~INTERPRETER_ELF;
719
720 retval = -ELIBBAD;
721 if (!interpreter_type)
722 goto out_free_dentry;
723
724 /* Make sure only one type was selected */
725 if ((interpreter_type & INTERPRETER_ELF) &&
726 interpreter_type != INTERPRETER_ELF) {
727 // FIXME - ratelimit this before re-enabling
728 // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
729 interpreter_type = INTERPRETER_ELF;
730 }
731 /* Verify the interpreter has a valid arch */
732 if ((interpreter_type == INTERPRETER_ELF) &&
733 !elf_check_arch(&loc->interp_elf_ex))
734 goto out_free_dentry;
735 } else {
736 /* Executables without an interpreter also need a personality */
737 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
738 }
739
740 /* OK, we are done with that, now set up the arg stuff,
741 and then start this sucker up */
742
743 if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
744 char *passed_p = passed_fileno;
745 sprintf(passed_fileno, "%d", elf_exec_fileno);
746
747 if (elf_interpreter) {
748 retval = copy_strings_kernel(1, &passed_p, bprm);
749 if (retval)
750 goto out_free_dentry;
751 bprm->argc++;
752 }
753 }
754
755 /* Flush all traces of the currently running executable */
756 retval = flush_old_exec(bprm);
757 if (retval)
758 goto out_free_dentry;
759
760 /* Discard our unneeded old files struct */
761 if (files) {
762 put_files_struct(files);
763 files = NULL;
764 }
765
766 /* OK, This is the point of no return */
767 current->mm->start_data = 0;
768 current->mm->end_data = 0;
769 current->mm->end_code = 0;
770 current->mm->mmap = NULL;
771 current->flags &= ~PF_FORKNOEXEC;
772 current->mm->def_flags = def_flags;
773
774 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
775 may depend on the personality. */
776 SET_PERSONALITY(loc->elf_ex, ibcs2_interpreter);
777 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
778 current->personality |= READ_IMPLIES_EXEC;
779
780 if ( !(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
781 current->flags |= PF_RANDOMIZE;
782 arch_pick_mmap_layout(current->mm);
783
784 /* Do this so that we can load the interpreter, if need be. We will
785 change some of these later */
786 current->mm->free_area_cache = current->mm->mmap_base;
787 current->mm->cached_hole_size = 0;
788 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
789 executable_stack);
790 if (retval < 0) {
791 send_sig(SIGKILL, current, 0);
792 goto out_free_dentry;
793 }
794
795 current->mm->start_stack = bprm->p;
796
797 /* Now we do a little grungy work by mmaping the ELF image into
798 the correct location in memory. At this point, we assume that
799 the image should be loaded at fixed address, not at a variable
800 address. */
801
802 for(i = 0, elf_ppnt = elf_phdata; i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
803 int elf_prot = 0, elf_flags;
804 unsigned long k, vaddr;
805
806 if (elf_ppnt->p_type != PT_LOAD)
807 continue;
808
809 if (unlikely (elf_brk > elf_bss)) {
810 unsigned long nbyte;
811
812 /* There was a PT_LOAD segment with p_memsz > p_filesz
813 before this one. Map anonymous pages, if needed,
814 and clear the area. */
815 retval = set_brk (elf_bss + load_bias,
816 elf_brk + load_bias);
817 if (retval) {
818 send_sig(SIGKILL, current, 0);
819 goto out_free_dentry;
820 }
821 nbyte = ELF_PAGEOFFSET(elf_bss);
822 if (nbyte) {
823 nbyte = ELF_MIN_ALIGN - nbyte;
824 if (nbyte > elf_brk - elf_bss)
825 nbyte = elf_brk - elf_bss;
826 if (clear_user((void __user *)elf_bss +
827 load_bias, nbyte)) {
828 /*
829 * This bss-zeroing can fail if the ELF
830 * file specifies odd protections. So
831 * we don't check the return value
832 */
833 }
834 }
835 }
836
837 if (elf_ppnt->p_flags & PF_R) elf_prot |= PROT_READ;
838 if (elf_ppnt->p_flags & PF_W) elf_prot |= PROT_WRITE;
839 if (elf_ppnt->p_flags & PF_X) elf_prot |= PROT_EXEC;
840
841 elf_flags = MAP_PRIVATE|MAP_DENYWRITE|MAP_EXECUTABLE;
842
843 vaddr = elf_ppnt->p_vaddr;
844 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
845 elf_flags |= MAP_FIXED;
846 } else if (loc->elf_ex.e_type == ET_DYN) {
847 /* Try and get dynamic programs out of the way of the default mmap
848 base, as well as whatever program they might try to exec. This
849 is because the brk will follow the loader, and is not movable. */
850 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
851 }
852
853 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt, elf_prot, elf_flags);
854 if (BAD_ADDR(error)) {
855 send_sig(SIGKILL, current, 0);
856 goto out_free_dentry;
857 }
858
859 if (!load_addr_set) {
860 load_addr_set = 1;
861 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
862 if (loc->elf_ex.e_type == ET_DYN) {
863 load_bias += error -
864 ELF_PAGESTART(load_bias + vaddr);
865 load_addr += load_bias;
866 reloc_func_desc = load_bias;
867 }
868 }
869 k = elf_ppnt->p_vaddr;
870 if (k < start_code) start_code = k;
871 if (start_data < k) start_data = k;
872
873 /*
874 * Check to see if the section's size will overflow the
875 * allowed task size. Note that p_filesz must always be
876 * <= p_memsz so it is only necessary to check p_memsz.
877 */
878 if (k > TASK_SIZE || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
879 elf_ppnt->p_memsz > TASK_SIZE ||
880 TASK_SIZE - elf_ppnt->p_memsz < k) {
881 /* set_brk can never work. Avoid overflows. */
882 send_sig(SIGKILL, current, 0);
883 goto out_free_dentry;
884 }
885
886 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
887
888 if (k > elf_bss)
889 elf_bss = k;
890 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
891 end_code = k;
892 if (end_data < k)
893 end_data = k;
894 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
895 if (k > elf_brk)
896 elf_brk = k;
897 }
898
899 loc->elf_ex.e_entry += load_bias;
900 elf_bss += load_bias;
901 elf_brk += load_bias;
902 start_code += load_bias;
903 end_code += load_bias;
904 start_data += load_bias;
905 end_data += load_bias;
906
907 /* Calling set_brk effectively mmaps the pages that we need
908 * for the bss and break sections. We must do this before
909 * mapping in the interpreter, to make sure it doesn't wind
910 * up getting placed where the bss needs to go.
911 */
912 retval = set_brk(elf_bss, elf_brk);
913 if (retval) {
914 send_sig(SIGKILL, current, 0);
915 goto out_free_dentry;
916 }
917 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
918 send_sig(SIGSEGV, current, 0);
919 retval = -EFAULT; /* Nobody gets to see this, but.. */
920 goto out_free_dentry;
921 }
922
923 if (elf_interpreter) {
924 if (interpreter_type == INTERPRETER_AOUT)
925 elf_entry = load_aout_interp(&loc->interp_ex,
926 interpreter);
927 else
928 elf_entry = load_elf_interp(&loc->interp_elf_ex,
929 interpreter,
930 &interp_load_addr);
931 if (BAD_ADDR(elf_entry)) {
932 printk(KERN_ERR "Unable to load interpreter %.128s\n",
933 elf_interpreter);
934 force_sig(SIGSEGV, current);
935 retval = -ENOEXEC; /* Nobody gets to see this, but.. */
936 goto out_free_dentry;
937 }
938 reloc_func_desc = interp_load_addr;
939
940 allow_write_access(interpreter);
941 fput(interpreter);
942 kfree(elf_interpreter);
943 } else {
944 elf_entry = loc->elf_ex.e_entry;
945 if (BAD_ADDR(elf_entry)) {
946 send_sig(SIGSEGV, current, 0);
947 retval = -ENOEXEC; /* Nobody gets to see this, but.. */
948 goto out_free_dentry;
949 }
950 }
951
952 kfree(elf_phdata);
953
954 if (interpreter_type != INTERPRETER_AOUT)
955 sys_close(elf_exec_fileno);
956
957 set_binfmt(&elf_format);
958
959 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
960 retval = arch_setup_additional_pages(bprm, executable_stack);
961 if (retval < 0) {
962 send_sig(SIGKILL, current, 0);
963 goto out;
964 }
965 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
966
967 compute_creds(bprm);
968 current->flags &= ~PF_FORKNOEXEC;
969 create_elf_tables(bprm, &loc->elf_ex, (interpreter_type == INTERPRETER_AOUT),
970 load_addr, interp_load_addr);
971 /* N.B. passed_fileno might not be initialized? */
972 if (interpreter_type == INTERPRETER_AOUT)
973 current->mm->arg_start += strlen(passed_fileno) + 1;
974 current->mm->end_code = end_code;
975 current->mm->start_code = start_code;
976 current->mm->start_data = start_data;
977 current->mm->end_data = end_data;
978 current->mm->start_stack = bprm->p;
979
980 if (current->personality & MMAP_PAGE_ZERO) {
981 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
982 and some applications "depend" upon this behavior.
983 Since we do not have the power to recompile these, we
984 emulate the SVr4 behavior. Sigh. */
985 down_write(&current->mm->mmap_sem);
986 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
987 MAP_FIXED | MAP_PRIVATE, 0);
988 up_write(&current->mm->mmap_sem);
989 }
990
991 #ifdef ELF_PLAT_INIT
992 /*
993 * The ABI may specify that certain registers be set up in special
994 * ways (on i386 %edx is the address of a DT_FINI function, for
995 * example. In addition, it may also specify (eg, PowerPC64 ELF)
996 * that the e_entry field is the address of the function descriptor
997 * for the startup routine, rather than the address of the startup
998 * routine itself. This macro performs whatever initialization to
999 * the regs structure is required as well as any relocations to the
1000 * function descriptor entries when executing dynamically links apps.
1001 */
1002 ELF_PLAT_INIT(regs, reloc_func_desc);
1003 #endif
1004
1005 start_thread(regs, elf_entry, bprm->p);
1006 if (unlikely(current->ptrace & PT_PTRACED)) {
1007 if (current->ptrace & PT_TRACE_EXEC)
1008 ptrace_notify ((PTRACE_EVENT_EXEC << 8) | SIGTRAP);
1009 else
1010 send_sig(SIGTRAP, current, 0);
1011 }
1012 retval = 0;
1013 out:
1014 kfree(loc);
1015 out_ret:
1016 return retval;
1017
1018 /* error cleanup */
1019 out_free_dentry:
1020 allow_write_access(interpreter);
1021 if (interpreter)
1022 fput(interpreter);
1023 out_free_interp:
1024 kfree(elf_interpreter);
1025 out_free_file:
1026 sys_close(elf_exec_fileno);
1027 out_free_fh:
1028 if (files) {
1029 put_files_struct(current->files);
1030 current->files = files;
1031 }
1032 out_free_ph:
1033 kfree(elf_phdata);
1034 goto out;
1035 }
1036
1037 /* This is really simpleminded and specialized - we are loading an
1038 a.out library that is given an ELF header. */
1039
1040 static int load_elf_library(struct file *file)
1041 {
1042 struct elf_phdr *elf_phdata;
1043 struct elf_phdr *eppnt;
1044 unsigned long elf_bss, bss, len;
1045 int retval, error, i, j;
1046 struct elfhdr elf_ex;
1047
1048 error = -ENOEXEC;
1049 retval = kernel_read(file, 0, (char *) &elf_ex, sizeof(elf_ex));
1050 if (retval != sizeof(elf_ex))
1051 goto out;
1052
1053 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1054 goto out;
1055
1056 /* First of all, some simple consistency checks */
1057 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1058 !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1059 goto out;
1060
1061 /* Now read in all of the header information */
1062
1063 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1064 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1065
1066 error = -ENOMEM;
1067 elf_phdata = kmalloc(j, GFP_KERNEL);
1068 if (!elf_phdata)
1069 goto out;
1070
1071 eppnt = elf_phdata;
1072 error = -ENOEXEC;
1073 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1074 if (retval != j)
1075 goto out_free_ph;
1076
1077 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1078 if ((eppnt + i)->p_type == PT_LOAD)
1079 j++;
1080 if (j != 1)
1081 goto out_free_ph;
1082
1083 while (eppnt->p_type != PT_LOAD)
1084 eppnt++;
1085
1086 /* Now use mmap to map the library into memory. */
1087 down_write(&current->mm->mmap_sem);
1088 error = do_mmap(file,
1089 ELF_PAGESTART(eppnt->p_vaddr),
1090 (eppnt->p_filesz +
1091 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1092 PROT_READ | PROT_WRITE | PROT_EXEC,
1093 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1094 (eppnt->p_offset -
1095 ELF_PAGEOFFSET(eppnt->p_vaddr)));
1096 up_write(&current->mm->mmap_sem);
1097 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1098 goto out_free_ph;
1099
1100 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1101 if (padzero(elf_bss)) {
1102 error = -EFAULT;
1103 goto out_free_ph;
1104 }
1105
1106 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr + ELF_MIN_ALIGN - 1);
1107 bss = eppnt->p_memsz + eppnt->p_vaddr;
1108 if (bss > len) {
1109 down_write(&current->mm->mmap_sem);
1110 do_brk(len, bss - len);
1111 up_write(&current->mm->mmap_sem);
1112 }
1113 error = 0;
1114
1115 out_free_ph:
1116 kfree(elf_phdata);
1117 out:
1118 return error;
1119 }
1120
1121 /*
1122 * Note that some platforms still use traditional core dumps and not
1123 * the ELF core dump. Each platform can select it as appropriate.
1124 */
1125 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1126
1127 /*
1128 * ELF core dumper
1129 *
1130 * Modelled on fs/exec.c:aout_core_dump()
1131 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1132 */
1133 /*
1134 * These are the only things you should do on a core-file: use only these
1135 * functions to write out all the necessary info.
1136 */
1137 static int dump_write(struct file *file, const void *addr, int nr)
1138 {
1139 return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1140 }
1141
1142 static int dump_seek(struct file *file, loff_t off)
1143 {
1144 if (file->f_op->llseek) {
1145 if (file->f_op->llseek(file, off, 0) != off)
1146 return 0;
1147 } else
1148 file->f_pos = off;
1149 return 1;
1150 }
1151
1152 /*
1153 * Decide whether a segment is worth dumping; default is yes to be
1154 * sure (missing info is worse than too much; etc).
1155 * Personally I'd include everything, and use the coredump limit...
1156 *
1157 * I think we should skip something. But I am not sure how. H.J.
1158 */
1159 static int maydump(struct vm_area_struct *vma)
1160 {
1161 /* Do not dump I/O mapped devices or special mappings */
1162 if (vma->vm_flags & (VM_IO | VM_RESERVED))
1163 return 0;
1164
1165 /* Dump shared memory only if mapped from an anonymous file. */
1166 if (vma->vm_flags & VM_SHARED)
1167 return vma->vm_file->f_dentry->d_inode->i_nlink == 0;
1168
1169 /* If it hasn't been written to, don't write it out */
1170 if (!vma->anon_vma)
1171 return 0;
1172
1173 return 1;
1174 }
1175
1176 #define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
1177
1178 /* An ELF note in memory */
1179 struct memelfnote
1180 {
1181 const char *name;
1182 int type;
1183 unsigned int datasz;
1184 void *data;
1185 };
1186
1187 static int notesize(struct memelfnote *en)
1188 {
1189 int sz;
1190
1191 sz = sizeof(struct elf_note);
1192 sz += roundup(strlen(en->name) + 1, 4);
1193 sz += roundup(en->datasz, 4);
1194
1195 return sz;
1196 }
1197
1198 #define DUMP_WRITE(addr, nr) \
1199 do { if (!dump_write(file, (addr), (nr))) return 0; } while(0)
1200 #define DUMP_SEEK(off) \
1201 do { if (!dump_seek(file, (off))) return 0; } while(0)
1202
1203 static int writenote(struct memelfnote *men, struct file *file)
1204 {
1205 struct elf_note en;
1206
1207 en.n_namesz = strlen(men->name) + 1;
1208 en.n_descsz = men->datasz;
1209 en.n_type = men->type;
1210
1211 DUMP_WRITE(&en, sizeof(en));
1212 DUMP_WRITE(men->name, en.n_namesz);
1213 /* XXX - cast from long long to long to avoid need for libgcc.a */
1214 DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */
1215 DUMP_WRITE(men->data, men->datasz);
1216 DUMP_SEEK(roundup((unsigned long)file->f_pos, 4)); /* XXX */
1217
1218 return 1;
1219 }
1220 #undef DUMP_WRITE
1221 #undef DUMP_SEEK
1222
1223 #define DUMP_WRITE(addr, nr) \
1224 if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1225 goto end_coredump;
1226 #define DUMP_SEEK(off) \
1227 if (!dump_seek(file, (off))) \
1228 goto end_coredump;
1229
1230 static void fill_elf_header(struct elfhdr *elf, int segs)
1231 {
1232 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1233 elf->e_ident[EI_CLASS] = ELF_CLASS;
1234 elf->e_ident[EI_DATA] = ELF_DATA;
1235 elf->e_ident[EI_VERSION] = EV_CURRENT;
1236 elf->e_ident[EI_OSABI] = ELF_OSABI;
1237 memset(elf->e_ident+EI_PAD, 0, EI_NIDENT-EI_PAD);
1238
1239 elf->e_type = ET_CORE;
1240 elf->e_machine = ELF_ARCH;
1241 elf->e_version = EV_CURRENT;
1242 elf->e_entry = 0;
1243 elf->e_phoff = sizeof(struct elfhdr);
1244 elf->e_shoff = 0;
1245 elf->e_flags = ELF_CORE_EFLAGS;
1246 elf->e_ehsize = sizeof(struct elfhdr);
1247 elf->e_phentsize = sizeof(struct elf_phdr);
1248 elf->e_phnum = segs;
1249 elf->e_shentsize = 0;
1250 elf->e_shnum = 0;
1251 elf->e_shstrndx = 0;
1252 return;
1253 }
1254
1255 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, off_t offset)
1256 {
1257 phdr->p_type = PT_NOTE;
1258 phdr->p_offset = offset;
1259 phdr->p_vaddr = 0;
1260 phdr->p_paddr = 0;
1261 phdr->p_filesz = sz;
1262 phdr->p_memsz = 0;
1263 phdr->p_flags = 0;
1264 phdr->p_align = 0;
1265 return;
1266 }
1267
1268 static void fill_note(struct memelfnote *note, const char *name, int type,
1269 unsigned int sz, void *data)
1270 {
1271 note->name = name;
1272 note->type = type;
1273 note->datasz = sz;
1274 note->data = data;
1275 return;
1276 }
1277
1278 /*
1279 * fill up all the fields in prstatus from the given task struct, except registers
1280 * which need to be filled up separately.
1281 */
1282 static void fill_prstatus(struct elf_prstatus *prstatus,
1283 struct task_struct *p, long signr)
1284 {
1285 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1286 prstatus->pr_sigpend = p->pending.signal.sig[0];
1287 prstatus->pr_sighold = p->blocked.sig[0];
1288 prstatus->pr_pid = p->pid;
1289 prstatus->pr_ppid = p->parent->pid;
1290 prstatus->pr_pgrp = process_group(p);
1291 prstatus->pr_sid = p->signal->session;
1292 if (thread_group_leader(p)) {
1293 /*
1294 * This is the record for the group leader. Add in the
1295 * cumulative times of previous dead threads. This total
1296 * won't include the time of each live thread whose state
1297 * is included in the core dump. The final total reported
1298 * to our parent process when it calls wait4 will include
1299 * those sums as well as the little bit more time it takes
1300 * this and each other thread to finish dying after the
1301 * core dump synchronization phase.
1302 */
1303 cputime_to_timeval(cputime_add(p->utime, p->signal->utime),
1304 &prstatus->pr_utime);
1305 cputime_to_timeval(cputime_add(p->stime, p->signal->stime),
1306 &prstatus->pr_stime);
1307 } else {
1308 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1309 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1310 }
1311 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1312 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1313 }
1314
1315 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1316 struct mm_struct *mm)
1317 {
1318 unsigned int i, len;
1319
1320 /* first copy the parameters from user space */
1321 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1322
1323 len = mm->arg_end - mm->arg_start;
1324 if (len >= ELF_PRARGSZ)
1325 len = ELF_PRARGSZ-1;
1326 if (copy_from_user(&psinfo->pr_psargs,
1327 (const char __user *)mm->arg_start, len))
1328 return -EFAULT;
1329 for(i = 0; i < len; i++)
1330 if (psinfo->pr_psargs[i] == 0)
1331 psinfo->pr_psargs[i] = ' ';
1332 psinfo->pr_psargs[len] = 0;
1333
1334 psinfo->pr_pid = p->pid;
1335 psinfo->pr_ppid = p->parent->pid;
1336 psinfo->pr_pgrp = process_group(p);
1337 psinfo->pr_sid = p->signal->session;
1338
1339 i = p->state ? ffz(~p->state) + 1 : 0;
1340 psinfo->pr_state = i;
1341 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1342 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1343 psinfo->pr_nice = task_nice(p);
1344 psinfo->pr_flag = p->flags;
1345 SET_UID(psinfo->pr_uid, p->uid);
1346 SET_GID(psinfo->pr_gid, p->gid);
1347 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1348
1349 return 0;
1350 }
1351
1352 /* Here is the structure in which status of each thread is captured. */
1353 struct elf_thread_status
1354 {
1355 struct list_head list;
1356 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1357 elf_fpregset_t fpu; /* NT_PRFPREG */
1358 struct task_struct *thread;
1359 #ifdef ELF_CORE_COPY_XFPREGS
1360 elf_fpxregset_t xfpu; /* NT_PRXFPREG */
1361 #endif
1362 struct memelfnote notes[3];
1363 int num_notes;
1364 };
1365
1366 /*
1367 * In order to add the specific thread information for the elf file format,
1368 * we need to keep a linked list of every threads pr_status and then
1369 * create a single section for them in the final core file.
1370 */
1371 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1372 {
1373 int sz = 0;
1374 struct task_struct *p = t->thread;
1375 t->num_notes = 0;
1376
1377 fill_prstatus(&t->prstatus, p, signr);
1378 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1379
1380 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus), &(t->prstatus));
1381 t->num_notes++;
1382 sz += notesize(&t->notes[0]);
1383
1384 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL, &t->fpu))) {
1385 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu), &(t->fpu));
1386 t->num_notes++;
1387 sz += notesize(&t->notes[1]);
1388 }
1389
1390 #ifdef ELF_CORE_COPY_XFPREGS
1391 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1392 fill_note(&t->notes[2], "LINUX", NT_PRXFPREG, sizeof(t->xfpu), &t->xfpu);
1393 t->num_notes++;
1394 sz += notesize(&t->notes[2]);
1395 }
1396 #endif
1397 return sz;
1398 }
1399
1400 /*
1401 * Actual dumper
1402 *
1403 * This is a two-pass process; first we find the offsets of the bits,
1404 * and then they are actually written out. If we run out of core limit
1405 * we just truncate.
1406 */
1407 static int elf_core_dump(long signr, struct pt_regs * regs, struct file * file)
1408 {
1409 #define NUM_NOTES 6
1410 int has_dumped = 0;
1411 mm_segment_t fs;
1412 int segs;
1413 size_t size = 0;
1414 int i;
1415 struct vm_area_struct *vma;
1416 struct elfhdr *elf = NULL;
1417 off_t offset = 0, dataoff;
1418 unsigned long limit = current->signal->rlim[RLIMIT_CORE].rlim_cur;
1419 int numnote;
1420 struct memelfnote *notes = NULL;
1421 struct elf_prstatus *prstatus = NULL; /* NT_PRSTATUS */
1422 struct elf_prpsinfo *psinfo = NULL; /* NT_PRPSINFO */
1423 struct task_struct *g, *p;
1424 LIST_HEAD(thread_list);
1425 struct list_head *t;
1426 elf_fpregset_t *fpu = NULL;
1427 #ifdef ELF_CORE_COPY_XFPREGS
1428 elf_fpxregset_t *xfpu = NULL;
1429 #endif
1430 int thread_status_size = 0;
1431 elf_addr_t *auxv;
1432
1433 /*
1434 * We no longer stop all VM operations.
1435 *
1436 * This is because those proceses that could possibly change map_count or
1437 * the mmap / vma pages are now blocked in do_exit on current finishing
1438 * this core dump.
1439 *
1440 * Only ptrace can touch these memory addresses, but it doesn't change
1441 * the map_count or the pages allocated. So no possibility of crashing
1442 * exists while dumping the mm->vm_next areas to the core file.
1443 */
1444
1445 /* alloc memory for large data structures: too large to be on stack */
1446 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1447 if (!elf)
1448 goto cleanup;
1449 prstatus = kmalloc(sizeof(*prstatus), GFP_KERNEL);
1450 if (!prstatus)
1451 goto cleanup;
1452 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1453 if (!psinfo)
1454 goto cleanup;
1455 notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote), GFP_KERNEL);
1456 if (!notes)
1457 goto cleanup;
1458 fpu = kmalloc(sizeof(*fpu), GFP_KERNEL);
1459 if (!fpu)
1460 goto cleanup;
1461 #ifdef ELF_CORE_COPY_XFPREGS
1462 xfpu = kmalloc(sizeof(*xfpu), GFP_KERNEL);
1463 if (!xfpu)
1464 goto cleanup;
1465 #endif
1466
1467 if (signr) {
1468 struct elf_thread_status *tmp;
1469 read_lock(&tasklist_lock);
1470 do_each_thread(g,p)
1471 if (current->mm == p->mm && current != p) {
1472 tmp = kzalloc(sizeof(*tmp), GFP_ATOMIC);
1473 if (!tmp) {
1474 read_unlock(&tasklist_lock);
1475 goto cleanup;
1476 }
1477 INIT_LIST_HEAD(&tmp->list);
1478 tmp->thread = p;
1479 list_add(&tmp->list, &thread_list);
1480 }
1481 while_each_thread(g,p);
1482 read_unlock(&tasklist_lock);
1483 list_for_each(t, &thread_list) {
1484 struct elf_thread_status *tmp;
1485 int sz;
1486
1487 tmp = list_entry(t, struct elf_thread_status, list);
1488 sz = elf_dump_thread_status(signr, tmp);
1489 thread_status_size += sz;
1490 }
1491 }
1492 /* now collect the dump for the current */
1493 memset(prstatus, 0, sizeof(*prstatus));
1494 fill_prstatus(prstatus, current, signr);
1495 elf_core_copy_regs(&prstatus->pr_reg, regs);
1496
1497 segs = current->mm->map_count;
1498 #ifdef ELF_CORE_EXTRA_PHDRS
1499 segs += ELF_CORE_EXTRA_PHDRS;
1500 #endif
1501
1502 /* Set up header */
1503 fill_elf_header(elf, segs+1); /* including notes section */
1504
1505 has_dumped = 1;
1506 current->flags |= PF_DUMPCORE;
1507
1508 /*
1509 * Set up the notes in similar form to SVR4 core dumps made
1510 * with info from their /proc.
1511 */
1512
1513 fill_note(notes +0, "CORE", NT_PRSTATUS, sizeof(*prstatus), prstatus);
1514
1515 fill_psinfo(psinfo, current->group_leader, current->mm);
1516 fill_note(notes +1, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1517
1518 numnote = 2;
1519
1520 auxv = (elf_addr_t *) current->mm->saved_auxv;
1521
1522 i = 0;
1523 do
1524 i += 2;
1525 while (auxv[i - 2] != AT_NULL);
1526 fill_note(&notes[numnote++], "CORE", NT_AUXV,
1527 i * sizeof (elf_addr_t), auxv);
1528
1529 /* Try to dump the FPU. */
1530 if ((prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs, fpu)))
1531 fill_note(notes + numnote++,
1532 "CORE", NT_PRFPREG, sizeof(*fpu), fpu);
1533 #ifdef ELF_CORE_COPY_XFPREGS
1534 if (elf_core_copy_task_xfpregs(current, xfpu))
1535 fill_note(notes + numnote++,
1536 "LINUX", NT_PRXFPREG, sizeof(*xfpu), xfpu);
1537 #endif
1538
1539 fs = get_fs();
1540 set_fs(KERNEL_DS);
1541
1542 DUMP_WRITE(elf, sizeof(*elf));
1543 offset += sizeof(*elf); /* Elf header */
1544 offset += (segs+1) * sizeof(struct elf_phdr); /* Program headers */
1545
1546 /* Write notes phdr entry */
1547 {
1548 struct elf_phdr phdr;
1549 int sz = 0;
1550
1551 for (i = 0; i < numnote; i++)
1552 sz += notesize(notes + i);
1553
1554 sz += thread_status_size;
1555
1556 fill_elf_note_phdr(&phdr, sz, offset);
1557 offset += sz;
1558 DUMP_WRITE(&phdr, sizeof(phdr));
1559 }
1560
1561 /* Page-align dumped data */
1562 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1563
1564 /* Write program headers for segments dump */
1565 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1566 struct elf_phdr phdr;
1567 size_t sz;
1568
1569 sz = vma->vm_end - vma->vm_start;
1570
1571 phdr.p_type = PT_LOAD;
1572 phdr.p_offset = offset;
1573 phdr.p_vaddr = vma->vm_start;
1574 phdr.p_paddr = 0;
1575 phdr.p_filesz = maydump(vma) ? sz : 0;
1576 phdr.p_memsz = sz;
1577 offset += phdr.p_filesz;
1578 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1579 if (vma->vm_flags & VM_WRITE) phdr.p_flags |= PF_W;
1580 if (vma->vm_flags & VM_EXEC) phdr.p_flags |= PF_X;
1581 phdr.p_align = ELF_EXEC_PAGESIZE;
1582
1583 DUMP_WRITE(&phdr, sizeof(phdr));
1584 }
1585
1586 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1587 ELF_CORE_WRITE_EXTRA_PHDRS;
1588 #endif
1589
1590 /* write out the notes section */
1591 for (i = 0; i < numnote; i++)
1592 if (!writenote(notes + i, file))
1593 goto end_coredump;
1594
1595 /* write out the thread status notes section */
1596 list_for_each(t, &thread_list) {
1597 struct elf_thread_status *tmp = list_entry(t, struct elf_thread_status, list);
1598 for (i = 0; i < tmp->num_notes; i++)
1599 if (!writenote(&tmp->notes[i], file))
1600 goto end_coredump;
1601 }
1602
1603 DUMP_SEEK(dataoff);
1604
1605 for (vma = current->mm->mmap; vma != NULL; vma = vma->vm_next) {
1606 unsigned long addr;
1607
1608 if (!maydump(vma))
1609 continue;
1610
1611 for (addr = vma->vm_start;
1612 addr < vma->vm_end;
1613 addr += PAGE_SIZE) {
1614 struct page* page;
1615 struct vm_area_struct *vma;
1616
1617 if (get_user_pages(current, current->mm, addr, 1, 0, 1,
1618 &page, &vma) <= 0) {
1619 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1620 } else {
1621 if (page == ZERO_PAGE(addr)) {
1622 DUMP_SEEK (file->f_pos + PAGE_SIZE);
1623 } else {
1624 void *kaddr;
1625 flush_cache_page(vma, addr, page_to_pfn(page));
1626 kaddr = kmap(page);
1627 if ((size += PAGE_SIZE) > limit ||
1628 !dump_write(file, kaddr,
1629 PAGE_SIZE)) {
1630 kunmap(page);
1631 page_cache_release(page);
1632 goto end_coredump;
1633 }
1634 kunmap(page);
1635 }
1636 page_cache_release(page);
1637 }
1638 }
1639 }
1640
1641 #ifdef ELF_CORE_WRITE_EXTRA_DATA
1642 ELF_CORE_WRITE_EXTRA_DATA;
1643 #endif
1644
1645 if ((off_t)file->f_pos != offset) {
1646 /* Sanity check */
1647 printk(KERN_WARNING "elf_core_dump: file->f_pos (%ld) != offset (%ld)\n",
1648 (off_t)file->f_pos, offset);
1649 }
1650
1651 end_coredump:
1652 set_fs(fs);
1653
1654 cleanup:
1655 while (!list_empty(&thread_list)) {
1656 struct list_head *tmp = thread_list.next;
1657 list_del(tmp);
1658 kfree(list_entry(tmp, struct elf_thread_status, list));
1659 }
1660
1661 kfree(elf);
1662 kfree(prstatus);
1663 kfree(psinfo);
1664 kfree(notes);
1665 kfree(fpu);
1666 #ifdef ELF_CORE_COPY_XFPREGS
1667 kfree(xfpu);
1668 #endif
1669 return has_dumped;
1670 #undef NUM_NOTES
1671 }
1672
1673 #endif /* USE_ELF_CORE_DUMP */
1674
1675 static int __init init_elf_binfmt(void)
1676 {
1677 return register_binfmt(&elf_format);
1678 }
1679
1680 static void __exit exit_elf_binfmt(void)
1681 {
1682 /* Remove the COFF and ELF loaders. */
1683 unregister_binfmt(&elf_format);
1684 }
1685
1686 core_initcall(init_elf_binfmt);
1687 module_exit(exit_elf_binfmt);
1688 MODULE_LICENSE("GPL");
linux v2.6.22.y-op