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/mm.h>
16 #include <linux/mman.h>
17 #include <linux/errno.h>
18 #include <linux/signal.h>
19 #include <linux/binfmts.h>
20 #include <linux/string.h>
21 #include <linux/file.h>
22 #include <linux/slab.h>
23 #include <linux/personality.h>
24 #include <linux/elfcore.h>
25 #include <linux/init.h>
26 #include <linux/highuid.h>
27 #include <linux/compiler.h>
28 #include <linux/highmem.h>
29 #include <linux/pagemap.h>
30 #include <linux/security.h>
31 #include <linux/random.h>
32 #include <linux/elf.h>
33 #include <linux/utsname.h>
34 #include <asm/uaccess.h>
35 #include <asm/param.h>
36 #include <asm/page.h>
37
38 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs);
39 static int load_elf_library(struct file *);
40 static unsigned long elf_map(struct file *, unsigned long, struct elf_phdr *,
41 int, int, unsigned long);
42
43 /*
44 * If we don't support core dumping, then supply a NULL so we
45 * don't even try.
46 */
47 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
48 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file, unsigned long limit);
49 #else
50 #define elf_core_dump NULL
51 #endif
52
53 #if ELF_EXEC_PAGESIZE > PAGE_SIZE
54 #define ELF_MIN_ALIGN ELF_EXEC_PAGESIZE
55 #else
56 #define ELF_MIN_ALIGN PAGE_SIZE
57 #endif
58
59 #ifndef ELF_CORE_EFLAGS
60 #define ELF_CORE_EFLAGS 0
61 #endif
62
63 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
64 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
65 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
66
67 static struct linux_binfmt elf_format = {
68 .module = THIS_MODULE,
69 .load_binary = load_elf_binary,
70 .load_shlib = load_elf_library,
71 .core_dump = elf_core_dump,
72 .min_coredump = ELF_EXEC_PAGESIZE,
73 .hasvdso = 1
74 };
75
76 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
77
78 static int set_brk(unsigned long start, unsigned long end)
79 {
80 start = ELF_PAGEALIGN(start);
81 end = ELF_PAGEALIGN(end);
82 if (end > start) {
83 unsigned long addr;
84 down_write(¤t->mm->mmap_sem);
85 addr = do_brk(start, end - start);
86 up_write(¤t->mm->mmap_sem);
87 if (BAD_ADDR(addr))
88 return addr;
89 }
90 current->mm->start_brk = current->mm->brk = end;
91 return 0;
92 }
93
94 /* We need to explicitly zero any fractional pages
95 after the data section (i.e. bss). This would
96 contain the junk from the file that should not
97 be in memory
98 */
99 static int padzero(unsigned long elf_bss)
100 {
101 unsigned long nbyte;
102
103 nbyte = ELF_PAGEOFFSET(elf_bss);
104 if (nbyte) {
105 nbyte = ELF_MIN_ALIGN - nbyte;
106 if (clear_user((void __user *) elf_bss, nbyte))
107 return -EFAULT;
108 }
109 return 0;
110 }
111
112 /* Let's use some macros to make this stack manipulation a little clearer */
113 #ifdef CONFIG_STACK_GROWSUP
114 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) + (items))
115 #define STACK_ROUND(sp, items) \
116 ((15 + (unsigned long) ((sp) + (items))) &~ 15UL)
117 #define STACK_ALLOC(sp, len) ({ \
118 elf_addr_t __user *old_sp = (elf_addr_t __user *)sp; sp += len; \
119 old_sp; })
120 #else
121 #define STACK_ADD(sp, items) ((elf_addr_t __user *)(sp) - (items))
122 #define STACK_ROUND(sp, items) \
123 (((unsigned long) (sp - items)) &~ 15UL)
124 #define STACK_ALLOC(sp, len) ({ sp -= len ; sp; })
125 #endif
126
127 #ifndef ELF_BASE_PLATFORM
128 /*
129 * AT_BASE_PLATFORM indicates the "real" hardware/microarchitecture.
130 * If the arch defines ELF_BASE_PLATFORM (in asm/elf.h), the value
131 * will be copied to the user stack in the same manner as AT_PLATFORM.
132 */
133 #define ELF_BASE_PLATFORM NULL
134 #endif
135
136 static int
137 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
138 unsigned long load_addr, unsigned long interp_load_addr)
139 {
140 unsigned long p = bprm->p;
141 int argc = bprm->argc;
142 int envc = bprm->envc;
143 elf_addr_t __user *argv;
144 elf_addr_t __user *envp;
145 elf_addr_t __user *sp;
146 elf_addr_t __user *u_platform;
147 elf_addr_t __user *u_base_platform;
148 elf_addr_t __user *u_rand_bytes;
149 const char *k_platform = ELF_PLATFORM;
150 const char *k_base_platform = ELF_BASE_PLATFORM;
151 unsigned char k_rand_bytes[16];
152 int items;
153 elf_addr_t *elf_info;
154 int ei_index = 0;
155 const struct cred *cred = current_cred();
156 struct vm_area_struct *vma;
157
158 /*
159 * In some cases (e.g. Hyper-Threading), we want to avoid L1
160 * evictions by the processes running on the same package. One
161 * thing we can do is to shuffle the initial stack for them.
162 */
163
164 p = arch_align_stack(p);
165
166 /*
167 * If this architecture has a platform capability string, copy it
168 * to userspace. In some cases (Sparc), this info is impossible
169 * for userspace to get any other way, in others (i386) it is
170 * merely difficult.
171 */
172 u_platform = NULL;
173 if (k_platform) {
174 size_t len = strlen(k_platform) + 1;
175
176 u_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
177 if (__copy_to_user(u_platform, k_platform, len))
178 return -EFAULT;
179 }
180
181 /*
182 * If this architecture has a "base" platform capability
183 * string, copy it to userspace.
184 */
185 u_base_platform = NULL;
186 if (k_base_platform) {
187 size_t len = strlen(k_base_platform) + 1;
188
189 u_base_platform = (elf_addr_t __user *)STACK_ALLOC(p, len);
190 if (__copy_to_user(u_base_platform, k_base_platform, len))
191 return -EFAULT;
192 }
193
194 /*
195 * Generate 16 random bytes for userspace PRNG seeding.
196 */
197 get_random_bytes(k_rand_bytes, sizeof(k_rand_bytes));
198 u_rand_bytes = (elf_addr_t __user *)
199 STACK_ALLOC(p, sizeof(k_rand_bytes));
200 if (__copy_to_user(u_rand_bytes, k_rand_bytes, sizeof(k_rand_bytes)))
201 return -EFAULT;
202
203 /* Create the ELF interpreter info */
204 elf_info = (elf_addr_t *)current->mm->saved_auxv;
205 /* update AT_VECTOR_SIZE_BASE if the number of NEW_AUX_ENT() changes */
206 #define NEW_AUX_ENT(id, val) \
207 do { \
208 elf_info[ei_index++] = id; \
209 elf_info[ei_index++] = val; \
210 } while (0)
211
212 #ifdef ARCH_DLINFO
213 /*
214 * ARCH_DLINFO must come first so PPC can do its special alignment of
215 * AUXV.
216 * update AT_VECTOR_SIZE_ARCH if the number of NEW_AUX_ENT() in
217 * ARCH_DLINFO changes
218 */
219 ARCH_DLINFO;
220 #endif
221 NEW_AUX_ENT(AT_HWCAP, ELF_HWCAP);
222 NEW_AUX_ENT(AT_PAGESZ, ELF_EXEC_PAGESIZE);
223 NEW_AUX_ENT(AT_CLKTCK, CLOCKS_PER_SEC);
224 NEW_AUX_ENT(AT_PHDR, load_addr + exec->e_phoff);
225 NEW_AUX_ENT(AT_PHENT, sizeof(struct elf_phdr));
226 NEW_AUX_ENT(AT_PHNUM, exec->e_phnum);
227 NEW_AUX_ENT(AT_BASE, interp_load_addr);
228 NEW_AUX_ENT(AT_FLAGS, 0);
229 NEW_AUX_ENT(AT_ENTRY, exec->e_entry);
230 NEW_AUX_ENT(AT_UID, cred->uid);
231 NEW_AUX_ENT(AT_EUID, cred->euid);
232 NEW_AUX_ENT(AT_GID, cred->gid);
233 NEW_AUX_ENT(AT_EGID, cred->egid);
234 NEW_AUX_ENT(AT_SECURE, security_bprm_secureexec(bprm));
235 NEW_AUX_ENT(AT_RANDOM, (elf_addr_t)(unsigned long)u_rand_bytes);
236 NEW_AUX_ENT(AT_EXECFN, bprm->exec);
237 if (k_platform) {
238 NEW_AUX_ENT(AT_PLATFORM,
239 (elf_addr_t)(unsigned long)u_platform);
240 }
241 if (k_base_platform) {
242 NEW_AUX_ENT(AT_BASE_PLATFORM,
243 (elf_addr_t)(unsigned long)u_base_platform);
244 }
245 if (bprm->interp_flags & BINPRM_FLAGS_EXECFD) {
246 NEW_AUX_ENT(AT_EXECFD, bprm->interp_data);
247 }
248 #undef NEW_AUX_ENT
249 /* AT_NULL is zero; clear the rest too */
250 memset(&elf_info[ei_index], 0,
251 sizeof current->mm->saved_auxv - ei_index * sizeof elf_info[0]);
252
253 /* And advance past the AT_NULL entry. */
254 ei_index += 2;
255
256 sp = STACK_ADD(p, ei_index);
257
258 items = (argc + 1) + (envc + 1) + 1;
259 bprm->p = STACK_ROUND(sp, items);
260
261 /* Point sp at the lowest address on the stack */
262 #ifdef CONFIG_STACK_GROWSUP
263 sp = (elf_addr_t __user *)bprm->p - items - ei_index;
264 bprm->exec = (unsigned long)sp; /* XXX: PARISC HACK */
265 #else
266 sp = (elf_addr_t __user *)bprm->p;
267 #endif
268
269
270 /*
271 * Grow the stack manually; some architectures have a limit on how
272 * far ahead a user-space access may be in order to grow the stack.
273 */
274 vma = find_extend_vma(current->mm, bprm->p);
275 if (!vma)
276 return -EFAULT;
277
278 /* Now, let's put argc (and argv, envp if appropriate) on the stack */
279 if (__put_user(argc, sp++))
280 return -EFAULT;
281 argv = sp;
282 envp = argv + argc + 1;
283
284 /* Populate argv and envp */
285 p = current->mm->arg_end = current->mm->arg_start;
286 while (argc-- > 0) {
287 size_t len;
288 if (__put_user((elf_addr_t)p, argv++))
289 return -EFAULT;
290 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
291 if (!len || len > MAX_ARG_STRLEN)
292 return -EINVAL;
293 p += len;
294 }
295 if (__put_user(0, argv))
296 return -EFAULT;
297 current->mm->arg_end = current->mm->env_start = p;
298 while (envc-- > 0) {
299 size_t len;
300 if (__put_user((elf_addr_t)p, envp++))
301 return -EFAULT;
302 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
303 if (!len || len > MAX_ARG_STRLEN)
304 return -EINVAL;
305 p += len;
306 }
307 if (__put_user(0, envp))
308 return -EFAULT;
309 current->mm->env_end = p;
310
311 /* Put the elf_info on the stack in the right place. */
312 sp = (elf_addr_t __user *)envp + 1;
313 if (copy_to_user(sp, elf_info, ei_index * sizeof(elf_addr_t)))
314 return -EFAULT;
315 return 0;
316 }
317
318 #ifndef elf_map
319
320 static unsigned long elf_map(struct file *filep, unsigned long addr,
321 struct elf_phdr *eppnt, int prot, int type,
322 unsigned long total_size)
323 {
324 unsigned long map_addr;
325 unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
326 unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
327 addr = ELF_PAGESTART(addr);
328 size = ELF_PAGEALIGN(size);
329
330 /* mmap() will return -EINVAL if given a zero size, but a
331 * segment with zero filesize is perfectly valid */
332 if (!size)
333 return addr;
334
335 down_write(¤t->mm->mmap_sem);
336 /*
337 * total_size is the size of the ELF (interpreter) image.
338 * The _first_ mmap needs to know the full size, otherwise
339 * randomization might put this image into an overlapping
340 * position with the ELF binary image. (since size < total_size)
341 * So we first map the 'big' image - and unmap the remainder at
342 * the end. (which unmap is needed for ELF images with holes.)
343 */
344 if (total_size) {
345 total_size = ELF_PAGEALIGN(total_size);
346 map_addr = do_mmap(filep, addr, total_size, prot, type, off);
347 if (!BAD_ADDR(map_addr))
348 do_munmap(current->mm, map_addr+size, total_size-size);
349 } else
350 map_addr = do_mmap(filep, addr, size, prot, type, off);
351
352 up_write(¤t->mm->mmap_sem);
353 return(map_addr);
354 }
355
356 #endif /* !elf_map */
357
358 static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
359 {
360 int i, first_idx = -1, last_idx = -1;
361
362 for (i = 0; i < nr; i++) {
363 if (cmds[i].p_type == PT_LOAD) {
364 last_idx = i;
365 if (first_idx == -1)
366 first_idx = i;
367 }
368 }
369 if (first_idx == -1)
370 return 0;
371
372 return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
373 ELF_PAGESTART(cmds[first_idx].p_vaddr);
374 }
375
376
377 /* This is much more generalized than the library routine read function,
378 so we keep this separate. Technically the library read function
379 is only provided so that we can read a.out libraries that have
380 an ELF header */
381
382 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
383 struct file *interpreter, unsigned long *interp_map_addr,
384 unsigned long no_base)
385 {
386 struct elf_phdr *elf_phdata;
387 struct elf_phdr *eppnt;
388 unsigned long load_addr = 0;
389 int load_addr_set = 0;
390 unsigned long last_bss = 0, elf_bss = 0;
391 unsigned long error = ~0UL;
392 unsigned long total_size;
393 int retval, i, size;
394
395 /* First of all, some simple consistency checks */
396 if (interp_elf_ex->e_type != ET_EXEC &&
397 interp_elf_ex->e_type != ET_DYN)
398 goto out;
399 if (!elf_check_arch(interp_elf_ex))
400 goto out;
401 if (!interpreter->f_op || !interpreter->f_op->mmap)
402 goto out;
403
404 /*
405 * If the size of this structure has changed, then punt, since
406 * we will be doing the wrong thing.
407 */
408 if (interp_elf_ex->e_phentsize != sizeof(struct elf_phdr))
409 goto out;
410 if (interp_elf_ex->e_phnum < 1 ||
411 interp_elf_ex->e_phnum > 65536U / sizeof(struct elf_phdr))
412 goto out;
413
414 /* Now read in all of the header information */
415 size = sizeof(struct elf_phdr) * interp_elf_ex->e_phnum;
416 if (size > ELF_MIN_ALIGN)
417 goto out;
418 elf_phdata = kmalloc(size, GFP_KERNEL);
419 if (!elf_phdata)
420 goto out;
421
422 retval = kernel_read(interpreter, interp_elf_ex->e_phoff,
423 (char *)elf_phdata,size);
424 error = -EIO;
425 if (retval != size) {
426 if (retval < 0)
427 error = retval;
428 goto out_close;
429 }
430
431 total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
432 if (!total_size) {
433 error = -EINVAL;
434 goto out_close;
435 }
436
437 eppnt = elf_phdata;
438 for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
439 if (eppnt->p_type == PT_LOAD) {
440 int elf_type = MAP_PRIVATE | MAP_DENYWRITE;
441 int elf_prot = 0;
442 unsigned long vaddr = 0;
443 unsigned long k, map_addr;
444
445 if (eppnt->p_flags & PF_R)
446 elf_prot = PROT_READ;
447 if (eppnt->p_flags & PF_W)
448 elf_prot |= PROT_WRITE;
449 if (eppnt->p_flags & PF_X)
450 elf_prot |= PROT_EXEC;
451 vaddr = eppnt->p_vaddr;
452 if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
453 elf_type |= MAP_FIXED;
454 else if (no_base && interp_elf_ex->e_type == ET_DYN)
455 load_addr = -vaddr;
456
457 map_addr = elf_map(interpreter, load_addr + vaddr,
458 eppnt, elf_prot, elf_type, total_size);
459 total_size = 0;
460 if (!*interp_map_addr)
461 *interp_map_addr = map_addr;
462 error = map_addr;
463 if (BAD_ADDR(map_addr))
464 goto out_close;
465
466 if (!load_addr_set &&
467 interp_elf_ex->e_type == ET_DYN) {
468 load_addr = map_addr - ELF_PAGESTART(vaddr);
469 load_addr_set = 1;
470 }
471
472 /*
473 * Check to see if the section's size will overflow the
474 * allowed task size. Note that p_filesz must always be
475 * <= p_memsize so it's only necessary to check p_memsz.
476 */
477 k = load_addr + eppnt->p_vaddr;
478 if (BAD_ADDR(k) ||
479 eppnt->p_filesz > eppnt->p_memsz ||
480 eppnt->p_memsz > TASK_SIZE ||
481 TASK_SIZE - eppnt->p_memsz < k) {
482 error = -ENOMEM;
483 goto out_close;
484 }
485
486 /*
487 * Find the end of the file mapping for this phdr, and
488 * keep track of the largest address we see for this.
489 */
490 k = load_addr + eppnt->p_vaddr + eppnt->p_filesz;
491 if (k > elf_bss)
492 elf_bss = k;
493
494 /*
495 * Do the same thing for the memory mapping - between
496 * elf_bss and last_bss is the bss section.
497 */
498 k = load_addr + eppnt->p_memsz + eppnt->p_vaddr;
499 if (k > last_bss)
500 last_bss = k;
501 }
502 }
503
504 if (last_bss > elf_bss) {
505 /*
506 * Now fill out the bss section. First pad the last page up
507 * to the page boundary, and then perform a mmap to make sure
508 * that there are zero-mapped pages up to and including the
509 * last bss page.
510 */
511 if (padzero(elf_bss)) {
512 error = -EFAULT;
513 goto out_close;
514 }
515
516 /* What we have mapped so far */
517 elf_bss = ELF_PAGESTART(elf_bss + ELF_MIN_ALIGN - 1);
518
519 /* Map the last of the bss segment */
520 down_write(¤t->mm->mmap_sem);
521 error = do_brk(elf_bss, last_bss - elf_bss);
522 up_write(¤t->mm->mmap_sem);
523 if (BAD_ADDR(error))
524 goto out_close;
525 }
526
527 error = load_addr;
528
529 out_close:
530 kfree(elf_phdata);
531 out:
532 return error;
533 }
534
535 /*
536 * These are the functions used to load ELF style executables and shared
537 * libraries. There is no binary dependent code anywhere else.
538 */
539
540 #define INTERPRETER_NONE 0
541 #define INTERPRETER_ELF 2
542
543 #ifndef STACK_RND_MASK
544 #define STACK_RND_MASK (0x7ff >> (PAGE_SHIFT - 12)) /* 8MB of VA */
545 #endif
546
547 static unsigned long randomize_stack_top(unsigned long stack_top)
548 {
549 unsigned int random_variable = 0;
550
551 if ((current->flags & PF_RANDOMIZE) &&
552 !(current->personality & ADDR_NO_RANDOMIZE)) {
553 random_variable = get_random_int() & STACK_RND_MASK;
554 random_variable <<= PAGE_SHIFT;
555 }
556 #ifdef CONFIG_STACK_GROWSUP
557 return PAGE_ALIGN(stack_top) + random_variable;
558 #else
559 return PAGE_ALIGN(stack_top) - random_variable;
560 #endif
561 }
562
563 static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
564 {
565 struct file *interpreter = NULL; /* to shut gcc up */
566 unsigned long load_addr = 0, load_bias = 0;
567 int load_addr_set = 0;
568 char * elf_interpreter = NULL;
569 unsigned long error;
570 struct elf_phdr *elf_ppnt, *elf_phdata;
571 unsigned long elf_bss, elf_brk;
572 int retval, i;
573 unsigned int size;
574 unsigned long elf_entry;
575 unsigned long interp_load_addr = 0;
576 unsigned long start_code, end_code, start_data, end_data;
577 unsigned long reloc_func_desc = 0;
578 int executable_stack = EXSTACK_DEFAULT;
579 unsigned long def_flags = 0;
580 struct {
581 struct elfhdr elf_ex;
582 struct elfhdr interp_elf_ex;
583 } *loc;
584
585 loc = kmalloc(sizeof(*loc), GFP_KERNEL);
586 if (!loc) {
587 retval = -ENOMEM;
588 goto out_ret;
589 }
590
591 /* Get the exec-header */
592 loc->elf_ex = *((struct elfhdr *)bprm->buf);
593
594 retval = -ENOEXEC;
595 /* First of all, some simple consistency checks */
596 if (memcmp(loc->elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
597 goto out;
598
599 if (loc->elf_ex.e_type != ET_EXEC && loc->elf_ex.e_type != ET_DYN)
600 goto out;
601 if (!elf_check_arch(&loc->elf_ex))
602 goto out;
603 if (!bprm->file->f_op||!bprm->file->f_op->mmap)
604 goto out;
605
606 /* Now read in all of the header information */
607 if (loc->elf_ex.e_phentsize != sizeof(struct elf_phdr))
608 goto out;
609 if (loc->elf_ex.e_phnum < 1 ||
610 loc->elf_ex.e_phnum > 65536U / sizeof(struct elf_phdr))
611 goto out;
612 size = loc->elf_ex.e_phnum * sizeof(struct elf_phdr);
613 retval = -ENOMEM;
614 elf_phdata = kmalloc(size, GFP_KERNEL);
615 if (!elf_phdata)
616 goto out;
617
618 retval = kernel_read(bprm->file, loc->elf_ex.e_phoff,
619 (char *)elf_phdata, size);
620 if (retval != size) {
621 if (retval >= 0)
622 retval = -EIO;
623 goto out_free_ph;
624 }
625
626 elf_ppnt = elf_phdata;
627 elf_bss = 0;
628 elf_brk = 0;
629
630 start_code = ~0UL;
631 end_code = 0;
632 start_data = 0;
633 end_data = 0;
634
635 for (i = 0; i < loc->elf_ex.e_phnum; i++) {
636 if (elf_ppnt->p_type == PT_INTERP) {
637 /* This is the program interpreter used for
638 * shared libraries - for now assume that this
639 * is an a.out format binary
640 */
641 retval = -ENOEXEC;
642 if (elf_ppnt->p_filesz > PATH_MAX ||
643 elf_ppnt->p_filesz < 2)
644 goto out_free_ph;
645
646 retval = -ENOMEM;
647 elf_interpreter = kmalloc(elf_ppnt->p_filesz,
648 GFP_KERNEL);
649 if (!elf_interpreter)
650 goto out_free_ph;
651
652 retval = kernel_read(bprm->file, elf_ppnt->p_offset,
653 elf_interpreter,
654 elf_ppnt->p_filesz);
655 if (retval != elf_ppnt->p_filesz) {
656 if (retval >= 0)
657 retval = -EIO;
658 goto out_free_interp;
659 }
660 /* make sure path is NULL terminated */
661 retval = -ENOEXEC;
662 if (elf_interpreter[elf_ppnt->p_filesz - 1] != '\0')
663 goto out_free_interp;
664
665 interpreter = open_exec(elf_interpreter);
666 retval = PTR_ERR(interpreter);
667 if (IS_ERR(interpreter))
668 goto out_free_interp;
669
670 /*
671 * If the binary is not readable then enforce
672 * mm->dumpable = 0 regardless of the interpreter's
673 * permissions.
674 */
675 if (file_permission(interpreter, MAY_READ) < 0)
676 bprm->interp_flags |= BINPRM_FLAGS_ENFORCE_NONDUMP;
677
678 retval = kernel_read(interpreter, 0, bprm->buf,
679 BINPRM_BUF_SIZE);
680 if (retval != BINPRM_BUF_SIZE) {
681 if (retval >= 0)
682 retval = -EIO;
683 goto out_free_dentry;
684 }
685
686 /* Get the exec headers */
687 loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
688 break;
689 }
690 elf_ppnt++;
691 }
692
693 elf_ppnt = elf_phdata;
694 for (i = 0; i < loc->elf_ex.e_phnum; i++, elf_ppnt++)
695 if (elf_ppnt->p_type == PT_GNU_STACK) {
696 if (elf_ppnt->p_flags & PF_X)
697 executable_stack = EXSTACK_ENABLE_X;
698 else
699 executable_stack = EXSTACK_DISABLE_X;
700 break;
701 }
702
703 /* Some simple consistency checks for the interpreter */
704 if (elf_interpreter) {
705 retval = -ELIBBAD;
706 /* Not an ELF interpreter */
707 if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
708 goto out_free_dentry;
709 /* Verify the interpreter has a valid arch */
710 if (!elf_check_arch(&loc->interp_elf_ex))
711 goto out_free_dentry;
712 }
713
714 /* Flush all traces of the currently running executable */
715 retval = flush_old_exec(bprm);
716 if (retval)
717 goto out_free_dentry;
718
719 /* OK, This is the point of no return */
720 current->flags &= ~PF_FORKNOEXEC;
721 current->mm->def_flags = def_flags;
722
723 /* Do this immediately, since STACK_TOP as used in setup_arg_pages
724 may depend on the personality. */
725 SET_PERSONALITY(loc->elf_ex);
726 if (elf_read_implies_exec(loc->elf_ex, executable_stack))
727 current->personality |= READ_IMPLIES_EXEC;
728
729 if (!(current->personality & ADDR_NO_RANDOMIZE) && randomize_va_space)
730 current->flags |= PF_RANDOMIZE;
731
732 setup_new_exec(bprm);
733
734 /* Do this so that we can load the interpreter, if need be. We will
735 change some of these later */
736 current->mm->free_area_cache = current->mm->mmap_base;
737 current->mm->cached_hole_size = 0;
738 retval = setup_arg_pages(bprm, randomize_stack_top(STACK_TOP),
739 executable_stack);
740 if (retval < 0) {
741 send_sig(SIGKILL, current, 0);
742 goto out_free_dentry;
743 }
744
745 current->mm->start_stack = bprm->p;
746
747 /* Now we do a little grungy work by mmaping the ELF image into
748 the correct location in memory. */
749 for(i = 0, elf_ppnt = elf_phdata;
750 i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
751 int elf_prot = 0, elf_flags;
752 unsigned long k, vaddr;
753
754 if (elf_ppnt->p_type != PT_LOAD)
755 continue;
756
757 if (unlikely (elf_brk > elf_bss)) {
758 unsigned long nbyte;
759
760 /* There was a PT_LOAD segment with p_memsz > p_filesz
761 before this one. Map anonymous pages, if needed,
762 and clear the area. */
763 retval = set_brk (elf_bss + load_bias,
764 elf_brk + load_bias);
765 if (retval) {
766 send_sig(SIGKILL, current, 0);
767 goto out_free_dentry;
768 }
769 nbyte = ELF_PAGEOFFSET(elf_bss);
770 if (nbyte) {
771 nbyte = ELF_MIN_ALIGN - nbyte;
772 if (nbyte > elf_brk - elf_bss)
773 nbyte = elf_brk - elf_bss;
774 if (clear_user((void __user *)elf_bss +
775 load_bias, nbyte)) {
776 /*
777 * This bss-zeroing can fail if the ELF
778 * file specifies odd protections. So
779 * we don't check the return value
780 */
781 }
782 }
783 }
784
785 if (elf_ppnt->p_flags & PF_R)
786 elf_prot |= PROT_READ;
787 if (elf_ppnt->p_flags & PF_W)
788 elf_prot |= PROT_WRITE;
789 if (elf_ppnt->p_flags & PF_X)
790 elf_prot |= PROT_EXEC;
791
792 elf_flags = MAP_PRIVATE | MAP_DENYWRITE | MAP_EXECUTABLE;
793
794 vaddr = elf_ppnt->p_vaddr;
795 if (loc->elf_ex.e_type == ET_EXEC || load_addr_set) {
796 elf_flags |= MAP_FIXED;
797 } else if (loc->elf_ex.e_type == ET_DYN) {
798 /* Try and get dynamic programs out of the way of the
799 * default mmap base, as well as whatever program they
800 * might try to exec. This is because the brk will
801 * follow the loader, and is not movable. */
802 #ifdef CONFIG_X86
803 load_bias = 0;
804 #else
805 load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
806 #endif
807 }
808
809 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
810 elf_prot, elf_flags, 0);
811 if (BAD_ADDR(error)) {
812 send_sig(SIGKILL, current, 0);
813 retval = IS_ERR((void *)error) ?
814 PTR_ERR((void*)error) : -EINVAL;
815 goto out_free_dentry;
816 }
817
818 if (!load_addr_set) {
819 load_addr_set = 1;
820 load_addr = (elf_ppnt->p_vaddr - elf_ppnt->p_offset);
821 if (loc->elf_ex.e_type == ET_DYN) {
822 load_bias += error -
823 ELF_PAGESTART(load_bias + vaddr);
824 load_addr += load_bias;
825 reloc_func_desc = load_bias;
826 }
827 }
828 k = elf_ppnt->p_vaddr;
829 if (k < start_code)
830 start_code = k;
831 if (start_data < k)
832 start_data = k;
833
834 /*
835 * Check to see if the section's size will overflow the
836 * allowed task size. Note that p_filesz must always be
837 * <= p_memsz so it is only necessary to check p_memsz.
838 */
839 if (BAD_ADDR(k) || elf_ppnt->p_filesz > elf_ppnt->p_memsz ||
840 elf_ppnt->p_memsz > TASK_SIZE ||
841 TASK_SIZE - elf_ppnt->p_memsz < k) {
842 /* set_brk can never work. Avoid overflows. */
843 send_sig(SIGKILL, current, 0);
844 retval = -EINVAL;
845 goto out_free_dentry;
846 }
847
848 k = elf_ppnt->p_vaddr + elf_ppnt->p_filesz;
849
850 if (k > elf_bss)
851 elf_bss = k;
852 if ((elf_ppnt->p_flags & PF_X) && end_code < k)
853 end_code = k;
854 if (end_data < k)
855 end_data = k;
856 k = elf_ppnt->p_vaddr + elf_ppnt->p_memsz;
857 if (k > elf_brk)
858 elf_brk = k;
859 }
860
861 loc->elf_ex.e_entry += load_bias;
862 elf_bss += load_bias;
863 elf_brk += load_bias;
864 start_code += load_bias;
865 end_code += load_bias;
866 start_data += load_bias;
867 end_data += load_bias;
868
869 /* Calling set_brk effectively mmaps the pages that we need
870 * for the bss and break sections. We must do this before
871 * mapping in the interpreter, to make sure it doesn't wind
872 * up getting placed where the bss needs to go.
873 */
874 retval = set_brk(elf_bss, elf_brk);
875 if (retval) {
876 send_sig(SIGKILL, current, 0);
877 goto out_free_dentry;
878 }
879 if (likely(elf_bss != elf_brk) && unlikely(padzero(elf_bss))) {
880 send_sig(SIGSEGV, current, 0);
881 retval = -EFAULT; /* Nobody gets to see this, but.. */
882 goto out_free_dentry;
883 }
884
885 if (elf_interpreter) {
886 unsigned long uninitialized_var(interp_map_addr);
887
888 elf_entry = load_elf_interp(&loc->interp_elf_ex,
889 interpreter,
890 &interp_map_addr,
891 load_bias);
892 if (!IS_ERR((void *)elf_entry)) {
893 /*
894 * load_elf_interp() returns relocation
895 * adjustment
896 */
897 interp_load_addr = elf_entry;
898 elf_entry += loc->interp_elf_ex.e_entry;
899 }
900 if (BAD_ADDR(elf_entry)) {
901 force_sig(SIGSEGV, current);
902 retval = IS_ERR((void *)elf_entry) ?
903 (int)elf_entry : -EINVAL;
904 goto out_free_dentry;
905 }
906 reloc_func_desc = interp_load_addr;
907
908 allow_write_access(interpreter);
909 fput(interpreter);
910 kfree(elf_interpreter);
911 } else {
912 elf_entry = loc->elf_ex.e_entry;
913 if (BAD_ADDR(elf_entry)) {
914 force_sig(SIGSEGV, current);
915 retval = -EINVAL;
916 goto out_free_dentry;
917 }
918 }
919
920 kfree(elf_phdata);
921
922 set_binfmt(&elf_format);
923
924 #ifdef ARCH_HAS_SETUP_ADDITIONAL_PAGES
925 retval = arch_setup_additional_pages(bprm, !!elf_interpreter);
926 if (retval < 0) {
927 send_sig(SIGKILL, current, 0);
928 goto out;
929 }
930 #endif /* ARCH_HAS_SETUP_ADDITIONAL_PAGES */
931
932 install_exec_creds(bprm);
933 current->flags &= ~PF_FORKNOEXEC;
934 retval = create_elf_tables(bprm, &loc->elf_ex,
935 load_addr, interp_load_addr);
936 if (retval < 0) {
937 send_sig(SIGKILL, current, 0);
938 goto out;
939 }
940 /* N.B. passed_fileno might not be initialized? */
941 current->mm->end_code = end_code;
942 current->mm->start_code = start_code;
943 current->mm->start_data = start_data;
944 current->mm->end_data = end_data;
945 current->mm->start_stack = bprm->p;
946
947 #ifdef arch_randomize_brk
948 if ((current->flags & PF_RANDOMIZE) && (randomize_va_space > 1))
949 current->mm->brk = current->mm->start_brk =
950 arch_randomize_brk(current->mm);
951 #endif
952
953 if (current->personality & MMAP_PAGE_ZERO) {
954 /* Why this, you ask??? Well SVr4 maps page 0 as read-only,
955 and some applications "depend" upon this behavior.
956 Since we do not have the power to recompile these, we
957 emulate the SVr4 behavior. Sigh. */
958 down_write(¤t->mm->mmap_sem);
959 error = do_mmap(NULL, 0, PAGE_SIZE, PROT_READ | PROT_EXEC,
960 MAP_FIXED | MAP_PRIVATE, 0);
961 up_write(¤t->mm->mmap_sem);
962 }
963
964 #ifdef ELF_PLAT_INIT
965 /*
966 * The ABI may specify that certain registers be set up in special
967 * ways (on i386 %edx is the address of a DT_FINI function, for
968 * example. In addition, it may also specify (eg, PowerPC64 ELF)
969 * that the e_entry field is the address of the function descriptor
970 * for the startup routine, rather than the address of the startup
971 * routine itself. This macro performs whatever initialization to
972 * the regs structure is required as well as any relocations to the
973 * function descriptor entries when executing dynamically links apps.
974 */
975 ELF_PLAT_INIT(regs, reloc_func_desc);
976 #endif
977
978 start_thread(regs, elf_entry, bprm->p);
979 retval = 0;
980 out:
981 kfree(loc);
982 out_ret:
983 return retval;
984
985 /* error cleanup */
986 out_free_dentry:
987 allow_write_access(interpreter);
988 if (interpreter)
989 fput(interpreter);
990 out_free_interp:
991 kfree(elf_interpreter);
992 out_free_ph:
993 kfree(elf_phdata);
994 goto out;
995 }
996
997 /* This is really simpleminded and specialized - we are loading an
998 a.out library that is given an ELF header. */
999 static int load_elf_library(struct file *file)
1000 {
1001 struct elf_phdr *elf_phdata;
1002 struct elf_phdr *eppnt;
1003 unsigned long elf_bss, bss, len;
1004 int retval, error, i, j;
1005 struct elfhdr elf_ex;
1006
1007 error = -ENOEXEC;
1008 retval = kernel_read(file, 0, (char *)&elf_ex, sizeof(elf_ex));
1009 if (retval != sizeof(elf_ex))
1010 goto out;
1011
1012 if (memcmp(elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
1013 goto out;
1014
1015 /* First of all, some simple consistency checks */
1016 if (elf_ex.e_type != ET_EXEC || elf_ex.e_phnum > 2 ||
1017 !elf_check_arch(&elf_ex) || !file->f_op || !file->f_op->mmap)
1018 goto out;
1019
1020 /* Now read in all of the header information */
1021
1022 j = sizeof(struct elf_phdr) * elf_ex.e_phnum;
1023 /* j < ELF_MIN_ALIGN because elf_ex.e_phnum <= 2 */
1024
1025 error = -ENOMEM;
1026 elf_phdata = kmalloc(j, GFP_KERNEL);
1027 if (!elf_phdata)
1028 goto out;
1029
1030 eppnt = elf_phdata;
1031 error = -ENOEXEC;
1032 retval = kernel_read(file, elf_ex.e_phoff, (char *)eppnt, j);
1033 if (retval != j)
1034 goto out_free_ph;
1035
1036 for (j = 0, i = 0; i<elf_ex.e_phnum; i++)
1037 if ((eppnt + i)->p_type == PT_LOAD)
1038 j++;
1039 if (j != 1)
1040 goto out_free_ph;
1041
1042 while (eppnt->p_type != PT_LOAD)
1043 eppnt++;
1044
1045 /* Now use mmap to map the library into memory. */
1046 down_write(¤t->mm->mmap_sem);
1047 error = do_mmap(file,
1048 ELF_PAGESTART(eppnt->p_vaddr),
1049 (eppnt->p_filesz +
1050 ELF_PAGEOFFSET(eppnt->p_vaddr)),
1051 PROT_READ | PROT_WRITE | PROT_EXEC,
1052 MAP_FIXED | MAP_PRIVATE | MAP_DENYWRITE,
1053 (eppnt->p_offset -
1054 ELF_PAGEOFFSET(eppnt->p_vaddr)));
1055 up_write(¤t->mm->mmap_sem);
1056 if (error != ELF_PAGESTART(eppnt->p_vaddr))
1057 goto out_free_ph;
1058
1059 elf_bss = eppnt->p_vaddr + eppnt->p_filesz;
1060 if (padzero(elf_bss)) {
1061 error = -EFAULT;
1062 goto out_free_ph;
1063 }
1064
1065 len = ELF_PAGESTART(eppnt->p_filesz + eppnt->p_vaddr +
1066 ELF_MIN_ALIGN - 1);
1067 bss = eppnt->p_memsz + eppnt->p_vaddr;
1068 if (bss > len) {
1069 down_write(¤t->mm->mmap_sem);
1070 do_brk(len, bss - len);
1071 up_write(¤t->mm->mmap_sem);
1072 }
1073 error = 0;
1074
1075 out_free_ph:
1076 kfree(elf_phdata);
1077 out:
1078 return error;
1079 }
1080
1081 /*
1082 * Note that some platforms still use traditional core dumps and not
1083 * the ELF core dump. Each platform can select it as appropriate.
1084 */
1085 #if defined(USE_ELF_CORE_DUMP) && defined(CONFIG_ELF_CORE)
1086
1087 /*
1088 * ELF core dumper
1089 *
1090 * Modelled on fs/exec.c:aout_core_dump()
1091 * Jeremy Fitzhardinge <jeremy@sw.oz.au>
1092 */
1093 /*
1094 * These are the only things you should do on a core-file: use only these
1095 * functions to write out all the necessary info.
1096 */
1097 static int dump_write(struct file *file, const void *addr, int nr)
1098 {
1099 return file->f_op->write(file, addr, nr, &file->f_pos) == nr;
1100 }
1101
1102 static int dump_seek(struct file *file, loff_t off)
1103 {
1104 if (file->f_op->llseek && file->f_op->llseek != no_llseek) {
1105 if (file->f_op->llseek(file, off, SEEK_CUR) < 0)
1106 return 0;
1107 } else {
1108 char *buf = (char *)get_zeroed_page(GFP_KERNEL);
1109 if (!buf)
1110 return 0;
1111 while (off > 0) {
1112 unsigned long n = off;
1113 if (n > PAGE_SIZE)
1114 n = PAGE_SIZE;
1115 if (!dump_write(file, buf, n))
1116 return 0;
1117 off -= n;
1118 }
1119 free_page((unsigned long)buf);
1120 }
1121 return 1;
1122 }
1123
1124 /*
1125 * Decide what to dump of a segment, part, all or none.
1126 */
1127 static unsigned long vma_dump_size(struct vm_area_struct *vma,
1128 unsigned long mm_flags)
1129 {
1130 #define FILTER(type) (mm_flags & (1UL << MMF_DUMP_##type))
1131
1132 /* The vma can be set up to tell us the answer directly. */
1133 if (vma->vm_flags & VM_ALWAYSDUMP)
1134 goto whole;
1135
1136 /* Hugetlb memory check */
1137 if (vma->vm_flags & VM_HUGETLB) {
1138 if ((vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_SHARED))
1139 goto whole;
1140 if (!(vma->vm_flags & VM_SHARED) && FILTER(HUGETLB_PRIVATE))
1141 goto whole;
1142 }
1143
1144 /* Do not dump I/O mapped devices or special mappings */
1145 if (vma->vm_flags & (VM_IO | VM_RESERVED))
1146 return 0;
1147
1148 /* By default, dump shared memory if mapped from an anonymous file. */
1149 if (vma->vm_flags & VM_SHARED) {
1150 if (vma->vm_file->f_path.dentry->d_inode->i_nlink == 0 ?
1151 FILTER(ANON_SHARED) : FILTER(MAPPED_SHARED))
1152 goto whole;
1153 return 0;
1154 }
1155
1156 /* Dump segments that have been written to. */
1157 if (vma->anon_vma && FILTER(ANON_PRIVATE))
1158 goto whole;
1159 if (vma->vm_file == NULL)
1160 return 0;
1161
1162 if (FILTER(MAPPED_PRIVATE))
1163 goto whole;
1164
1165 /*
1166 * If this looks like the beginning of a DSO or executable mapping,
1167 * check for an ELF header. If we find one, dump the first page to
1168 * aid in determining what was mapped here.
1169 */
1170 if (FILTER(ELF_HEADERS) &&
1171 vma->vm_pgoff == 0 && (vma->vm_flags & VM_READ)) {
1172 u32 __user *header = (u32 __user *) vma->vm_start;
1173 u32 word;
1174 mm_segment_t fs = get_fs();
1175 /*
1176 * Doing it this way gets the constant folded by GCC.
1177 */
1178 union {
1179 u32 cmp;
1180 char elfmag[SELFMAG];
1181 } magic;
1182 BUILD_BUG_ON(SELFMAG != sizeof word);
1183 magic.elfmag[EI_MAG0] = ELFMAG0;
1184 magic.elfmag[EI_MAG1] = ELFMAG1;
1185 magic.elfmag[EI_MAG2] = ELFMAG2;
1186 magic.elfmag[EI_MAG3] = ELFMAG3;
1187 /*
1188 * Switch to the user "segment" for get_user(),
1189 * then put back what elf_core_dump() had in place.
1190 */
1191 set_fs(USER_DS);
1192 if (unlikely(get_user(word, header)))
1193 word = 0;
1194 set_fs(fs);
1195 if (word == magic.cmp)
1196 return PAGE_SIZE;
1197 }
1198
1199 #undef FILTER
1200
1201 return 0;
1202
1203 whole:
1204 return vma->vm_end - vma->vm_start;
1205 }
1206
1207 /* An ELF note in memory */
1208 struct memelfnote
1209 {
1210 const char *name;
1211 int type;
1212 unsigned int datasz;
1213 void *data;
1214 };
1215
1216 static int notesize(struct memelfnote *en)
1217 {
1218 int sz;
1219
1220 sz = sizeof(struct elf_note);
1221 sz += roundup(strlen(en->name) + 1, 4);
1222 sz += roundup(en->datasz, 4);
1223
1224 return sz;
1225 }
1226
1227 #define DUMP_WRITE(addr, nr, foffset) \
1228 do { if (!dump_write(file, (addr), (nr))) return 0; *foffset += (nr); } while(0)
1229
1230 static int alignfile(struct file *file, loff_t *foffset)
1231 {
1232 static const char buf[4] = { 0, };
1233 DUMP_WRITE(buf, roundup(*foffset, 4) - *foffset, foffset);
1234 return 1;
1235 }
1236
1237 static int writenote(struct memelfnote *men, struct file *file,
1238 loff_t *foffset)
1239 {
1240 struct elf_note en;
1241 en.n_namesz = strlen(men->name) + 1;
1242 en.n_descsz = men->datasz;
1243 en.n_type = men->type;
1244
1245 DUMP_WRITE(&en, sizeof(en), foffset);
1246 DUMP_WRITE(men->name, en.n_namesz, foffset);
1247 if (!alignfile(file, foffset))
1248 return 0;
1249 DUMP_WRITE(men->data, men->datasz, foffset);
1250 if (!alignfile(file, foffset))
1251 return 0;
1252
1253 return 1;
1254 }
1255 #undef DUMP_WRITE
1256
1257 #define DUMP_WRITE(addr, nr) \
1258 if ((size += (nr)) > limit || !dump_write(file, (addr), (nr))) \
1259 goto end_coredump;
1260 #define DUMP_SEEK(off) \
1261 if (!dump_seek(file, (off))) \
1262 goto end_coredump;
1263
1264 static void fill_elf_header(struct elfhdr *elf, int segs,
1265 u16 machine, u32 flags, u8 osabi)
1266 {
1267 memset(elf, 0, sizeof(*elf));
1268
1269 memcpy(elf->e_ident, ELFMAG, SELFMAG);
1270 elf->e_ident[EI_CLASS] = ELF_CLASS;
1271 elf->e_ident[EI_DATA] = ELF_DATA;
1272 elf->e_ident[EI_VERSION] = EV_CURRENT;
1273 elf->e_ident[EI_OSABI] = ELF_OSABI;
1274
1275 elf->e_type = ET_CORE;
1276 elf->e_machine = machine;
1277 elf->e_version = EV_CURRENT;
1278 elf->e_phoff = sizeof(struct elfhdr);
1279 elf->e_flags = flags;
1280 elf->e_ehsize = sizeof(struct elfhdr);
1281 elf->e_phentsize = sizeof(struct elf_phdr);
1282 elf->e_phnum = segs;
1283
1284 return;
1285 }
1286
1287 static void fill_elf_note_phdr(struct elf_phdr *phdr, int sz, loff_t offset)
1288 {
1289 phdr->p_type = PT_NOTE;
1290 phdr->p_offset = offset;
1291 phdr->p_vaddr = 0;
1292 phdr->p_paddr = 0;
1293 phdr->p_filesz = sz;
1294 phdr->p_memsz = 0;
1295 phdr->p_flags = 0;
1296 phdr->p_align = 0;
1297 return;
1298 }
1299
1300 static void fill_note(struct memelfnote *note, const char *name, int type,
1301 unsigned int sz, void *data)
1302 {
1303 note->name = name;
1304 note->type = type;
1305 note->datasz = sz;
1306 note->data = data;
1307 return;
1308 }
1309
1310 /*
1311 * fill up all the fields in prstatus from the given task struct, except
1312 * registers which need to be filled up separately.
1313 */
1314 static void fill_prstatus(struct elf_prstatus *prstatus,
1315 struct task_struct *p, long signr)
1316 {
1317 prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
1318 prstatus->pr_sigpend = p->pending.signal.sig[0];
1319 prstatus->pr_sighold = p->blocked.sig[0];
1320 rcu_read_lock();
1321 prstatus->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1322 rcu_read_unlock();
1323 prstatus->pr_pid = task_pid_vnr(p);
1324 prstatus->pr_pgrp = task_pgrp_vnr(p);
1325 prstatus->pr_sid = task_session_vnr(p);
1326 if (thread_group_leader(p)) {
1327 struct task_cputime cputime;
1328
1329 /*
1330 * This is the record for the group leader. It shows the
1331 * group-wide total, not its individual thread total.
1332 */
1333 thread_group_cputime(p, &cputime);
1334 cputime_to_timeval(cputime.utime, &prstatus->pr_utime);
1335 cputime_to_timeval(cputime.stime, &prstatus->pr_stime);
1336 } else {
1337 cputime_to_timeval(p->utime, &prstatus->pr_utime);
1338 cputime_to_timeval(p->stime, &prstatus->pr_stime);
1339 }
1340 cputime_to_timeval(p->signal->cutime, &prstatus->pr_cutime);
1341 cputime_to_timeval(p->signal->cstime, &prstatus->pr_cstime);
1342 }
1343
1344 static int fill_psinfo(struct elf_prpsinfo *psinfo, struct task_struct *p,
1345 struct mm_struct *mm)
1346 {
1347 const struct cred *cred;
1348 unsigned int i, len;
1349
1350 /* first copy the parameters from user space */
1351 memset(psinfo, 0, sizeof(struct elf_prpsinfo));
1352
1353 len = mm->arg_end - mm->arg_start;
1354 if (len >= ELF_PRARGSZ)
1355 len = ELF_PRARGSZ-1;
1356 if (copy_from_user(&psinfo->pr_psargs,
1357 (const char __user *)mm->arg_start, len))
1358 return -EFAULT;
1359 for(i = 0; i < len; i++)
1360 if (psinfo->pr_psargs[i] == 0)
1361 psinfo->pr_psargs[i] = ' ';
1362 psinfo->pr_psargs[len] = 0;
1363
1364 rcu_read_lock();
1365 psinfo->pr_ppid = task_pid_vnr(rcu_dereference(p->real_parent));
1366 rcu_read_unlock();
1367 psinfo->pr_pid = task_pid_vnr(p);
1368 psinfo->pr_pgrp = task_pgrp_vnr(p);
1369 psinfo->pr_sid = task_session_vnr(p);
1370
1371 i = p->state ? ffz(~p->state) + 1 : 0;
1372 psinfo->pr_state = i;
1373 psinfo->pr_sname = (i > 5) ? '.' : "RSDTZW"[i];
1374 psinfo->pr_zomb = psinfo->pr_sname == 'Z';
1375 psinfo->pr_nice = task_nice(p);
1376 psinfo->pr_flag = p->flags;
1377 rcu_read_lock();
1378 cred = __task_cred(p);
1379 SET_UID(psinfo->pr_uid, cred->uid);
1380 SET_GID(psinfo->pr_gid, cred->gid);
1381 rcu_read_unlock();
1382 strncpy(psinfo->pr_fname, p->comm, sizeof(psinfo->pr_fname));
1383
1384 return 0;
1385 }
1386
1387 static void fill_auxv_note(struct memelfnote *note, struct mm_struct *mm)
1388 {
1389 elf_addr_t *auxv = (elf_addr_t *) mm->saved_auxv;
1390 int i = 0;
1391 do
1392 i += 2;
1393 while (auxv[i - 2] != AT_NULL);
1394 fill_note(note, "CORE", NT_AUXV, i * sizeof(elf_addr_t), auxv);
1395 }
1396
1397 #ifdef CORE_DUMP_USE_REGSET
1398 #include <linux/regset.h>
1399
1400 struct elf_thread_core_info {
1401 struct elf_thread_core_info *next;
1402 struct task_struct *task;
1403 struct elf_prstatus prstatus;
1404 struct memelfnote notes[0];
1405 };
1406
1407 struct elf_note_info {
1408 struct elf_thread_core_info *thread;
1409 struct memelfnote psinfo;
1410 struct memelfnote auxv;
1411 size_t size;
1412 int thread_notes;
1413 };
1414
1415 /*
1416 * When a regset has a writeback hook, we call it on each thread before
1417 * dumping user memory. On register window machines, this makes sure the
1418 * user memory backing the register data is up to date before we read it.
1419 */
1420 static void do_thread_regset_writeback(struct task_struct *task,
1421 const struct user_regset *regset)
1422 {
1423 if (regset->writeback)
1424 regset->writeback(task, regset, 1);
1425 }
1426
1427 static int fill_thread_core_info(struct elf_thread_core_info *t,
1428 const struct user_regset_view *view,
1429 long signr, size_t *total)
1430 {
1431 unsigned int i;
1432
1433 /*
1434 * NT_PRSTATUS is the one special case, because the regset data
1435 * goes into the pr_reg field inside the note contents, rather
1436 * than being the whole note contents. We fill the reset in here.
1437 * We assume that regset 0 is NT_PRSTATUS.
1438 */
1439 fill_prstatus(&t->prstatus, t->task, signr);
1440 (void) view->regsets[0].get(t->task, &view->regsets[0],
1441 0, sizeof(t->prstatus.pr_reg),
1442 &t->prstatus.pr_reg, NULL);
1443
1444 fill_note(&t->notes[0], "CORE", NT_PRSTATUS,
1445 sizeof(t->prstatus), &t->prstatus);
1446 *total += notesize(&t->notes[0]);
1447
1448 do_thread_regset_writeback(t->task, &view->regsets[0]);
1449
1450 /*
1451 * Each other regset might generate a note too. For each regset
1452 * that has no core_note_type or is inactive, we leave t->notes[i]
1453 * all zero and we'll know to skip writing it later.
1454 */
1455 for (i = 1; i < view->n; ++i) {
1456 const struct user_regset *regset = &view->regsets[i];
1457 do_thread_regset_writeback(t->task, regset);
1458 if (regset->core_note_type &&
1459 (!regset->active || regset->active(t->task, regset))) {
1460 int ret;
1461 size_t size = regset->n * regset->size;
1462 void *data = kmalloc(size, GFP_KERNEL);
1463 if (unlikely(!data))
1464 return 0;
1465 ret = regset->get(t->task, regset,
1466 0, size, data, NULL);
1467 if (unlikely(ret))
1468 kfree(data);
1469 else {
1470 if (regset->core_note_type != NT_PRFPREG)
1471 fill_note(&t->notes[i], "LINUX",
1472 regset->core_note_type,
1473 size, data);
1474 else {
1475 t->prstatus.pr_fpvalid = 1;
1476 fill_note(&t->notes[i], "CORE",
1477 NT_PRFPREG, size, data);
1478 }
1479 *total += notesize(&t->notes[i]);
1480 }
1481 }
1482 }
1483
1484 return 1;
1485 }
1486
1487 static int fill_note_info(struct elfhdr *elf, int phdrs,
1488 struct elf_note_info *info,
1489 long signr, struct pt_regs *regs)
1490 {
1491 struct task_struct *dump_task = current;
1492 const struct user_regset_view *view = task_user_regset_view(dump_task);
1493 struct elf_thread_core_info *t;
1494 struct elf_prpsinfo *psinfo;
1495 struct core_thread *ct;
1496 unsigned int i;
1497
1498 info->size = 0;
1499 info->thread = NULL;
1500
1501 psinfo = kmalloc(sizeof(*psinfo), GFP_KERNEL);
1502 if (psinfo == NULL)
1503 return 0;
1504
1505 fill_note(&info->psinfo, "CORE", NT_PRPSINFO, sizeof(*psinfo), psinfo);
1506
1507 /*
1508 * Figure out how many notes we're going to need for each thread.
1509 */
1510 info->thread_notes = 0;
1511 for (i = 0; i < view->n; ++i)
1512 if (view->regsets[i].core_note_type != 0)
1513 ++info->thread_notes;
1514
1515 /*
1516 * Sanity check. We rely on regset 0 being in NT_PRSTATUS,
1517 * since it is our one special case.
1518 */
1519 if (unlikely(info->thread_notes == 0) ||
1520 unlikely(view->regsets[0].core_note_type != NT_PRSTATUS)) {
1521 WARN_ON(1);
1522 return 0;
1523 }
1524
1525 /*
1526 * Initialize the ELF file header.
1527 */
1528 fill_elf_header(elf, phdrs,
1529 view->e_machine, view->e_flags, view->ei_osabi);
1530
1531 /*
1532 * Allocate a structure for each thread.
1533 */
1534 for (ct = &dump_task->mm->core_state->dumper; ct; ct = ct->next) {
1535 t = kzalloc(offsetof(struct elf_thread_core_info,
1536 notes[info->thread_notes]),
1537 GFP_KERNEL);
1538 if (unlikely(!t))
1539 return 0;
1540
1541 t->task = ct->task;
1542 if (ct->task == dump_task || !info->thread) {
1543 t->next = info->thread;
1544 info->thread = t;
1545 } else {
1546 /*
1547 * Make sure to keep the original task at
1548 * the head of the list.
1549 */
1550 t->next = info->thread->next;
1551 info->thread->next = t;
1552 }
1553 }
1554
1555 /*
1556 * Now fill in each thread's information.
1557 */
1558 for (t = info->thread; t != NULL; t = t->next)
1559 if (!fill_thread_core_info(t, view, signr, &info->size))
1560 return 0;
1561
1562 /*
1563 * Fill in the two process-wide notes.
1564 */
1565 fill_psinfo(psinfo, dump_task->group_leader, dump_task->mm);
1566 info->size += notesize(&info->psinfo);
1567
1568 fill_auxv_note(&info->auxv, current->mm);
1569 info->size += notesize(&info->auxv);
1570
1571 return 1;
1572 }
1573
1574 static size_t get_note_info_size(struct elf_note_info *info)
1575 {
1576 return info->size;
1577 }
1578
1579 /*
1580 * Write all the notes for each thread. When writing the first thread, the
1581 * process-wide notes are interleaved after the first thread-specific note.
1582 */
1583 static int write_note_info(struct elf_note_info *info,
1584 struct file *file, loff_t *foffset)
1585 {
1586 bool first = 1;
1587 struct elf_thread_core_info *t = info->thread;
1588
1589 do {
1590 int i;
1591
1592 if (!writenote(&t->notes[0], file, foffset))
1593 return 0;
1594
1595 if (first && !writenote(&info->psinfo, file, foffset))
1596 return 0;
1597 if (first && !writenote(&info->auxv, file, foffset))
1598 return 0;
1599
1600 for (i = 1; i < info->thread_notes; ++i)
1601 if (t->notes[i].data &&
1602 !writenote(&t->notes[i], file, foffset))
1603 return 0;
1604
1605 first = 0;
1606 t = t->next;
1607 } while (t);
1608
1609 return 1;
1610 }
1611
1612 static void free_note_info(struct elf_note_info *info)
1613 {
1614 struct elf_thread_core_info *threads = info->thread;
1615 while (threads) {
1616 unsigned int i;
1617 struct elf_thread_core_info *t = threads;
1618 threads = t->next;
1619 WARN_ON(t->notes[0].data && t->notes[0].data != &t->prstatus);
1620 for (i = 1; i < info->thread_notes; ++i)
1621 kfree(t->notes[i].data);
1622 kfree(t);
1623 }
1624 kfree(info->psinfo.data);
1625 }
1626
1627 #else
1628
1629 /* Here is the structure in which status of each thread is captured. */
1630 struct elf_thread_status
1631 {
1632 struct list_head list;
1633 struct elf_prstatus prstatus; /* NT_PRSTATUS */
1634 elf_fpregset_t fpu; /* NT_PRFPREG */
1635 struct task_struct *thread;
1636 #ifdef ELF_CORE_COPY_XFPREGS
1637 elf_fpxregset_t xfpu; /* ELF_CORE_XFPREG_TYPE */
1638 #endif
1639 struct memelfnote notes[3];
1640 int num_notes;
1641 };
1642
1643 /*
1644 * In order to add the specific thread information for the elf file format,
1645 * we need to keep a linked list of every threads pr_status and then create
1646 * a single section for them in the final core file.
1647 */
1648 static int elf_dump_thread_status(long signr, struct elf_thread_status *t)
1649 {
1650 int sz = 0;
1651 struct task_struct *p = t->thread;
1652 t->num_notes = 0;
1653
1654 fill_prstatus(&t->prstatus, p, signr);
1655 elf_core_copy_task_regs(p, &t->prstatus.pr_reg);
1656
1657 fill_note(&t->notes[0], "CORE", NT_PRSTATUS, sizeof(t->prstatus),
1658 &(t->prstatus));
1659 t->num_notes++;
1660 sz += notesize(&t->notes[0]);
1661
1662 if ((t->prstatus.pr_fpvalid = elf_core_copy_task_fpregs(p, NULL,
1663 &t->fpu))) {
1664 fill_note(&t->notes[1], "CORE", NT_PRFPREG, sizeof(t->fpu),
1665 &(t->fpu));
1666 t->num_notes++;
1667 sz += notesize(&t->notes[1]);
1668 }
1669
1670 #ifdef ELF_CORE_COPY_XFPREGS
1671 if (elf_core_copy_task_xfpregs(p, &t->xfpu)) {
1672 fill_note(&t->notes[2], "LINUX", ELF_CORE_XFPREG_TYPE,
1673 sizeof(t->xfpu), &t->xfpu);
1674 t->num_notes++;
1675 sz += notesize(&t->notes[2]);
1676 }
1677 #endif
1678 return sz;
1679 }
1680
1681 struct elf_note_info {
1682 struct memelfnote *notes;
1683 struct elf_prstatus *prstatus; /* NT_PRSTATUS */
1684 struct elf_prpsinfo *psinfo; /* NT_PRPSINFO */
1685 struct list_head thread_list;
1686 elf_fpregset_t *fpu;
1687 #ifdef ELF_CORE_COPY_XFPREGS
1688 elf_fpxregset_t *xfpu;
1689 #endif
1690 int thread_status_size;
1691 int numnote;
1692 };
1693
1694 static int fill_note_info(struct elfhdr *elf, int phdrs,
1695 struct elf_note_info *info,
1696 long signr, struct pt_regs *regs)
1697 {
1698 #define NUM_NOTES 6
1699 struct list_head *t;
1700
1701 info->notes = NULL;
1702 info->prstatus = NULL;
1703 info->psinfo = NULL;
1704 info->fpu = NULL;
1705 #ifdef ELF_CORE_COPY_XFPREGS
1706 info->xfpu = NULL;
1707 #endif
1708 INIT_LIST_HEAD(&info->thread_list);
1709
1710 info->notes = kmalloc(NUM_NOTES * sizeof(struct memelfnote),
1711 GFP_KERNEL);
1712 if (!info->notes)
1713 return 0;
1714 info->psinfo = kmalloc(sizeof(*info->psinfo), GFP_KERNEL);
1715 if (!info->psinfo)
1716 return 0;
1717 info->prstatus = kmalloc(sizeof(*info->prstatus), GFP_KERNEL);
1718 if (!info->prstatus)
1719 return 0;
1720 info->fpu = kmalloc(sizeof(*info->fpu), GFP_KERNEL);
1721 if (!info->fpu)
1722 return 0;
1723 #ifdef ELF_CORE_COPY_XFPREGS
1724 info->xfpu = kmalloc(sizeof(*info->xfpu), GFP_KERNEL);
1725 if (!info->xfpu)
1726 return 0;
1727 #endif
1728
1729 info->thread_status_size = 0;
1730 if (signr) {
1731 struct core_thread *ct;
1732 struct elf_thread_status *ets;
1733
1734 for (ct = current->mm->core_state->dumper.next;
1735 ct; ct = ct->next) {
1736 ets = kzalloc(sizeof(*ets), GFP_KERNEL);
1737 if (!ets)
1738 return 0;
1739
1740 ets->thread = ct->task;
1741 list_add(&ets->list, &info->thread_list);
1742 }
1743
1744 list_for_each(t, &info->thread_list) {
1745 int sz;
1746
1747 ets = list_entry(t, struct elf_thread_status, list);
1748 sz = elf_dump_thread_status(signr, ets);
1749 info->thread_status_size += sz;
1750 }
1751 }
1752 /* now collect the dump for the current */
1753 memset(info->prstatus, 0, sizeof(*info->prstatus));
1754 fill_prstatus(info->prstatus, current, signr);
1755 elf_core_copy_regs(&info->prstatus->pr_reg, regs);
1756
1757 /* Set up header */
1758 fill_elf_header(elf, phdrs, ELF_ARCH, ELF_CORE_EFLAGS, ELF_OSABI);
1759
1760 /*
1761 * Set up the notes in similar form to SVR4 core dumps made
1762 * with info from their /proc.
1763 */
1764
1765 fill_note(info->notes + 0, "CORE", NT_PRSTATUS,
1766 sizeof(*info->prstatus), info->prstatus);
1767 fill_psinfo(info->psinfo, current->group_leader, current->mm);
1768 fill_note(info->notes + 1, "CORE", NT_PRPSINFO,
1769 sizeof(*info->psinfo), info->psinfo);
1770
1771 info->numnote = 2;
1772
1773 fill_auxv_note(&info->notes[info->numnote++], current->mm);
1774
1775 /* Try to dump the FPU. */
1776 info->prstatus->pr_fpvalid = elf_core_copy_task_fpregs(current, regs,
1777 info->fpu);
1778 if (info->prstatus->pr_fpvalid)
1779 fill_note(info->notes + info->numnote++,
1780 "CORE", NT_PRFPREG, sizeof(*info->fpu), info->fpu);
1781 #ifdef ELF_CORE_COPY_XFPREGS
1782 if (elf_core_copy_task_xfpregs(current, info->xfpu))
1783 fill_note(info->notes + info->numnote++,
1784 "LINUX", ELF_CORE_XFPREG_TYPE,
1785 sizeof(*info->xfpu), info->xfpu);
1786 #endif
1787
1788 return 1;
1789
1790 #undef NUM_NOTES
1791 }
1792
1793 static size_t get_note_info_size(struct elf_note_info *info)
1794 {
1795 int sz = 0;
1796 int i;
1797
1798 for (i = 0; i < info->numnote; i++)
1799 sz += notesize(info->notes + i);
1800
1801 sz += info->thread_status_size;
1802
1803 return sz;
1804 }
1805
1806 static int write_note_info(struct elf_note_info *info,
1807 struct file *file, loff_t *foffset)
1808 {
1809 int i;
1810 struct list_head *t;
1811
1812 for (i = 0; i < info->numnote; i++)
1813 if (!writenote(info->notes + i, file, foffset))
1814 return 0;
1815
1816 /* write out the thread status notes section */
1817 list_for_each(t, &info->thread_list) {
1818 struct elf_thread_status *tmp =
1819 list_entry(t, struct elf_thread_status, list);
1820
1821 for (i = 0; i < tmp->num_notes; i++)
1822 if (!writenote(&tmp->notes[i], file, foffset))
1823 return 0;
1824 }
1825
1826 return 1;
1827 }
1828
1829 static void free_note_info(struct elf_note_info *info)
1830 {
1831 while (!list_empty(&info->thread_list)) {
1832 struct list_head *tmp = info->thread_list.next;
1833 list_del(tmp);
1834 kfree(list_entry(tmp, struct elf_thread_status, list));
1835 }
1836
1837 kfree(info->prstatus);
1838 kfree(info->psinfo);
1839 kfree(info->notes);
1840 kfree(info->fpu);
1841 #ifdef ELF_CORE_COPY_XFPREGS
1842 kfree(info->xfpu);
1843 #endif
1844 }
1845
1846 #endif
1847
1848 static struct vm_area_struct *first_vma(struct task_struct *tsk,
1849 struct vm_area_struct *gate_vma)
1850 {
1851 struct vm_area_struct *ret = tsk->mm->mmap;
1852
1853 if (ret)
1854 return ret;
1855 return gate_vma;
1856 }
1857 /*
1858 * Helper function for iterating across a vma list. It ensures that the caller
1859 * will visit `gate_vma' prior to terminating the search.
1860 */
1861 static struct vm_area_struct *next_vma(struct vm_area_struct *this_vma,
1862 struct vm_area_struct *gate_vma)
1863 {
1864 struct vm_area_struct *ret;
1865
1866 ret = this_vma->vm_next;
1867 if (ret)
1868 return ret;
1869 if (this_vma == gate_vma)
1870 return NULL;
1871 return gate_vma;
1872 }
1873
1874 /*
1875 * Actual dumper
1876 *
1877 * This is a two-pass process; first we find the offsets of the bits,
1878 * and then they are actually written out. If we run out of core limit
1879 * we just truncate.
1880 */
1881 static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file, unsigned long limit)
1882 {
1883 int has_dumped = 0;
1884 mm_segment_t fs;
1885 int segs;
1886 size_t size = 0;
1887 struct vm_area_struct *vma, *gate_vma;
1888 struct elfhdr *elf = NULL;
1889 loff_t offset = 0, dataoff, foffset;
1890 unsigned long mm_flags;
1891 struct elf_note_info info;
1892
1893 /*
1894 * We no longer stop all VM operations.
1895 *
1896 * This is because those proceses that could possibly change map_count
1897 * or the mmap / vma pages are now blocked in do_exit on current
1898 * finishing this core dump.
1899 *
1900 * Only ptrace can touch these memory addresses, but it doesn't change
1901 * the map_count or the pages allocated. So no possibility of crashing
1902 * exists while dumping the mm->vm_next areas to the core file.
1903 */
1904
1905 /* alloc memory for large data structures: too large to be on stack */
1906 elf = kmalloc(sizeof(*elf), GFP_KERNEL);
1907 if (!elf)
1908 goto out;
1909 /*
1910 * The number of segs are recored into ELF header as 16bit value.
1911 * Please check DEFAULT_MAX_MAP_COUNT definition when you modify here.
1912 */
1913 segs = current->mm->map_count;
1914 #ifdef ELF_CORE_EXTRA_PHDRS
1915 segs += ELF_CORE_EXTRA_PHDRS;
1916 #endif
1917
1918 gate_vma = get_gate_vma(current);
1919 if (gate_vma != NULL)
1920 segs++;
1921
1922 /*
1923 * Collect all the non-memory information about the process for the
1924 * notes. This also sets up the file header.
1925 */
1926 if (!fill_note_info(elf, segs + 1, /* including notes section */
1927 &info, signr, regs))
1928 goto cleanup;
1929
1930 has_dumped = 1;
1931 current->flags |= PF_DUMPCORE;
1932
1933 fs = get_fs();
1934 set_fs(KERNEL_DS);
1935
1936 DUMP_WRITE(elf, sizeof(*elf));
1937 offset += sizeof(*elf); /* Elf header */
1938 offset += (segs + 1) * sizeof(struct elf_phdr); /* Program headers */
1939 foffset = offset;
1940
1941 /* Write notes phdr entry */
1942 {
1943 struct elf_phdr phdr;
1944 size_t sz = get_note_info_size(&info);
1945
1946 sz += elf_coredump_extra_notes_size();
1947
1948 fill_elf_note_phdr(&phdr, sz, offset);
1949 offset += sz;
1950 DUMP_WRITE(&phdr, sizeof(phdr));
1951 }
1952
1953 dataoff = offset = roundup(offset, ELF_EXEC_PAGESIZE);
1954
1955 /*
1956 * We must use the same mm->flags while dumping core to avoid
1957 * inconsistency between the program headers and bodies, otherwise an
1958 * unusable core file can be generated.
1959 */
1960 mm_flags = current->mm->flags;
1961
1962 /* Write program headers for segments dump */
1963 for (vma = first_vma(current, gate_vma); vma != NULL;
1964 vma = next_vma(vma, gate_vma)) {
1965 struct elf_phdr phdr;
1966
1967 phdr.p_type = PT_LOAD;
1968 phdr.p_offset = offset;
1969 phdr.p_vaddr = vma->vm_start;
1970 phdr.p_paddr = 0;
1971 phdr.p_filesz = vma_dump_size(vma, mm_flags);
1972 phdr.p_memsz = vma->vm_end - vma->vm_start;
1973 offset += phdr.p_filesz;
1974 phdr.p_flags = vma->vm_flags & VM_READ ? PF_R : 0;
1975 if (vma->vm_flags & VM_WRITE)
1976 phdr.p_flags |= PF_W;
1977 if (vma->vm_flags & VM_EXEC)
1978 phdr.p_flags |= PF_X;
1979 phdr.p_align = ELF_EXEC_PAGESIZE;
1980
1981 DUMP_WRITE(&phdr, sizeof(phdr));
1982 }
1983
1984 #ifdef ELF_CORE_WRITE_EXTRA_PHDRS
1985 ELF_CORE_WRITE_EXTRA_PHDRS;
1986 #endif
1987
1988 /* write out the notes section */
1989 if (!write_note_info(&info, file, &foffset))
1990 goto end_coredump;
1991
1992 if (elf_coredump_extra_notes_write(file, &foffset))
1993 goto end_coredump;
1994
1995 /* Align to page */
1996 DUMP_SEEK(dataoff - foffset);
1997
1998 for (vma = first_vma(current, gate_vma); vma != NULL;
1999 vma = next_vma(vma, gate_vma)) {
2000 unsigned long addr;
2001 unsigned long end;
2002
2003 end = vma->vm_start + vma_dump_size(vma, mm_flags);
2004
2005 for (addr = vma->vm_start; addr < end; addr += PAGE_SIZE) {
2006 struct page *page;
2007 struct vm_area_struct *tmp_vma;
2008
2009 if (get_user_pages(current, current->mm, addr, 1, 0, 1,
2010 &page, &tmp_vma) <= 0) {
2011 DUMP_SEEK(PAGE_SIZE);
2012 } else {
2013 if (page == ZERO_PAGE(0)) {
2014 if (!dump_seek(file, PAGE_SIZE)) {
2015 page_cache_release(page);
2016 goto end_coredump;
2017 }
2018 } else {
2019 void *kaddr;
2020 flush_cache_page(tmp_vma, addr,
2021 page_to_pfn(page));
2022 kaddr = kmap(page);
2023 if ((size += PAGE_SIZE) > limit ||
2024 !dump_write(file, kaddr,
2025 PAGE_SIZE)) {
2026 kunmap(page);
2027 page_cache_release(page);
2028 goto end_coredump;
2029 }
2030 kunmap(page);
2031 }
2032 page_cache_release(page);
2033 }
2034 }
2035 }
2036
2037 #ifdef ELF_CORE_WRITE_EXTRA_DATA
2038 ELF_CORE_WRITE_EXTRA_DATA;
2039 #endif
2040
2041 end_coredump:
2042 set_fs(fs);
2043
2044 cleanup:
2045 free_note_info(&info);
2046 kfree(elf);
2047 out:
2048 return has_dumped;
2049 }
2050
2051 #endif /* USE_ELF_CORE_DUMP */
2052
2053 static int __init init_elf_binfmt(void)
2054 {
2055 return register_binfmt(&elf_format);
2056 }
2057
2058 static void __exit exit_elf_binfmt(void)
2059 {
2060 /* Remove the COFF and ELF loaders. */
2061 unregister_binfmt(&elf_format);
2062 }
2063
2064 core_initcall(init_elf_binfmt);
2065 module_exit(exit_elf_binfmt);
2066 MODULE_LICENSE("GPL");
2067
|
This page was automatically generated by the
LXR engine.
|