2 * Copyright (c) 2000 David O'Brien
3 * Copyright (c) 1995-1996 Søren Schmidt
4 * Copyright (c) 1996 Peter Wemm
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer
12 * in this position and unchanged.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 * 3. The name of the author may not be used to endorse or promote products
17 * derived from this software without specific prior written permission
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * $FreeBSD: src/sys/kern/imgact_elf.c,v 1.73.2.13 2002/12/28 19:49:41 dillon Exp $
33 #include <sys/param.h>
35 #include <sys/fcntl.h>
37 #include <sys/imgact.h>
38 #include <sys/imgact_elf.h>
39 #include <sys/kernel.h>
40 #include <sys/malloc.h>
42 #include <sys/systm.h>
44 #include <sys/nlookup.h>
45 #include <sys/pioctl.h>
46 #include <sys/procfs.h>
47 #include <sys/resourcevar.h>
48 #include <sys/signalvar.h>
50 #include <sys/syscall.h>
51 #include <sys/sysctl.h>
52 #include <sys/sysent.h>
53 #include <sys/vnode.h>
54 #include <sys/eventhandler.h>
56 #include <cpu/lwbuf.h>
59 #include <vm/vm_kern.h>
60 #include <vm/vm_param.h>
63 #include <vm/vm_map.h>
64 #include <vm/vm_object.h>
65 #include <vm/vm_extern.h>
67 #include <machine/elf.h>
68 #include <machine/md_var.h>
69 #include <sys/mount.h>
72 #define OLD_EI_BRAND 8
73 #define truncps(va,ps) ((va) & ~(ps - 1))
74 #define aligned(a,t) (truncps((u_long)(a), sizeof(t)) == (u_long)(a))
76 static int __elfN(check_header
)(const Elf_Ehdr
*hdr
);
77 static Elf_Brandinfo
*__elfN(get_brandinfo
)(struct image_params
*imgp
,
78 const char *interp
, int32_t *osrel
);
79 static int __elfN(load_file
)(struct proc
*p
, const char *file
, u_long
*addr
,
81 static int __elfN(load_section
)(struct proc
*p
,
82 struct vmspace
*vmspace
, struct vnode
*vp
,
83 vm_offset_t offset
, caddr_t vmaddr
, size_t memsz
, size_t filsz
,
85 static int __CONCAT(exec_
, __elfN(imgact
))(struct image_params
*imgp
);
86 static boolean_t
__elfN(bsd_trans_osrel
)(const Elf_Note
*note
,
88 static boolean_t
__elfN(check_note
)(struct image_params
*imgp
,
89 Elf_Brandnote
*checknote
, int32_t *osrel
);
90 static vm_prot_t
__elfN(trans_prot
)(Elf_Word
);
91 static Elf_Word
__elfN(untrans_prot
)(vm_prot_t
);
92 static boolean_t
check_PT_NOTE(struct image_params
*imgp
,
93 Elf_Brandnote
*checknote
, int32_t *osrel
, const Elf_Phdr
* pnote
);
94 static boolean_t
extract_interpreter(struct image_params
*imgp
,
95 const Elf_Phdr
*pinterpreter
, char *data
);
96 static u_long
pie_base_hint(struct proc
*p
);
98 static int elf_legacy_coredump
= 0;
99 static int __elfN(fallback_brand
) = -1;
100 static int elf_pie_base_mmap
= 0;
101 #if defined(__x86_64__)
102 SYSCTL_NODE(_kern
, OID_AUTO
, elf64
, CTLFLAG_RW
, 0, "");
103 SYSCTL_INT(_debug
, OID_AUTO
, elf64_legacy_coredump
, CTLFLAG_RW
,
104 &elf_legacy_coredump
, 0, "legacy coredump mode");
105 SYSCTL_INT(_kern_elf64
, OID_AUTO
, fallback_brand
, CTLFLAG_RW
,
106 &elf64_fallback_brand
, 0, "ELF64 brand of last resort");
107 TUNABLE_INT("kern.elf64.fallback_brand", &elf64_fallback_brand
);
108 SYSCTL_INT(_kern_elf64
, OID_AUTO
, pie_base_mmap
, CTLFLAG_RW
,
109 &elf_pie_base_mmap
, 0,
110 "choose a base address for PIE as if it is mapped with mmap()");
111 TUNABLE_INT("kern.elf64.pie_base_mmap", &elf_pie_base_mmap
);
112 #else /* i386 assumed */
113 SYSCTL_NODE(_kern
, OID_AUTO
, elf32
, CTLFLAG_RW
, 0, "");
114 SYSCTL_INT(_debug
, OID_AUTO
, elf32_legacy_coredump
, CTLFLAG_RW
,
115 &elf_legacy_coredump
, 0, "legacy coredump mode");
116 SYSCTL_INT(_kern_elf32
, OID_AUTO
, fallback_brand
, CTLFLAG_RW
,
117 &elf32_fallback_brand
, 0, "ELF32 brand of last resort");
118 TUNABLE_INT("kern.elf32.fallback_brand", &elf32_fallback_brand
);
119 SYSCTL_INT(_kern_elf32
, OID_AUTO
, pie_base_mmap
, CTLFLAG_RW
,
120 &elf_pie_base_mmap
, 0,
121 "choose a base address for PIE as if it is mapped with mmap()");
122 TUNABLE_INT("kern.elf32.pie_base_mmap", &elf_pie_base_mmap
);
125 static Elf_Brandinfo
*elf_brand_list
[MAX_BRANDS
];
127 static const char DRAGONFLY_ABI_VENDOR
[] = "DragonFly";
128 static const char FREEBSD_ABI_VENDOR
[] = "FreeBSD";
130 Elf_Brandnote
__elfN(dragonfly_brandnote
) = {
131 .hdr
.n_namesz
= sizeof(DRAGONFLY_ABI_VENDOR
),
132 .hdr
.n_descsz
= sizeof(int32_t),
134 .vendor
= DRAGONFLY_ABI_VENDOR
,
135 .flags
= BN_TRANSLATE_OSREL
,
136 .trans_osrel
= __elfN(bsd_trans_osrel
),
139 Elf_Brandnote
__elfN(freebsd_brandnote
) = {
140 .hdr
.n_namesz
= sizeof(FREEBSD_ABI_VENDOR
),
141 .hdr
.n_descsz
= sizeof(int32_t),
143 .vendor
= FREEBSD_ABI_VENDOR
,
144 .flags
= BN_TRANSLATE_OSREL
,
145 .trans_osrel
= __elfN(bsd_trans_osrel
),
149 __elfN(insert_brand_entry
)(Elf_Brandinfo
*entry
)
153 for (i
= 0; i
< MAX_BRANDS
; i
++) {
154 if (elf_brand_list
[i
] == NULL
) {
155 elf_brand_list
[i
] = entry
;
159 if (i
== MAX_BRANDS
) {
160 uprintf("WARNING: %s: could not insert brandinfo entry: %p\n",
168 __elfN(remove_brand_entry
)(Elf_Brandinfo
*entry
)
172 for (i
= 0; i
< MAX_BRANDS
; i
++) {
173 if (elf_brand_list
[i
] == entry
) {
174 elf_brand_list
[i
] = NULL
;
184 * Check if an elf brand is being used anywhere in the system.
186 * Used by the linux emulation module unloader. This isn't safe from
189 struct elf_brand_inuse_info
{
191 Elf_Brandinfo
*entry
;
194 static int elf_brand_inuse_callback(struct proc
*p
, void *data
);
197 __elfN(brand_inuse
)(Elf_Brandinfo
*entry
)
199 struct elf_brand_inuse_info info
;
203 allproc_scan(elf_brand_inuse_callback
, &info
, 0);
209 elf_brand_inuse_callback(struct proc
*p
, void *data
)
211 struct elf_brand_inuse_info
*info
= data
;
213 if (p
->p_sysent
== info
->entry
->sysvec
) {
221 __elfN(check_header
)(const Elf_Ehdr
*hdr
)
227 hdr
->e_ident
[EI_CLASS
] != ELF_TARG_CLASS
||
228 hdr
->e_ident
[EI_DATA
] != ELF_TARG_DATA
||
229 hdr
->e_ident
[EI_VERSION
] != EV_CURRENT
||
230 hdr
->e_phentsize
!= sizeof(Elf_Phdr
) ||
231 hdr
->e_ehsize
!= sizeof(Elf_Ehdr
) ||
232 hdr
->e_version
!= ELF_TARG_VER
)
236 * Make sure we have at least one brand for this machine.
239 for (i
= 0; i
< MAX_BRANDS
; i
++) {
240 bi
= elf_brand_list
[i
];
241 if (bi
!= NULL
&& bi
->machine
== hdr
->e_machine
)
251 __elfN(load_section
)(struct proc
*p
, struct vmspace
*vmspace
, struct vnode
*vp
,
252 vm_offset_t offset
, caddr_t vmaddr
, size_t memsz
,
253 size_t filsz
, vm_prot_t prot
)
256 vm_offset_t map_addr
;
262 vm_offset_t file_addr
;
264 object
= vp
->v_object
;
268 * In most cases we will be able to use a shared lock on the
269 * object we are inserting into the map. The lock will be
270 * upgraded in situations where new VM pages must be allocated.
272 vm_object_hold_shared(object
);
276 * It's necessary to fail if the filsz + offset taken from the
277 * header is greater than the actual file pager object's size.
278 * If we were to allow this, then the vm_map_find() below would
279 * walk right off the end of the file object and into the ether.
281 * While I'm here, might as well check for something else that
282 * is invalid: filsz cannot be greater than memsz.
284 if ((off_t
)filsz
+ offset
> vp
->v_filesize
|| filsz
> memsz
) {
285 uprintf("elf_load_section: truncated ELF file\n");
286 vm_object_drop(object
);
290 map_addr
= trunc_page((vm_offset_t
)vmaddr
);
291 file_addr
= trunc_page(offset
);
294 * We have two choices. We can either clear the data in the last page
295 * of an oversized mapping, or we can start the anon mapping a page
296 * early and copy the initialized data into that first page. We
297 * choose the second..
300 map_len
= trunc_page(offset
+filsz
) - file_addr
;
302 map_len
= round_page(offset
+filsz
) - file_addr
;
305 vm_object_reference_locked(object
);
307 /* cow flags: don't dump readonly sections in core */
308 cow
= MAP_COPY_ON_WRITE
| MAP_PREFAULT
;
309 if ((prot
& VM_PROT_WRITE
) == 0)
310 cow
|= MAP_DISABLE_COREDUMP
;
312 cow
|= MAP_PREFAULT_RELOCK
;
314 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
315 vm_map_lock(&vmspace
->vm_map
);
316 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
318 file_addr
, /* file offset */
319 map_addr
, /* virtual start */
320 map_addr
+ map_len
,/* virtual end */
323 prot
, VM_PROT_ALL
, cow
);
324 vm_map_unlock(&vmspace
->vm_map
);
325 vm_map_entry_release(count
);
328 * NOTE: Object must have a hold ref when calling
329 * vm_object_deallocate().
331 if (rv
!= KERN_SUCCESS
) {
332 vm_object_drop(object
);
333 vm_object_deallocate(object
);
337 /* we can stop now if we've covered it all */
338 if (memsz
== filsz
) {
339 vm_object_drop(object
);
345 * We have to get the remaining bit of the file into the first part
346 * of the oversized map segment. This is normally because the .data
347 * segment in the file is extended to provide bss. It's a neat idea
348 * to try and save a page, but it's a pain in the behind to implement.
350 copy_len
= (offset
+ filsz
) - trunc_page(offset
+ filsz
);
351 map_addr
= trunc_page((vm_offset_t
)vmaddr
+ filsz
);
352 map_len
= round_page((vm_offset_t
)vmaddr
+ memsz
) - map_addr
;
354 /* This had damn well better be true! */
356 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
357 vm_map_lock(&vmspace
->vm_map
);
358 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
365 VM_PROT_ALL
, VM_PROT_ALL
, 0);
366 vm_map_unlock(&vmspace
->vm_map
);
367 vm_map_entry_release(count
);
368 if (rv
!= KERN_SUCCESS
) {
369 vm_object_drop(object
);
376 struct lwbuf lwb_cache
;
379 m
= vm_fault_object_page(object
, trunc_page(offset
+ filsz
),
380 VM_PROT_READ
, 0, &shared
, &error
);
381 vm_object_drop(object
);
383 lwb
= lwbuf_alloc(m
, &lwb_cache
);
384 error
= copyout((caddr_t
)lwbuf_kva(lwb
),
385 (caddr_t
)map_addr
, copy_len
);
390 vm_object_drop(object
);
394 * set it to the specified protection
397 vm_map_protect(&vmspace
->vm_map
,
398 map_addr
, map_addr
+ map_len
,
405 * Load the file "file" into memory. It may be either a shared object
408 * The "addr" reference parameter is in/out. On entry, it specifies
409 * the address where a shared object should be loaded. If the file is
410 * an executable, this value is ignored. On exit, "addr" specifies
411 * where the file was actually loaded.
413 * The "entry" reference parameter is out only. On exit, it specifies
414 * the entry point for the loaded file.
417 __elfN(load_file
)(struct proc
*p
, const char *file
, u_long
*addr
, u_long
*entry
)
420 struct nlookupdata nd
;
422 struct image_params image_params
;
424 const Elf_Ehdr
*hdr
= NULL
;
425 const Elf_Phdr
*phdr
= NULL
;
426 struct nlookupdata
*nd
;
427 struct vmspace
*vmspace
= p
->p_vmspace
;
429 struct image_params
*imgp
;
430 struct mount
*topmnt
;
433 u_long base_addr
= 0;
434 int error
, i
, numsegs
;
436 tempdata
= kmalloc(sizeof(*tempdata
), M_TEMP
, M_WAITOK
);
438 attr
= &tempdata
->attr
;
439 imgp
= &tempdata
->image_params
;
442 * Initialize part of the common data
446 imgp
->firstpage
= NULL
;
447 imgp
->image_header
= NULL
;
450 error
= nlookup_init(nd
, file
, UIO_SYSSPACE
, NLC_FOLLOW
);
454 error
= cache_vget(&nd
->nl_nch
, nd
->nl_cred
,
455 LK_SHARED
, &imgp
->vp
);
456 topmnt
= nd
->nl_nch
.mount
;
462 * Check permissions, modes, uid, etc on the file, and "open" it.
464 error
= exec_check_permissions(imgp
, topmnt
);
470 error
= exec_map_first_page(imgp
);
472 * Also make certain that the interpreter stays the same, so set
473 * its VTEXT flag, too.
476 vsetflags(imgp
->vp
, VTEXT
);
481 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
482 if ((error
= __elfN(check_header
)(hdr
)) != 0)
484 if (hdr
->e_type
== ET_DYN
)
486 else if (hdr
->e_type
== ET_EXEC
)
493 /* Only support headers that fit within first page for now */
494 /* (multiplication of two Elf_Half fields will not overflow) */
495 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
496 (hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
- hdr
->e_phoff
) {
501 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
502 if (!aligned(phdr
, Elf_Addr
)) {
507 for (i
= 0, numsegs
= 0; i
< hdr
->e_phnum
; i
++) {
508 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_memsz
!= 0) {
509 /* Loadable segment */
510 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
511 error
= __elfN(load_section
)(
512 p
, vmspace
, imgp
->vp
,
514 (caddr_t
)phdr
[i
].p_vaddr
+
517 phdr
[i
].p_filesz
, prot
);
521 * Establish the base address if this is the
525 base_addr
= trunc_page(phdr
[i
].p_vaddr
+ rbase
);
530 *entry
= (unsigned long)hdr
->e_entry
+ rbase
;
534 exec_unmap_first_page(imgp
);
539 kfree(tempdata
, M_TEMP
);
544 static Elf_Brandinfo
*
545 __elfN(get_brandinfo
)(struct image_params
*imgp
, const char *interp
,
548 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
553 /* We support four types of branding -- (1) the ELF EI_OSABI field
554 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
555 * branding within the ELF header, (3) path of the `interp_path' field,
556 * and (4) the ".note.ABI-tag" ELF section.
559 /* Look for an ".note.ABI-tag" ELF section */
560 for (i
= 0; i
< MAX_BRANDS
; i
++) {
561 bi
= elf_brand_list
[i
];
565 if (hdr
->e_machine
== bi
->machine
&& (bi
->flags
&
566 (BI_BRAND_NOTE
|BI_BRAND_NOTE_MANDATORY
)) != 0) {
567 ret
= __elfN(check_note
)(imgp
, bi
->brand_note
, osrel
);
573 /* If the executable has a brand, search for it in the brand list. */
574 for (i
= 0; i
< MAX_BRANDS
; i
++) {
575 bi
= elf_brand_list
[i
];
577 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
579 if (hdr
->e_machine
== bi
->machine
&&
580 (hdr
->e_ident
[EI_OSABI
] == bi
->brand
||
581 strncmp((const char *)&hdr
->e_ident
[OLD_EI_BRAND
],
582 bi
->compat_3_brand
, strlen(bi
->compat_3_brand
)) == 0))
586 /* Lacking a known brand, search for a recognized interpreter. */
587 if (interp
!= NULL
) {
588 for (i
= 0; i
< MAX_BRANDS
; i
++) {
589 bi
= elf_brand_list
[i
];
591 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
593 if (hdr
->e_machine
== bi
->machine
&&
594 strcmp(interp
, bi
->interp_path
) == 0)
599 /* Lacking a recognized interpreter, try the default brand */
600 for (i
= 0; i
< MAX_BRANDS
; i
++) {
601 bi
= elf_brand_list
[i
];
603 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
605 if (hdr
->e_machine
== bi
->machine
&&
606 __elfN(fallback_brand
) == bi
->brand
)
613 __CONCAT(exec_
,__elfN(imgact
))(struct image_params
*imgp
)
615 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*) imgp
->image_header
;
616 const Elf_Phdr
*phdr
;
617 Elf_Auxargs
*elf_auxargs
;
618 struct vmspace
*vmspace
;
620 u_long text_size
= 0, data_size
= 0, total_size
= 0;
621 u_long text_addr
= 0, data_addr
= 0;
622 u_long seg_size
, seg_addr
;
623 u_long addr
, baddr
, et_dyn_addr
= 0, entry
= 0, proghdr
= 0;
628 const char *newinterp
= NULL
;
629 Elf_Brandinfo
*brand_info
;
633 * Do we have a valid ELF header ?
635 * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later if a particular
636 * brand doesn't support it. Both DragonFly platforms do by default.
638 if (__elfN(check_header
)(hdr
) != 0 ||
639 (hdr
->e_type
!= ET_EXEC
&& hdr
->e_type
!= ET_DYN
))
643 * From here on down, we return an errno, not -1, as we've
644 * detected an ELF file.
647 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
648 (hdr
->e_phoff
+ hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
) {
649 /* Only support headers in first page for now */
652 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
653 if (!aligned(phdr
, Elf_Addr
))
657 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
658 if (phdr
[i
].p_type
== PT_LOAD
) {
660 baddr
= phdr
[i
].p_vaddr
;
664 if (phdr
[i
].p_type
== PT_INTERP
) {
666 * If interp is already defined there are more than
667 * one PT_INTERP program headers present. Take only
668 * the first one and ignore the rest.
673 if (phdr
[i
].p_filesz
== 0 ||
674 phdr
[i
].p_filesz
> PAGE_SIZE
||
675 phdr
[i
].p_filesz
> MAXPATHLEN
)
678 interp
= kmalloc(phdr
[i
].p_filesz
, M_TEMP
, M_WAITOK
);
679 failure
= extract_interpreter(imgp
, &phdr
[i
], interp
);
681 kfree(interp
, M_TEMP
);
688 brand_info
= __elfN(get_brandinfo
)(imgp
, interp
, &osrel
);
689 if (brand_info
== NULL
) {
690 uprintf("ELF binary type \"%u\" not known.\n",
691 hdr
->e_ident
[EI_OSABI
]);
693 kfree(interp
, M_TEMP
);
696 if (hdr
->e_type
== ET_DYN
) {
697 if ((brand_info
->flags
& BI_CAN_EXEC_DYN
) == 0) {
699 kfree(interp
, M_TEMP
);
703 * If p_vaddr field of PT_LOAD program header is zero and type of an
704 * executale is ET_DYN, then it must be a position independent
705 * executable (PIE). In this case the system needs to pick a base
706 * address for us. Set et_dyn_addr to non-zero and choose the actual
707 * address when we are ready.
713 if (interp
!= NULL
&& brand_info
->interp_newpath
!= NULL
)
714 newinterp
= brand_info
->interp_newpath
;
716 exec_new_vmspace(imgp
, NULL
);
719 * Yeah, I'm paranoid. There is every reason in the world to get
720 * VTEXT now since from here on out, there are places we can have
721 * a context switch. Better safe than sorry; I really don't want
722 * the file to change while it's being loaded.
724 vsetflags(imgp
->vp
, VTEXT
);
726 vmspace
= imgp
->proc
->p_vmspace
;
727 /* Choose the base address for dynamic executables if we need to. */
729 et_dyn_addr
= pie_base_hint(imgp
->proc
);
731 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
732 switch (phdr
[i
].p_type
) {
733 case PT_LOAD
: /* Loadable segment */
734 if (phdr
[i
].p_memsz
== 0)
736 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
738 if ((error
= __elfN(load_section
)(
743 (caddr_t
)phdr
[i
].p_vaddr
+ et_dyn_addr
,
748 kfree (interp
, M_TEMP
);
753 * If this segment contains the program headers,
754 * remember their virtual address for the AT_PHDR
755 * aux entry. Static binaries don't usually include
758 if (phdr
[i
].p_offset
== 0 &&
759 hdr
->e_phoff
+ hdr
->e_phnum
* hdr
->e_phentsize
761 proghdr
= phdr
[i
].p_vaddr
+ hdr
->e_phoff
+
764 seg_addr
= trunc_page(phdr
[i
].p_vaddr
+ et_dyn_addr
);
765 seg_size
= round_page(phdr
[i
].p_memsz
+
766 phdr
[i
].p_vaddr
+ et_dyn_addr
- seg_addr
);
769 * Is this .text or .data? We can't use
770 * VM_PROT_WRITE or VM_PROT_EXEC, it breaks the
771 * alpha terribly and possibly does other bad
772 * things so we stick to the old way of figuring
773 * it out: If the segment contains the program
774 * entry point, it's a text segment, otherwise it
777 * Note that obreak() assumes that data_addr +
778 * data_size == end of data load area, and the ELF
779 * file format expects segments to be sorted by
780 * address. If multiple data segments exist, the
781 * last one will be used.
783 if (hdr
->e_entry
>= phdr
[i
].p_vaddr
&&
784 hdr
->e_entry
< (phdr
[i
].p_vaddr
+
786 text_size
= seg_size
;
787 text_addr
= seg_addr
;
788 entry
= (u_long
)hdr
->e_entry
+ et_dyn_addr
;
790 data_size
= seg_size
;
791 data_addr
= seg_addr
;
793 total_size
+= seg_size
;
796 * Check limits. It should be safe to check the
797 * limits after loading the segment since we do
798 * not actually fault in all the segment's pages.
801 imgp
->proc
->p_rlimit
[RLIMIT_DATA
].rlim_cur
||
802 text_size
> maxtsiz
||
804 imgp
->proc
->p_rlimit
[RLIMIT_VMEM
].rlim_cur
) {
806 kfree(interp
, M_TEMP
);
811 case PT_PHDR
: /* Program header table info */
812 proghdr
= phdr
[i
].p_vaddr
+ et_dyn_addr
;
819 vmspace
->vm_tsize
= text_size
>> PAGE_SHIFT
;
820 vmspace
->vm_taddr
= (caddr_t
)(uintptr_t)text_addr
;
821 vmspace
->vm_dsize
= data_size
>> PAGE_SHIFT
;
822 vmspace
->vm_daddr
= (caddr_t
)(uintptr_t)data_addr
;
824 addr
= ELF_RTLD_ADDR(vmspace
);
826 imgp
->entry_addr
= entry
;
828 imgp
->proc
->p_sysent
= brand_info
->sysvec
;
830 if (interp
!= NULL
) {
831 int have_interp
= FALSE
;
832 if (brand_info
->emul_path
!= NULL
&&
833 brand_info
->emul_path
[0] != '\0') {
834 path
= kmalloc(MAXPATHLEN
, M_TEMP
, M_WAITOK
);
835 ksnprintf(path
, MAXPATHLEN
, "%s%s",
836 brand_info
->emul_path
, interp
);
837 error
= __elfN(load_file
)(imgp
->proc
, path
, &addr
,
843 if (!have_interp
&& newinterp
!= NULL
) {
844 error
= __elfN(load_file
)(imgp
->proc
, newinterp
,
845 &addr
, &imgp
->entry_addr
);
850 error
= __elfN(load_file
)(imgp
->proc
, interp
, &addr
,
854 uprintf("ELF interpreter %s not found\n", interp
);
855 kfree(interp
, M_TEMP
);
858 kfree(interp
, M_TEMP
);
863 * Construct auxargs table (used by the fixup routine)
865 elf_auxargs
= kmalloc(sizeof(Elf_Auxargs
), M_TEMP
, M_WAITOK
);
866 elf_auxargs
->execfd
= -1;
867 elf_auxargs
->phdr
= proghdr
;
868 elf_auxargs
->phent
= hdr
->e_phentsize
;
869 elf_auxargs
->phnum
= hdr
->e_phnum
;
870 elf_auxargs
->pagesz
= PAGE_SIZE
;
871 elf_auxargs
->base
= addr
;
872 elf_auxargs
->flags
= 0;
873 elf_auxargs
->entry
= entry
;
875 imgp
->auxargs
= elf_auxargs
;
876 imgp
->interpreted
= 0;
877 imgp
->proc
->p_osrel
= osrel
;
883 __elfN(dragonfly_fixup
)(register_t
**stack_base
, struct image_params
*imgp
)
885 Elf_Auxargs
*args
= (Elf_Auxargs
*)imgp
->auxargs
;
889 base
= (Elf_Addr
*)*stack_base
;
890 pos
= base
+ (imgp
->args
->argc
+ imgp
->args
->envc
+ 2);
892 if (args
->execfd
!= -1)
893 AUXARGS_ENTRY(pos
, AT_EXECFD
, args
->execfd
);
894 AUXARGS_ENTRY(pos
, AT_PHDR
, args
->phdr
);
895 AUXARGS_ENTRY(pos
, AT_PHENT
, args
->phent
);
896 AUXARGS_ENTRY(pos
, AT_PHNUM
, args
->phnum
);
897 AUXARGS_ENTRY(pos
, AT_PAGESZ
, args
->pagesz
);
898 AUXARGS_ENTRY(pos
, AT_FLAGS
, args
->flags
);
899 AUXARGS_ENTRY(pos
, AT_ENTRY
, args
->entry
);
900 AUXARGS_ENTRY(pos
, AT_BASE
, args
->base
);
901 if (imgp
->execpathp
!= 0)
902 AUXARGS_ENTRY(pos
, AT_EXECPATH
, imgp
->execpathp
);
903 AUXARGS_ENTRY(pos
, AT_OSRELDATE
, osreldate
);
904 AUXARGS_ENTRY(pos
, AT_NULL
, 0);
906 kfree(imgp
->auxargs
, M_TEMP
);
907 imgp
->auxargs
= NULL
;
910 suword64(base
, (long)imgp
->args
->argc
);
911 *stack_base
= (register_t
*)base
;
916 * Code for generating ELF core dumps.
919 typedef int (*segment_callback
)(vm_map_entry_t
, void *);
921 /* Closure for cb_put_phdr(). */
922 struct phdr_closure
{
923 Elf_Phdr
*phdr
; /* Program header to fill in (incremented) */
924 Elf_Phdr
*phdr_max
; /* Pointer bound for error check */
925 Elf_Off offset
; /* Offset of segment in core file */
928 /* Closure for cb_size_segment(). */
929 struct sseg_closure
{
930 int count
; /* Count of writable segments. */
931 size_t vsize
; /* Total size of all writable segments. */
934 /* Closure for cb_put_fp(). */
937 struct vn_hdr
*vnh_max
;
942 typedef struct elf_buf
{
948 static void *target_reserve(elf_buf_t target
, size_t bytes
, int *error
);
950 static int cb_put_phdr (vm_map_entry_t
, void *);
951 static int cb_size_segment (vm_map_entry_t
, void *);
952 static int cb_fpcount_segment(vm_map_entry_t
, void *);
953 static int cb_put_fp(vm_map_entry_t
, void *);
956 static int each_segment (struct proc
*, segment_callback
, void *, int);
957 static int __elfN(corehdr
)(struct lwp
*, int, struct file
*, struct ucred
*,
959 enum putmode
{ WRITE
, DRYRUN
};
960 static int __elfN(puthdr
)(struct lwp
*, elf_buf_t
, int sig
, enum putmode
,
962 static int elf_putallnotes(struct lwp
*, elf_buf_t
, int, enum putmode
);
963 static int __elfN(putnote
)(elf_buf_t
, const char *, int, const void *, size_t);
965 static int elf_putsigs(struct lwp
*, elf_buf_t
);
966 static int elf_puttextvp(struct proc
*, elf_buf_t
);
967 static int elf_putfiles(struct proc
*, elf_buf_t
, struct file
*);
970 __elfN(coredump
)(struct lwp
*lp
, int sig
, struct vnode
*vp
, off_t limit
)
975 if ((error
= falloc(NULL
, &fp
, NULL
)) != 0)
977 fsetcred(fp
, lp
->lwp_proc
->p_ucred
);
982 fp
->f_type
= DTYPE_VNODE
;
983 fp
->f_flag
= O_CREAT
|O_WRONLY
|O_NOFOLLOW
;
984 fp
->f_ops
= &vnode_fileops
;
987 error
= generic_elf_coredump(lp
, sig
, fp
, limit
);
991 fp
->f_ops
= &badfileops
;
998 generic_elf_coredump(struct lwp
*lp
, int sig
, struct file
*fp
, off_t limit
)
1000 struct proc
*p
= lp
->lwp_proc
;
1001 struct ucred
*cred
= p
->p_ucred
;
1003 struct sseg_closure seginfo
;
1004 struct elf_buf target
;
1007 kprintf("can't dump core - null fp\n");
1010 * Size the program segments
1014 each_segment(p
, cb_size_segment
, &seginfo
, 1);
1017 * Calculate the size of the core file header area by making
1018 * a dry run of generating it. Nothing is written, but the
1019 * size is calculated.
1021 bzero(&target
, sizeof(target
));
1022 __elfN(puthdr
)(lp
, &target
, sig
, DRYRUN
, seginfo
.count
, fp
);
1024 if (target
.off
+ seginfo
.vsize
>= limit
)
1028 * Allocate memory for building the header, fill it up,
1031 target
.off_max
= target
.off
;
1033 target
.buf
= kmalloc(target
.off_max
, M_TEMP
, M_WAITOK
|M_ZERO
);
1035 error
= __elfN(corehdr
)(lp
, sig
, fp
, cred
, seginfo
.count
, &target
);
1037 /* Write the contents of all of the writable segments. */
1043 php
= (Elf_Phdr
*)(target
.buf
+ sizeof(Elf_Ehdr
)) + 1;
1044 for (i
= 0; i
< seginfo
.count
; i
++) {
1045 error
= fp_write(fp
, (caddr_t
)php
->p_vaddr
,
1046 php
->p_filesz
, &nbytes
, UIO_USERSPACE
);
1052 kfree(target
.buf
, M_TEMP
);
1058 * A callback for each_segment() to write out the segment's
1059 * program header entry.
1062 cb_put_phdr(vm_map_entry_t entry
, void *closure
)
1064 struct phdr_closure
*phc
= closure
;
1065 Elf_Phdr
*phdr
= phc
->phdr
;
1067 if (phc
->phdr
== phc
->phdr_max
)
1070 phc
->offset
= round_page(phc
->offset
);
1072 phdr
->p_type
= PT_LOAD
;
1073 phdr
->p_offset
= phc
->offset
;
1074 phdr
->p_vaddr
= entry
->start
;
1076 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1077 phdr
->p_align
= PAGE_SIZE
;
1078 phdr
->p_flags
= __elfN(untrans_prot
)(entry
->protection
);
1080 phc
->offset
+= phdr
->p_filesz
;
1086 * A callback for each_writable_segment() to gather information about
1087 * the number of segments and their total size.
1090 cb_size_segment(vm_map_entry_t entry
, void *closure
)
1092 struct sseg_closure
*ssc
= closure
;
1095 ssc
->vsize
+= entry
->end
- entry
->start
;
1100 * A callback for each_segment() to gather information about
1101 * the number of text segments.
1104 cb_fpcount_segment(vm_map_entry_t entry
, void *closure
)
1106 int *count
= closure
;
1109 if (entry
->object
.vm_object
->type
== OBJT_VNODE
) {
1110 vp
= (struct vnode
*)entry
->object
.vm_object
->handle
;
1111 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1119 cb_put_fp(vm_map_entry_t entry
, void *closure
)
1121 struct fp_closure
*fpc
= closure
;
1122 struct vn_hdr
*vnh
= fpc
->vnh
;
1123 Elf_Phdr
*phdr
= &vnh
->vnh_phdr
;
1128 * If an entry represents a vnode then write out a file handle.
1130 * If we are checkpointing a checkpoint-restored program we do
1131 * NOT record the filehandle for the old checkpoint vnode (which
1132 * is mapped all over the place). Instead we rely on the fact
1133 * that a checkpoint-restored program does not mmap() the checkpt
1134 * vnode NOCORE, so its contents will be written out to the
1135 * new checkpoint file. This is necessary because the 'old'
1136 * checkpoint file is typically destroyed when a new one is created
1137 * and thus cannot be used to restore the new checkpoint.
1139 * Theoretically we could create a chain of checkpoint files and
1140 * operate the checkpointing operation kinda like an incremental
1141 * checkpoint, but a checkpoint restore would then likely wind up
1142 * referencing many prior checkpoint files and that is a bit over
1143 * the top for the purpose of the checkpoint API.
1145 if (entry
->object
.vm_object
->type
== OBJT_VNODE
) {
1146 vp
= (struct vnode
*)entry
->object
.vm_object
->handle
;
1147 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1149 if (vnh
== fpc
->vnh_max
)
1153 vnh
->vnh_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1154 error
= VFS_VPTOFH(vp
, &vnh
->vnh_fh
.fh_fid
);
1156 char *freepath
, *fullpath
;
1159 * This is actually a relatively common occurance,
1160 * so don't spew on the console by default.
1162 if (vn_fullpath(curproc
, vp
, &fullpath
, &freepath
, 0)) {
1164 kprintf("Warning: coredump, error %d: cannot store file handle for vnode %p\n", error
, vp
);
1167 kprintf("Warning: coredump, error %d: cannot store file handle for %s\n", error
, fullpath
);
1168 kfree(freepath
, M_TEMP
);
1173 phdr
->p_type
= PT_LOAD
;
1174 phdr
->p_offset
= 0; /* not written to core */
1175 phdr
->p_vaddr
= entry
->start
;
1177 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1178 phdr
->p_align
= PAGE_SIZE
;
1180 if (entry
->protection
& VM_PROT_READ
)
1181 phdr
->p_flags
|= PF_R
;
1182 if (entry
->protection
& VM_PROT_WRITE
)
1183 phdr
->p_flags
|= PF_W
;
1184 if (entry
->protection
& VM_PROT_EXECUTE
)
1185 phdr
->p_flags
|= PF_X
;
1193 * For each writable segment in the process's memory map, call the given
1194 * function with a pointer to the map entry and some arbitrary
1195 * caller-supplied data.
1198 each_segment(struct proc
*p
, segment_callback func
, void *closure
, int writable
)
1201 vm_map_t map
= &p
->p_vmspace
->vm_map
;
1202 vm_map_entry_t entry
;
1204 for (entry
= map
->header
.next
; error
== 0 && entry
!= &map
->header
;
1205 entry
= entry
->next
) {
1211 * Don't dump inaccessible mappings, deal with legacy
1214 * Note that read-only segments related to the elf binary
1215 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1216 * need to arbitrarily ignore such segments.
1218 if (elf_legacy_coredump
) {
1219 if (writable
&& (entry
->protection
& VM_PROT_RW
) != VM_PROT_RW
)
1222 if (writable
&& (entry
->protection
& VM_PROT_ALL
) == 0)
1227 * Dont include memory segment in the coredump if
1228 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1231 * Currently we only dump normal VM object maps. We do
1232 * not dump submaps or virtual page tables.
1234 if (writable
&& (entry
->eflags
& MAP_ENTRY_NOCOREDUMP
))
1236 if (entry
->maptype
!= VM_MAPTYPE_NORMAL
)
1238 if ((obj
= entry
->object
.vm_object
) == NULL
)
1242 * Find the bottom-most object, leaving the base object
1243 * and the bottom-most object held (but only one hold
1244 * if they happen to be the same).
1246 vm_object_hold_shared(obj
);
1249 while (lobj
&& (tobj
= lobj
->backing_object
) != NULL
) {
1250 KKASSERT(tobj
!= obj
);
1251 vm_object_hold_shared(tobj
);
1252 if (tobj
== lobj
->backing_object
) {
1254 vm_object_lock_swap();
1255 vm_object_drop(lobj
);
1259 vm_object_drop(tobj
);
1264 * The callback only applies to default, swap, or vnode
1265 * objects. Other types of objects such as memory-mapped
1266 * devices are ignored.
1268 if (lobj
->type
== OBJT_DEFAULT
|| lobj
->type
== OBJT_SWAP
||
1269 lobj
->type
== OBJT_VNODE
) {
1270 error
= (*func
)(entry
, closure
);
1273 vm_object_drop(lobj
);
1274 vm_object_drop(obj
);
1281 target_reserve(elf_buf_t target
, size_t bytes
, int *error
)
1286 if (target
->off
+ bytes
> target
->off_max
)
1289 res
= target
->buf
+ target
->off
;
1291 target
->off
+= bytes
;
1296 * Write the core file header to the file, including padding up to
1297 * the page boundary.
1300 __elfN(corehdr
)(struct lwp
*lp
, int sig
, struct file
*fp
, struct ucred
*cred
,
1301 int numsegs
, elf_buf_t target
)
1307 * Fill in the header. The fp is passed so we can detect and flag
1308 * a checkpoint file pointer within the core file itself, because
1309 * it may not be restored from the same file handle.
1311 error
= __elfN(puthdr
)(lp
, target
, sig
, WRITE
, numsegs
, fp
);
1313 /* Write it to the core file. */
1315 error
= fp_write(fp
, target
->buf
, target
->off
, &nbytes
,
1322 __elfN(puthdr
)(struct lwp
*lp
, elf_buf_t target
, int sig
, enum putmode mode
,
1323 int numsegs
, struct file
*fp
)
1325 struct proc
*p
= lp
->lwp_proc
;
1333 ehdr
= target_reserve(target
, sizeof(Elf_Ehdr
), &error
);
1335 phoff
= target
->off
;
1336 phdr
= target_reserve(target
, (numsegs
+ 1) * sizeof(Elf_Phdr
), &error
);
1338 noteoff
= target
->off
;
1340 elf_putallnotes(lp
, target
, sig
, mode
);
1341 notesz
= target
->off
- noteoff
;
1344 * put extra cruft for dumping process state here
1345 * - we really want it be before all the program
1347 * - we just need to update the offset accordingly
1348 * and GDB will be none the wiser.
1351 error
= elf_puttextvp(p
, target
);
1353 error
= elf_putsigs(lp
, target
);
1355 error
= elf_putfiles(p
, target
, fp
);
1358 * Align up to a page boundary for the program segments. The
1359 * actual data will be written to the outptu file, not to elf_buf_t,
1360 * so we do not have to do any further bounds checking.
1362 target
->off
= round_page(target
->off
);
1363 if (error
== 0 && ehdr
!= NULL
) {
1365 * Fill in the ELF header.
1367 ehdr
->e_ident
[EI_MAG0
] = ELFMAG0
;
1368 ehdr
->e_ident
[EI_MAG1
] = ELFMAG1
;
1369 ehdr
->e_ident
[EI_MAG2
] = ELFMAG2
;
1370 ehdr
->e_ident
[EI_MAG3
] = ELFMAG3
;
1371 ehdr
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1372 ehdr
->e_ident
[EI_DATA
] = ELF_DATA
;
1373 ehdr
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1374 ehdr
->e_ident
[EI_OSABI
] = ELFOSABI_NONE
;
1375 ehdr
->e_ident
[EI_ABIVERSION
] = 0;
1376 ehdr
->e_ident
[EI_PAD
] = 0;
1377 ehdr
->e_type
= ET_CORE
;
1378 ehdr
->e_machine
= ELF_ARCH
;
1379 ehdr
->e_version
= EV_CURRENT
;
1381 ehdr
->e_phoff
= phoff
;
1383 ehdr
->e_ehsize
= sizeof(Elf_Ehdr
);
1384 ehdr
->e_phentsize
= sizeof(Elf_Phdr
);
1385 ehdr
->e_phnum
= numsegs
+ 1;
1386 ehdr
->e_shentsize
= sizeof(Elf_Shdr
);
1388 ehdr
->e_shstrndx
= SHN_UNDEF
;
1390 if (error
== 0 && phdr
!= NULL
) {
1392 * Fill in the program header entries.
1394 struct phdr_closure phc
;
1396 /* The note segement. */
1397 phdr
->p_type
= PT_NOTE
;
1398 phdr
->p_offset
= noteoff
;
1401 phdr
->p_filesz
= notesz
;
1407 /* All the writable segments from the program. */
1409 phc
.phdr_max
= phdr
+ numsegs
;
1410 phc
.offset
= target
->off
;
1411 each_segment(p
, cb_put_phdr
, &phc
, 1);
1417 * Append core dump notes to target ELF buffer or simply update target size
1418 * if dryrun selected.
1421 elf_putallnotes(struct lwp
*corelp
, elf_buf_t target
, int sig
,
1424 struct proc
*p
= corelp
->lwp_proc
;
1428 prfpregset_t fpregs
;
1432 prfpregset_t
*fpregs
;
1437 * Allocate temporary storage for notes on heap to avoid stack overflow.
1439 if (mode
!= DRYRUN
) {
1440 tmpdata
= kmalloc(sizeof(*tmpdata
), M_TEMP
, M_ZERO
| M_WAITOK
);
1441 status
= &tmpdata
->status
;
1442 fpregs
= &tmpdata
->fpregs
;
1443 psinfo
= &tmpdata
->psinfo
;
1452 * Append LWP-agnostic note.
1454 if (mode
!= DRYRUN
) {
1455 psinfo
->pr_version
= PRPSINFO_VERSION
;
1456 psinfo
->pr_psinfosz
= sizeof(prpsinfo_t
);
1457 strlcpy(psinfo
->pr_fname
, p
->p_comm
,
1458 sizeof(psinfo
->pr_fname
));
1460 * XXX - We don't fill in the command line arguments
1463 strlcpy(psinfo
->pr_psargs
, p
->p_comm
,
1464 sizeof(psinfo
->pr_psargs
));
1467 __elfN(putnote
)(target
, "CORE", NT_PRPSINFO
, psinfo
, sizeof *psinfo
);
1472 * Append first note for LWP that triggered core so that it is
1473 * the selected one when the debugger starts.
1475 if (mode
!= DRYRUN
) {
1476 status
->pr_version
= PRSTATUS_VERSION
;
1477 status
->pr_statussz
= sizeof(prstatus_t
);
1478 status
->pr_gregsetsz
= sizeof(gregset_t
);
1479 status
->pr_fpregsetsz
= sizeof(fpregset_t
);
1480 status
->pr_osreldate
= osreldate
;
1481 status
->pr_cursig
= sig
;
1482 status
->pr_pid
= corelp
->lwp_tid
;
1483 fill_regs(corelp
, &status
->pr_reg
);
1484 fill_fpregs(corelp
, fpregs
);
1487 __elfN(putnote
)(target
, "CORE", NT_PRSTATUS
, status
, sizeof *status
);
1491 __elfN(putnote
)(target
, "CORE", NT_FPREGSET
, fpregs
, sizeof *fpregs
);
1496 * Then append notes for other LWPs.
1498 FOREACH_LWP_IN_PROC(lp
, p
) {
1501 /* skip lwps being created */
1502 if (lp
->lwp_thread
== NULL
)
1504 if (mode
!= DRYRUN
) {
1505 status
->pr_pid
= lp
->lwp_tid
;
1506 fill_regs(lp
, &status
->pr_reg
);
1507 fill_fpregs(lp
, fpregs
);
1509 error
= __elfN(putnote
)(target
, "CORE", NT_PRSTATUS
,
1510 status
, sizeof *status
);
1513 error
= __elfN(putnote
)(target
, "CORE", NT_FPREGSET
,
1514 fpregs
, sizeof *fpregs
);
1520 if (tmpdata
!= NULL
)
1521 kfree(tmpdata
, M_TEMP
);
1526 * Generate a note sub-structure.
1528 * NOTE: 4-byte alignment.
1531 __elfN(putnote
)(elf_buf_t target
, const char *name
, int type
,
1532 const void *desc
, size_t descsz
)
1538 note
.n_namesz
= strlen(name
) + 1;
1539 note
.n_descsz
= descsz
;
1541 dst
= target_reserve(target
, sizeof(note
), &error
);
1543 bcopy(¬e
, dst
, sizeof note
);
1544 dst
= target_reserve(target
, note
.n_namesz
, &error
);
1546 bcopy(name
, dst
, note
.n_namesz
);
1547 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1548 dst
= target_reserve(target
, note
.n_descsz
, &error
);
1550 bcopy(desc
, dst
, note
.n_descsz
);
1551 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1557 elf_putsigs(struct lwp
*lp
, elf_buf_t target
)
1559 /* XXX lwp handle more than one lwp */
1560 struct proc
*p
= lp
->lwp_proc
;
1562 struct ckpt_siginfo
*csi
;
1564 csi
= target_reserve(target
, sizeof(struct ckpt_siginfo
), &error
);
1566 csi
->csi_ckptpisz
= sizeof(struct ckpt_siginfo
);
1567 bcopy(p
->p_sigacts
, &csi
->csi_sigacts
, sizeof(*p
->p_sigacts
));
1568 bcopy(&p
->p_realtimer
, &csi
->csi_itimerval
, sizeof(struct itimerval
));
1569 bcopy(&lp
->lwp_sigmask
, &csi
->csi_sigmask
,
1571 csi
->csi_sigparent
= p
->p_sigparent
;
1577 elf_putfiles(struct proc
*p
, elf_buf_t target
, struct file
*ckfp
)
1579 thread_t td
= curthread
;
1582 struct ckpt_filehdr
*cfh
= NULL
;
1583 struct ckpt_fileinfo
*cfi
;
1588 * the duplicated loop is gross, but it was the only way
1589 * to eliminate uninitialized variable warnings
1591 cfh
= target_reserve(target
, sizeof(struct ckpt_filehdr
), &error
);
1593 cfh
->cfh_nfiles
= 0;
1597 * ignore STDIN/STDERR/STDOUT.
1599 KKASSERT(td
->td_proc
== p
);
1600 for (i
= 3; error
== 0 && i
< p
->p_fd
->fd_nfiles
; i
++) {
1601 fp
= holdfp(td
, i
, -1);
1605 * XXX Only checkpoint vnodes for now.
1607 if (fp
->f_type
!= DTYPE_VNODE
) {
1611 cfi
= target_reserve(target
, sizeof(struct ckpt_fileinfo
),
1617 cfi
->cfi_index
= -1;
1618 cfi
->cfi_type
= fp
->f_type
;
1619 cfi
->cfi_flags
= fp
->f_flag
;
1620 cfi
->cfi_offset
= fp
->f_offset
;
1621 cfi
->cfi_ckflags
= 0;
1624 cfi
->cfi_ckflags
|= CKFIF_ISCKPTFD
;
1625 /* f_count and f_msgcount should not be saved/restored */
1626 /* XXX save cred info */
1628 switch(fp
->f_type
) {
1630 vp
= (struct vnode
*)fp
->f_data
;
1632 * it looks like a bug in ptrace is marking
1633 * a non-vnode as a vnode - until we find the
1634 * root cause this will at least prevent
1635 * further panics from truss
1637 if (vp
== NULL
|| vp
->v_mount
== NULL
)
1641 cfi
->cfi_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1642 error
= VFS_VPTOFH(vp
, &cfi
->cfi_fh
.fh_fid
);
1653 elf_puttextvp(struct proc
*p
, elf_buf_t target
)
1657 struct fp_closure fpc
;
1658 struct ckpt_vminfo
*vminfo
;
1660 vminfo
= target_reserve(target
, sizeof(struct ckpt_vminfo
), &error
);
1661 if (vminfo
!= NULL
) {
1662 vminfo
->cvm_dsize
= p
->p_vmspace
->vm_dsize
;
1663 vminfo
->cvm_tsize
= p
->p_vmspace
->vm_tsize
;
1664 vminfo
->cvm_daddr
= p
->p_vmspace
->vm_daddr
;
1665 vminfo
->cvm_taddr
= p
->p_vmspace
->vm_taddr
;
1669 vn_count
= target_reserve(target
, sizeof(int), &error
);
1670 if (target
->buf
!= NULL
) {
1671 fpc
.vnh
= (struct vn_hdr
*)(target
->buf
+ target
->off
);
1672 fpc
.vnh_max
= fpc
.vnh
+
1673 (target
->off_max
- target
->off
) / sizeof(struct vn_hdr
);
1674 error
= each_segment(p
, cb_put_fp
, &fpc
, 0);
1676 *vn_count
= fpc
.count
;
1678 error
= each_segment(p
, cb_fpcount_segment
, &fpc
.count
, 0);
1680 target
->off
+= fpc
.count
* sizeof(struct vn_hdr
);
1685 * Try to find the appropriate ABI-note section for checknote,
1686 * The entire image is searched if necessary, not only the first page.
1689 __elfN(check_note
)(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
1692 boolean_t valid_note_found
;
1693 const Elf_Phdr
*phdr
, *pnote
;
1694 const Elf_Ehdr
*hdr
;
1697 valid_note_found
= FALSE
;
1698 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
1699 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
1701 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
1702 if (phdr
[i
].p_type
== PT_NOTE
) {
1704 valid_note_found
= check_PT_NOTE (imgp
, checknote
,
1706 if (valid_note_found
)
1710 return valid_note_found
;
1714 * Be careful not to create new overflow conditions when checking
1718 note_overflow(const Elf_Note
*note
, size_t maxsize
)
1720 if (sizeof(*note
) > maxsize
)
1722 if (note
->n_namesz
> maxsize
- sizeof(*note
))
1728 hdr_overflow(__ElfN(Off
) off_beg
, __ElfN(Size
) size
)
1730 __ElfN(Off
) off_end
;
1732 off_end
= off_beg
+ size
;
1733 if (off_end
< off_beg
)
1739 check_PT_NOTE(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
1740 int32_t *osrel
, const Elf_Phdr
* pnote
)
1742 boolean_t limited_to_first_page
;
1743 boolean_t found
= FALSE
;
1744 const Elf_Note
*note
, *note0
, *note_end
;
1745 const char *note_name
;
1746 __ElfN(Off
) noteloc
, firstloc
;
1747 __ElfN(Size
) notesz
, firstlen
, endbyte
;
1749 struct lwbuf lwb_cache
;
1754 if (hdr_overflow(pnote
->p_offset
, pnote
->p_filesz
))
1756 notesz
= pnote
->p_filesz
;
1757 noteloc
= pnote
->p_offset
;
1758 endbyte
= noteloc
+ notesz
;
1759 limited_to_first_page
= noteloc
< PAGE_SIZE
&& endbyte
< PAGE_SIZE
;
1761 if (limited_to_first_page
) {
1762 note
= (const Elf_Note
*)(imgp
->image_header
+ noteloc
);
1763 note_end
= (const Elf_Note
*)(imgp
->image_header
+ endbyte
);
1766 firstloc
= noteloc
& PAGE_MASK
;
1767 firstlen
= PAGE_SIZE
- firstloc
;
1768 if (notesz
< sizeof(Elf_Note
) || notesz
> PAGE_SIZE
)
1772 if (exec_map_page(imgp
, noteloc
>> PAGE_SHIFT
, &lwb
, &page
))
1774 if (firstlen
< notesz
) { /* crosses page boundary */
1775 data
= kmalloc(notesz
, M_TEMP
, M_WAITOK
);
1776 bcopy(page
+ firstloc
, data
, firstlen
);
1778 exec_unmap_page(lwb
);
1780 if (exec_map_page(imgp
, (noteloc
>> PAGE_SHIFT
) + 1,
1782 kfree(data
, M_TEMP
);
1785 bcopy(page
, data
+ firstlen
, notesz
- firstlen
);
1786 note
= note0
= (const Elf_Note
*)(data
);
1787 note_end
= (const Elf_Note
*)(data
+ notesz
);
1789 note
= note0
= (const Elf_Note
*)(page
+ firstloc
);
1790 note_end
= (const Elf_Note
*)(page
+ firstloc
+
1795 for (n
= 0; n
< 100 && note
>= note0
&& note
< note_end
; n
++) {
1796 if (!aligned(note
, Elf32_Addr
))
1798 if (note_overflow(note
, (const char *)note_end
-
1799 (const char *)note
)) {
1802 note_name
= (const char *)(note
+ 1);
1804 if (note
->n_namesz
== checknote
->hdr
.n_namesz
1805 && note
->n_descsz
== checknote
->hdr
.n_descsz
1806 && note
->n_type
== checknote
->hdr
.n_type
1807 && (strncmp(checknote
->vendor
, note_name
,
1808 checknote
->hdr
.n_namesz
) == 0)) {
1809 /* Fetch osreldata from ABI.note-tag */
1810 if ((checknote
->flags
& BN_TRANSLATE_OSREL
) != 0 &&
1811 checknote
->trans_osrel
!= NULL
)
1812 checknote
->trans_osrel(note
, osrel
);
1816 note
= (const Elf_Note
*)((const char *)(note
+ 1) +
1817 roundup2(note
->n_namesz
, sizeof(Elf32_Addr
)) +
1818 roundup2(note
->n_descsz
, sizeof(Elf32_Addr
)));
1821 if (!limited_to_first_page
) {
1823 kfree(data
, M_TEMP
);
1824 exec_unmap_page(lwb
);
1830 * The interpreter program header may be located beyond the first page, so
1831 * regardless of its location, a copy of the interpreter path is created so
1832 * that it may be safely referenced by the calling function in all case. The
1833 * memory is allocated by calling function, and the copying is done here.
1836 extract_interpreter(struct image_params
*imgp
, const Elf_Phdr
*pinterpreter
,
1839 boolean_t limited_to_first_page
;
1840 const boolean_t result_success
= FALSE
;
1841 const boolean_t result_failure
= TRUE
;
1842 __ElfN(Off
) pathloc
, firstloc
;
1843 __ElfN(Size
) pathsz
, firstlen
, endbyte
;
1845 struct lwbuf lwb_cache
;
1848 if (hdr_overflow(pinterpreter
->p_offset
, pinterpreter
->p_filesz
))
1849 return (result_failure
);
1850 pathsz
= pinterpreter
->p_filesz
;
1851 pathloc
= pinterpreter
->p_offset
;
1852 endbyte
= pathloc
+ pathsz
;
1854 limited_to_first_page
= pathloc
< PAGE_SIZE
&& endbyte
< PAGE_SIZE
;
1855 if (limited_to_first_page
) {
1856 bcopy(imgp
->image_header
+ pathloc
, data
, pathsz
);
1857 return (result_success
);
1860 firstloc
= pathloc
& PAGE_MASK
;
1861 firstlen
= PAGE_SIZE
- firstloc
;
1864 if (exec_map_page(imgp
, pathloc
>> PAGE_SHIFT
, &lwb
, &page
))
1865 return (result_failure
);
1867 if (firstlen
< pathsz
) { /* crosses page boundary */
1868 bcopy(page
+ firstloc
, data
, firstlen
);
1870 exec_unmap_page(lwb
);
1872 if (exec_map_page(imgp
, (pathloc
>> PAGE_SHIFT
) + 1, &lwb
,
1874 return (result_failure
);
1875 bcopy(page
, data
+ firstlen
, pathsz
- firstlen
);
1877 bcopy(page
+ firstloc
, data
, pathsz
);
1879 exec_unmap_page(lwb
);
1880 return (result_success
);
1884 __elfN(bsd_trans_osrel
)(const Elf_Note
*note
, int32_t *osrel
)
1888 p
= (uintptr_t)(note
+ 1);
1889 p
+= roundup2(note
->n_namesz
, sizeof(Elf32_Addr
));
1890 *osrel
= *(const int32_t *)(p
);
1896 * Tell kern_execve.c about it, with a little help from the linker.
1898 #if defined(__x86_64__)
1899 static struct execsw elf_execsw
= {exec_elf64_imgact
, "ELF64"};
1900 EXEC_SET_ORDERED(elf64
, elf_execsw
, SI_ORDER_FIRST
);
1901 #else /* i386 assumed */
1902 static struct execsw elf_execsw
= {exec_elf32_imgact
, "ELF32"};
1903 EXEC_SET_ORDERED(elf32
, elf_execsw
, SI_ORDER_FIRST
);
1907 __elfN(trans_prot
)(Elf_Word flags
)
1913 prot
|= VM_PROT_EXECUTE
;
1915 prot
|= VM_PROT_WRITE
;
1917 prot
|= VM_PROT_READ
;
1922 __elfN(untrans_prot
)(vm_prot_t prot
)
1927 if (prot
& VM_PROT_EXECUTE
)
1929 if (prot
& VM_PROT_READ
)
1931 if (prot
& VM_PROT_WRITE
)
1937 pie_base_hint(struct proc
*p
)
1941 if (elf_pie_base_mmap
)
1942 base
= vm_map_hint(p
, 0, VM_PROT_READ
| VM_PROT_EXECUTE
);
1944 base
= ET_DYN_LOAD_ADDR
;