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