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.
31 #include <sys/cdefs.h>
32 __FBSDID("$FreeBSD$");
34 #include "opt_capsicum.h"
35 #include "opt_compat.h"
38 #include <sys/param.h>
39 #include <sys/capsicum.h>
41 #include <sys/fcntl.h>
43 #include <sys/imgact.h>
44 #include <sys/imgact_elf.h>
46 #include <sys/kernel.h>
48 #include <sys/malloc.h>
49 #include <sys/mount.h>
51 #include <sys/namei.h>
52 #include <sys/pioctl.h>
54 #include <sys/procfs.h>
55 #include <sys/racct.h>
56 #include <sys/resourcevar.h>
57 #include <sys/rwlock.h>
59 #include <sys/sf_buf.h>
61 #include <sys/systm.h>
62 #include <sys/signalvar.h>
65 #include <sys/syscall.h>
66 #include <sys/sysctl.h>
67 #include <sys/sysent.h>
68 #include <sys/vnode.h>
69 #include <sys/syslog.h>
70 #include <sys/eventhandler.h>
74 #include <vm/vm_kern.h>
75 #include <vm/vm_param.h>
77 #include <vm/vm_map.h>
78 #include <vm/vm_object.h>
79 #include <vm/vm_extern.h>
81 #include <machine/elf.h>
82 #include <machine/md_var.h>
84 #define ELF_NOTE_ROUNDSIZE 4
85 #define OLD_EI_BRAND 8
87 static int __elfN(check_header
)(const Elf_Ehdr
*hdr
);
88 static Elf_Brandinfo
*__elfN(get_brandinfo
)(struct image_params
*imgp
,
89 const char *interp
, int interp_name_len
, int32_t *osrel
);
90 static int __elfN(load_file
)(struct proc
*p
, const char *file
, u_long
*addr
,
91 u_long
*entry
, size_t pagesize
);
92 static int __elfN(load_section
)(struct image_params
*imgp
, vm_offset_t offset
,
93 caddr_t vmaddr
, size_t memsz
, size_t filsz
, vm_prot_t prot
,
95 static int __CONCAT(exec_
, __elfN(imgact
))(struct image_params
*imgp
);
96 static boolean_t
__elfN(freebsd_trans_osrel
)(const Elf_Note
*note
,
98 static boolean_t
kfreebsd_trans_osrel(const Elf_Note
*note
, int32_t *osrel
);
99 static boolean_t
__elfN(check_note
)(struct image_params
*imgp
,
100 Elf_Brandnote
*checknote
, int32_t *osrel
);
101 static vm_prot_t
__elfN(trans_prot
)(Elf_Word
);
102 static Elf_Word
__elfN(untrans_prot
)(vm_prot_t
);
104 SYSCTL_NODE(_kern
, OID_AUTO
, __CONCAT(elf
, __ELF_WORD_SIZE
), CTLFLAG_RW
, 0,
107 #define CORE_BUF_SIZE (16 * 1024)
109 int __elfN(fallback_brand
) = -1;
110 SYSCTL_INT(__CONCAT(_kern_elf
, __ELF_WORD_SIZE
), OID_AUTO
,
111 fallback_brand
, CTLFLAG_RWTUN
, &__elfN(fallback_brand
), 0,
112 __XSTRING(__CONCAT(ELF
, __ELF_WORD_SIZE
)) " brand of last resort");
114 static int elf_legacy_coredump
= 0;
115 SYSCTL_INT(_debug
, OID_AUTO
, __elfN(legacy_coredump
), CTLFLAG_RW
,
116 &elf_legacy_coredump
, 0,
117 "include all and only RW pages in core dumps");
119 int __elfN(nxstack
) =
120 #if defined(__amd64__) || defined(__powerpc64__) /* both 64 and 32 bit */ || \
121 (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__)
126 SYSCTL_INT(__CONCAT(_kern_elf
, __ELF_WORD_SIZE
), OID_AUTO
,
127 nxstack
, CTLFLAG_RW
, &__elfN(nxstack
), 0,
128 __XSTRING(__CONCAT(ELF
, __ELF_WORD_SIZE
)) ": enable non-executable stack");
130 #if __ELF_WORD_SIZE == 32
131 #if defined(__amd64__)
132 int i386_read_exec
= 0;
133 SYSCTL_INT(_kern_elf32
, OID_AUTO
, read_exec
, CTLFLAG_RW
, &i386_read_exec
, 0,
134 "enable execution from readable segments");
138 static Elf_Brandinfo
*elf_brand_list
[MAX_BRANDS
];
140 #define trunc_page_ps(va, ps) rounddown2(va, ps)
141 #define round_page_ps(va, ps) roundup2(va, ps)
142 #define aligned(a, t) (trunc_page_ps((u_long)(a), sizeof(t)) == (u_long)(a))
144 static const char FREEBSD_ABI_VENDOR
[] = "FreeBSD";
146 Elf_Brandnote
__elfN(freebsd_brandnote
) = {
147 .hdr
.n_namesz
= sizeof(FREEBSD_ABI_VENDOR
),
148 .hdr
.n_descsz
= sizeof(int32_t),
149 .hdr
.n_type
= NT_FREEBSD_ABI_TAG
,
150 .vendor
= FREEBSD_ABI_VENDOR
,
151 .flags
= BN_TRANSLATE_OSREL
,
152 .trans_osrel
= __elfN(freebsd_trans_osrel
)
156 __elfN(freebsd_trans_osrel
)(const Elf_Note
*note
, int32_t *osrel
)
160 p
= (uintptr_t)(note
+ 1);
161 p
+= roundup2(note
->n_namesz
, ELF_NOTE_ROUNDSIZE
);
162 *osrel
= *(const int32_t *)(p
);
167 static const char GNU_ABI_VENDOR
[] = "GNU";
168 static int GNU_KFREEBSD_ABI_DESC
= 3;
170 Elf_Brandnote
__elfN(kfreebsd_brandnote
) = {
171 .hdr
.n_namesz
= sizeof(GNU_ABI_VENDOR
),
172 .hdr
.n_descsz
= 16, /* XXX at least 16 */
174 .vendor
= GNU_ABI_VENDOR
,
175 .flags
= BN_TRANSLATE_OSREL
,
176 .trans_osrel
= kfreebsd_trans_osrel
180 kfreebsd_trans_osrel(const Elf_Note
*note
, int32_t *osrel
)
182 const Elf32_Word
*desc
;
185 p
= (uintptr_t)(note
+ 1);
186 p
+= roundup2(note
->n_namesz
, ELF_NOTE_ROUNDSIZE
);
188 desc
= (const Elf32_Word
*)p
;
189 if (desc
[0] != GNU_KFREEBSD_ABI_DESC
)
193 * Debian GNU/kFreeBSD embed the earliest compatible kernel version
194 * (__FreeBSD_version: <major><two digit minor>Rxx) in the LSB way.
196 *osrel
= desc
[1] * 100000 + desc
[2] * 1000 + desc
[3];
202 __elfN(insert_brand_entry
)(Elf_Brandinfo
*entry
)
206 for (i
= 0; i
< MAX_BRANDS
; i
++) {
207 if (elf_brand_list
[i
] == NULL
) {
208 elf_brand_list
[i
] = entry
;
212 if (i
== MAX_BRANDS
) {
213 printf("WARNING: %s: could not insert brandinfo entry: %p\n",
221 __elfN(remove_brand_entry
)(Elf_Brandinfo
*entry
)
225 for (i
= 0; i
< MAX_BRANDS
; i
++) {
226 if (elf_brand_list
[i
] == entry
) {
227 elf_brand_list
[i
] = NULL
;
237 __elfN(brand_inuse
)(Elf_Brandinfo
*entry
)
242 sx_slock(&allproc_lock
);
243 FOREACH_PROC_IN_SYSTEM(p
) {
244 if (p
->p_sysent
== entry
->sysvec
) {
249 sx_sunlock(&allproc_lock
);
254 static Elf_Brandinfo
*
255 __elfN(get_brandinfo
)(struct image_params
*imgp
, const char *interp
,
256 int interp_name_len
, int32_t *osrel
)
258 const Elf_Ehdr
*hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
259 Elf_Brandinfo
*bi
, *bi_m
;
264 * We support four types of branding -- (1) the ELF EI_OSABI field
265 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
266 * branding w/in the ELF header, (3) path of the `interp_path'
267 * field, and (4) the ".note.ABI-tag" ELF section.
270 /* Look for an ".note.ABI-tag" ELF section */
272 for (i
= 0; i
< MAX_BRANDS
; i
++) {
273 bi
= elf_brand_list
[i
];
276 if (hdr
->e_machine
== bi
->machine
&& (bi
->flags
&
277 (BI_BRAND_NOTE
|BI_BRAND_NOTE_MANDATORY
)) != 0) {
278 ret
= __elfN(check_note
)(imgp
, bi
->brand_note
, osrel
);
279 /* Give brand a chance to veto check_note's guess */
280 if (ret
&& bi
->header_supported
)
281 ret
= bi
->header_supported(imgp
);
283 * If note checker claimed the binary, but the
284 * interpreter path in the image does not
285 * match default one for the brand, try to
286 * search for other brands with the same
287 * interpreter. Either there is better brand
288 * with the right interpreter, or, failing
289 * this, we return first brand which accepted
290 * our note and, optionally, header.
292 if (ret
&& bi_m
== NULL
&& (strlen(bi
->interp_path
) +
293 1 != interp_name_len
|| strncmp(interp
,
294 bi
->interp_path
, interp_name_len
) != 0)) {
305 /* If the executable has a brand, search for it in the brand list. */
306 for (i
= 0; i
< MAX_BRANDS
; i
++) {
307 bi
= elf_brand_list
[i
];
308 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
310 if (hdr
->e_machine
== bi
->machine
&&
311 (hdr
->e_ident
[EI_OSABI
] == bi
->brand
||
312 strncmp((const char *)&hdr
->e_ident
[OLD_EI_BRAND
],
313 bi
->compat_3_brand
, strlen(bi
->compat_3_brand
)) == 0)) {
314 /* Looks good, but give brand a chance to veto */
315 if (!bi
->header_supported
|| bi
->header_supported(imgp
))
320 /* No known brand, see if the header is recognized by any brand */
321 for (i
= 0; i
< MAX_BRANDS
; i
++) {
322 bi
= elf_brand_list
[i
];
323 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
||
324 bi
->header_supported
== NULL
)
326 if (hdr
->e_machine
== bi
->machine
) {
327 ret
= bi
->header_supported(imgp
);
333 /* Lacking a known brand, search for a recognized interpreter. */
334 if (interp
!= NULL
) {
335 for (i
= 0; i
< MAX_BRANDS
; i
++) {
336 bi
= elf_brand_list
[i
];
337 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
339 if (hdr
->e_machine
== bi
->machine
&&
340 /* ELF image p_filesz includes terminating zero */
341 strlen(bi
->interp_path
) + 1 == interp_name_len
&&
342 strncmp(interp
, bi
->interp_path
, interp_name_len
)
348 /* Lacking a recognized interpreter, try the default brand */
349 for (i
= 0; i
< MAX_BRANDS
; i
++) {
350 bi
= elf_brand_list
[i
];
351 if (bi
== NULL
|| bi
->flags
& BI_BRAND_NOTE_MANDATORY
)
353 if (hdr
->e_machine
== bi
->machine
&&
354 __elfN(fallback_brand
) == bi
->brand
)
361 __elfN(check_header
)(const Elf_Ehdr
*hdr
)
367 hdr
->e_ident
[EI_CLASS
] != ELF_TARG_CLASS
||
368 hdr
->e_ident
[EI_DATA
] != ELF_TARG_DATA
||
369 hdr
->e_ident
[EI_VERSION
] != EV_CURRENT
||
370 hdr
->e_phentsize
!= sizeof(Elf_Phdr
) ||
371 hdr
->e_version
!= ELF_TARG_VER
)
375 * Make sure we have at least one brand for this machine.
378 for (i
= 0; i
< MAX_BRANDS
; i
++) {
379 bi
= elf_brand_list
[i
];
380 if (bi
!= NULL
&& bi
->machine
== hdr
->e_machine
)
390 __elfN(map_partial
)(vm_map_t map
, vm_object_t object
, vm_ooffset_t offset
,
391 vm_offset_t start
, vm_offset_t end
, vm_prot_t prot
)
398 * Create the page if it doesn't exist yet. Ignore errors.
401 vm_map_insert(map
, NULL
, 0, trunc_page(start
), round_page(end
),
402 VM_PROT_ALL
, VM_PROT_ALL
, 0);
406 * Find the page from the underlying object.
409 sf
= vm_imgact_map_page(object
, offset
);
411 return (KERN_FAILURE
);
412 off
= offset
- trunc_page(offset
);
413 error
= copyout((caddr_t
)sf_buf_kva(sf
) + off
, (caddr_t
)start
,
415 vm_imgact_unmap_page(sf
);
417 return (KERN_FAILURE
);
421 return (KERN_SUCCESS
);
425 __elfN(map_insert
)(vm_map_t map
, vm_object_t object
, vm_ooffset_t offset
,
426 vm_offset_t start
, vm_offset_t end
, vm_prot_t prot
, int cow
)
433 if (start
!= trunc_page(start
)) {
434 rv
= __elfN(map_partial
)(map
, object
, offset
, start
,
435 round_page(start
), prot
);
438 offset
+= round_page(start
) - start
;
439 start
= round_page(start
);
441 if (end
!= round_page(end
)) {
442 rv
= __elfN(map_partial
)(map
, object
, offset
+
443 trunc_page(end
) - start
, trunc_page(end
), end
, prot
);
446 end
= trunc_page(end
);
449 if (offset
& PAGE_MASK
) {
451 * The mapping is not page aligned. This means we have
452 * to copy the data. Sigh.
454 rv
= vm_map_find(map
, NULL
, 0, &start
, end
- start
, 0,
455 VMFS_NO_SPACE
, prot
| VM_PROT_WRITE
, VM_PROT_ALL
,
460 return (KERN_SUCCESS
);
461 for (; start
< end
; start
+= sz
) {
462 sf
= vm_imgact_map_page(object
, offset
);
464 return (KERN_FAILURE
);
465 off
= offset
- trunc_page(offset
);
467 if (sz
> PAGE_SIZE
- off
)
468 sz
= PAGE_SIZE
- off
;
469 error
= copyout((caddr_t
)sf_buf_kva(sf
) + off
,
471 vm_imgact_unmap_page(sf
);
473 return (KERN_FAILURE
);
479 vm_object_reference(object
);
481 rv
= vm_map_insert(map
, object
, offset
, start
, end
,
482 prot
, VM_PROT_ALL
, cow
);
484 if (rv
!= KERN_SUCCESS
)
485 vm_object_deallocate(object
);
489 return (KERN_SUCCESS
);
494 __elfN(load_section
)(struct image_params
*imgp
, vm_offset_t offset
,
495 caddr_t vmaddr
, size_t memsz
, size_t filsz
, vm_prot_t prot
,
502 vm_offset_t map_addr
;
505 vm_offset_t file_addr
;
508 * It's necessary to fail if the filsz + offset taken from the
509 * header is greater than the actual file pager object's size.
510 * If we were to allow this, then the vm_map_find() below would
511 * walk right off the end of the file object and into the ether.
513 * While I'm here, might as well check for something else that
514 * is invalid: filsz cannot be greater than memsz.
516 if ((off_t
)filsz
+ offset
> imgp
->attr
->va_size
|| filsz
> memsz
) {
517 uprintf("elf_load_section: truncated ELF file\n");
521 object
= imgp
->object
;
522 map
= &imgp
->proc
->p_vmspace
->vm_map
;
523 map_addr
= trunc_page_ps((vm_offset_t
)vmaddr
, pagesize
);
524 file_addr
= trunc_page_ps(offset
, pagesize
);
527 * We have two choices. We can either clear the data in the last page
528 * of an oversized mapping, or we can start the anon mapping a page
529 * early and copy the initialized data into that first page. We
530 * choose the second..
533 map_len
= trunc_page_ps(offset
+ filsz
, pagesize
) - file_addr
;
535 map_len
= round_page_ps(offset
+ filsz
, pagesize
) - file_addr
;
538 /* cow flags: don't dump readonly sections in core */
539 cow
= MAP_COPY_ON_WRITE
| MAP_PREFAULT
|
540 (prot
& VM_PROT_WRITE
? 0 : MAP_DISABLE_COREDUMP
);
542 rv
= __elfN(map_insert
)(map
,
544 file_addr
, /* file offset */
545 map_addr
, /* virtual start */
546 map_addr
+ map_len
,/* virtual end */
549 if (rv
!= KERN_SUCCESS
)
552 /* we can stop now if we've covered it all */
553 if (memsz
== filsz
) {
560 * We have to get the remaining bit of the file into the first part
561 * of the oversized map segment. This is normally because the .data
562 * segment in the file is extended to provide bss. It's a neat idea
563 * to try and save a page, but it's a pain in the behind to implement.
565 copy_len
= (offset
+ filsz
) - trunc_page_ps(offset
+ filsz
, pagesize
);
566 map_addr
= trunc_page_ps((vm_offset_t
)vmaddr
+ filsz
, pagesize
);
567 map_len
= round_page_ps((vm_offset_t
)vmaddr
+ memsz
, pagesize
) -
570 /* This had damn well better be true! */
572 rv
= __elfN(map_insert
)(map
, NULL
, 0, map_addr
, map_addr
+
573 map_len
, VM_PROT_ALL
, 0);
574 if (rv
!= KERN_SUCCESS
) {
582 sf
= vm_imgact_map_page(object
, offset
+ filsz
);
586 /* send the page fragment to user space */
587 off
= trunc_page_ps(offset
+ filsz
, pagesize
) -
588 trunc_page(offset
+ filsz
);
589 error
= copyout((caddr_t
)sf_buf_kva(sf
) + off
,
590 (caddr_t
)map_addr
, copy_len
);
591 vm_imgact_unmap_page(sf
);
598 * set it to the specified protection.
599 * XXX had better undo the damage from pasting over the cracks here!
601 vm_map_protect(map
, trunc_page(map_addr
), round_page(map_addr
+
602 map_len
), prot
, FALSE
);
608 * Load the file "file" into memory. It may be either a shared object
611 * The "addr" reference parameter is in/out. On entry, it specifies
612 * the address where a shared object should be loaded. If the file is
613 * an executable, this value is ignored. On exit, "addr" specifies
614 * where the file was actually loaded.
616 * The "entry" reference parameter is out only. On exit, it specifies
617 * the entry point for the loaded file.
620 __elfN(load_file
)(struct proc
*p
, const char *file
, u_long
*addr
,
621 u_long
*entry
, size_t pagesize
)
626 struct image_params image_params
;
628 const Elf_Ehdr
*hdr
= NULL
;
629 const Elf_Phdr
*phdr
= NULL
;
630 struct nameidata
*nd
;
632 struct image_params
*imgp
;
635 u_long base_addr
= 0;
636 int error
, i
, numsegs
;
638 #ifdef CAPABILITY_MODE
640 * XXXJA: This check can go away once we are sufficiently confident
641 * that the checks in namei() are correct.
643 if (IN_CAPABILITY_MODE(curthread
))
647 tempdata
= malloc(sizeof(*tempdata
), M_TEMP
, M_WAITOK
);
649 attr
= &tempdata
->attr
;
650 imgp
= &tempdata
->image_params
;
653 * Initialize part of the common data
657 imgp
->firstpage
= NULL
;
658 imgp
->image_header
= NULL
;
660 imgp
->execlabel
= NULL
;
662 NDINIT(nd
, LOOKUP
, LOCKLEAF
| FOLLOW
, UIO_SYSSPACE
, file
, curthread
);
663 if ((error
= namei(nd
)) != 0) {
667 NDFREE(nd
, NDF_ONLY_PNBUF
);
668 imgp
->vp
= nd
->ni_vp
;
671 * Check permissions, modes, uid, etc on the file, and "open" it.
673 error
= exec_check_permissions(imgp
);
677 error
= exec_map_first_page(imgp
);
682 * Also make certain that the interpreter stays the same, so set
683 * its VV_TEXT flag, too.
685 VOP_SET_TEXT(nd
->ni_vp
);
687 imgp
->object
= nd
->ni_vp
->v_object
;
689 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
690 if ((error
= __elfN(check_header
)(hdr
)) != 0)
692 if (hdr
->e_type
== ET_DYN
)
694 else if (hdr
->e_type
== ET_EXEC
)
701 /* Only support headers that fit within first page for now */
702 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
703 (u_int
)hdr
->e_phentsize
* hdr
->e_phnum
> PAGE_SIZE
- hdr
->e_phoff
) {
708 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
709 if (!aligned(phdr
, Elf_Addr
)) {
714 for (i
= 0, numsegs
= 0; i
< hdr
->e_phnum
; i
++) {
715 if (phdr
[i
].p_type
== PT_LOAD
&& phdr
[i
].p_memsz
!= 0) {
716 /* Loadable segment */
717 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
718 error
= __elfN(load_section
)(imgp
, phdr
[i
].p_offset
,
719 (caddr_t
)(uintptr_t)phdr
[i
].p_vaddr
+ rbase
,
720 phdr
[i
].p_memsz
, phdr
[i
].p_filesz
, prot
, pagesize
);
724 * Establish the base address if this is the
728 base_addr
= trunc_page(phdr
[i
].p_vaddr
+
734 *entry
= (unsigned long)hdr
->e_entry
+ rbase
;
738 exec_unmap_first_page(imgp
);
743 free(tempdata
, M_TEMP
);
749 __CONCAT(exec_
, __elfN(imgact
))(struct image_params
*imgp
)
753 const Elf_Phdr
*phdr
;
754 Elf_Auxargs
*elf_auxargs
;
755 struct vmspace
*vmspace
;
756 const char *err_str
, *newinterp
;
757 char *interp
, *interp_buf
, *path
;
758 Elf_Brandinfo
*brand_info
;
759 struct sysentvec
*sv
;
761 u_long text_size
, data_size
, total_size
, text_addr
, data_addr
;
762 u_long seg_size
, seg_addr
, addr
, baddr
, et_dyn_addr
, entry
, proghdr
;
764 int error
, i
, n
, interp_name_len
, have_interp
;
766 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
769 * Do we have a valid ELF header ?
771 * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later
772 * if particular brand doesn't support it.
774 if (__elfN(check_header
)(hdr
) != 0 ||
775 (hdr
->e_type
!= ET_EXEC
&& hdr
->e_type
!= ET_DYN
))
779 * From here on down, we return an errno, not -1, as we've
780 * detected an ELF file.
783 if ((hdr
->e_phoff
> PAGE_SIZE
) ||
784 (u_int
)hdr
->e_phentsize
* hdr
->e_phnum
> PAGE_SIZE
- hdr
->e_phoff
) {
785 /* Only support headers in first page for now */
786 uprintf("Program headers not in the first page\n");
789 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
790 if (!aligned(phdr
, Elf_Addr
)) {
791 uprintf("Unaligned program headers\n");
798 text_size
= data_size
= total_size
= text_addr
= data_addr
= 0;
801 err_str
= newinterp
= NULL
;
802 interp
= interp_buf
= NULL
;
805 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
806 switch (phdr
[i
].p_type
) {
809 baddr
= phdr
[i
].p_vaddr
;
813 /* Path to interpreter */
814 if (phdr
[i
].p_filesz
> MAXPATHLEN
) {
815 uprintf("Invalid PT_INTERP\n");
819 if (interp
!= NULL
) {
820 uprintf("Multiple PT_INTERP headers\n");
824 interp_name_len
= phdr
[i
].p_filesz
;
825 if (phdr
[i
].p_offset
> PAGE_SIZE
||
826 interp_name_len
> PAGE_SIZE
- phdr
[i
].p_offset
) {
827 VOP_UNLOCK(imgp
->vp
, 0);
828 interp_buf
= malloc(interp_name_len
+ 1, M_TEMP
,
830 vn_lock(imgp
->vp
, LK_EXCLUSIVE
| LK_RETRY
);
831 error
= vn_rdwr(UIO_READ
, imgp
->vp
, interp_buf
,
832 interp_name_len
, phdr
[i
].p_offset
,
833 UIO_SYSSPACE
, IO_NODELOCKED
, td
->td_ucred
,
836 uprintf("i/o error PT_INTERP\n");
839 interp_buf
[interp_name_len
] = '\0';
842 interp
= __DECONST(char *, imgp
->image_header
) +
849 __elfN(trans_prot
)(phdr
[i
].p_flags
);
850 imgp
->stack_sz
= phdr
[i
].p_memsz
;
855 brand_info
= __elfN(get_brandinfo
)(imgp
, interp
, interp_name_len
,
857 if (brand_info
== NULL
) {
858 uprintf("ELF binary type \"%u\" not known.\n",
859 hdr
->e_ident
[EI_OSABI
]);
863 if (hdr
->e_type
== ET_DYN
) {
864 if ((brand_info
->flags
& BI_CAN_EXEC_DYN
) == 0) {
865 uprintf("Cannot execute shared object\n");
870 * Honour the base load address from the dso if it is
871 * non-zero for some reason.
874 et_dyn_addr
= ET_DYN_LOAD_ADDR
;
879 sv
= brand_info
->sysvec
;
880 if (interp
!= NULL
&& brand_info
->interp_newpath
!= NULL
)
881 newinterp
= brand_info
->interp_newpath
;
884 * Avoid a possible deadlock if the current address space is destroyed
885 * and that address space maps the locked vnode. In the common case,
886 * the locked vnode's v_usecount is decremented but remains greater
887 * than zero. Consequently, the vnode lock is not needed by vrele().
888 * However, in cases where the vnode lock is external, such as nullfs,
889 * v_usecount may become zero.
891 * The VV_TEXT flag prevents modifications to the executable while
892 * the vnode is unlocked.
894 VOP_UNLOCK(imgp
->vp
, 0);
896 error
= exec_new_vmspace(imgp
, sv
);
897 imgp
->proc
->p_sysent
= sv
;
899 vn_lock(imgp
->vp
, LK_EXCLUSIVE
| LK_RETRY
);
903 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
904 switch (phdr
[i
].p_type
) {
905 case PT_LOAD
: /* Loadable segment */
906 if (phdr
[i
].p_memsz
== 0)
908 prot
= __elfN(trans_prot
)(phdr
[i
].p_flags
);
909 error
= __elfN(load_section
)(imgp
, phdr
[i
].p_offset
,
910 (caddr_t
)(uintptr_t)phdr
[i
].p_vaddr
+ et_dyn_addr
,
911 phdr
[i
].p_memsz
, phdr
[i
].p_filesz
, prot
,
917 * If this segment contains the program headers,
918 * remember their virtual address for the AT_PHDR
919 * aux entry. Static binaries don't usually include
922 if (phdr
[i
].p_offset
== 0 &&
923 hdr
->e_phoff
+ hdr
->e_phnum
* hdr
->e_phentsize
925 proghdr
= phdr
[i
].p_vaddr
+ hdr
->e_phoff
+
928 seg_addr
= trunc_page(phdr
[i
].p_vaddr
+ et_dyn_addr
);
929 seg_size
= round_page(phdr
[i
].p_memsz
+
930 phdr
[i
].p_vaddr
+ et_dyn_addr
- seg_addr
);
933 * Make the largest executable segment the official
934 * text segment and all others data.
936 * Note that obreak() assumes that data_addr +
937 * data_size == end of data load area, and the ELF
938 * file format expects segments to be sorted by
939 * address. If multiple data segments exist, the
940 * last one will be used.
943 if (phdr
[i
].p_flags
& PF_X
&& text_size
< seg_size
) {
944 text_size
= seg_size
;
945 text_addr
= seg_addr
;
947 data_size
= seg_size
;
948 data_addr
= seg_addr
;
950 total_size
+= seg_size
;
952 case PT_PHDR
: /* Program header table info */
953 proghdr
= phdr
[i
].p_vaddr
+ et_dyn_addr
;
960 if (data_addr
== 0 && data_size
== 0) {
961 data_addr
= text_addr
;
962 data_size
= text_size
;
965 entry
= (u_long
)hdr
->e_entry
+ et_dyn_addr
;
968 * Check limits. It should be safe to check the
969 * limits after loading the segments since we do
970 * not actually fault in all the segments pages.
972 PROC_LOCK(imgp
->proc
);
973 if (data_size
> lim_cur_proc(imgp
->proc
, RLIMIT_DATA
))
974 err_str
= "Data segment size exceeds process limit";
975 else if (text_size
> maxtsiz
)
976 err_str
= "Text segment size exceeds system limit";
977 else if (total_size
> lim_cur_proc(imgp
->proc
, RLIMIT_VMEM
))
978 err_str
= "Total segment size exceeds process limit";
979 else if (racct_set(imgp
->proc
, RACCT_DATA
, data_size
) != 0)
980 err_str
= "Data segment size exceeds resource limit";
981 else if (racct_set(imgp
->proc
, RACCT_VMEM
, total_size
) != 0)
982 err_str
= "Total segment size exceeds resource limit";
983 if (err_str
!= NULL
) {
984 PROC_UNLOCK(imgp
->proc
);
985 uprintf("%s\n", err_str
);
990 vmspace
= imgp
->proc
->p_vmspace
;
991 vmspace
->vm_tsize
= text_size
>> PAGE_SHIFT
;
992 vmspace
->vm_taddr
= (caddr_t
)(uintptr_t)text_addr
;
993 vmspace
->vm_dsize
= data_size
>> PAGE_SHIFT
;
994 vmspace
->vm_daddr
= (caddr_t
)(uintptr_t)data_addr
;
997 * We load the dynamic linker where a userland call
998 * to mmap(0, ...) would put it. The rationale behind this
999 * calculation is that it leaves room for the heap to grow to
1000 * its maximum allowed size.
1002 addr
= round_page((vm_offset_t
)vmspace
->vm_daddr
+ lim_max(td
,
1004 PROC_UNLOCK(imgp
->proc
);
1006 imgp
->entry_addr
= entry
;
1008 if (interp
!= NULL
) {
1009 have_interp
= FALSE
;
1010 VOP_UNLOCK(imgp
->vp
, 0);
1011 if (brand_info
->emul_path
!= NULL
&&
1012 brand_info
->emul_path
[0] != '\0') {
1013 path
= malloc(MAXPATHLEN
, M_TEMP
, M_WAITOK
);
1014 snprintf(path
, MAXPATHLEN
, "%s%s",
1015 brand_info
->emul_path
, interp
);
1016 error
= __elfN(load_file
)(imgp
->proc
, path
, &addr
,
1017 &imgp
->entry_addr
, sv
->sv_pagesize
);
1022 if (!have_interp
&& newinterp
!= NULL
&&
1023 (brand_info
->interp_path
== NULL
||
1024 strcmp(interp
, brand_info
->interp_path
) == 0)) {
1025 error
= __elfN(load_file
)(imgp
->proc
, newinterp
, &addr
,
1026 &imgp
->entry_addr
, sv
->sv_pagesize
);
1031 error
= __elfN(load_file
)(imgp
->proc
, interp
, &addr
,
1032 &imgp
->entry_addr
, sv
->sv_pagesize
);
1034 vn_lock(imgp
->vp
, LK_EXCLUSIVE
| LK_RETRY
);
1036 uprintf("ELF interpreter %s not found, error %d\n",
1044 * Construct auxargs table (used by the fixup routine)
1046 elf_auxargs
= malloc(sizeof(Elf_Auxargs
), M_TEMP
, M_WAITOK
);
1047 elf_auxargs
->execfd
= -1;
1048 elf_auxargs
->phdr
= proghdr
;
1049 elf_auxargs
->phent
= hdr
->e_phentsize
;
1050 elf_auxargs
->phnum
= hdr
->e_phnum
;
1051 elf_auxargs
->pagesz
= PAGE_SIZE
;
1052 elf_auxargs
->base
= addr
;
1053 elf_auxargs
->flags
= 0;
1054 elf_auxargs
->entry
= entry
;
1055 elf_auxargs
->hdr_eflags
= hdr
->e_flags
;
1057 imgp
->auxargs
= elf_auxargs
;
1058 imgp
->interpreted
= 0;
1059 imgp
->reloc_base
= addr
;
1060 imgp
->proc
->p_osrel
= osrel
;
1063 free(interp_buf
, M_TEMP
);
1067 #define suword __CONCAT(suword, __ELF_WORD_SIZE)
1070 __elfN(freebsd_fixup
)(register_t
**stack_base
, struct image_params
*imgp
)
1072 Elf_Auxargs
*args
= (Elf_Auxargs
*)imgp
->auxargs
;
1076 base
= (Elf_Addr
*)*stack_base
;
1077 pos
= base
+ (imgp
->args
->argc
+ imgp
->args
->envc
+ 2);
1079 if (args
->execfd
!= -1)
1080 AUXARGS_ENTRY(pos
, AT_EXECFD
, args
->execfd
);
1081 AUXARGS_ENTRY(pos
, AT_PHDR
, args
->phdr
);
1082 AUXARGS_ENTRY(pos
, AT_PHENT
, args
->phent
);
1083 AUXARGS_ENTRY(pos
, AT_PHNUM
, args
->phnum
);
1084 AUXARGS_ENTRY(pos
, AT_PAGESZ
, args
->pagesz
);
1085 AUXARGS_ENTRY(pos
, AT_FLAGS
, args
->flags
);
1086 AUXARGS_ENTRY(pos
, AT_ENTRY
, args
->entry
);
1087 AUXARGS_ENTRY(pos
, AT_BASE
, args
->base
);
1089 AUXARGS_ENTRY(pos
, AT_EHDRFLAGS
, args
->hdr_eflags
);
1091 if (imgp
->execpathp
!= 0)
1092 AUXARGS_ENTRY(pos
, AT_EXECPATH
, imgp
->execpathp
);
1093 AUXARGS_ENTRY(pos
, AT_OSRELDATE
,
1094 imgp
->proc
->p_ucred
->cr_prison
->pr_osreldate
);
1095 if (imgp
->canary
!= 0) {
1096 AUXARGS_ENTRY(pos
, AT_CANARY
, imgp
->canary
);
1097 AUXARGS_ENTRY(pos
, AT_CANARYLEN
, imgp
->canarylen
);
1099 AUXARGS_ENTRY(pos
, AT_NCPUS
, mp_ncpus
);
1100 if (imgp
->pagesizes
!= 0) {
1101 AUXARGS_ENTRY(pos
, AT_PAGESIZES
, imgp
->pagesizes
);
1102 AUXARGS_ENTRY(pos
, AT_PAGESIZESLEN
, imgp
->pagesizeslen
);
1104 if (imgp
->sysent
->sv_timekeep_base
!= 0) {
1105 AUXARGS_ENTRY(pos
, AT_TIMEKEEP
,
1106 imgp
->sysent
->sv_timekeep_base
);
1108 AUXARGS_ENTRY(pos
, AT_STACKPROT
, imgp
->sysent
->sv_shared_page_obj
1109 != NULL
&& imgp
->stack_prot
!= 0 ? imgp
->stack_prot
:
1110 imgp
->sysent
->sv_stackprot
);
1111 AUXARGS_ENTRY(pos
, AT_NULL
, 0);
1113 free(imgp
->auxargs
, M_TEMP
);
1114 imgp
->auxargs
= NULL
;
1117 suword(base
, (long)imgp
->args
->argc
);
1118 *stack_base
= (register_t
*)base
;
1123 * Code for generating ELF core dumps.
1126 typedef void (*segment_callback
)(vm_map_entry_t
, void *);
1128 /* Closure for cb_put_phdr(). */
1129 struct phdr_closure
{
1130 Elf_Phdr
*phdr
; /* Program header to fill in */
1131 Elf_Off offset
; /* Offset of segment in core file */
1134 /* Closure for cb_size_segment(). */
1135 struct sseg_closure
{
1136 int count
; /* Count of writable segments. */
1137 size_t size
; /* Total size of all writable segments. */
1140 typedef void (*outfunc_t
)(void *, struct sbuf
*, size_t *);
1143 int type
; /* Note type. */
1144 outfunc_t outfunc
; /* Output function. */
1145 void *outarg
; /* Argument for the output function. */
1146 size_t outsize
; /* Output size. */
1147 TAILQ_ENTRY(note_info
) link
; /* Link to the next note info. */
1150 TAILQ_HEAD(note_info_list
, note_info
);
1152 /* Coredump output parameters. */
1153 struct coredump_params
{
1155 struct ucred
*active_cred
;
1156 struct ucred
*file_cred
;
1159 struct gzio_stream
*gzs
;
1162 static void cb_put_phdr(vm_map_entry_t
, void *);
1163 static void cb_size_segment(vm_map_entry_t
, void *);
1164 static int core_write(struct coredump_params
*, void *, size_t, off_t
,
1166 static void each_writable_segment(struct thread
*, segment_callback
, void *);
1167 static int __elfN(corehdr
)(struct coredump_params
*, int, void *, size_t,
1168 struct note_info_list
*, size_t);
1169 static void __elfN(prepare_notes
)(struct thread
*, struct note_info_list
*,
1171 static void __elfN(puthdr
)(struct thread
*, void *, size_t, int, size_t);
1172 static void __elfN(putnote
)(struct note_info
*, struct sbuf
*);
1173 static size_t register_note(struct note_info_list
*, int, outfunc_t
, void *);
1174 static int sbuf_drain_core_output(void *, const char *, int);
1175 static int sbuf_drain_count(void *arg
, const char *data
, int len
);
1177 static void __elfN(note_fpregset
)(void *, struct sbuf
*, size_t *);
1178 static void __elfN(note_prpsinfo
)(void *, struct sbuf
*, size_t *);
1179 static void __elfN(note_prstatus
)(void *, struct sbuf
*, size_t *);
1180 static void __elfN(note_threadmd
)(void *, struct sbuf
*, size_t *);
1181 static void __elfN(note_thrmisc
)(void *, struct sbuf
*, size_t *);
1182 static void __elfN(note_procstat_auxv
)(void *, struct sbuf
*, size_t *);
1183 static void __elfN(note_procstat_proc
)(void *, struct sbuf
*, size_t *);
1184 static void __elfN(note_procstat_psstrings
)(void *, struct sbuf
*, size_t *);
1185 static void note_procstat_files(void *, struct sbuf
*, size_t *);
1186 static void note_procstat_groups(void *, struct sbuf
*, size_t *);
1187 static void note_procstat_osrel(void *, struct sbuf
*, size_t *);
1188 static void note_procstat_rlimit(void *, struct sbuf
*, size_t *);
1189 static void note_procstat_umask(void *, struct sbuf
*, size_t *);
1190 static void note_procstat_vmmap(void *, struct sbuf
*, size_t *);
1193 extern int compress_user_cores_gzlevel
;
1196 * Write out a core segment to the compression stream.
1199 compress_chunk(struct coredump_params
*p
, char *base
, char *buf
, u_int len
)
1205 chunk_len
= MIN(len
, CORE_BUF_SIZE
);
1206 copyin(base
, buf
, chunk_len
);
1207 error
= gzio_write(p
->gzs
, buf
, chunk_len
);
1217 core_gz_write(void *base
, size_t len
, off_t offset
, void *arg
)
1220 return (core_write((struct coredump_params
*)arg
, base
, len
, offset
,
1226 core_write(struct coredump_params
*p
, void *base
, size_t len
, off_t offset
,
1230 return (vn_rdwr_inchunks(UIO_WRITE
, p
->vp
, base
, len
, offset
,
1231 seg
, IO_UNIT
| IO_DIRECT
| IO_RANGELOCKED
,
1232 p
->active_cred
, p
->file_cred
, NULL
, p
->td
));
1236 core_output(void *base
, size_t len
, off_t offset
, struct coredump_params
*p
,
1242 return (compress_chunk(p
, base
, tmpbuf
, len
));
1244 return (core_write(p
, base
, len
, offset
, UIO_USERSPACE
));
1248 * Drain into a core file.
1251 sbuf_drain_core_output(void *arg
, const char *data
, int len
)
1253 struct coredump_params
*p
;
1256 p
= (struct coredump_params
*)arg
;
1259 * Some kern_proc out routines that print to this sbuf may
1260 * call us with the process lock held. Draining with the
1261 * non-sleepable lock held is unsafe. The lock is needed for
1262 * those routines when dumping a live process. In our case we
1263 * can safely release the lock before draining and acquire
1266 locked
= PROC_LOCKED(p
->td
->td_proc
);
1268 PROC_UNLOCK(p
->td
->td_proc
);
1271 error
= gzio_write(p
->gzs
, __DECONST(char *, data
), len
);
1274 error
= core_write(p
, __DECONST(void *, data
), len
, p
->offset
,
1277 PROC_LOCK(p
->td
->td_proc
);
1285 * Drain into a counter.
1288 sbuf_drain_count(void *arg
, const char *data __unused
, int len
)
1292 sizep
= (size_t *)arg
;
1298 __elfN(coredump
)(struct thread
*td
, struct vnode
*vp
, off_t limit
, int flags
)
1300 struct ucred
*cred
= td
->td_ucred
;
1302 struct sseg_closure seginfo
;
1303 struct note_info_list notelst
;
1304 struct coredump_params params
;
1305 struct note_info
*ninfo
;
1307 size_t hdrsize
, notesz
, coresize
;
1311 compress
= (flags
& IMGACT_CORE_COMPRESS
) != 0;
1315 TAILQ_INIT(¬elst
);
1317 /* Size the program segments. */
1320 each_writable_segment(td
, cb_size_segment
, &seginfo
);
1323 * Collect info about the core file header area.
1325 hdrsize
= sizeof(Elf_Ehdr
) + sizeof(Elf_Phdr
) * (1 + seginfo
.count
);
1326 __elfN(prepare_notes
)(td
, ¬elst
, ¬esz
);
1327 coresize
= round_page(hdrsize
+ notesz
) + seginfo
.size
;
1329 /* Set up core dump parameters. */
1331 params
.active_cred
= cred
;
1332 params
.file_cred
= NOCRED
;
1339 PROC_LOCK(td
->td_proc
);
1340 error
= racct_add(td
->td_proc
, RACCT_CORE
, coresize
);
1341 PROC_UNLOCK(td
->td_proc
);
1348 if (coresize
>= limit
) {
1354 /* Create a compression stream if necessary. */
1356 params
.gzs
= gzio_init(core_gz_write
, GZIO_DEFLATE
,
1357 CORE_BUF_SIZE
, compress_user_cores_gzlevel
, ¶ms
);
1358 if (params
.gzs
== NULL
) {
1362 tmpbuf
= malloc(CORE_BUF_SIZE
, M_TEMP
, M_WAITOK
| M_ZERO
);
1367 * Allocate memory for building the header, fill it up,
1368 * and write it out following the notes.
1370 hdr
= malloc(hdrsize
, M_TEMP
, M_WAITOK
);
1371 error
= __elfN(corehdr
)(¶ms
, seginfo
.count
, hdr
, hdrsize
, ¬elst
,
1374 /* Write the contents of all of the writable segments. */
1380 php
= (Elf_Phdr
*)((char *)hdr
+ sizeof(Elf_Ehdr
)) + 1;
1381 offset
= round_page(hdrsize
+ notesz
);
1382 for (i
= 0; i
< seginfo
.count
; i
++) {
1383 error
= core_output((caddr_t
)(uintptr_t)php
->p_vaddr
,
1384 php
->p_filesz
, offset
, ¶ms
, tmpbuf
);
1387 offset
+= php
->p_filesz
;
1391 if (error
== 0 && compress
)
1392 error
= gzio_flush(params
.gzs
);
1397 "Failed to write core file for process %s (error %d)\n",
1398 curproc
->p_comm
, error
);
1404 free(tmpbuf
, M_TEMP
);
1405 if (params
.gzs
!= NULL
)
1406 gzio_fini(params
.gzs
);
1409 while ((ninfo
= TAILQ_FIRST(¬elst
)) != NULL
) {
1410 TAILQ_REMOVE(¬elst
, ninfo
, link
);
1411 free(ninfo
, M_TEMP
);
1420 * A callback for each_writable_segment() to write out the segment's
1421 * program header entry.
1424 cb_put_phdr(entry
, closure
)
1425 vm_map_entry_t entry
;
1428 struct phdr_closure
*phc
= (struct phdr_closure
*)closure
;
1429 Elf_Phdr
*phdr
= phc
->phdr
;
1431 phc
->offset
= round_page(phc
->offset
);
1433 phdr
->p_type
= PT_LOAD
;
1434 phdr
->p_offset
= phc
->offset
;
1435 phdr
->p_vaddr
= entry
->start
;
1437 phdr
->p_filesz
= phdr
->p_memsz
= entry
->end
- entry
->start
;
1438 phdr
->p_align
= PAGE_SIZE
;
1439 phdr
->p_flags
= __elfN(untrans_prot
)(entry
->protection
);
1441 phc
->offset
+= phdr
->p_filesz
;
1446 * A callback for each_writable_segment() to gather information about
1447 * the number of segments and their total size.
1450 cb_size_segment(entry
, closure
)
1451 vm_map_entry_t entry
;
1454 struct sseg_closure
*ssc
= (struct sseg_closure
*)closure
;
1457 ssc
->size
+= entry
->end
- entry
->start
;
1461 * For each writable segment in the process's memory map, call the given
1462 * function with a pointer to the map entry and some arbitrary
1463 * caller-supplied data.
1466 each_writable_segment(td
, func
, closure
)
1468 segment_callback func
;
1471 struct proc
*p
= td
->td_proc
;
1472 vm_map_t map
= &p
->p_vmspace
->vm_map
;
1473 vm_map_entry_t entry
;
1474 vm_object_t backing_object
, object
;
1475 boolean_t ignore_entry
;
1477 vm_map_lock_read(map
);
1478 for (entry
= map
->header
.next
; entry
!= &map
->header
;
1479 entry
= entry
->next
) {
1481 * Don't dump inaccessible mappings, deal with legacy
1484 * Note that read-only segments related to the elf binary
1485 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1486 * need to arbitrarily ignore such segments.
1488 if (elf_legacy_coredump
) {
1489 if ((entry
->protection
& VM_PROT_RW
) != VM_PROT_RW
)
1492 if ((entry
->protection
& VM_PROT_ALL
) == 0)
1497 * Dont include memory segment in the coredump if
1498 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1499 * madvise(2). Do not dump submaps (i.e. parts of the
1502 if (entry
->eflags
& (MAP_ENTRY_NOCOREDUMP
|MAP_ENTRY_IS_SUB_MAP
))
1505 if ((object
= entry
->object
.vm_object
) == NULL
)
1508 /* Ignore memory-mapped devices and such things. */
1509 VM_OBJECT_RLOCK(object
);
1510 while ((backing_object
= object
->backing_object
) != NULL
) {
1511 VM_OBJECT_RLOCK(backing_object
);
1512 VM_OBJECT_RUNLOCK(object
);
1513 object
= backing_object
;
1515 ignore_entry
= object
->type
!= OBJT_DEFAULT
&&
1516 object
->type
!= OBJT_SWAP
&& object
->type
!= OBJT_VNODE
&&
1517 object
->type
!= OBJT_PHYS
;
1518 VM_OBJECT_RUNLOCK(object
);
1522 (*func
)(entry
, closure
);
1524 vm_map_unlock_read(map
);
1528 * Write the core file header to the file, including padding up to
1529 * the page boundary.
1532 __elfN(corehdr
)(struct coredump_params
*p
, int numsegs
, void *hdr
,
1533 size_t hdrsize
, struct note_info_list
*notelst
, size_t notesz
)
1535 struct note_info
*ninfo
;
1539 /* Fill in the header. */
1540 bzero(hdr
, hdrsize
);
1541 __elfN(puthdr
)(p
->td
, hdr
, hdrsize
, numsegs
, notesz
);
1543 sb
= sbuf_new(NULL
, NULL
, CORE_BUF_SIZE
, SBUF_FIXEDLEN
);
1544 sbuf_set_drain(sb
, sbuf_drain_core_output
, p
);
1545 sbuf_start_section(sb
, NULL
);
1546 sbuf_bcat(sb
, hdr
, hdrsize
);
1547 TAILQ_FOREACH(ninfo
, notelst
, link
)
1548 __elfN(putnote
)(ninfo
, sb
);
1549 /* Align up to a page boundary for the program segments. */
1550 sbuf_end_section(sb
, -1, PAGE_SIZE
, 0);
1551 error
= sbuf_finish(sb
);
1558 __elfN(prepare_notes
)(struct thread
*td
, struct note_info_list
*list
,
1568 size
+= register_note(list
, NT_PRPSINFO
, __elfN(note_prpsinfo
), p
);
1571 * To have the debugger select the right thread (LWP) as the initial
1572 * thread, we dump the state of the thread passed to us in td first.
1573 * This is the thread that causes the core dump and thus likely to
1574 * be the right thread one wants to have selected in the debugger.
1577 while (thr
!= NULL
) {
1578 size
+= register_note(list
, NT_PRSTATUS
,
1579 __elfN(note_prstatus
), thr
);
1580 size
+= register_note(list
, NT_FPREGSET
,
1581 __elfN(note_fpregset
), thr
);
1582 size
+= register_note(list
, NT_THRMISC
,
1583 __elfN(note_thrmisc
), thr
);
1584 size
+= register_note(list
, -1,
1585 __elfN(note_threadmd
), thr
);
1587 thr
= (thr
== td
) ? TAILQ_FIRST(&p
->p_threads
) :
1588 TAILQ_NEXT(thr
, td_plist
);
1590 thr
= TAILQ_NEXT(thr
, td_plist
);
1593 size
+= register_note(list
, NT_PROCSTAT_PROC
,
1594 __elfN(note_procstat_proc
), p
);
1595 size
+= register_note(list
, NT_PROCSTAT_FILES
,
1596 note_procstat_files
, p
);
1597 size
+= register_note(list
, NT_PROCSTAT_VMMAP
,
1598 note_procstat_vmmap
, p
);
1599 size
+= register_note(list
, NT_PROCSTAT_GROUPS
,
1600 note_procstat_groups
, p
);
1601 size
+= register_note(list
, NT_PROCSTAT_UMASK
,
1602 note_procstat_umask
, p
);
1603 size
+= register_note(list
, NT_PROCSTAT_RLIMIT
,
1604 note_procstat_rlimit
, p
);
1605 size
+= register_note(list
, NT_PROCSTAT_OSREL
,
1606 note_procstat_osrel
, p
);
1607 size
+= register_note(list
, NT_PROCSTAT_PSSTRINGS
,
1608 __elfN(note_procstat_psstrings
), p
);
1609 size
+= register_note(list
, NT_PROCSTAT_AUXV
,
1610 __elfN(note_procstat_auxv
), p
);
1616 __elfN(puthdr
)(struct thread
*td
, void *hdr
, size_t hdrsize
, int numsegs
,
1621 struct phdr_closure phc
;
1623 ehdr
= (Elf_Ehdr
*)hdr
;
1624 phdr
= (Elf_Phdr
*)((char *)hdr
+ sizeof(Elf_Ehdr
));
1626 ehdr
->e_ident
[EI_MAG0
] = ELFMAG0
;
1627 ehdr
->e_ident
[EI_MAG1
] = ELFMAG1
;
1628 ehdr
->e_ident
[EI_MAG2
] = ELFMAG2
;
1629 ehdr
->e_ident
[EI_MAG3
] = ELFMAG3
;
1630 ehdr
->e_ident
[EI_CLASS
] = ELF_CLASS
;
1631 ehdr
->e_ident
[EI_DATA
] = ELF_DATA
;
1632 ehdr
->e_ident
[EI_VERSION
] = EV_CURRENT
;
1633 ehdr
->e_ident
[EI_OSABI
] = ELFOSABI_FREEBSD
;
1634 ehdr
->e_ident
[EI_ABIVERSION
] = 0;
1635 ehdr
->e_ident
[EI_PAD
] = 0;
1636 ehdr
->e_type
= ET_CORE
;
1637 #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1638 ehdr
->e_machine
= ELF_ARCH32
;
1640 ehdr
->e_machine
= ELF_ARCH
;
1642 ehdr
->e_version
= EV_CURRENT
;
1644 ehdr
->e_phoff
= sizeof(Elf_Ehdr
);
1646 ehdr
->e_ehsize
= sizeof(Elf_Ehdr
);
1647 ehdr
->e_phentsize
= sizeof(Elf_Phdr
);
1648 ehdr
->e_phnum
= numsegs
+ 1;
1649 ehdr
->e_shentsize
= sizeof(Elf_Shdr
);
1651 ehdr
->e_shstrndx
= SHN_UNDEF
;
1654 * Fill in the program header entries.
1657 /* The note segement. */
1658 phdr
->p_type
= PT_NOTE
;
1659 phdr
->p_offset
= hdrsize
;
1662 phdr
->p_filesz
= notesz
;
1664 phdr
->p_flags
= PF_R
;
1665 phdr
->p_align
= ELF_NOTE_ROUNDSIZE
;
1668 /* All the writable segments from the program. */
1670 phc
.offset
= round_page(hdrsize
+ notesz
);
1671 each_writable_segment(td
, cb_put_phdr
, &phc
);
1675 register_note(struct note_info_list
*list
, int type
, outfunc_t out
, void *arg
)
1677 struct note_info
*ninfo
;
1678 size_t size
, notesize
;
1681 out(arg
, NULL
, &size
);
1682 ninfo
= malloc(sizeof(*ninfo
), M_TEMP
, M_ZERO
| M_WAITOK
);
1684 ninfo
->outfunc
= out
;
1685 ninfo
->outarg
= arg
;
1686 ninfo
->outsize
= size
;
1687 TAILQ_INSERT_TAIL(list
, ninfo
, link
);
1692 notesize
= sizeof(Elf_Note
) + /* note header */
1693 roundup2(sizeof(FREEBSD_ABI_VENDOR
), ELF_NOTE_ROUNDSIZE
) +
1695 roundup2(size
, ELF_NOTE_ROUNDSIZE
); /* note description */
1701 append_note_data(const void *src
, void *dst
, size_t len
)
1705 padded_len
= roundup2(len
, ELF_NOTE_ROUNDSIZE
);
1707 bcopy(src
, dst
, len
);
1708 bzero((char *)dst
+ len
, padded_len
- len
);
1710 return (padded_len
);
1714 __elfN(populate_note
)(int type
, void *src
, void *dst
, size_t size
, void **descp
)
1722 note
= (Elf_Note
*)buf
;
1723 note
->n_namesz
= sizeof(FREEBSD_ABI_VENDOR
);
1724 note
->n_descsz
= size
;
1725 note
->n_type
= type
;
1726 buf
+= sizeof(*note
);
1727 buf
+= append_note_data(FREEBSD_ABI_VENDOR
, buf
,
1728 sizeof(FREEBSD_ABI_VENDOR
));
1729 append_note_data(src
, buf
, size
);
1734 notesize
= sizeof(Elf_Note
) + /* note header */
1735 roundup2(sizeof(FREEBSD_ABI_VENDOR
), ELF_NOTE_ROUNDSIZE
) +
1737 roundup2(size
, ELF_NOTE_ROUNDSIZE
); /* note description */
1743 __elfN(putnote
)(struct note_info
*ninfo
, struct sbuf
*sb
)
1746 ssize_t old_len
, sect_len
;
1747 size_t new_len
, descsz
, i
;
1749 if (ninfo
->type
== -1) {
1750 ninfo
->outfunc(ninfo
->outarg
, sb
, &ninfo
->outsize
);
1754 note
.n_namesz
= sizeof(FREEBSD_ABI_VENDOR
);
1755 note
.n_descsz
= ninfo
->outsize
;
1756 note
.n_type
= ninfo
->type
;
1758 sbuf_bcat(sb
, ¬e
, sizeof(note
));
1759 sbuf_start_section(sb
, &old_len
);
1760 sbuf_bcat(sb
, FREEBSD_ABI_VENDOR
, sizeof(FREEBSD_ABI_VENDOR
));
1761 sbuf_end_section(sb
, old_len
, ELF_NOTE_ROUNDSIZE
, 0);
1762 if (note
.n_descsz
== 0)
1764 sbuf_start_section(sb
, &old_len
);
1765 ninfo
->outfunc(ninfo
->outarg
, sb
, &ninfo
->outsize
);
1766 sect_len
= sbuf_end_section(sb
, old_len
, ELF_NOTE_ROUNDSIZE
, 0);
1770 new_len
= (size_t)sect_len
;
1771 descsz
= roundup(note
.n_descsz
, ELF_NOTE_ROUNDSIZE
);
1772 if (new_len
< descsz
) {
1774 * It is expected that individual note emitters will correctly
1775 * predict their expected output size and fill up to that size
1776 * themselves, padding in a format-specific way if needed.
1777 * However, in case they don't, just do it here with zeros.
1779 for (i
= 0; i
< descsz
- new_len
; i
++)
1781 } else if (new_len
> descsz
) {
1783 * We can't always truncate sb -- we may have drained some
1786 KASSERT(new_len
== descsz
, ("%s: Note type %u changed as we "
1787 "read it (%zu > %zu). Since it is longer than "
1788 "expected, this coredump's notes are corrupt. THIS "
1789 "IS A BUG in the note_procstat routine for type %u.\n",
1790 __func__
, (unsigned)note
.n_type
, new_len
, descsz
,
1791 (unsigned)note
.n_type
));
1796 * Miscellaneous note out functions.
1799 #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1800 #include <compat/freebsd32/freebsd32.h>
1802 typedef struct prstatus32 elf_prstatus_t
;
1803 typedef struct prpsinfo32 elf_prpsinfo_t
;
1804 typedef struct fpreg32 elf_prfpregset_t
;
1805 typedef struct fpreg32 elf_fpregset_t
;
1806 typedef struct reg32 elf_gregset_t
;
1807 typedef struct thrmisc32 elf_thrmisc_t
;
1808 #define ELF_KERN_PROC_MASK KERN_PROC_MASK32
1809 typedef struct kinfo_proc32 elf_kinfo_proc_t
;
1810 typedef uint32_t elf_ps_strings_t
;
1812 typedef prstatus_t elf_prstatus_t
;
1813 typedef prpsinfo_t elf_prpsinfo_t
;
1814 typedef prfpregset_t elf_prfpregset_t
;
1815 typedef prfpregset_t elf_fpregset_t
;
1816 typedef gregset_t elf_gregset_t
;
1817 typedef thrmisc_t elf_thrmisc_t
;
1818 #define ELF_KERN_PROC_MASK 0
1819 typedef struct kinfo_proc elf_kinfo_proc_t
;
1820 typedef vm_offset_t elf_ps_strings_t
;
1824 __elfN(note_prpsinfo
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1827 elf_prpsinfo_t
*psinfo
;
1829 p
= (struct proc
*)arg
;
1831 KASSERT(*sizep
== sizeof(*psinfo
), ("invalid size"));
1832 psinfo
= malloc(sizeof(*psinfo
), M_TEMP
, M_ZERO
| M_WAITOK
);
1833 psinfo
->pr_version
= PRPSINFO_VERSION
;
1834 psinfo
->pr_psinfosz
= sizeof(elf_prpsinfo_t
);
1835 strlcpy(psinfo
->pr_fname
, p
->p_comm
, sizeof(psinfo
->pr_fname
));
1837 * XXX - We don't fill in the command line arguments properly
1840 strlcpy(psinfo
->pr_psargs
, p
->p_comm
,
1841 sizeof(psinfo
->pr_psargs
));
1843 sbuf_bcat(sb
, psinfo
, sizeof(*psinfo
));
1844 free(psinfo
, M_TEMP
);
1846 *sizep
= sizeof(*psinfo
);
1850 __elfN(note_prstatus
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1853 elf_prstatus_t
*status
;
1855 td
= (struct thread
*)arg
;
1857 KASSERT(*sizep
== sizeof(*status
), ("invalid size"));
1858 status
= malloc(sizeof(*status
), M_TEMP
, M_ZERO
| M_WAITOK
);
1859 status
->pr_version
= PRSTATUS_VERSION
;
1860 status
->pr_statussz
= sizeof(elf_prstatus_t
);
1861 status
->pr_gregsetsz
= sizeof(elf_gregset_t
);
1862 status
->pr_fpregsetsz
= sizeof(elf_fpregset_t
);
1863 status
->pr_osreldate
= osreldate
;
1864 status
->pr_cursig
= td
->td_proc
->p_sig
;
1865 status
->pr_pid
= td
->td_tid
;
1866 #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1867 fill_regs32(td
, &status
->pr_reg
);
1869 fill_regs(td
, &status
->pr_reg
);
1871 sbuf_bcat(sb
, status
, sizeof(*status
));
1872 free(status
, M_TEMP
);
1874 *sizep
= sizeof(*status
);
1878 __elfN(note_fpregset
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1881 elf_prfpregset_t
*fpregset
;
1883 td
= (struct thread
*)arg
;
1885 KASSERT(*sizep
== sizeof(*fpregset
), ("invalid size"));
1886 fpregset
= malloc(sizeof(*fpregset
), M_TEMP
, M_ZERO
| M_WAITOK
);
1887 #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1888 fill_fpregs32(td
, fpregset
);
1890 fill_fpregs(td
, fpregset
);
1892 sbuf_bcat(sb
, fpregset
, sizeof(*fpregset
));
1893 free(fpregset
, M_TEMP
);
1895 *sizep
= sizeof(*fpregset
);
1899 __elfN(note_thrmisc
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1902 elf_thrmisc_t thrmisc
;
1904 td
= (struct thread
*)arg
;
1906 KASSERT(*sizep
== sizeof(thrmisc
), ("invalid size"));
1907 bzero(&thrmisc
._pad
, sizeof(thrmisc
._pad
));
1908 strcpy(thrmisc
.pr_tname
, td
->td_name
);
1909 sbuf_bcat(sb
, &thrmisc
, sizeof(thrmisc
));
1911 *sizep
= sizeof(thrmisc
);
1915 * Allow for MD specific notes, as well as any MD
1916 * specific preparations for writing MI notes.
1919 __elfN(note_threadmd
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1925 td
= (struct thread
*)arg
;
1927 if (size
!= 0 && sb
!= NULL
)
1928 buf
= malloc(size
, M_TEMP
, M_ZERO
| M_WAITOK
);
1932 __elfN(dump_thread
)(td
, buf
, &size
);
1933 KASSERT(sb
== NULL
|| *sizep
== size
, ("invalid size"));
1934 if (size
!= 0 && sb
!= NULL
)
1935 sbuf_bcat(sb
, buf
, size
);
1940 #ifdef KINFO_PROC_SIZE
1941 CTASSERT(sizeof(struct kinfo_proc
) == KINFO_PROC_SIZE
);
1945 __elfN(note_procstat_proc
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1951 p
= (struct proc
*)arg
;
1952 size
= sizeof(structsize
) + p
->p_numthreads
*
1953 sizeof(elf_kinfo_proc_t
);
1956 KASSERT(*sizep
== size
, ("invalid size"));
1957 structsize
= sizeof(elf_kinfo_proc_t
);
1958 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
1959 sx_slock(&proctree_lock
);
1961 kern_proc_out(p
, sb
, ELF_KERN_PROC_MASK
);
1962 sx_sunlock(&proctree_lock
);
1967 #ifdef KINFO_FILE_SIZE
1968 CTASSERT(sizeof(struct kinfo_file
) == KINFO_FILE_SIZE
);
1972 note_procstat_files(void *arg
, struct sbuf
*sb
, size_t *sizep
)
1975 size_t size
, sect_sz
, i
;
1976 ssize_t start_len
, sect_len
;
1977 int structsize
, filedesc_flags
;
1979 if (coredump_pack_fileinfo
)
1980 filedesc_flags
= KERN_FILEDESC_PACK_KINFO
;
1984 p
= (struct proc
*)arg
;
1985 structsize
= sizeof(struct kinfo_file
);
1988 sb
= sbuf_new(NULL
, NULL
, 128, SBUF_FIXEDLEN
);
1989 sbuf_set_drain(sb
, sbuf_drain_count
, &size
);
1990 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
1992 kern_proc_filedesc_out(p
, sb
, -1, filedesc_flags
);
1997 sbuf_start_section(sb
, &start_len
);
1999 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2001 kern_proc_filedesc_out(p
, sb
, *sizep
- sizeof(structsize
),
2004 sect_len
= sbuf_end_section(sb
, start_len
, 0, 0);
2009 KASSERT(sect_sz
<= *sizep
,
2010 ("kern_proc_filedesc_out did not respect maxlen; "
2011 "requested %zu, got %zu", *sizep
- sizeof(structsize
),
2012 sect_sz
- sizeof(structsize
)));
2014 for (i
= 0; i
< *sizep
- sect_sz
&& sb
->s_error
== 0; i
++)
2019 #ifdef KINFO_VMENTRY_SIZE
2020 CTASSERT(sizeof(struct kinfo_vmentry
) == KINFO_VMENTRY_SIZE
);
2024 note_procstat_vmmap(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2028 int structsize
, vmmap_flags
;
2030 if (coredump_pack_vmmapinfo
)
2031 vmmap_flags
= KERN_VMMAP_PACK_KINFO
;
2035 p
= (struct proc
*)arg
;
2036 structsize
= sizeof(struct kinfo_vmentry
);
2039 sb
= sbuf_new(NULL
, NULL
, 128, SBUF_FIXEDLEN
);
2040 sbuf_set_drain(sb
, sbuf_drain_count
, &size
);
2041 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2043 kern_proc_vmmap_out(p
, sb
, -1, vmmap_flags
);
2048 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2050 kern_proc_vmmap_out(p
, sb
, *sizep
- sizeof(structsize
),
2056 note_procstat_groups(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2062 p
= (struct proc
*)arg
;
2063 size
= sizeof(structsize
) + p
->p_ucred
->cr_ngroups
* sizeof(gid_t
);
2065 KASSERT(*sizep
== size
, ("invalid size"));
2066 structsize
= sizeof(gid_t
);
2067 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2068 sbuf_bcat(sb
, p
->p_ucred
->cr_groups
, p
->p_ucred
->cr_ngroups
*
2075 note_procstat_umask(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2081 p
= (struct proc
*)arg
;
2082 size
= sizeof(structsize
) + sizeof(p
->p_fd
->fd_cmask
);
2084 KASSERT(*sizep
== size
, ("invalid size"));
2085 structsize
= sizeof(p
->p_fd
->fd_cmask
);
2086 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2087 sbuf_bcat(sb
, &p
->p_fd
->fd_cmask
, sizeof(p
->p_fd
->fd_cmask
));
2093 note_procstat_rlimit(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2096 struct rlimit rlim
[RLIM_NLIMITS
];
2100 p
= (struct proc
*)arg
;
2101 size
= sizeof(structsize
) + sizeof(rlim
);
2103 KASSERT(*sizep
== size
, ("invalid size"));
2104 structsize
= sizeof(rlim
);
2105 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2107 for (i
= 0; i
< RLIM_NLIMITS
; i
++)
2108 lim_rlimit_proc(p
, i
, &rlim
[i
]);
2110 sbuf_bcat(sb
, rlim
, sizeof(rlim
));
2116 note_procstat_osrel(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2122 p
= (struct proc
*)arg
;
2123 size
= sizeof(structsize
) + sizeof(p
->p_osrel
);
2125 KASSERT(*sizep
== size
, ("invalid size"));
2126 structsize
= sizeof(p
->p_osrel
);
2127 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2128 sbuf_bcat(sb
, &p
->p_osrel
, sizeof(p
->p_osrel
));
2134 __elfN(note_procstat_psstrings
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2137 elf_ps_strings_t ps_strings
;
2141 p
= (struct proc
*)arg
;
2142 size
= sizeof(structsize
) + sizeof(ps_strings
);
2144 KASSERT(*sizep
== size
, ("invalid size"));
2145 structsize
= sizeof(ps_strings
);
2146 #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
2147 ps_strings
= PTROUT(p
->p_sysent
->sv_psstrings
);
2149 ps_strings
= p
->p_sysent
->sv_psstrings
;
2151 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2152 sbuf_bcat(sb
, &ps_strings
, sizeof(ps_strings
));
2158 __elfN(note_procstat_auxv
)(void *arg
, struct sbuf
*sb
, size_t *sizep
)
2164 p
= (struct proc
*)arg
;
2167 sb
= sbuf_new(NULL
, NULL
, 128, SBUF_FIXEDLEN
);
2168 sbuf_set_drain(sb
, sbuf_drain_count
, &size
);
2169 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2171 proc_getauxv(curthread
, p
, sb
);
2177 structsize
= sizeof(Elf_Auxinfo
);
2178 sbuf_bcat(sb
, &structsize
, sizeof(structsize
));
2180 proc_getauxv(curthread
, p
, sb
);
2186 __elfN(parse_notes
)(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
2187 int32_t *osrel
, const Elf_Phdr
*pnote
)
2189 const Elf_Note
*note
, *note0
, *note_end
;
2190 const char *note_name
;
2195 /* We need some limit, might as well use PAGE_SIZE. */
2196 if (pnote
== NULL
|| pnote
->p_filesz
> PAGE_SIZE
)
2198 ASSERT_VOP_LOCKED(imgp
->vp
, "parse_notes");
2199 if (pnote
->p_offset
> PAGE_SIZE
||
2200 pnote
->p_filesz
> PAGE_SIZE
- pnote
->p_offset
) {
2201 VOP_UNLOCK(imgp
->vp
, 0);
2202 buf
= malloc(pnote
->p_filesz
, M_TEMP
, M_WAITOK
);
2203 vn_lock(imgp
->vp
, LK_EXCLUSIVE
| LK_RETRY
);
2204 error
= vn_rdwr(UIO_READ
, imgp
->vp
, buf
, pnote
->p_filesz
,
2205 pnote
->p_offset
, UIO_SYSSPACE
, IO_NODELOCKED
,
2206 curthread
->td_ucred
, NOCRED
, NULL
, curthread
);
2208 uprintf("i/o error PT_NOTE\n");
2212 note
= note0
= (const Elf_Note
*)buf
;
2213 note_end
= (const Elf_Note
*)(buf
+ pnote
->p_filesz
);
2215 note
= note0
= (const Elf_Note
*)(imgp
->image_header
+
2217 note_end
= (const Elf_Note
*)(imgp
->image_header
+
2218 pnote
->p_offset
+ pnote
->p_filesz
);
2221 for (i
= 0; i
< 100 && note
>= note0
&& note
< note_end
; i
++) {
2222 if (!aligned(note
, Elf32_Addr
) || (const char *)note_end
-
2223 (const char *)note
< sizeof(Elf_Note
)) {
2227 if (note
->n_namesz
!= checknote
->hdr
.n_namesz
||
2228 note
->n_descsz
!= checknote
->hdr
.n_descsz
||
2229 note
->n_type
!= checknote
->hdr
.n_type
)
2231 note_name
= (const char *)(note
+ 1);
2232 if (note_name
+ checknote
->hdr
.n_namesz
>=
2233 (const char *)note_end
|| strncmp(checknote
->vendor
,
2234 note_name
, checknote
->hdr
.n_namesz
) != 0)
2238 * Fetch the osreldate for binary
2239 * from the ELF OSABI-note if necessary.
2241 if ((checknote
->flags
& BN_TRANSLATE_OSREL
) != 0 &&
2242 checknote
->trans_osrel
!= NULL
) {
2243 res
= checknote
->trans_osrel(note
, osrel
);
2249 note
= (const Elf_Note
*)((const char *)(note
+ 1) +
2250 roundup2(note
->n_namesz
, ELF_NOTE_ROUNDSIZE
) +
2251 roundup2(note
->n_descsz
, ELF_NOTE_ROUNDSIZE
));
2260 * Try to find the appropriate ABI-note section for checknote,
2261 * fetch the osreldate for binary from the ELF OSABI-note. Only the
2262 * first page of the image is searched, the same as for headers.
2265 __elfN(check_note
)(struct image_params
*imgp
, Elf_Brandnote
*checknote
,
2268 const Elf_Phdr
*phdr
;
2269 const Elf_Ehdr
*hdr
;
2272 hdr
= (const Elf_Ehdr
*)imgp
->image_header
;
2273 phdr
= (const Elf_Phdr
*)(imgp
->image_header
+ hdr
->e_phoff
);
2275 for (i
= 0; i
< hdr
->e_phnum
; i
++) {
2276 if (phdr
[i
].p_type
== PT_NOTE
&&
2277 __elfN(parse_notes
)(imgp
, checknote
, osrel
, &phdr
[i
]))
2285 * Tell kern_execve.c about it, with a little help from the linker.
2287 static struct execsw
__elfN(execsw
) = {
2288 __CONCAT(exec_
, __elfN(imgact
)),
2289 __XSTRING(__CONCAT(ELF
, __ELF_WORD_SIZE
))
2291 EXEC_SET(__CONCAT(elf
, __ELF_WORD_SIZE
), __elfN(execsw
));
2294 __elfN(trans_prot
)(Elf_Word flags
)
2300 prot
|= VM_PROT_EXECUTE
;
2302 prot
|= VM_PROT_WRITE
;
2304 prot
|= VM_PROT_READ
;
2305 #if __ELF_WORD_SIZE == 32
2306 #if defined(__amd64__)
2307 if (i386_read_exec
&& (flags
& PF_R
))
2308 prot
|= VM_PROT_EXECUTE
;
2315 __elfN(untrans_prot
)(vm_prot_t prot
)
2320 if (prot
& VM_PROT_EXECUTE
)
2322 if (prot
& VM_PROT_READ
)
2324 if (prot
& VM_PROT_WRITE
)