2 * Copyright (c) 1995-1996 Søren Schmidt
3 * Copyright (c) 1996 Peter Wemm
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer
11 * in this position and unchanged.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software withough specific prior written permission
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 * $FreeBSD: src/sys/kern/imgact_elf.c,v 1.73.2.13 2002/12/28 19:49:41 dillon Exp $
30 * $DragonFly: src/sys/kern/imgact_elf.c,v 1.55 2008/08/17 17:21:36 nth 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/sfbuf.h>
57 #include <vm/vm_kern.h>
58 #include <vm/vm_param.h>
61 #include <vm/vm_map.h>
62 #include <vm/vm_object.h>
63 #include <vm/vm_extern.h>
65 #include <machine/elf.h>
66 #include <machine/md_var.h>
67 #include <sys/mount.h>
69 #define OLD_EI_BRAND 8
74 static int elf_check_header (const Elf_Ehdr
*hdr
);
75 static int elf_freebsd_fixup (register_t
**stack_base
,
76 struct image_params
*imgp
);
77 static int elf_load_file (struct proc
*p
, const char *file
, u_long
*addr
,
79 static int elf_load_section (struct proc
*p
,
80 struct vmspace
*vmspace
, struct vnode
*vp
,
81 vm_offset_t offset
, caddr_t vmaddr
, size_t memsz
, size_t filsz
,
83 static int exec_elf_imgact (struct image_params
*imgp
);
85 static int elf_trace
= 0;
86 SYSCTL_INT(_debug
, OID_AUTO
, elf_trace
, CTLFLAG_RW
, &elf_trace
, 0, "");
87 static int elf_legacy_coredump
= 0;
88 SYSCTL_INT(_debug
, OID_AUTO
, elf_legacy_coredump
, CTLFLAG_RW
,
89 &elf_legacy_coredump
, 0, "");
91 static int dragonfly_match_abi_note(const Elf_Note
*);
92 static int freebsd_match_abi_note(const Elf_Note
*);
94 static struct sysentvec elf_freebsd_sysvec
= {
114 static Elf_Brandinfo freebsd_brand_info
= {
117 freebsd_match_abi_note
,
119 "/usr/libexec/ld-elf.so.1",
123 static Elf_Brandinfo dragonfly_brand_info
= {
126 dragonfly_match_abi_note
,
128 "/usr/libexec/ld-elf.so.2",
132 static Elf_Brandinfo
*elf_brand_list
[MAX_BRANDS
] = {
133 &dragonfly_brand_info
,
140 freebsd_match_abi_note(const Elf_Note
*abi_note
)
142 const char *abi_name
= (const char *)
143 ((const uint8_t *)abi_note
+ sizeof(*abi_note
));
145 if (abi_note
->n_namesz
!= sizeof("FreeBSD"))
147 if (memcmp(abi_name
, "FreeBSD", sizeof("FreeBSD")))
153 dragonfly_match_abi_note(const Elf_Note
*abi_note
)
155 const char *abi_name
= (const char *)
156 ((const uint8_t *)abi_note
+ sizeof(*abi_note
));
158 if (abi_note
->n_namesz
!= sizeof("DragonFly"))
160 if (memcmp(abi_name
, "DragonFly", sizeof("DragonFly")))
166 elf_insert_brand_entry(Elf_Brandinfo
*entry
)
170 for (i
=1; i
<MAX_BRANDS
; i
++) {
171 if (elf_brand_list
[i
] == NULL
) {
172 elf_brand_list
[i
] = entry
;
182 elf_remove_brand_entry(Elf_Brandinfo
*entry
)
186 for (i
=1; i
<MAX_BRANDS
; i
++) {
187 if (elf_brand_list
[i
] == entry
) {
188 elf_brand_list
[i
] = NULL
;
198 * Check if an elf brand is being used anywhere in the system.
200 * Used by the linux emulation module unloader. This isn't safe from
203 struct elf_brand_inuse_info
{
205 Elf_Brandinfo
*entry
;
208 static int elf_brand_inuse_callback(struct proc
*p
, void *data
);
211 elf_brand_inuse(Elf_Brandinfo
*entry
)
213 struct elf_brand_inuse_info info
;
217 allproc_scan(elf_brand_inuse_callback
, entry
);
223 elf_brand_inuse_callback(struct proc
*p
, void *data
)
225 struct elf_brand_inuse_info
*info
= data
;
227 if (p
->p_sysent
== info
->entry
->sysvec
) {
235 elf_check_header(const Elf_Ehdr
*hdr
)
238 hdr
->e_ident
[EI_CLASS
] != ELF_TARG_CLASS
||
239 hdr
->e_ident
[EI_DATA
] != ELF_TARG_DATA
||
240 hdr
->e_ident
[EI_VERSION
] != EV_CURRENT
||
241 hdr
->e_phentsize
!= sizeof(Elf_Phdr
) ||
242 hdr
->e_ehsize
!= sizeof(Elf_Ehdr
) ||
243 hdr
->e_version
!= ELF_TARG_VER
)
246 if (!ELF_MACHINE_OK(hdr
->e_machine
))
253 elf_load_section(struct proc
*p
, struct vmspace
*vmspace
, struct vnode
*vp
,
254 vm_offset_t offset
, caddr_t vmaddr
, size_t memsz
,
255 size_t filsz
, vm_prot_t prot
)
258 vm_offset_t map_addr
;
263 vm_offset_t file_addr
;
265 object
= vp
->v_object
;
269 * It's necessary to fail if the filsz + offset taken from the
270 * header is greater than the actual file pager object's size.
271 * If we were to allow this, then the vm_map_find() below would
272 * walk right off the end of the file object and into the ether.
274 * While I'm here, might as well check for something else that
275 * is invalid: filsz cannot be greater than memsz.
277 if ((off_t
)filsz
+ offset
> vp
->v_filesize
|| filsz
> memsz
) {
278 uprintf("elf_load_section: truncated ELF file\n");
282 map_addr
= trunc_page((vm_offset_t
)vmaddr
);
283 file_addr
= trunc_page(offset
);
286 * We have two choices. We can either clear the data in the last page
287 * of an oversized mapping, or we can start the anon mapping a page
288 * early and copy the initialized data into that first page. We
289 * choose the second..
292 map_len
= trunc_page(offset
+filsz
) - file_addr
;
294 map_len
= round_page(offset
+filsz
) - file_addr
;
297 vm_object_reference(object
);
299 /* cow flags: don't dump readonly sections in core */
300 cow
= MAP_COPY_ON_WRITE
| MAP_PREFAULT
|
301 (prot
& VM_PROT_WRITE
? 0 : MAP_DISABLE_COREDUMP
);
303 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
304 vm_map_lock(&vmspace
->vm_map
);
305 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
307 file_addr
, /* file offset */
308 map_addr
, /* virtual start */
309 map_addr
+ map_len
,/* virtual end */
313 vm_map_unlock(&vmspace
->vm_map
);
314 vm_map_entry_release(count
);
315 if (rv
!= KERN_SUCCESS
) {
316 vm_object_deallocate(object
);
320 /* we can stop now if we've covered it all */
321 if (memsz
== filsz
) {
328 * We have to get the remaining bit of the file into the first part
329 * of the oversized map segment. This is normally because the .data
330 * segment in the file is extended to provide bss. It's a neat idea
331 * to try and save a page, but it's a pain in the behind to implement.
333 copy_len
= (offset
+ filsz
) - trunc_page(offset
+ filsz
);
334 map_addr
= trunc_page((vm_offset_t
)vmaddr
+ filsz
);
335 map_len
= round_page((vm_offset_t
)vmaddr
+ memsz
) - map_addr
;
337 /* This had damn well better be true! */
339 count
= vm_map_entry_reserve(MAP_RESERVE_COUNT
);
340 vm_map_lock(&vmspace
->vm_map
);
341 rv
= vm_map_insert(&vmspace
->vm_map
, &count
,
343 map_addr
, map_addr
+ map_len
,
345 VM_PROT_ALL
, VM_PROT_ALL
,
347 vm_map_unlock(&vmspace
->vm_map
);
348 vm_map_entry_release(count
);
349 if (rv
!= KERN_SUCCESS
) {
358 m
= vm_fault_object_page(object
, trunc_page(offset
+ filsz
),
359 VM_PROT_READ
, 0, &error
);
361 sf
= sf_buf_alloc(m
, SFB_CPUPRIVATE
);
362 error
= copyout((caddr_t
)sf_buf_kva(sf
),
363 (caddr_t
)map_addr
, copy_len
);
373 * set it to the specified protection
375 vm_map_protect(&vmspace
->vm_map
, map_addr
, map_addr
+ map_len
, prot
,
382 * Load the file "file" into memory. It may be either a shared object
385 * The "addr" reference parameter is in/out. On entry, it specifies
386 * the address where a shared object should be loaded. If the file is
387 * an executable, this value is ignored. On exit, "addr" specifies
388 * where the file was actually loaded.
390 * The "entry" reference parameter is out only. On exit, it specifies
391 * the entry point for the loaded file.
394 elf_load_file(struct proc
*p
, const char *file
, u_long
*addr
, u_long
*entry
)
397 struct nlookupdata nd
;
399 struct image_params image_params
;
401 const Elf_Ehdr
*hdr
= NULL
;
402 const Elf_Phdr
*phdr
= NULL
;
403 struct nlookupdata
*nd
;
404 struct vmspace
*vmspace
= p
->p_vmspace
;
406 struct image_params
*imgp
;
409 u_long base_addr
= 0;
410 int error
, i
, numsegs
;
412 tempdata
= kmalloc(sizeof(*tempdata
), M_TEMP
, M_WAITOK
);
414 attr
= &tempdata
->attr
;
415 imgp
= &tempdata
->image_params
;
418 * Initialize part of the common data
422 imgp
->firstpage
= NULL
;
423 imgp
->image_header
= NULL
;
426 error
= nlookup_init(nd
, file
, UIO_SYSSPACE
, NLC_FOLLOW
);
430 error
= cache_vget(&nd
->nl_nch
, nd
->nl_cred
, LK_EXCLUSIVE
, &imgp
->vp
);
436 * Check permissions, modes, uid, etc on the file, and "open" it.
438 error
= exec_check_permissions(imgp
);
444 error
= exec_map_first_page(imgp
);
446 * Also make certain that the interpreter stays the same, so set
447 * its VTEXT flag, too.
450 imgp
->vp
->v_flag
|= VTEXT
;
455 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
456 if ((error
= elf_check_header(hdr
)) != 0)
458 if (hdr
->e_type
== ET_DYN
)
460 else if (hdr
->e_type
== ET_EXEC
)
467 /* Only support headers that fit within first page for now
468 * (multiplication of two Elf_Half fields will not overflow) */
469 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
470 (hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
- hdr
->e_phoff
) {
475 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
477 for (i
= 0, numsegs
= 0; i
< hdr
->e_phnum
; i
++) {
478 if (phdr
[i
].p_type
== PT_LOAD
) { /* Loadable segment */
480 if (phdr
[i
].p_flags
& PF_X
)
481 prot
|= VM_PROT_EXECUTE
;
482 if (phdr
[i
].p_flags
& PF_W
)
483 prot
|= VM_PROT_WRITE
;
484 if (phdr
[i
].p_flags
& PF_R
)
485 prot
|= VM_PROT_READ
;
487 error
= elf_load_section(
488 p
, vmspace
, imgp
->vp
,
490 (caddr_t
)phdr
[i
].p_vaddr
+
493 phdr
[i
].p_filesz
, prot
);
497 * Establish the base address if this is the
501 base_addr
= trunc_page(phdr
[i
].p_vaddr
+ rbase
);
506 *entry
=(unsigned long)hdr
->e_entry
+ rbase
;
510 exec_unmap_first_page(imgp
);
515 kfree(tempdata
, M_TEMP
);
521 * non static, as it can be overridden by start_init()
523 int fallback_elf_brand
= -1;
524 SYSCTL_INT(_kern
, OID_AUTO
, fallback_elf_brand
, CTLFLAG_RW
,
525 &fallback_elf_brand
, -1,
526 "ELF brand of last resort");
528 static int can_exec_dyn
= 1;
529 SYSCTL_INT(_kern
, OID_AUTO
, elf_exec_dyn
, CTLFLAG_RW
,
531 "ELF: can exec shared libraries");
534 exec_elf_imgact(struct image_params
*imgp
)
536 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*) imgp
->image_header
;
537 const Elf_Phdr
*phdr
;
538 Elf_Auxargs
*elf_auxargs
= NULL
;
539 struct vmspace
*vmspace
;
541 u_long text_size
= 0, data_size
= 0, total_size
= 0;
542 u_long text_addr
= 0, data_addr
= 0;
543 u_long seg_size
, seg_addr
;
544 u_long addr
, entry
= 0, proghdr
= 0;
546 const char *interp
= NULL
;
547 const Elf_Note
*abi_note
= NULL
;
548 Elf_Brandinfo
*brand_info
;
554 * Do we have a valid ELF header ?
555 * We allow execution of ET_EXEC and, if kern.elf_exec_dyn is 1, ET_DYN.
557 if (elf_check_header(hdr
) != 0 ||
558 (hdr
->e_type
!= ET_EXEC
&& (!can_exec_dyn
|| hdr
->e_type
!= ET_DYN
)))
562 * From here on down, we return an errno, not -1, as we've
563 * detected an ELF file.
566 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
567 (hdr
->e_phoff
+ hdr
->e_phentsize
* hdr
->e_phnum
) > PAGE_SIZE
) {
568 /* Only support headers in first page for now */
571 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
574 * From this point on, we may have resources that need to be freed.
577 exec_new_vmspace(imgp
, NULL
);
580 * Yeah, I'm paranoid. There is every reason in the world to get
581 * VTEXT now since from here on out, there are places we can have
582 * a context switch. Better safe than sorry; I really don't want
583 * the file to change while it's being loaded.
585 vsetflags(imgp
->vp
, VTEXT
);
587 vmspace
= imgp
->proc
->p_vmspace
;
589 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
590 switch(phdr
[i
].p_type
) {
592 case PT_LOAD
: /* Loadable segment */
594 if (phdr
[i
].p_flags
& PF_X
)
595 prot
|= VM_PROT_EXECUTE
;
596 if (phdr
[i
].p_flags
& PF_W
)
597 prot
|= VM_PROT_WRITE
;
598 if (phdr
[i
].p_flags
& PF_R
)
599 prot
|= VM_PROT_READ
;
601 if ((error
= elf_load_section(imgp
->proc
,
604 (caddr_t
)phdr
[i
].p_vaddr
,
606 phdr
[i
].p_filesz
, prot
)) != 0)
610 * If this segment contains the program headers,
611 * remember their virtual address for the AT_PHDR
612 * aux entry. Static binaries don't usually include
615 if (phdr
[i
].p_offset
== 0 &&
616 hdr
->e_phoff
+ hdr
->e_phnum
* hdr
->e_phentsize
618 proghdr
= phdr
[i
].p_vaddr
+ hdr
->e_phoff
;
620 seg_addr
= trunc_page(phdr
[i
].p_vaddr
);
621 seg_size
= round_page(phdr
[i
].p_memsz
+
622 phdr
[i
].p_vaddr
- seg_addr
);
625 * Is this .text or .data? We can't use
626 * VM_PROT_WRITE or VM_PROT_EXEC, it breaks the
627 * alpha terribly and possibly does other bad
628 * things so we stick to the old way of figuring
629 * it out: If the segment contains the program
630 * entry point, it's a text segment, otherwise it
633 * Note that obreak() assumes that data_addr +
634 * data_size == end of data load area, and the ELF
635 * file format expects segments to be sorted by
636 * address. If multiple data segments exist, the
637 * last one will be used.
639 if (hdr
->e_entry
>= phdr
[i
].p_vaddr
&&
640 hdr
->e_entry
< (phdr
[i
].p_vaddr
+
642 text_size
= seg_size
;
643 text_addr
= seg_addr
;
644 entry
= (u_long
)hdr
->e_entry
;
646 data_size
= seg_size
;
647 data_addr
= seg_addr
;
649 total_size
+= seg_size
;
652 * Check limits. It should be safe to check the
653 * limits after loading the segment since we do
654 * not actually fault in all the segment's pages.
657 imgp
->proc
->p_rlimit
[RLIMIT_DATA
].rlim_cur
||
658 text_size
> maxtsiz
||
660 imgp
->proc
->p_rlimit
[RLIMIT_VMEM
].rlim_cur
) {
665 case PT_INTERP
: /* Path to interpreter */
666 if (phdr
[i
].p_filesz
> MAXPATHLEN
||
667 phdr
[i
].p_offset
+ phdr
[i
].p_filesz
> PAGE_SIZE
) {
671 interp
= imgp
->image_header
+ phdr
[i
].p_offset
;
673 case PT_NOTE
: /* Check for .note.ABI-tag */
675 const Elf_Note
*tmp_note
;
676 /* XXX handle anything outside the first page */
677 if (phdr
[i
].p_offset
+ phdr
[i
].p_filesz
> PAGE_SIZE
)
679 if (phdr
[i
].p_filesz
< sizeof(Elf_Note
))
680 continue; /* ENOEXEC? */
681 tmp_note
= (const Elf_Note
*)(imgp
->image_header
+ phdr
[i
].p_offset
);
682 if (tmp_note
->n_type
!= 1)
684 if (tmp_note
->n_namesz
+ sizeof(Elf_Note
) +
685 tmp_note
->n_descsz
> phdr
[i
].p_filesz
)
686 continue; /* ENOEXEC? */
690 case PT_PHDR
: /* Program header table info */
691 proghdr
= phdr
[i
].p_vaddr
;
698 vmspace
->vm_tsize
= text_size
>> PAGE_SHIFT
;
699 vmspace
->vm_taddr
= (caddr_t
)(uintptr_t)text_addr
;
700 vmspace
->vm_dsize
= data_size
>> PAGE_SHIFT
;
701 vmspace
->vm_daddr
= (caddr_t
)(uintptr_t)data_addr
;
703 addr
= ELF_RTLD_ADDR(vmspace
);
705 imgp
->entry_addr
= entry
;
709 /* We support three types of branding -- (1) the ELF EI_OSABI field
710 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
711 * branding w/in the ELF header, and (3) path of the `interp_path'
712 * field. We should also look for an ".note.ABI-tag" ELF section now
713 * in all Linux ELF binaries, FreeBSD 4.1+, and some NetBSD ones.
716 /* If the executable has a brand, search for it in the brand list. */
717 if (brand_info
== NULL
&& hdr
->e_ident
[EI_OSABI
] != ELFOSABI_NONE
) {
718 for (i
= 0; i
< MAX_BRANDS
; i
++) {
719 Elf_Brandinfo
*bi
= elf_brand_list
[i
];
722 (hdr
->e_ident
[EI_OSABI
] == bi
->brand
724 strncmp((const char *)&hdr
->e_ident
[OLD_EI_BRAND
],
725 bi
->compat_3_brand
, strlen(bi
->compat_3_brand
)))) {
732 /* Search for a recognized ABI. */
733 if (brand_info
== NULL
&& abi_note
!= NULL
) {
734 for (i
= 0; i
< MAX_BRANDS
; i
++) {
735 Elf_Brandinfo
*bi
= elf_brand_list
[i
];
737 if (bi
!= NULL
&& bi
->match_abi_note
!= NULL
&&
738 (*bi
->match_abi_note
)(abi_note
)) {
746 * ELFOSABI_NONE == ELFOSABI_SYSV, so a SYSV binary misses all
747 * checks so far, since it is neither branded nor does it have
748 * an ABI note. If the EI_OSABI field is ELFOSABI_NONE, assume
749 * it is svr4 and look for an entry in the elf_brand_list with
750 * match_abi_note == NULL.
752 if (brand_info
== NULL
&& hdr
->e_ident
[EI_OSABI
] == ELFOSABI_NONE
) {
753 for (i
= 0; i
< MAX_BRANDS
; i
++) {
754 Elf_Brandinfo
*bi
= elf_brand_list
[i
];
756 if (bi
!= NULL
&& bi
->match_abi_note
== NULL
&&
757 ELFOSABI_SYSV
== bi
->brand
) {
764 /* Lacking a recognized ABI, search for a recognized interpreter. */
765 if (brand_info
== NULL
&& interp
!= NULL
) {
766 for (i
= 0; i
< MAX_BRANDS
; i
++) {
767 Elf_Brandinfo
*bi
= elf_brand_list
[i
];
770 strcmp(interp
, bi
->interp_path
) == 0) {
777 /* Lacking a recognized interpreter, try the default brand */
778 if (brand_info
== NULL
) {
779 for (i
= 0; i
< MAX_BRANDS
; i
++) {
780 Elf_Brandinfo
*bi
= elf_brand_list
[i
];
782 if (bi
!= NULL
&& fallback_elf_brand
== bi
->brand
) {
789 if (brand_info
== NULL
) {
790 uprintf("ELF binary type \"%u\" not known.\n",
791 hdr
->e_ident
[EI_OSABI
]);
796 imgp
->proc
->p_sysent
= brand_info
->sysvec
;
797 if (interp
!= NULL
) {
798 path
= kmalloc(MAXPATHLEN
, M_TEMP
, M_WAITOK
);
799 ksnprintf(path
, MAXPATHLEN
, "%s%s",
800 brand_info
->emul_path
, interp
);
801 if ((error
= elf_load_file(imgp
->proc
, path
, &addr
,
802 &imgp
->entry_addr
)) != 0) {
803 if ((error
= elf_load_file(imgp
->proc
, interp
, &addr
,
804 &imgp
->entry_addr
)) != 0) {
805 uprintf("ELF interpreter %s not found\n", path
);
816 * Construct auxargs table (used by the fixup routine)
818 elf_auxargs
= kmalloc(sizeof(Elf_Auxargs
), M_TEMP
, M_WAITOK
);
819 elf_auxargs
->execfd
= -1;
820 elf_auxargs
->phdr
= proghdr
;
821 elf_auxargs
->phent
= hdr
->e_phentsize
;
822 elf_auxargs
->phnum
= hdr
->e_phnum
;
823 elf_auxargs
->pagesz
= PAGE_SIZE
;
824 elf_auxargs
->base
= addr
;
825 elf_auxargs
->flags
= 0;
826 elf_auxargs
->entry
= entry
;
827 elf_auxargs
->trace
= elf_trace
;
829 imgp
->auxargs
= elf_auxargs
;
830 imgp
->interpreted
= 0;
837 elf_freebsd_fixup(register_t
**stack_base
, struct image_params
*imgp
)
839 Elf_Auxargs
*args
= (Elf_Auxargs
*)imgp
->auxargs
;
842 pos
= *stack_base
+ (imgp
->args
->argc
+ imgp
->args
->envc
+ 2);
845 AUXARGS_ENTRY(pos
, AT_DEBUG
, 1);
847 if (args
->execfd
!= -1) {
848 AUXARGS_ENTRY(pos
, AT_EXECFD
, args
->execfd
);
850 AUXARGS_ENTRY(pos
, AT_PHDR
, args
->phdr
);
851 AUXARGS_ENTRY(pos
, AT_PHENT
, args
->phent
);
852 AUXARGS_ENTRY(pos
, AT_PHNUM
, args
->phnum
);
853 AUXARGS_ENTRY(pos
, AT_PAGESZ
, args
->pagesz
);
854 AUXARGS_ENTRY(pos
, AT_FLAGS
, args
->flags
);
855 AUXARGS_ENTRY(pos
, AT_ENTRY
, args
->entry
);
856 AUXARGS_ENTRY(pos
, AT_BASE
, args
->base
);
857 AUXARGS_ENTRY(pos
, AT_NULL
, 0);
859 kfree(imgp
->auxargs
, M_TEMP
);
860 imgp
->auxargs
= NULL
;
863 suword(*stack_base
, (long) imgp
->args
->argc
);
868 * Code for generating ELF core dumps.
871 typedef int (*segment_callback
) (vm_map_entry_t
, void *);
873 /* Closure for cb_put_phdr(). */
874 struct phdr_closure
{
875 Elf_Phdr
*phdr
; /* Program header to fill in (incremented) */
876 Elf_Phdr
*phdr_max
; /* Pointer bound for error check */
877 Elf_Off offset
; /* Offset of segment in core file */
880 /* Closure for cb_size_segment(). */
881 struct sseg_closure
{
882 int count
; /* Count of writable segments. */
883 size_t vsize
; /* Total size of all writable segments. */
886 /* Closure for cb_put_fp(). */
889 struct vn_hdr
*vnh_max
;
894 typedef struct elf_buf
{
900 static void *target_reserve(elf_buf_t target
, size_t bytes
, int *error
);
902 static int cb_put_phdr (vm_map_entry_t
, void *);
903 static int cb_size_segment (vm_map_entry_t
, void *);
904 static int cb_fpcount_segment(vm_map_entry_t
, void *);
905 static int cb_put_fp(vm_map_entry_t
, void *);
908 static int each_segment (struct proc
*, segment_callback
, void *, int);
909 static int elf_corehdr (struct lwp
*, int, struct file
*, struct ucred
*,
911 enum putmode
{ WRITE
, DRYRUN
};
912 static int elf_puthdr (struct lwp
*, elf_buf_t
, int sig
, enum putmode
,
914 static int elf_putallnotes(struct lwp
*, elf_buf_t
, int, enum putmode
);
915 static int elf_putnote (elf_buf_t
, const char *, int, const void *, size_t);
917 static int elf_putsigs(struct lwp
*, elf_buf_t
);
918 static int elf_puttextvp(struct proc
*, elf_buf_t
);
919 static int elf_putfiles(struct proc
*, elf_buf_t
, struct file
*);
921 extern int osreldate
;
924 elf_coredump(struct lwp
*lp
, int sig
, struct vnode
*vp
, off_t limit
)
929 if ((error
= falloc(NULL
, &fp
, NULL
)) != 0)
931 fsetcred(fp
, lp
->lwp_proc
->p_ucred
);
936 fp
->f_type
= DTYPE_VNODE
;
937 fp
->f_flag
= O_CREAT
|O_WRONLY
|O_NOFOLLOW
;
938 fp
->f_ops
= &vnode_fileops
;
942 error
= generic_elf_coredump(lp
, sig
, fp
, limit
);
946 fp
->f_ops
= &badfileops
;
953 generic_elf_coredump(struct lwp
*lp
, int sig
, struct file
*fp
, off_t limit
)
955 struct proc
*p
= lp
->lwp_proc
;
956 struct ucred
*cred
= p
->p_ucred
;
958 struct sseg_closure seginfo
;
959 struct elf_buf target
;
962 kprintf("can't dump core - null fp\n");
965 * Size the program segments
969 each_segment(p
, cb_size_segment
, &seginfo
, 1);
972 * Calculate the size of the core file header area by making
973 * a dry run of generating it. Nothing is written, but the
974 * size is calculated.
976 bzero(&target
, sizeof(target
));
977 elf_puthdr(lp
, &target
, sig
, DRYRUN
, seginfo
.count
, fp
);
979 if (target
.off
+ seginfo
.vsize
>= limit
)
983 * Allocate memory for building the header, fill it up,
986 target
.off_max
= target
.off
;
988 target
.buf
= kmalloc(target
.off_max
, M_TEMP
, M_WAITOK
|M_ZERO
);
990 error
= elf_corehdr(lp
, sig
, fp
, cred
, seginfo
.count
, &target
);
992 /* Write the contents of all of the writable segments. */
998 php
= (Elf_Phdr
*)(target
.buf
+ sizeof(Elf_Ehdr
)) + 1;
999 for (i
= 0; i
< seginfo
.count
; i
++) {
1000 error
= fp_write(fp
, (caddr_t
)php
->p_vaddr
,
1001 php
->p_filesz
, &nbytes
, UIO_USERSPACE
);
1007 kfree(target
.buf
, M_TEMP
);
1013 * A callback for each_segment() to write out the segment's
1014 * program header entry.
1017 cb_put_phdr(vm_map_entry_t entry
, void *closure
)
1019 struct phdr_closure
*phc
= closure
;
1020 Elf_Phdr
*phdr
= phc
->phdr
;
1022 if (phc
->phdr
== phc
->phdr_max
)
1025 phc
->offset
= round_page(phc
->offset
);
1027 phdr
->p_type
= PT_LOAD
;
1028 phdr
->p_offset
= phc
->offset
;
1029 phdr
->p_vaddr
= entry
->start
;
1031 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1032 phdr
->p_align
= PAGE_SIZE
;
1034 if (entry
->protection
& VM_PROT_READ
)
1035 phdr
->p_flags
|= PF_R
;
1036 if (entry
->protection
& VM_PROT_WRITE
)
1037 phdr
->p_flags
|= PF_W
;
1038 if (entry
->protection
& VM_PROT_EXECUTE
)
1039 phdr
->p_flags
|= PF_X
;
1041 phc
->offset
+= phdr
->p_filesz
;
1047 * A callback for each_writable_segment() to gather information about
1048 * the number of segments and their total size.
1051 cb_size_segment(vm_map_entry_t entry
, void *closure
)
1053 struct sseg_closure
*ssc
= closure
;
1056 ssc
->vsize
+= entry
->end
- entry
->start
;
1061 * A callback for each_segment() to gather information about
1062 * the number of text segments.
1065 cb_fpcount_segment(vm_map_entry_t entry
, void *closure
)
1067 int *count
= closure
;
1070 if (entry
->object
.vm_object
->type
== OBJT_VNODE
) {
1071 vp
= (struct vnode
*)entry
->object
.vm_object
->handle
;
1072 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1080 cb_put_fp(vm_map_entry_t entry
, void *closure
)
1082 struct fp_closure
*fpc
= closure
;
1083 struct vn_hdr
*vnh
= fpc
->vnh
;
1084 Elf_Phdr
*phdr
= &vnh
->vnh_phdr
;
1089 * If an entry represents a vnode then write out a file handle.
1091 * If we are checkpointing a checkpoint-restored program we do
1092 * NOT record the filehandle for the old checkpoint vnode (which
1093 * is mapped all over the place). Instead we rely on the fact
1094 * that a checkpoint-restored program does not mmap() the checkpt
1095 * vnode NOCORE, so its contents will be written out to the
1096 * new checkpoint file. This is necessary because the 'old'
1097 * checkpoint file is typically destroyed when a new one is created
1098 * and thus cannot be used to restore the new checkpoint.
1100 * Theoretically we could create a chain of checkpoint files and
1101 * operate the checkpointing operation kinda like an incremental
1102 * checkpoint, but a checkpoint restore would then likely wind up
1103 * referencing many prior checkpoint files and that is a bit over
1104 * the top for the purpose of the checkpoint API.
1106 if (entry
->object
.vm_object
->type
== OBJT_VNODE
) {
1107 vp
= (struct vnode
*)entry
->object
.vm_object
->handle
;
1108 if ((vp
->v_flag
& VCKPT
) && curproc
->p_textvp
== vp
)
1110 if (vnh
== fpc
->vnh_max
)
1114 vnh
->vnh_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1115 error
= VFS_VPTOFH(vp
, &vnh
->vnh_fh
.fh_fid
);
1117 char *freepath
, *fullpath
;
1119 if (vn_fullpath(curproc
, vp
, &fullpath
, &freepath
)) {
1120 kprintf("Warning: coredump, error %d: cannot store file handle for vnode %p\n", error
, vp
);
1122 kprintf("Warning: coredump, error %d: cannot store file handle for %s\n", error
, fullpath
);
1123 kfree(freepath
, M_TEMP
);
1128 phdr
->p_type
= PT_LOAD
;
1129 phdr
->p_offset
= 0; /* not written to core */
1130 phdr
->p_vaddr
= entry
->start
;
1132 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1133 phdr
->p_align
= PAGE_SIZE
;
1135 if (entry
->protection
& VM_PROT_READ
)
1136 phdr
->p_flags
|= PF_R
;
1137 if (entry
->protection
& VM_PROT_WRITE
)
1138 phdr
->p_flags
|= PF_W
;
1139 if (entry
->protection
& VM_PROT_EXECUTE
)
1140 phdr
->p_flags
|= PF_X
;
1148 * For each writable segment in the process's memory map, call the given
1149 * function with a pointer to the map entry and some arbitrary
1150 * caller-supplied data.
1153 each_segment(struct proc
*p
, segment_callback func
, void *closure
, int writable
)
1156 vm_map_t map
= &p
->p_vmspace
->vm_map
;
1157 vm_map_entry_t entry
;
1159 for (entry
= map
->header
.next
; error
== 0 && entry
!= &map
->header
;
1160 entry
= entry
->next
) {
1164 * Don't dump inaccessible mappings, deal with legacy
1167 * Note that read-only segments related to the elf binary
1168 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1169 * need to arbitrarily ignore such segments.
1171 if (elf_legacy_coredump
) {
1172 if (writable
&& (entry
->protection
& VM_PROT_RW
) != VM_PROT_RW
)
1175 if (writable
&& (entry
->protection
& VM_PROT_ALL
) == 0)
1180 * Dont include memory segment in the coredump if
1181 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1184 * Currently we only dump normal VM object maps. We do
1185 * not dump submaps or virtual page tables.
1187 if (writable
&& (entry
->eflags
& MAP_ENTRY_NOCOREDUMP
))
1189 if (entry
->maptype
!= VM_MAPTYPE_NORMAL
)
1191 if ((obj
= entry
->object
.vm_object
) == NULL
)
1194 /* Find the deepest backing object. */
1195 while (obj
->backing_object
!= NULL
)
1196 obj
= obj
->backing_object
;
1198 /* Ignore memory-mapped devices and such things. */
1199 if (obj
->type
!= OBJT_DEFAULT
&&
1200 obj
->type
!= OBJT_SWAP
&&
1201 obj
->type
!= OBJT_VNODE
)
1204 error
= (*func
)(entry
, closure
);
1211 target_reserve(elf_buf_t target
, size_t bytes
, int *error
)
1216 if (target
->off
+ bytes
> target
->off_max
)
1219 res
= target
->buf
+ target
->off
;
1221 target
->off
+= bytes
;
1226 * Write the core file header to the file, including padding up to
1227 * the page boundary.
1230 elf_corehdr(struct lwp
*lp
, int sig
, struct file
*fp
, struct ucred
*cred
,
1231 int numsegs
, elf_buf_t target
)
1237 * Fill in the header. The fp is passed so we can detect and flag
1238 * a checkpoint file pointer within the core file itself, because
1239 * it may not be restored from the same file handle.
1241 error
= elf_puthdr(lp
, target
, sig
, WRITE
, numsegs
, fp
);
1243 /* Write it to the core file. */
1245 error
= fp_write(fp
, target
->buf
, target
->off
, &nbytes
,
1252 elf_puthdr(struct lwp
*lp
, elf_buf_t target
, int sig
, enum putmode mode
,
1253 int numsegs
, struct file
*fp
)
1255 struct proc
*p
= lp
->lwp_proc
;
1263 ehdr
= target_reserve(target
, sizeof(Elf_Ehdr
), &error
);
1265 phoff
= target
->off
;
1266 phdr
= target_reserve(target
, (numsegs
+ 1) * sizeof(Elf_Phdr
), &error
);
1268 noteoff
= target
->off
;
1270 elf_putallnotes(lp
, target
, sig
, mode
);
1271 notesz
= target
->off
- noteoff
;
1274 * put extra cruft for dumping process state here
1275 * - we really want it be before all the program
1277 * - we just need to update the offset accordingly
1278 * and GDB will be none the wiser.
1281 error
= elf_puttextvp(p
, target
);
1283 error
= elf_putsigs(lp
, target
);
1285 error
= elf_putfiles(p
, target
, fp
);
1288 * Align up to a page boundary for the program segments. The
1289 * actual data will be written to the outptu file, not to elf_buf_t,
1290 * so we do not have to do any further bounds checking.
1292 target
->off
= round_page(target
->off
);
1293 if (error
== 0 && ehdr
!= NULL
) {
1295 * Fill in the ELF header.
1297 ehdr
->e_ident
[EI_MAG0
] = ELFMAG0
;
1298 ehdr
->e_ident
[EI_MAG1
] = ELFMAG1
;
1299 ehdr
->e_ident
[EI_MAG2
] = ELFMAG2
;
1300 ehdr
->e_ident
[EI_MAG3
] = ELFMAG3
;
1301 ehdr
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1302 ehdr
->e_ident
[EI_DATA
] = ELF_DATA
;
1303 ehdr
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1304 ehdr
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1305 ehdr
->e_ident
[EI_ABIVERSION
] = 0;
1306 ehdr
->e_ident
[EI_PAD
] = 0;
1307 ehdr
->e_type
= ET_CORE
;
1308 ehdr
->e_machine
= ELF_ARCH
;
1309 ehdr
->e_version
= EV_CURRENT
;
1311 ehdr
->e_phoff
= phoff
;
1313 ehdr
->e_ehsize
= sizeof(Elf_Ehdr
);
1314 ehdr
->e_phentsize
= sizeof(Elf_Phdr
);
1315 ehdr
->e_phnum
= numsegs
+ 1;
1316 ehdr
->e_shentsize
= sizeof(Elf_Shdr
);
1318 ehdr
->e_shstrndx
= SHN_UNDEF
;
1320 if (error
== 0 && phdr
!= NULL
) {
1322 * Fill in the program header entries.
1324 struct phdr_closure phc
;
1326 /* The note segement. */
1327 phdr
->p_type
= PT_NOTE
;
1328 phdr
->p_offset
= noteoff
;
1331 phdr
->p_filesz
= notesz
;
1337 /* All the writable segments from the program. */
1339 phc
.phdr_max
= phdr
+ numsegs
;
1340 phc
.offset
= target
->off
;
1341 each_segment(p
, cb_put_phdr
, &phc
, 1);
1347 * Append core dump notes to target ELF buffer or simply update target size
1348 * if dryrun selected.
1351 elf_putallnotes(struct lwp
*corelp
, elf_buf_t target
, int sig
,
1354 struct proc
*p
= corelp
->lwp_proc
;
1358 prfpregset_t fpregs
;
1362 prfpregset_t
*fpregs
;
1367 * Allocate temporary storage for notes on heap to avoid stack overflow.
1369 if (mode
!= DRYRUN
) {
1370 tmpdata
= kmalloc(sizeof(*tmpdata
), M_TEMP
, M_ZERO
| M_WAITOK
);
1371 status
= &tmpdata
->status
;
1372 fpregs
= &tmpdata
->fpregs
;
1373 psinfo
= &tmpdata
->psinfo
;
1382 * Append LWP-agnostic note.
1384 if (mode
!= DRYRUN
) {
1385 psinfo
->pr_version
= PRPSINFO_VERSION
;
1386 psinfo
->pr_psinfosz
= sizeof(prpsinfo_t
);
1387 strncpy(psinfo
->pr_fname
, p
->p_comm
,
1388 sizeof(psinfo
->pr_fname
) - 1);
1390 * XXX - We don't fill in the command line arguments
1393 strncpy(psinfo
->pr_psargs
, p
->p_comm
, PRARGSZ
);
1396 elf_putnote(target
, "FreeBSD", NT_PRPSINFO
, psinfo
, sizeof *psinfo
);
1401 * Append first note for LWP that triggered core so that it is
1402 * the selected one when the debugger starts.
1404 if (mode
!= DRYRUN
) {
1405 status
->pr_version
= PRSTATUS_VERSION
;
1406 status
->pr_statussz
= sizeof(prstatus_t
);
1407 status
->pr_gregsetsz
= sizeof(gregset_t
);
1408 status
->pr_fpregsetsz
= sizeof(fpregset_t
);
1409 status
->pr_osreldate
= osreldate
;
1410 status
->pr_cursig
= sig
;
1412 * XXX GDB needs unique pr_pid for each LWP and does not
1413 * not support pr_pid==0 but lwp_tid can be 0, so hack unique
1416 status
->pr_pid
= p
->p_pid
+ corelp
->lwp_tid
;
1417 fill_regs(corelp
, &status
->pr_reg
);
1418 fill_fpregs(corelp
, fpregs
);
1421 elf_putnote(target
, "FreeBSD", NT_PRSTATUS
, status
, sizeof *status
);
1425 elf_putnote(target
, "FreeBSD", NT_FPREGSET
, fpregs
, sizeof *fpregs
);
1430 * Then append notes for other LWPs.
1432 FOREACH_LWP_IN_PROC(lp
, p
) {
1435 /* skip lwps being created */
1436 if (lp
->lwp_thread
== NULL
)
1438 if (mode
!= DRYRUN
) {
1439 status
->pr_pid
= p
->p_pid
+ lp
->lwp_tid
;
1440 fill_regs(lp
, &status
->pr_reg
);
1441 fill_fpregs(lp
, fpregs
);
1443 error
= elf_putnote(target
, "FreeBSD", NT_PRSTATUS
,
1444 status
, sizeof *status
);
1447 error
= elf_putnote(target
, "FreeBSD", NT_FPREGSET
,
1448 fpregs
, sizeof *fpregs
);
1454 if (tmpdata
!= NULL
)
1455 kfree(tmpdata
, M_TEMP
);
1460 * Generate a note sub-structure.
1462 * NOTE: 4-byte alignment.
1465 elf_putnote(elf_buf_t target
, const char *name
, int type
,
1466 const void *desc
, size_t descsz
)
1472 note
.n_namesz
= strlen(name
) + 1;
1473 note
.n_descsz
= descsz
;
1475 dst
= target_reserve(target
, sizeof(note
), &error
);
1477 bcopy(¬e
, dst
, sizeof note
);
1478 dst
= target_reserve(target
, note
.n_namesz
, &error
);
1480 bcopy(name
, dst
, note
.n_namesz
);
1481 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1482 dst
= target_reserve(target
, note
.n_descsz
, &error
);
1484 bcopy(desc
, dst
, note
.n_descsz
);
1485 target
->off
= roundup2(target
->off
, sizeof(Elf_Word
));
1491 elf_putsigs(struct lwp
*lp
, elf_buf_t target
)
1493 /* XXX lwp handle more than one lwp */
1494 struct proc
*p
= lp
->lwp_proc
;
1496 struct ckpt_siginfo
*csi
;
1498 csi
= target_reserve(target
, sizeof(struct ckpt_siginfo
), &error
);
1500 csi
->csi_ckptpisz
= sizeof(struct ckpt_siginfo
);
1501 bcopy(p
->p_sigacts
, &csi
->csi_sigacts
, sizeof(*p
->p_sigacts
));
1502 bcopy(&p
->p_realtimer
, &csi
->csi_itimerval
, sizeof(struct itimerval
));
1503 bcopy(&lp
->lwp_sigmask
, &csi
->csi_sigmask
,
1505 csi
->csi_sigparent
= p
->p_sigparent
;
1511 elf_putfiles(struct proc
*p
, elf_buf_t target
, struct file
*ckfp
)
1515 struct ckpt_filehdr
*cfh
= NULL
;
1516 struct ckpt_fileinfo
*cfi
;
1520 * the duplicated loop is gross, but it was the only way
1521 * to eliminate uninitialized variable warnings
1523 cfh
= target_reserve(target
, sizeof(struct ckpt_filehdr
), &error
);
1525 cfh
->cfh_nfiles
= 0;
1529 * ignore STDIN/STDERR/STDOUT.
1531 for (i
= 3; error
== 0 && i
< p
->p_fd
->fd_nfiles
; i
++) {
1532 fp
= holdfp(p
->p_fd
, i
, -1);
1536 * XXX Only checkpoint vnodes for now.
1538 if (fp
->f_type
!= DTYPE_VNODE
) {
1542 cfi
= target_reserve(target
, sizeof(struct ckpt_fileinfo
),
1548 cfi
->cfi_index
= -1;
1549 cfi
->cfi_type
= fp
->f_type
;
1550 cfi
->cfi_flags
= fp
->f_flag
;
1551 cfi
->cfi_offset
= fp
->f_offset
;
1552 cfi
->cfi_ckflags
= 0;
1555 cfi
->cfi_ckflags
|= CKFIF_ISCKPTFD
;
1556 /* f_count and f_msgcount should not be saved/restored */
1557 /* XXX save cred info */
1559 switch(fp
->f_type
) {
1561 vp
= (struct vnode
*)fp
->f_data
;
1563 * it looks like a bug in ptrace is marking
1564 * a non-vnode as a vnode - until we find the
1565 * root cause this will at least prevent
1566 * further panics from truss
1568 if (vp
== NULL
|| vp
->v_mount
== NULL
)
1572 cfi
->cfi_fh
.fh_fsid
= vp
->v_mount
->mnt_stat
.f_fsid
;
1573 error
= VFS_VPTOFH(vp
, &cfi
->cfi_fh
.fh_fid
);
1584 elf_puttextvp(struct proc
*p
, elf_buf_t target
)
1588 struct fp_closure fpc
;
1589 struct ckpt_vminfo
*vminfo
;
1591 vminfo
= target_reserve(target
, sizeof(struct ckpt_vminfo
), &error
);
1592 if (vminfo
!= NULL
) {
1593 vminfo
->cvm_dsize
= p
->p_vmspace
->vm_dsize
;
1594 vminfo
->cvm_tsize
= p
->p_vmspace
->vm_tsize
;
1595 vminfo
->cvm_daddr
= p
->p_vmspace
->vm_daddr
;
1596 vminfo
->cvm_taddr
= p
->p_vmspace
->vm_taddr
;
1600 vn_count
= target_reserve(target
, sizeof(int), &error
);
1601 if (target
->buf
!= NULL
) {
1602 fpc
.vnh
= (struct vn_hdr
*)(target
->buf
+ target
->off
);
1603 fpc
.vnh_max
= fpc
.vnh
+
1604 (target
->off_max
- target
->off
) / sizeof(struct vn_hdr
);
1605 error
= each_segment(p
, cb_put_fp
, &fpc
, 0);
1607 *vn_count
= fpc
.count
;
1609 error
= each_segment(p
, cb_fpcount_segment
, &fpc
.count
, 0);
1611 target
->off
+= fpc
.count
* sizeof(struct vn_hdr
);
1617 * Tell kern_execve.c about it, with a little help from the linker.
1619 static struct execsw elf_execsw
= {exec_elf_imgact
, "ELF"};
1620 EXEC_SET_ORDERED(elf
, elf_execsw
, SI_ORDER_FIRST
);