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";
129 Elf_Brandnote
__elfN(dragonfly_brandnote
) = {
130 .hdr
.n_namesz
= sizeof(DRAGONFLY_ABI_VENDOR
),
131 .hdr
.n_descsz
= sizeof(int32_t),
133 .vendor
= DRAGONFLY_ABI_VENDOR
,
134 .flags
= BN_TRANSLATE_OSREL
,
135 .trans_osrel
= __elfN(bsd_trans_osrel
),
139 __elfN(insert_brand_entry
)(Elf_Brandinfo
*entry
)
143 for (i
= 0; i
< MAX_BRANDS
; i
++) {
144 if (elf_brand_list
[i
] == NULL
) {
145 elf_brand_list
[i
] = entry
;
149 if (i
== MAX_BRANDS
) {
150 uprintf("WARNING: %s: could not insert brandinfo entry: %p\n",
158 __elfN(remove_brand_entry
)(Elf_Brandinfo
*entry
)
162 for (i
= 0; i
< MAX_BRANDS
; i
++) {
163 if (elf_brand_list
[i
] == entry
) {
164 elf_brand_list
[i
] = NULL
;
174 * Check if an elf brand is being used anywhere in the system.
176 * Used by the linux emulation module unloader. This isn't safe from
179 struct elf_brand_inuse_info
{
181 Elf_Brandinfo
*entry
;
184 static int elf_brand_inuse_callback(struct proc
*p
, void *data
);
187 __elfN(brand_inuse
)(Elf_Brandinfo
*entry
)
189 struct elf_brand_inuse_info info
;
193 allproc_scan(elf_brand_inuse_callback
, &info
, 0);
199 elf_brand_inuse_callback(struct proc
*p
, void *data
)
201 struct elf_brand_inuse_info
*info
= data
;
203 if (p
->p_sysent
== info
->entry
->sysvec
) {
211 __elfN(check_header
)(const Elf_Ehdr
*hdr
)
217 hdr
->e_ident
[EI_CLASS
] != ELF_TARG_CLASS
||
218 hdr
->e_ident
[EI_DATA
] != ELF_TARG_DATA
||
219 hdr
->e_ident
[EI_VERSION
] != EV_CURRENT
||
220 hdr
->e_phentsize
!= sizeof(Elf_Phdr
) ||
221 hdr
->e_ehsize
!= sizeof(Elf_Ehdr
) ||
222 hdr
->e_version
!= ELF_TARG_VER
)
226 * Make sure we have at least one brand for this machine.
229 for (i
= 0; i
< MAX_BRANDS
; i
++) {
230 bi
= elf_brand_list
[i
];
231 if (bi
!= NULL
&& bi
->machine
== hdr
->e_machine
)
241 __elfN(load_section
)(struct proc
*p
, struct vmspace
*vmspace
, struct vnode
*vp
,
242 vm_offset_t offset
, caddr_t vmaddr
, size_t memsz
,
243 size_t filsz
, vm_prot_t prot
)
246 vm_offset_t map_addr
;
252 vm_offset_t file_addr
;
254 object
= vp
->v_object
;
258 * In most cases we will be able to use a shared lock on the
259 * object we are inserting into the map. The lock will be
260 * upgraded in situations where new VM pages must be allocated.
262 vm_object_hold_shared(object
);
266 * It's necessary to fail if the filsz + offset taken from the
267 * header is greater than the actual file pager object's size.
268 * If we were to allow this, then the vm_map_find() below would
269 * walk right off the end of the file object and into the ether.
271 * While I'm here, might as well check for something else that
272 * is invalid: filsz cannot be greater than memsz.
274 if ((off_t
)filsz
+ offset
> vp
->v_filesize
|| filsz
> memsz
) {
275 uprintf("elf_load_section: truncated ELF file\n");
276 vm_object_drop(object
);
280 map_addr
= trunc_page((vm_offset_t
)vmaddr
);
281 file_addr
= trunc_page(offset
);
284 * We have two choices. We can either clear the data in the last page
285 * of an oversized mapping, or we can start the anon mapping a page
286 * early and copy the initialized data into that first page. We
287 * choose the second..
290 map_len
= trunc_page(offset
+filsz
) - file_addr
;
292 map_len
= round_page(offset
+filsz
) - file_addr
;
295 vm_object_reference_locked(object
);
297 /* cow flags: don't dump readonly sections in core */
298 cow
= MAP_COPY_ON_WRITE
| MAP_PREFAULT
;
299 if ((prot
& VM_PROT_WRITE
) == 0)
300 cow
|= MAP_DISABLE_COREDUMP
;
302 cow
|= MAP_PREFAULT_RELOCK
;
304 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
305 vm_map_lock(&vmspace
->vm_map
);
306 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
308 file_addr
, /* file offset */
309 map_addr
, /* virtual start */
310 map_addr
+ map_len
,/* virtual end */
313 prot
, VM_PROT_ALL
, cow
);
314 vm_map_unlock(&vmspace
->vm_map
);
315 vm_map_entry_release(count
);
318 * NOTE: Object must have a hold ref when calling
319 * vm_object_deallocate().
321 if (rv
!= KERN_SUCCESS
) {
322 vm_object_deallocate_locked(object
);
323 vm_object_drop(object
);
327 /* we can stop now if we've covered it all */
328 if (memsz
== filsz
) {
329 vm_object_drop(object
);
335 * We have to get the remaining bit of the file into the first part
336 * of the oversized map segment. This is normally because the .data
337 * segment in the file is extended to provide bss. It's a neat idea
338 * to try and save a page, but it's a pain in the behind to implement.
340 copy_len
= (offset
+ filsz
) - trunc_page(offset
+ filsz
);
341 map_addr
= trunc_page((vm_offset_t
)vmaddr
+ filsz
);
342 map_len
= round_page((vm_offset_t
)vmaddr
+ memsz
) - map_addr
;
344 /* This had damn well better be true! */
346 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
347 vm_map_lock(&vmspace
->vm_map
);
348 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
355 VM_PROT_ALL
, VM_PROT_ALL
, 0);
356 vm_map_unlock(&vmspace
->vm_map
);
357 vm_map_entry_release(count
);
358 if (rv
!= KERN_SUCCESS
) {
359 vm_object_drop(object
);
366 struct lwbuf lwb_cache
;
369 m
= vm_fault_object_page(object
, trunc_page(offset
+ filsz
),
370 VM_PROT_READ
, 0, &shared
, &error
);
371 vm_object_drop(object
);
373 lwb
= lwbuf_alloc(m
, &lwb_cache
);
374 error
= copyout((caddr_t
)lwbuf_kva(lwb
),
375 (caddr_t
)map_addr
, copy_len
);
380 vm_object_drop(object
);
384 * set it to the specified protection
387 vm_map_protect(&vmspace
->vm_map
,
388 map_addr
, map_addr
+ map_len
,
395 * Load the file "file" into memory. It may be either a shared object
398 * The "addr" reference parameter is in/out. On entry, it specifies
399 * the address where a shared object should be loaded. If the file is
400 * an executable, this value is ignored. On exit, "addr" specifies
401 * where the file was actually loaded.
403 * The "entry" reference parameter is out only. On exit, it specifies
404 * the entry point for the loaded file.
407 __elfN(load_file
)(struct proc
*p
, const char *file
, u_long
*addr
, u_long
*entry
)
410 struct nlookupdata nd
;
412 struct image_params image_params
;
414 const Elf_Ehdr
*hdr
= NULL
;
415 const Elf_Phdr
*phdr
= NULL
;
416 struct nlookupdata
*nd
;
417 struct vmspace
*vmspace
= p
->p_vmspace
;
419 struct image_params
*imgp
;
420 struct mount
*topmnt
;
423 u_long base_addr
= 0;
424 int error
, i
, numsegs
;
426 tempdata
= kmalloc(sizeof(*tempdata
), M_TEMP
, M_WAITOK
);
428 attr
= &tempdata
->attr
;
429 imgp
= &tempdata
->image_params
;
432 * Initialize part of the common data
436 imgp
->firstpage
= NULL
;
437 imgp
->image_header
= NULL
;
440 error
= nlookup_init(nd
, file
, UIO_SYSSPACE
, NLC_FOLLOW
);
444 error
= cache_vget(&nd
->nl_nch
, nd
->nl_cred
,
445 LK_SHARED
, &imgp
->vp
);
446 topmnt
= nd
->nl_nch
.mount
;
452 * Check permissions, modes, uid, etc on the file, and "open" it.
454 error
= exec_check_permissions(imgp
, topmnt
);
460 error
= exec_map_first_page(imgp
);
462 * Also make certain that the interpreter stays the same, so set
463 * its VTEXT flag, too.
466 vsetflags(imgp
->vp
, VTEXT
);
471 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
472 if ((error
= __elfN(check_header
)(hdr
)) != 0)
474 if (hdr
->e_type
== ET_DYN
)
476 else if (hdr
->e_type
== ET_EXEC
)
483 /* Only support headers that fit within first page for now */
484 /* (multiplication of two Elf_Half fields will not overflow) */
485 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
486 (hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
- hdr
->e_phoff
) {
491 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
492 if (!aligned(phdr
, Elf_Addr
)) {
497 for (i
= 0, numsegs
= 0; i
< hdr
->e_phnum
; i
++) {
498 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_memsz
!= 0) {
499 /* Loadable segment */
500 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
501 error
= __elfN(load_section
)(
502 p
, vmspace
, imgp
->vp
,
504 (caddr_t
)phdr
[i
].p_vaddr
+
507 phdr
[i
].p_filesz
, prot
);
511 * Establish the base address if this is the
515 base_addr
= trunc_page(phdr
[i
].p_vaddr
+ rbase
);
520 *entry
= (unsigned long)hdr
->e_entry
+ rbase
;
524 exec_unmap_first_page(imgp
);
529 kfree(tempdata
, M_TEMP
);
534 static Elf_Brandinfo
*
535 __elfN(get_brandinfo
)(struct image_params
*imgp
, const char *interp
,
538 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
543 /* We support four types of branding -- (1) the ELF EI_OSABI field
544 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
545 * branding within the ELF header, (3) path of the `interp_path' field,
546 * and (4) the ".note.ABI-tag" ELF section.
549 /* Look for an ".note.ABI-tag" ELF section */
550 for (i
= 0; i
< MAX_BRANDS
; i
++) {
551 bi
= elf_brand_list
[i
];
555 if (hdr
->e_machine
== bi
->machine
&& (bi
->flags
&
556 (BI_BRAND_NOTE
|BI_BRAND_NOTE_MANDATORY
)) != 0) {
557 ret
= __elfN(check_note
)(imgp
, bi
->brand_note
, osrel
);
563 /* If the executable has a brand, search for it in the brand list. */
564 for (i
= 0; i
< MAX_BRANDS
; i
++) {
565 bi
= elf_brand_list
[i
];
567 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
569 if (hdr
->e_machine
== bi
->machine
&&
570 (hdr
->e_ident
[EI_OSABI
] == bi
->brand
||
571 strncmp((const char *)&hdr
->e_ident
[OLD_EI_BRAND
],
572 bi
->compat_3_brand
, strlen(bi
->compat_3_brand
)) == 0))
576 /* Lacking a known brand, search for a recognized interpreter. */
577 if (interp
!= NULL
) {
578 for (i
= 0; i
< MAX_BRANDS
; i
++) {
579 bi
= elf_brand_list
[i
];
581 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
583 if (hdr
->e_machine
== bi
->machine
&&
584 strcmp(interp
, bi
->interp_path
) == 0)
589 /* Lacking a recognized interpreter, try the default brand */
590 for (i
= 0; i
< MAX_BRANDS
; i
++) {
591 bi
= elf_brand_list
[i
];
593 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
595 if (hdr
->e_machine
== bi
->machine
&&
596 __elfN(fallback_brand
) == bi
->brand
)
603 __CONCAT(exec_
,__elfN(imgact
))(struct image_params
*imgp
)
605 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*) imgp
->image_header
;
606 const Elf_Phdr
*phdr
;
607 Elf_Auxargs
*elf_auxargs
;
608 struct vmspace
*vmspace
;
610 u_long text_size
= 0, data_size
= 0, total_size
= 0;
611 u_long text_addr
= 0, data_addr
= 0;
612 u_long seg_size
, seg_addr
;
613 u_long addr
, baddr
, et_dyn_addr
= 0, entry
= 0, proghdr
= 0;
618 const char *newinterp
= NULL
;
619 Elf_Brandinfo
*brand_info
;
623 * Do we have a valid ELF header ?
625 * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later if a particular
626 * brand doesn't support it. Both DragonFly platforms do by default.
628 if (__elfN(check_header
)(hdr
) != 0 ||
629 (hdr
->e_type
!= ET_EXEC
&& hdr
->e_type
!= ET_DYN
))
633 * From here on down, we return an errno, not -1, as we've
634 * detected an ELF file.
637 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
638 (hdr
->e_phoff
+ hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
) {
639 /* Only support headers in first page for now */
642 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
643 if (!aligned(phdr
, Elf_Addr
))
647 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
648 if (phdr
[i
].p_type
== PT_LOAD
) {
650 baddr
= phdr
[i
].p_vaddr
;
654 if (phdr
[i
].p_type
== PT_INTERP
) {
656 * If interp is already defined there are more than
657 * one PT_INTERP program headers present. Take only
658 * the first one and ignore the rest.
663 if (phdr
[i
].p_filesz
== 0 ||
664 phdr
[i
].p_filesz
> PAGE_SIZE
||
665 phdr
[i
].p_filesz
> MAXPATHLEN
)
668 interp
= kmalloc(phdr
[i
].p_filesz
, M_TEMP
, M_WAITOK
);
669 failure
= extract_interpreter(imgp
, &phdr
[i
], interp
);
671 kfree(interp
, M_TEMP
);
678 brand_info
= __elfN(get_brandinfo
)(imgp
, interp
, &osrel
);
679 if (brand_info
== NULL
) {
680 uprintf("ELF binary type \"%u\" not known.\n",
681 hdr
->e_ident
[EI_OSABI
]);
683 kfree(interp
, M_TEMP
);
686 if (hdr
->e_type
== ET_DYN
) {
687 if ((brand_info
->flags
& BI_CAN_EXEC_DYN
) == 0) {
689 kfree(interp
, M_TEMP
);
693 * If p_vaddr field of PT_LOAD program header is zero and type of an
694 * executale is ET_DYN, then it must be a position independent
695 * executable (PIE). In this case the system needs to pick a base
696 * address for us. Set et_dyn_addr to non-zero and choose the actual
697 * address when we are ready.
703 if (interp
!= NULL
&& brand_info
->interp_newpath
!= NULL
)
704 newinterp
= brand_info
->interp_newpath
;
706 exec_new_vmspace(imgp
, NULL
);
709 * Yeah, I'm paranoid. There is every reason in the world to get
710 * VTEXT now since from here on out, there are places we can have
711 * a context switch. Better safe than sorry; I really don't want
712 * the file to change while it's being loaded.
714 vsetflags(imgp
->vp
, VTEXT
);
716 vmspace
= imgp
->proc
->p_vmspace
;
717 /* Choose the base address for dynamic executables if we need to. */
719 et_dyn_addr
= pie_base_hint(imgp
->proc
);
721 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
722 switch (phdr
[i
].p_type
) {
723 case PT_LOAD
: /* Loadable segment */
724 if (phdr
[i
].p_memsz
== 0)
726 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
728 if ((error
= __elfN(load_section
)(
733 (caddr_t
)phdr
[i
].p_vaddr
+ et_dyn_addr
,
738 kfree (interp
, M_TEMP
);
743 * If this segment contains the program headers,
744 * remember their virtual address for the AT_PHDR
745 * aux entry. Static binaries don't usually include
748 if (phdr
[i
].p_offset
== 0 &&
749 hdr
->e_phoff
+ hdr
->e_phnum
* hdr
->e_phentsize
751 proghdr
= phdr
[i
].p_vaddr
+ hdr
->e_phoff
+
754 seg_addr
= trunc_page(phdr
[i
].p_vaddr
+ et_dyn_addr
);
755 seg_size
= round_page(phdr
[i
].p_memsz
+
756 phdr
[i
].p_vaddr
+ et_dyn_addr
- seg_addr
);
759 * Is this .text or .data? We can't use
760 * VM_PROT_WRITE or VM_PROT_EXEC, it breaks the
761 * alpha terribly and possibly does other bad
762 * things so we stick to the old way of figuring
763 * it out: If the segment contains the program
764 * entry point, it's a text segment, otherwise it
767 * Note that obreak() assumes that data_addr +
768 * data_size == end of data load area, and the ELF
769 * file format expects segments to be sorted by
770 * address. If multiple data segments exist, the
771 * last one will be used.
773 if (hdr
->e_entry
>= phdr
[i
].p_vaddr
&&
774 hdr
->e_entry
< (phdr
[i
].p_vaddr
+
776 text_size
= seg_size
;
777 text_addr
= seg_addr
;
778 entry
= (u_long
)hdr
->e_entry
+ et_dyn_addr
;
780 data_size
= seg_size
;
781 data_addr
= seg_addr
;
783 total_size
+= seg_size
;
786 * Check limits. It should be safe to check the
787 * limits after loading the segment since we do
788 * not actually fault in all the segment's pages.
791 imgp
->proc
->p_rlimit
[RLIMIT_DATA
].rlim_cur
||
792 text_size
> maxtsiz
||
794 imgp
->proc
->p_rlimit
[RLIMIT_VMEM
].rlim_cur
) {
796 kfree(interp
, M_TEMP
);
801 case PT_PHDR
: /* Program header table info */
802 proghdr
= phdr
[i
].p_vaddr
+ et_dyn_addr
;
809 vmspace
->vm_tsize
= text_size
; /* in bytes */
810 vmspace
->vm_taddr
= (caddr_t
)(uintptr_t)text_addr
;
811 vmspace
->vm_dsize
= data_size
; /* in bytes */
812 vmspace
->vm_daddr
= (caddr_t
)(uintptr_t)data_addr
;
814 addr
= ELF_RTLD_ADDR(vmspace
);
816 imgp
->entry_addr
= entry
;
818 imgp
->proc
->p_sysent
= brand_info
->sysvec
;
820 if (interp
!= NULL
) {
821 int have_interp
= FALSE
;
822 if (brand_info
->emul_path
!= NULL
&&
823 brand_info
->emul_path
[0] != '\0') {
824 path
= kmalloc(MAXPATHLEN
, M_TEMP
, M_WAITOK
);
825 ksnprintf(path
, MAXPATHLEN
, "%s%s",
826 brand_info
->emul_path
, interp
);
827 error
= __elfN(load_file
)(imgp
->proc
, path
, &addr
,
833 if (!have_interp
&& newinterp
!= NULL
) {
834 error
= __elfN(load_file
)(imgp
->proc
, newinterp
,
835 &addr
, &imgp
->entry_addr
);
840 error
= __elfN(load_file
)(imgp
->proc
, interp
, &addr
,
844 uprintf("ELF interpreter %s not found\n", interp
);
845 kfree(interp
, M_TEMP
);
848 kfree(interp
, M_TEMP
);
853 * Construct auxargs table (used by the fixup routine)
855 elf_auxargs
= kmalloc(sizeof(Elf_Auxargs
), M_TEMP
, M_WAITOK
);
856 elf_auxargs
->execfd
= -1;
857 elf_auxargs
->phdr
= proghdr
;
858 elf_auxargs
->phent
= hdr
->e_phentsize
;
859 elf_auxargs
->phnum
= hdr
->e_phnum
;
860 elf_auxargs
->pagesz
= PAGE_SIZE
;
861 elf_auxargs
->base
= addr
;
862 elf_auxargs
->flags
= 0;
863 elf_auxargs
->entry
= entry
;
865 imgp
->auxargs
= elf_auxargs
;
866 imgp
->interpreted
= 0;
867 imgp
->proc
->p_osrel
= osrel
;
873 __elfN(dragonfly_fixup
)(register_t
**stack_base
, struct image_params
*imgp
)
875 Elf_Auxargs
*args
= (Elf_Auxargs
*)imgp
->auxargs
;
879 base
= (Elf_Addr
*)*stack_base
;
880 pos
= base
+ (imgp
->args
->argc
+ imgp
->args
->envc
+ 2);
882 if (args
->execfd
!= -1)
883 AUXARGS_ENTRY(pos
, AT_EXECFD
, args
->execfd
);
884 AUXARGS_ENTRY(pos
, AT_PHDR
, args
->phdr
);
885 AUXARGS_ENTRY(pos
, AT_PHENT
, args
->phent
);
886 AUXARGS_ENTRY(pos
, AT_PHNUM
, args
->phnum
);
887 AUXARGS_ENTRY(pos
, AT_PAGESZ
, args
->pagesz
);
888 AUXARGS_ENTRY(pos
, AT_FLAGS
, args
->flags
);
889 AUXARGS_ENTRY(pos
, AT_ENTRY
, args
->entry
);
890 AUXARGS_ENTRY(pos
, AT_BASE
, args
->base
);
891 if (imgp
->execpathp
!= 0)
892 AUXARGS_ENTRY(pos
, AT_EXECPATH
, imgp
->execpathp
);
893 AUXARGS_ENTRY(pos
, AT_OSRELDATE
, osreldate
);
894 AUXARGS_ENTRY(pos
, AT_NULL
, 0);
896 kfree(imgp
->auxargs
, M_TEMP
);
897 imgp
->auxargs
= NULL
;
900 suword64(base
, (long)imgp
->args
->argc
);
901 *stack_base
= (register_t
*)base
;
906 * Code for generating ELF core dumps.
909 typedef int (*segment_callback
)(vm_map_entry_t
, void *);
911 /* Closure for cb_put_phdr(). */
912 struct phdr_closure
{
913 Elf_Phdr
*phdr
; /* Program header to fill in (incremented) */
914 Elf_Phdr
*phdr_max
; /* Pointer bound for error check */
915 Elf_Off offset
; /* Offset of segment in core file */
918 /* Closure for cb_size_segment(). */
919 struct sseg_closure
{
920 int count
; /* Count of writable segments. */
921 size_t vsize
; /* Total size of all writable segments. */
924 /* Closure for cb_put_fp(). */
927 struct vn_hdr
*vnh_max
;
932 typedef struct elf_buf
{
938 static void *target_reserve(elf_buf_t target
, size_t bytes
, int *error
);
940 static int cb_put_phdr (vm_map_entry_t
, void *);
941 static int cb_size_segment (vm_map_entry_t
, void *);
942 static int cb_fpcount_segment(vm_map_entry_t
, void *);
943 static int cb_put_fp(vm_map_entry_t
, void *);
946 static int each_segment (struct proc
*, segment_callback
, void *, int);
947 static int __elfN(corehdr
)(struct lwp
*, int, struct file
*, struct ucred
*,
949 enum putmode
{ WRITE
, DRYRUN
};
950 static int __elfN(puthdr
)(struct lwp
*, elf_buf_t
, int sig
, enum putmode
,
952 static int elf_putallnotes(struct lwp
*, elf_buf_t
, int, enum putmode
);
953 static int __elfN(putnote
)(elf_buf_t
, const char *, int, const void *, size_t);
955 static int elf_putsigs(struct lwp
*, elf_buf_t
);
956 static int elf_puttextvp(struct proc
*, elf_buf_t
);
957 static int elf_putfiles(struct proc
*, elf_buf_t
, struct file
*);
960 __elfN(coredump
)(struct lwp
*lp
, int sig
, struct vnode
*vp
, off_t limit
)
965 if ((error
= falloc(NULL
, &fp
, NULL
)) != 0)
967 fsetcred(fp
, lp
->lwp_proc
->p_ucred
);
972 fp
->f_type
= DTYPE_VNODE
;
973 fp
->f_flag
= O_CREAT
|O_WRONLY
|O_NOFOLLOW
;
974 fp
->f_ops
= &vnode_fileops
;
977 error
= generic_elf_coredump(lp
, sig
, fp
, limit
);
981 fp
->f_ops
= &badfileops
;
988 generic_elf_coredump(struct lwp
*lp
, int sig
, struct file
*fp
, off_t limit
)
990 struct proc
*p
= lp
->lwp_proc
;
991 struct ucred
*cred
= p
->p_ucred
;
993 struct sseg_closure seginfo
;
994 struct elf_buf target
;
997 kprintf("can't dump core - null fp\n");
1000 * Size the program segments
1004 each_segment(p
, cb_size_segment
, &seginfo
, 1);
1007 * Calculate the size of the core file header area by making
1008 * a dry run of generating it. Nothing is written, but the
1009 * size is calculated.
1011 bzero(&target
, sizeof(target
));
1012 __elfN(puthdr
)(lp
, &target
, sig
, DRYRUN
, seginfo
.count
, fp
);
1014 if (target
.off
+ seginfo
.vsize
>= limit
)
1018 * Allocate memory for building the header, fill it up,
1021 target
.off_max
= target
.off
;
1023 target
.buf
= kmalloc(target
.off_max
, M_TEMP
, M_WAITOK
|M_ZERO
);
1025 error
= __elfN(corehdr
)(lp
, sig
, fp
, cred
, seginfo
.count
, &target
);
1027 /* Write the contents of all of the writable segments. */
1033 php
= (Elf_Phdr
*)(target
.buf
+ sizeof(Elf_Ehdr
)) + 1;
1034 for (i
= 0; i
< seginfo
.count
; i
++) {
1035 error
= fp_write(fp
, (caddr_t
)php
->p_vaddr
,
1036 php
->p_filesz
, &nbytes
, UIO_USERSPACE
);
1042 kfree(target
.buf
, M_TEMP
);
1048 * A callback for each_segment() to write out the segment's
1049 * program header entry.
1052 cb_put_phdr(vm_map_entry_t entry
, void *closure
)
1054 struct phdr_closure
*phc
= closure
;
1055 Elf_Phdr
*phdr
= phc
->phdr
;
1057 if (phc
->phdr
== phc
->phdr_max
)
1060 phc
->offset
= round_page(phc
->offset
);
1062 phdr
->p_type
= PT_LOAD
;
1063 phdr
->p_offset
= phc
->offset
;
1064 phdr
->p_vaddr
= entry
->start
;
1066 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1067 phdr
->p_align
= PAGE_SIZE
;
1068 phdr
->p_flags
= __elfN(untrans_prot
)(entry
->protection
);
1070 phc
->offset
+= phdr
->p_filesz
;
1076 * A callback for each_writable_segment() to gather information about
1077 * the number of segments and their total size.
1080 cb_size_segment(vm_map_entry_t entry
, void *closure
)
1082 struct sseg_closure
*ssc
= closure
;
1085 ssc
->vsize
+= entry
->end
- entry
->start
;
1090 * A callback for each_segment() to gather information about
1091 * the number of text segments.
1094 cb_fpcount_segment(vm_map_entry_t entry
, void *closure
)
1096 int *count
= closure
;
1099 if (entry
->ba
.object
&& entry
->ba
.object
->type
== OBJT_VNODE
) {
1100 vp
= (struct vnode
*)entry
->ba
.object
->handle
;
1101 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1109 cb_put_fp(vm_map_entry_t entry
, void *closure
)
1111 struct fp_closure
*fpc
= closure
;
1112 struct vn_hdr
*vnh
= fpc
->vnh
;
1113 Elf_Phdr
*phdr
= &vnh
->vnh_phdr
;
1118 * If an entry represents a vnode then write out a file handle.
1120 * If we are checkpointing a checkpoint-restored program we do
1121 * NOT record the filehandle for the old checkpoint vnode (which
1122 * is mapped all over the place). Instead we rely on the fact
1123 * that a checkpoint-restored program does not mmap() the checkpt
1124 * vnode NOCORE, so its contents will be written out to the
1125 * new checkpoint file. This is necessary because the 'old'
1126 * checkpoint file is typically destroyed when a new one is created
1127 * and thus cannot be used to restore the new checkpoint.
1129 * Theoretically we could create a chain of checkpoint files and
1130 * operate the checkpointing operation kinda like an incremental
1131 * checkpoint, but a checkpoint restore would then likely wind up
1132 * referencing many prior checkpoint files and that is a bit over
1133 * the top for the purpose of the checkpoint API.
1135 if (entry
->ba
.object
&& entry
->ba
.object
->type
== OBJT_VNODE
) {
1136 vp
= (struct vnode
*)entry
->ba
.object
->handle
;
1137 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1139 if (vnh
== fpc
->vnh_max
)
1143 vnh
->vnh_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1144 error
= VFS_VPTOFH(vp
, &vnh
->vnh_fh
.fh_fid
);
1146 char *freepath
, *fullpath
;
1149 * This is actually a relatively common occurance,
1150 * so don't spew on the console by default.
1152 if (vn_fullpath(curproc
, vp
, &fullpath
, &freepath
, 0)) {
1154 kprintf("Warning: coredump, error %d: cannot store file handle for vnode %p\n", error
, vp
);
1157 kprintf("Warning: coredump, error %d: cannot store file handle for %s\n", error
, fullpath
);
1158 kfree(freepath
, M_TEMP
);
1163 phdr
->p_type
= PT_LOAD
;
1164 phdr
->p_offset
= 0; /* not written to core */
1165 phdr
->p_vaddr
= entry
->start
;
1167 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1168 phdr
->p_align
= PAGE_SIZE
;
1170 if (entry
->protection
& VM_PROT_READ
)
1171 phdr
->p_flags
|= PF_R
;
1172 if (entry
->protection
& VM_PROT_WRITE
)
1173 phdr
->p_flags
|= PF_W
;
1174 if (entry
->protection
& VM_PROT_EXECUTE
)
1175 phdr
->p_flags
|= PF_X
;
1183 * For each writable segment in the process's memory map, call the given
1184 * function with a pointer to the map entry and some arbitrary
1185 * caller-supplied data.
1188 each_segment(struct proc
*p
, segment_callback func
, void *closure
, int writable
)
1191 vm_map_t map
= &p
->p_vmspace
->vm_map
;
1192 vm_map_entry_t entry
;
1194 RB_FOREACH(entry
, vm_map_rb_tree
, &map
->rb_root
) {
1195 vm_map_backing_t ba
;
1199 * Don't dump inaccessible mappings, deal with legacy
1202 * Note that read-only segments related to the elf binary
1203 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1204 * need to arbitrarily ignore such segments.
1206 if (elf_legacy_coredump
) {
1207 if (writable
&& (entry
->protection
& VM_PROT_RW
) != VM_PROT_RW
)
1210 if (writable
&& (entry
->protection
& VM_PROT_ALL
) == 0)
1215 * Dont include memory segment in the coredump if
1216 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1219 * Currently we only dump normal VM object maps. We do
1220 * not dump submaps or virtual page tables.
1222 if (writable
&& (entry
->eflags
& MAP_ENTRY_NOCOREDUMP
))
1224 if (entry
->maptype
!= VM_MAPTYPE_NORMAL
)
1228 * Find the bottom-most object, leaving the base object
1229 * and the bottom-most object held (but only one hold
1230 * if they happen to be the same).
1233 while (ba
->backing_ba
)
1234 ba
= ba
->backing_ba
;
1238 * The callback only applies to default, swap, or vnode
1239 * objects. Other types of objects such as memory-mapped
1240 * devices are ignored.
1243 vm_object_hold_shared(obj
);
1245 if (obj
->type
== OBJT_DEFAULT
||
1246 obj
->type
== OBJT_SWAP
||
1247 obj
->type
== OBJT_VNODE
) {
1248 error
= (*func
)(entry
, closure
);
1250 vm_object_drop(obj
);
1258 target_reserve(elf_buf_t target
, size_t bytes
, int *error
)
1263 if (target
->off
+ bytes
> target
->off_max
)
1266 res
= target
->buf
+ target
->off
;
1268 target
->off
+= bytes
;
1273 * Write the core file header to the file, including padding up to
1274 * the page boundary.
1277 __elfN(corehdr
)(struct lwp
*lp
, int sig
, struct file
*fp
, struct ucred
*cred
,
1278 int numsegs
, elf_buf_t target
)
1284 * Fill in the header. The fp is passed so we can detect and flag
1285 * a checkpoint file pointer within the core file itself, because
1286 * it may not be restored from the same file handle.
1288 error
= __elfN(puthdr
)(lp
, target
, sig
, WRITE
, numsegs
, fp
);
1290 /* Write it to the core file. */
1292 error
= fp_write(fp
, target
->buf
, target
->off
, &nbytes
,
1299 __elfN(puthdr
)(struct lwp
*lp
, elf_buf_t target
, int sig
, enum putmode mode
,
1300 int numsegs
, struct file
*fp
)
1302 struct proc
*p
= lp
->lwp_proc
;
1310 ehdr
= target_reserve(target
, sizeof(Elf_Ehdr
), &error
);
1312 phoff
= target
->off
;
1313 phdr
= target_reserve(target
, (numsegs
+ 1) * sizeof(Elf_Phdr
), &error
);
1315 noteoff
= target
->off
;
1317 elf_putallnotes(lp
, target
, sig
, mode
);
1318 notesz
= target
->off
- noteoff
;
1321 * put extra cruft for dumping process state here
1322 * - we really want it be before all the program
1324 * - we just need to update the offset accordingly
1325 * and GDB will be none the wiser.
1328 error
= elf_puttextvp(p
, target
);
1330 error
= elf_putsigs(lp
, target
);
1332 error
= elf_putfiles(p
, target
, fp
);
1335 * Align up to a page boundary for the program segments. The
1336 * actual data will be written to the outptu file, not to elf_buf_t,
1337 * so we do not have to do any further bounds checking.
1339 target
->off
= round_page(target
->off
);
1340 if (error
== 0 && ehdr
!= NULL
) {
1342 * Fill in the ELF header.
1344 ehdr
->e_ident
[EI_MAG0
] = ELFMAG0
;
1345 ehdr
->e_ident
[EI_MAG1
] = ELFMAG1
;
1346 ehdr
->e_ident
[EI_MAG2
] = ELFMAG2
;
1347 ehdr
->e_ident
[EI_MAG3
] = ELFMAG3
;
1348 ehdr
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1349 ehdr
->e_ident
[EI_DATA
] = ELF_DATA
;
1350 ehdr
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1351 ehdr
->e_ident
[EI_OSABI
] = ELFOSABI_NONE
;
1352 ehdr
->e_ident
[EI_ABIVERSION
] = 0;
1353 ehdr
->e_ident
[EI_PAD
] = 0;
1354 ehdr
->e_type
= ET_CORE
;
1355 ehdr
->e_machine
= ELF_ARCH
;
1356 ehdr
->e_version
= EV_CURRENT
;
1358 ehdr
->e_phoff
= phoff
;
1360 ehdr
->e_ehsize
= sizeof(Elf_Ehdr
);
1361 ehdr
->e_phentsize
= sizeof(Elf_Phdr
);
1362 ehdr
->e_phnum
= numsegs
+ 1;
1363 ehdr
->e_shentsize
= sizeof(Elf_Shdr
);
1365 ehdr
->e_shstrndx
= SHN_UNDEF
;
1367 if (error
== 0 && phdr
!= NULL
) {
1369 * Fill in the program header entries.
1371 struct phdr_closure phc
;
1373 /* The note segement. */
1374 phdr
->p_type
= PT_NOTE
;
1375 phdr
->p_offset
= noteoff
;
1378 phdr
->p_filesz
= notesz
;
1384 /* All the writable segments from the program. */
1386 phc
.phdr_max
= phdr
+ numsegs
;
1387 phc
.offset
= target
->off
;
1388 each_segment(p
, cb_put_phdr
, &phc
, 1);
1394 * Append core dump notes to target ELF buffer or simply update target size
1395 * if dryrun selected.
1398 elf_putallnotes(struct lwp
*corelp
, elf_buf_t target
, int sig
,
1401 struct proc
*p
= corelp
->lwp_proc
;
1405 prfpregset_t fpregs
;
1409 prfpregset_t
*fpregs
;
1414 * Allocate temporary storage for notes on heap to avoid stack overflow.
1416 if (mode
!= DRYRUN
) {
1417 tmpdata
= kmalloc(sizeof(*tmpdata
), M_TEMP
, M_ZERO
| M_WAITOK
);
1418 status
= &tmpdata
->status
;
1419 fpregs
= &tmpdata
->fpregs
;
1420 psinfo
= &tmpdata
->psinfo
;
1429 * Append LWP-agnostic note.
1431 if (mode
!= DRYRUN
) {
1432 psinfo
->pr_version
= PRPSINFO_VERSION
;
1433 psinfo
->pr_psinfosz
= sizeof(prpsinfo_t
);
1434 strlcpy(psinfo
->pr_fname
, p
->p_comm
,
1435 sizeof(psinfo
->pr_fname
));
1437 * XXX - We don't fill in the command line arguments
1440 strlcpy(psinfo
->pr_psargs
, p
->p_comm
,
1441 sizeof(psinfo
->pr_psargs
));
1444 __elfN(putnote
)(target
, "CORE", NT_PRPSINFO
, psinfo
, sizeof *psinfo
);
1449 * Append first note for LWP that triggered core so that it is
1450 * the selected one when the debugger starts.
1452 if (mode
!= DRYRUN
) {
1453 status
->pr_version
= PRSTATUS_VERSION
;
1454 status
->pr_statussz
= sizeof(prstatus_t
);
1455 status
->pr_gregsetsz
= sizeof(gregset_t
);
1456 status
->pr_fpregsetsz
= sizeof(fpregset_t
);
1457 status
->pr_osreldate
= osreldate
;
1458 status
->pr_cursig
= sig
;
1459 status
->pr_pid
= corelp
->lwp_tid
;
1460 fill_regs(corelp
, &status
->pr_reg
);
1461 fill_fpregs(corelp
, fpregs
);
1464 __elfN(putnote
)(target
, "CORE", NT_PRSTATUS
, status
, sizeof *status
);
1468 __elfN(putnote
)(target
, "CORE", NT_FPREGSET
, fpregs
, sizeof *fpregs
);
1473 * Then append notes for other LWPs.
1475 FOREACH_LWP_IN_PROC(lp
, p
) {
1478 /* skip lwps being created */
1479 if (lp
->lwp_thread
== NULL
)
1481 if (mode
!= DRYRUN
) {
1482 status
->pr_pid
= lp
->lwp_tid
;
1483 fill_regs(lp
, &status
->pr_reg
);
1484 fill_fpregs(lp
, fpregs
);
1486 error
= __elfN(putnote
)(target
, "CORE", NT_PRSTATUS
,
1487 status
, sizeof *status
);
1490 error
= __elfN(putnote
)(target
, "CORE", NT_FPREGSET
,
1491 fpregs
, sizeof *fpregs
);
1497 if (tmpdata
!= NULL
)
1498 kfree(tmpdata
, M_TEMP
);
1503 * Generate a note sub-structure.
1505 * NOTE: 4-byte alignment.
1508 __elfN(putnote
)(elf_buf_t target
, const char *name
, int type
,
1509 const void *desc
, size_t descsz
)
1515 note
.n_namesz
= strlen(name
) + 1;
1516 note
.n_descsz
= descsz
;
1518 dst
= target_reserve(target
, sizeof(note
), &error
);
1520 bcopy(¬e
, dst
, sizeof note
);
1521 dst
= target_reserve(target
, note
.n_namesz
, &error
);
1523 bcopy(name
, dst
, note
.n_namesz
);
1524 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1525 dst
= target_reserve(target
, note
.n_descsz
, &error
);
1527 bcopy(desc
, dst
, note
.n_descsz
);
1528 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1534 elf_putsigs(struct lwp
*lp
, elf_buf_t target
)
1536 /* XXX lwp handle more than one lwp */
1537 struct proc
*p
= lp
->lwp_proc
;
1539 struct ckpt_siginfo
*csi
;
1541 csi
= target_reserve(target
, sizeof(struct ckpt_siginfo
), &error
);
1543 csi
->csi_ckptpisz
= sizeof(struct ckpt_siginfo
);
1544 bcopy(p
->p_sigacts
, &csi
->csi_sigacts
, sizeof(*p
->p_sigacts
));
1545 bcopy(&p
->p_realtimer
, &csi
->csi_itimerval
, sizeof(struct itimerval
));
1546 bcopy(&lp
->lwp_sigmask
, &csi
->csi_sigmask
,
1548 csi
->csi_sigparent
= p
->p_sigparent
;
1554 elf_putfiles(struct proc
*p
, elf_buf_t target
, struct file
*ckfp
)
1556 thread_t td
= curthread
;
1559 struct ckpt_filehdr
*cfh
= NULL
;
1560 struct ckpt_fileinfo
*cfi
;
1565 * the duplicated loop is gross, but it was the only way
1566 * to eliminate uninitialized variable warnings
1568 cfh
= target_reserve(target
, sizeof(struct ckpt_filehdr
), &error
);
1570 cfh
->cfh_nfiles
= 0;
1574 * ignore STDIN/STDERR/STDOUT.
1576 KKASSERT(td
->td_proc
== p
);
1577 for (i
= 3; error
== 0 && i
< p
->p_fd
->fd_nfiles
; i
++) {
1578 fp
= holdfp(td
, i
, -1);
1582 * XXX Only checkpoint vnodes for now.
1584 if (fp
->f_type
!= DTYPE_VNODE
) {
1588 cfi
= target_reserve(target
, sizeof(struct ckpt_fileinfo
),
1594 cfi
->cfi_index
= -1;
1595 cfi
->cfi_type
= fp
->f_type
;
1596 cfi
->cfi_flags
= fp
->f_flag
;
1597 cfi
->cfi_offset
= fp
->f_offset
;
1598 cfi
->cfi_ckflags
= 0;
1601 cfi
->cfi_ckflags
|= CKFIF_ISCKPTFD
;
1602 /* f_count and f_msgcount should not be saved/restored */
1603 /* XXX save cred info */
1605 switch(fp
->f_type
) {
1607 vp
= (struct vnode
*)fp
->f_data
;
1609 * it looks like a bug in ptrace is marking
1610 * a non-vnode as a vnode - until we find the
1611 * root cause this will at least prevent
1612 * further panics from truss
1614 if (vp
== NULL
|| vp
->v_mount
== NULL
)
1618 cfi
->cfi_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1619 error
= VFS_VPTOFH(vp
, &cfi
->cfi_fh
.fh_fid
);
1630 elf_puttextvp(struct proc
*p
, elf_buf_t target
)
1634 struct fp_closure fpc
;
1635 struct ckpt_vminfo
*vminfo
;
1637 vminfo
= target_reserve(target
, sizeof(struct ckpt_vminfo
), &error
);
1638 if (vminfo
!= NULL
) {
1639 vminfo
->cvm_dsize
= btoc(p
->p_vmspace
->vm_dsize
); /* pages */
1640 vminfo
->cvm_tsize
= btoc(p
->p_vmspace
->vm_tsize
); /* pages */
1641 vminfo
->cvm_daddr
= p
->p_vmspace
->vm_daddr
;
1642 vminfo
->cvm_taddr
= p
->p_vmspace
->vm_taddr
;
1646 vn_count
= target_reserve(target
, sizeof(int), &error
);
1647 if (target
->buf
!= NULL
) {
1648 fpc
.vnh
= (struct vn_hdr
*)(target
->buf
+ target
->off
);
1649 fpc
.vnh_max
= fpc
.vnh
+
1650 (target
->off_max
- target
->off
) / sizeof(struct vn_hdr
);
1651 error
= each_segment(p
, cb_put_fp
, &fpc
, 0);
1653 *vn_count
= fpc
.count
;
1655 error
= each_segment(p
, cb_fpcount_segment
, &fpc
.count
, 0);
1657 target
->off
+= fpc
.count
* sizeof(struct vn_hdr
);
1662 * Try to find the appropriate ABI-note section for checknote,
1663 * The entire image is searched if necessary, not only the first page.
1666 __elfN(check_note
)(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
1669 boolean_t valid_note_found
;
1670 const Elf_Phdr
*phdr
, *pnote
;
1671 const Elf_Ehdr
*hdr
;
1674 valid_note_found
= FALSE
;
1675 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
1676 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
1678 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
1679 if (phdr
[i
].p_type
== PT_NOTE
) {
1681 valid_note_found
= check_PT_NOTE (imgp
, checknote
,
1683 if (valid_note_found
)
1687 return valid_note_found
;
1691 * Be careful not to create new overflow conditions when checking
1695 note_overflow(const Elf_Note
*note
, size_t maxsize
)
1697 if (sizeof(*note
) > maxsize
)
1699 if (note
->n_namesz
> maxsize
- sizeof(*note
))
1705 hdr_overflow(__ElfN(Off
) off_beg
, __ElfN(Size
) size
)
1707 __ElfN(Off
) off_end
;
1709 off_end
= off_beg
+ size
;
1710 if (off_end
< off_beg
)
1716 check_PT_NOTE(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
1717 int32_t *osrel
, const Elf_Phdr
* pnote
)
1719 boolean_t limited_to_first_page
;
1720 boolean_t found
= FALSE
;
1721 const Elf_Note
*note
, *note0
, *note_end
;
1722 const char *note_name
;
1723 __ElfN(Off
) noteloc
, firstloc
;
1724 __ElfN(Size
) notesz
, firstlen
, endbyte
;
1726 struct lwbuf lwb_cache
;
1731 if (hdr_overflow(pnote
->p_offset
, pnote
->p_filesz
))
1733 notesz
= pnote
->p_filesz
;
1734 noteloc
= pnote
->p_offset
;
1735 endbyte
= noteloc
+ notesz
;
1736 limited_to_first_page
= noteloc
< PAGE_SIZE
&& endbyte
< PAGE_SIZE
;
1738 if (limited_to_first_page
) {
1739 note
= (const Elf_Note
*)(imgp
->image_header
+ noteloc
);
1740 note_end
= (const Elf_Note
*)(imgp
->image_header
+ endbyte
);
1743 firstloc
= noteloc
& PAGE_MASK
;
1744 firstlen
= PAGE_SIZE
- firstloc
;
1745 if (notesz
< sizeof(Elf_Note
) || notesz
> PAGE_SIZE
)
1749 if (exec_map_page(imgp
, noteloc
>> PAGE_SHIFT
, &lwb
, &page
))
1751 if (firstlen
< notesz
) { /* crosses page boundary */
1752 data
= kmalloc(notesz
, M_TEMP
, M_WAITOK
);
1753 bcopy(page
+ firstloc
, data
, firstlen
);
1755 exec_unmap_page(lwb
);
1757 if (exec_map_page(imgp
, (noteloc
>> PAGE_SHIFT
) + 1,
1759 kfree(data
, M_TEMP
);
1762 bcopy(page
, data
+ firstlen
, notesz
- firstlen
);
1763 note
= note0
= (const Elf_Note
*)(data
);
1764 note_end
= (const Elf_Note
*)(data
+ notesz
);
1766 note
= note0
= (const Elf_Note
*)(page
+ firstloc
);
1767 note_end
= (const Elf_Note
*)(page
+ firstloc
+
1772 for (n
= 0; n
< 100 && note
>= note0
&& note
< note_end
; n
++) {
1773 if (!aligned(note
, Elf32_Addr
))
1775 if (note_overflow(note
, (const char *)note_end
-
1776 (const char *)note
)) {
1779 note_name
= (const char *)(note
+ 1);
1781 if (note
->n_namesz
== checknote
->hdr
.n_namesz
1782 && note
->n_descsz
== checknote
->hdr
.n_descsz
1783 && note
->n_type
== checknote
->hdr
.n_type
1784 && (strncmp(checknote
->vendor
, note_name
,
1785 checknote
->hdr
.n_namesz
) == 0)) {
1786 /* Fetch osreldata from ABI.note-tag */
1787 if ((checknote
->flags
& BN_TRANSLATE_OSREL
) != 0 &&
1788 checknote
->trans_osrel
!= NULL
)
1789 checknote
->trans_osrel(note
, osrel
);
1793 note
= (const Elf_Note
*)((const char *)(note
+ 1) +
1794 roundup2(note
->n_namesz
, sizeof(Elf32_Addr
)) +
1795 roundup2(note
->n_descsz
, sizeof(Elf32_Addr
)));
1798 if (!limited_to_first_page
) {
1800 kfree(data
, M_TEMP
);
1801 exec_unmap_page(lwb
);
1807 * The interpreter program header may be located beyond the first page, so
1808 * regardless of its location, a copy of the interpreter path is created so
1809 * that it may be safely referenced by the calling function in all case. The
1810 * memory is allocated by calling function, and the copying is done here.
1813 extract_interpreter(struct image_params
*imgp
, const Elf_Phdr
*pinterpreter
,
1816 boolean_t limited_to_first_page
;
1817 const boolean_t result_success
= FALSE
;
1818 const boolean_t result_failure
= TRUE
;
1819 __ElfN(Off
) pathloc
, firstloc
;
1820 __ElfN(Size
) pathsz
, firstlen
, endbyte
;
1822 struct lwbuf lwb_cache
;
1825 if (hdr_overflow(pinterpreter
->p_offset
, pinterpreter
->p_filesz
))
1826 return (result_failure
);
1827 pathsz
= pinterpreter
->p_filesz
;
1828 pathloc
= pinterpreter
->p_offset
;
1829 endbyte
= pathloc
+ pathsz
;
1831 limited_to_first_page
= pathloc
< PAGE_SIZE
&& endbyte
< PAGE_SIZE
;
1832 if (limited_to_first_page
) {
1833 bcopy(imgp
->image_header
+ pathloc
, data
, pathsz
);
1834 return (result_success
);
1837 firstloc
= pathloc
& PAGE_MASK
;
1838 firstlen
= PAGE_SIZE
- firstloc
;
1841 if (exec_map_page(imgp
, pathloc
>> PAGE_SHIFT
, &lwb
, &page
))
1842 return (result_failure
);
1844 if (firstlen
< pathsz
) { /* crosses page boundary */
1845 bcopy(page
+ firstloc
, data
, firstlen
);
1847 exec_unmap_page(lwb
);
1849 if (exec_map_page(imgp
, (pathloc
>> PAGE_SHIFT
) + 1, &lwb
,
1851 return (result_failure
);
1852 bcopy(page
, data
+ firstlen
, pathsz
- firstlen
);
1854 bcopy(page
+ firstloc
, data
, pathsz
);
1856 exec_unmap_page(lwb
);
1857 return (result_success
);
1861 __elfN(bsd_trans_osrel
)(const Elf_Note
*note
, int32_t *osrel
)
1865 p
= (uintptr_t)(note
+ 1);
1866 p
+= roundup2(note
->n_namesz
, sizeof(Elf32_Addr
));
1867 *osrel
= *(const int32_t *)(p
);
1873 * Tell kern_execve.c about it, with a little help from the linker.
1875 #if defined(__x86_64__)
1876 static struct execsw elf_execsw
= {exec_elf64_imgact
, "ELF64"};
1877 EXEC_SET_ORDERED(elf64
, elf_execsw
, SI_ORDER_FIRST
);
1878 #else /* i386 assumed */
1879 static struct execsw elf_execsw
= {exec_elf32_imgact
, "ELF32"};
1880 EXEC_SET_ORDERED(elf32
, elf_execsw
, SI_ORDER_FIRST
);
1884 __elfN(trans_prot
)(Elf_Word flags
)
1890 prot
|= VM_PROT_EXECUTE
;
1892 prot
|= VM_PROT_WRITE
;
1894 prot
|= VM_PROT_READ
;
1899 __elfN(untrans_prot
)(vm_prot_t prot
)
1904 if (prot
& VM_PROT_EXECUTE
)
1906 if (prot
& VM_PROT_READ
)
1908 if (prot
& VM_PROT_WRITE
)
1914 pie_base_hint(struct proc
*p
)
1918 if (elf_pie_base_mmap
)
1919 base
= vm_map_hint(p
, 0, VM_PROT_READ
| VM_PROT_EXECUTE
);
1921 base
= ET_DYN_LOAD_ADDR
;