xref: /freebsd/sys/kern/imgact_elf.c (revision c2f37b92452cec6ab7fc5b9d2b682ac9af4bd436)
1e1743d02SSøren Schmidt /*-
286be94fcSTycho Nightingale  * Copyright (c) 2017 Dell EMC
321a3ee0eSDavid E. O'Brien  * Copyright (c) 2000 David O'Brien
49a14aa01SUlrich Spörlein  * Copyright (c) 1995-1996 Søren Schmidt
5e1743d02SSøren Schmidt  * Copyright (c) 1996 Peter Wemm
6e1743d02SSøren Schmidt  * All rights reserved.
7e1743d02SSøren Schmidt  *
8e1743d02SSøren Schmidt  * Redistribution and use in source and binary forms, with or without
9e1743d02SSøren Schmidt  * modification, are permitted provided that the following conditions
10e1743d02SSøren Schmidt  * are met:
11e1743d02SSøren Schmidt  * 1. Redistributions of source code must retain the above copyright
12e1743d02SSøren Schmidt  *    notice, this list of conditions and the following disclaimer
13e1743d02SSøren Schmidt  *    in this position and unchanged.
14e1743d02SSøren Schmidt  * 2. Redistributions in binary form must reproduce the above copyright
15e1743d02SSøren Schmidt  *    notice, this list of conditions and the following disclaimer in the
16e1743d02SSøren Schmidt  *    documentation and/or other materials provided with the distribution.
17e1743d02SSøren Schmidt  * 3. The name of the author may not be used to endorse or promote products
1821dc7d4fSJens Schweikhardt  *    derived from this software without specific prior written permission
19e1743d02SSøren Schmidt  *
20e1743d02SSøren Schmidt  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
21e1743d02SSøren Schmidt  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
22e1743d02SSøren Schmidt  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
23e1743d02SSøren Schmidt  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
24e1743d02SSøren Schmidt  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
25e1743d02SSøren Schmidt  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26e1743d02SSøren Schmidt  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27e1743d02SSøren Schmidt  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28e1743d02SSøren Schmidt  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
29e1743d02SSøren Schmidt  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30e1743d02SSøren Schmidt  */
31e1743d02SSøren Schmidt 
32677b542eSDavid E. O'Brien #include <sys/cdefs.h>
33677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
34677b542eSDavid E. O'Brien 
3512bc222eSJonathan Anderson #include "opt_capsicum.h"
3662919d78SPeter Wemm #include "opt_compat.h"
37aa14e9b7SMark Johnston #include "opt_gzio.h"
3862919d78SPeter Wemm 
39e1743d02SSøren Schmidt #include <sys/param.h>
404a144410SRobert Watson #include <sys/capsicum.h>
41e1743d02SSøren Schmidt #include <sys/exec.h>
428c64af4fSJohn Polstra #include <sys/fcntl.h>
43aa14e9b7SMark Johnston #include <sys/gzio.h>
44e1743d02SSøren Schmidt #include <sys/imgact.h>
45e1743d02SSøren Schmidt #include <sys/imgact_elf.h>
46b96bd95bSIan Lepore #include <sys/jail.h>
47e1743d02SSøren Schmidt #include <sys/kernel.h>
48f34fa851SJohn Baldwin #include <sys/lock.h>
49e1743d02SSøren Schmidt #include <sys/malloc.h>
5068ff2a43SChristian S.J. Peron #include <sys/mount.h>
518c64af4fSJohn Polstra #include <sys/mman.h>
52a794e791SBruce Evans #include <sys/namei.h>
538c64af4fSJohn Polstra #include <sys/pioctl.h>
54a794e791SBruce Evans #include <sys/proc.h>
558c64af4fSJohn Polstra #include <sys/procfs.h>
5686be94fcSTycho Nightingale #include <sys/ptrace.h>
571ba5ad42SEdward Tomasz Napierala #include <sys/racct.h>
588c64af4fSJohn Polstra #include <sys/resourcevar.h>
5989f6b863SAttilio Rao #include <sys/rwlock.h>
60bd390213SMikolaj Golub #include <sys/sbuf.h>
61da61b9a6SAlan Cox #include <sys/sf_buf.h>
62ee235befSKonstantin Belousov #include <sys/smp.h>
6336240ea5SDoug Rabson #include <sys/systm.h>
64e1743d02SSøren Schmidt #include <sys/signalvar.h>
658c64af4fSJohn Polstra #include <sys/stat.h>
661005a129SJohn Baldwin #include <sys/sx.h>
678c64af4fSJohn Polstra #include <sys/syscall.h>
68e1743d02SSøren Schmidt #include <sys/sysctl.h>
698c64af4fSJohn Polstra #include <sys/sysent.h>
70a794e791SBruce Evans #include <sys/vnode.h>
71e7228204SAlfred Perlstein #include <sys/syslog.h>
72e7228204SAlfred Perlstein #include <sys/eventhandler.h>
73f1fca82eSMikolaj Golub #include <sys/user.h>
74e7228204SAlfred Perlstein 
75e1743d02SSøren Schmidt #include <vm/vm.h>
76e1743d02SSøren Schmidt #include <vm/vm_kern.h>
77e1743d02SSøren Schmidt #include <vm/vm_param.h>
78e1743d02SSøren Schmidt #include <vm/pmap.h>
79e1743d02SSøren Schmidt #include <vm/vm_map.h>
800ff27d31SJohn Polstra #include <vm/vm_object.h>
81e1743d02SSøren Schmidt #include <vm/vm_extern.h>
82e1743d02SSøren Schmidt 
8352c24af7SPeter Wemm #include <machine/elf.h>
84e1743d02SSøren Schmidt #include <machine/md_var.h>
85e1743d02SSøren Schmidt 
861b8388cdSMikolaj Golub #define ELF_NOTE_ROUNDSIZE	4
87c815a20cSDavid E. O'Brien #define OLD_EI_BRAND	8
88c815a20cSDavid E. O'Brien 
893ebc1248SPeter Wemm static int __elfN(check_header)(const Elf_Ehdr *hdr);
9032c01de2SDmitry Chagin static Elf_Brandinfo *__elfN(get_brandinfo)(struct image_params *imgp,
91d1ae5c83SKonstantin Belousov     const char *interp, int interp_name_len, int32_t *osrel);
923ebc1248SPeter Wemm static int __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
933ebc1248SPeter Wemm     u_long *entry, size_t pagesize);
940bbee4cdSKonstantin Belousov static int __elfN(load_section)(struct image_params *imgp, vm_ooffset_t offset,
95292177e6SAlan Cox     caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot,
96292177e6SAlan Cox     size_t pagesize);
973ebc1248SPeter Wemm static int __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp);
9889ffc202SBjoern A. Zeeb static boolean_t __elfN(freebsd_trans_osrel)(const Elf_Note *note,
9989ffc202SBjoern A. Zeeb     int32_t *osrel);
10089ffc202SBjoern A. Zeeb static boolean_t kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel);
10132c01de2SDmitry Chagin static boolean_t __elfN(check_note)(struct image_params *imgp,
10232c01de2SDmitry Chagin     Elf_Brandnote *checknote, int32_t *osrel);
103ed167eaaSKonstantin Belousov static vm_prot_t __elfN(trans_prot)(Elf_Word);
104ed167eaaSKonstantin Belousov static Elf_Word __elfN(untrans_prot)(vm_prot_t);
105e1743d02SSøren Schmidt 
106a360a43dSJake Burkholder SYSCTL_NODE(_kern, OID_AUTO, __CONCAT(elf, __ELF_WORD_SIZE), CTLFLAG_RW, 0,
107a360a43dSJake Burkholder     "");
108a360a43dSJake Burkholder 
109bd390213SMikolaj Golub #define	CORE_BUF_SIZE	(16 * 1024)
110e7228204SAlfred Perlstein 
111e548a1d4SJake Burkholder int __elfN(fallback_brand) = -1;
112e548a1d4SJake Burkholder SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
113af3b2549SHans Petter Selasky     fallback_brand, CTLFLAG_RWTUN, &__elfN(fallback_brand), 0,
114a360a43dSJake Burkholder     __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) " brand of last resort");
115a360a43dSJake Burkholder 
116551d79e1SMarcel Moolenaar static int elf_legacy_coredump = 0;
117a360a43dSJake Burkholder SYSCTL_INT(_debug, OID_AUTO, __elfN(legacy_coredump), CTLFLAG_RW,
1181cbb879dSEd Maste     &elf_legacy_coredump, 0,
1191cbb879dSEd Maste     "include all and only RW pages in core dumps");
120e1743d02SSøren Schmidt 
12162c625fdSKonstantin Belousov int __elfN(nxstack) =
1224d22d07aSKonstantin Belousov #if defined(__amd64__) || defined(__powerpc64__) /* both 64 and 32 bit */ || \
1234d22d07aSKonstantin Belousov     (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__)
12462c625fdSKonstantin Belousov 	1;
12562c625fdSKonstantin Belousov #else
12662c625fdSKonstantin Belousov 	0;
12762c625fdSKonstantin Belousov #endif
128291c06a1SKonstantin Belousov SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
129291c06a1SKonstantin Belousov     nxstack, CTLFLAG_RW, &__elfN(nxstack), 0,
130291c06a1SKonstantin Belousov     __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) ": enable non-executable stack");
131291c06a1SKonstantin Belousov 
132126b36a2SKonstantin Belousov #if __ELF_WORD_SIZE == 32
133e7d939bdSMarcel Moolenaar #if defined(__amd64__)
134126b36a2SKonstantin Belousov int i386_read_exec = 0;
135126b36a2SKonstantin Belousov SYSCTL_INT(_kern_elf32, OID_AUTO, read_exec, CTLFLAG_RW, &i386_read_exec, 0,
136126b36a2SKonstantin Belousov     "enable execution from readable segments");
137126b36a2SKonstantin Belousov #endif
138126b36a2SKonstantin Belousov #endif
139126b36a2SKonstantin Belousov 
1403ebc1248SPeter Wemm static Elf_Brandinfo *elf_brand_list[MAX_BRANDS];
141e1743d02SSøren Schmidt 
142d9c9c81cSPedro F. Giffuni #define	trunc_page_ps(va, ps)	rounddown2(va, ps)
143d9c9c81cSPedro F. Giffuni #define	round_page_ps(va, ps)	roundup2(va, ps)
14493d1c728SKonstantin Belousov #define	aligned(a, t)	(trunc_page_ps((u_long)(a), sizeof(t)) == (u_long)(a))
14593d1c728SKonstantin Belousov 
14632c01de2SDmitry Chagin static const char FREEBSD_ABI_VENDOR[] = "FreeBSD";
14732c01de2SDmitry Chagin 
14832c01de2SDmitry Chagin Elf_Brandnote __elfN(freebsd_brandnote) = {
14932c01de2SDmitry Chagin 	.hdr.n_namesz	= sizeof(FREEBSD_ABI_VENDOR),
15032c01de2SDmitry Chagin 	.hdr.n_descsz	= sizeof(int32_t),
1514c22b468SEd Maste 	.hdr.n_type	= NT_FREEBSD_ABI_TAG,
15232c01de2SDmitry Chagin 	.vendor		= FREEBSD_ABI_VENDOR,
15389ffc202SBjoern A. Zeeb 	.flags		= BN_TRANSLATE_OSREL,
15489ffc202SBjoern A. Zeeb 	.trans_osrel	= __elfN(freebsd_trans_osrel)
15532c01de2SDmitry Chagin };
15632c01de2SDmitry Chagin 
15789ffc202SBjoern A. Zeeb static boolean_t
15889ffc202SBjoern A. Zeeb __elfN(freebsd_trans_osrel)(const Elf_Note *note, int32_t *osrel)
15989ffc202SBjoern A. Zeeb {
16089ffc202SBjoern A. Zeeb 	uintptr_t p;
16189ffc202SBjoern A. Zeeb 
16289ffc202SBjoern A. Zeeb 	p = (uintptr_t)(note + 1);
1631b8388cdSMikolaj Golub 	p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE);
16489ffc202SBjoern A. Zeeb 	*osrel = *(const int32_t *)(p);
16589ffc202SBjoern A. Zeeb 
16689ffc202SBjoern A. Zeeb 	return (TRUE);
16789ffc202SBjoern A. Zeeb }
16889ffc202SBjoern A. Zeeb 
16989ffc202SBjoern A. Zeeb static const char GNU_ABI_VENDOR[] = "GNU";
17089ffc202SBjoern A. Zeeb static int GNU_KFREEBSD_ABI_DESC = 3;
17189ffc202SBjoern A. Zeeb 
17289ffc202SBjoern A. Zeeb Elf_Brandnote __elfN(kfreebsd_brandnote) = {
17389ffc202SBjoern A. Zeeb 	.hdr.n_namesz	= sizeof(GNU_ABI_VENDOR),
17489ffc202SBjoern A. Zeeb 	.hdr.n_descsz	= 16,	/* XXX at least 16 */
17589ffc202SBjoern A. Zeeb 	.hdr.n_type	= 1,
17689ffc202SBjoern A. Zeeb 	.vendor		= GNU_ABI_VENDOR,
17789ffc202SBjoern A. Zeeb 	.flags		= BN_TRANSLATE_OSREL,
17889ffc202SBjoern A. Zeeb 	.trans_osrel	= kfreebsd_trans_osrel
17989ffc202SBjoern A. Zeeb };
18089ffc202SBjoern A. Zeeb 
18189ffc202SBjoern A. Zeeb static boolean_t
18289ffc202SBjoern A. Zeeb kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel)
18389ffc202SBjoern A. Zeeb {
18489ffc202SBjoern A. Zeeb 	const Elf32_Word *desc;
18589ffc202SBjoern A. Zeeb 	uintptr_t p;
18689ffc202SBjoern A. Zeeb 
18789ffc202SBjoern A. Zeeb 	p = (uintptr_t)(note + 1);
1881b8388cdSMikolaj Golub 	p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE);
18989ffc202SBjoern A. Zeeb 
19089ffc202SBjoern A. Zeeb 	desc = (const Elf32_Word *)p;
19189ffc202SBjoern A. Zeeb 	if (desc[0] != GNU_KFREEBSD_ABI_DESC)
19289ffc202SBjoern A. Zeeb 		return (FALSE);
19389ffc202SBjoern A. Zeeb 
19489ffc202SBjoern A. Zeeb 	/*
19589ffc202SBjoern A. Zeeb 	 * Debian GNU/kFreeBSD embed the earliest compatible kernel version
19689ffc202SBjoern A. Zeeb 	 * (__FreeBSD_version: <major><two digit minor>Rxx) in the LSB way.
19789ffc202SBjoern A. Zeeb 	 */
19889ffc202SBjoern A. Zeeb 	*osrel = desc[1] * 100000 + desc[2] * 1000 + desc[3];
19989ffc202SBjoern A. Zeeb 
20089ffc202SBjoern A. Zeeb 	return (TRUE);
20189ffc202SBjoern A. Zeeb }
20289ffc202SBjoern A. Zeeb 
203e1743d02SSøren Schmidt int
2043ebc1248SPeter Wemm __elfN(insert_brand_entry)(Elf_Brandinfo *entry)
205e1743d02SSøren Schmidt {
206e1743d02SSøren Schmidt 	int i;
207e1743d02SSøren Schmidt 
2083ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
209ea5a2b2eSSøren Schmidt 		if (elf_brand_list[i] == NULL) {
210ea5a2b2eSSøren Schmidt 			elf_brand_list[i] = entry;
211e1743d02SSøren Schmidt 			break;
212e1743d02SSøren Schmidt 		}
213e1743d02SSøren Schmidt 	}
214925c8b5bSBjoern A. Zeeb 	if (i == MAX_BRANDS) {
215925c8b5bSBjoern A. Zeeb 		printf("WARNING: %s: could not insert brandinfo entry: %p\n",
216925c8b5bSBjoern A. Zeeb 			__func__, entry);
217a7cddfedSJake Burkholder 		return (-1);
218925c8b5bSBjoern A. Zeeb 	}
219a7cddfedSJake Burkholder 	return (0);
220e1743d02SSøren Schmidt }
221e1743d02SSøren Schmidt 
222e1743d02SSøren Schmidt int
2233ebc1248SPeter Wemm __elfN(remove_brand_entry)(Elf_Brandinfo *entry)
224e1743d02SSøren Schmidt {
225e1743d02SSøren Schmidt 	int i;
226e1743d02SSøren Schmidt 
2273ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
228ea5a2b2eSSøren Schmidt 		if (elf_brand_list[i] == entry) {
229ea5a2b2eSSøren Schmidt 			elf_brand_list[i] = NULL;
230e1743d02SSøren Schmidt 			break;
231e1743d02SSøren Schmidt 		}
232e1743d02SSøren Schmidt 	}
233ea5a2b2eSSøren Schmidt 	if (i == MAX_BRANDS)
234a7cddfedSJake Burkholder 		return (-1);
235a7cddfedSJake Burkholder 	return (0);
236e1743d02SSøren Schmidt }
237e1743d02SSøren Schmidt 
238096977faSMark Newton int
2393ebc1248SPeter Wemm __elfN(brand_inuse)(Elf_Brandinfo *entry)
240096977faSMark Newton {
241096977faSMark Newton 	struct proc *p;
242553629ebSJake Burkholder 	int rval = FALSE;
243096977faSMark Newton 
2441005a129SJohn Baldwin 	sx_slock(&allproc_lock);
2454f506694SXin LI 	FOREACH_PROC_IN_SYSTEM(p) {
246553629ebSJake Burkholder 		if (p->p_sysent == entry->sysvec) {
247553629ebSJake Burkholder 			rval = TRUE;
248553629ebSJake Burkholder 			break;
249096977faSMark Newton 		}
250553629ebSJake Burkholder 	}
2511005a129SJohn Baldwin 	sx_sunlock(&allproc_lock);
252096977faSMark Newton 
253553629ebSJake Burkholder 	return (rval);
254096977faSMark Newton }
255096977faSMark Newton 
2565fe3ed62SJake Burkholder static Elf_Brandinfo *
25732c01de2SDmitry Chagin __elfN(get_brandinfo)(struct image_params *imgp, const char *interp,
258d1ae5c83SKonstantin Belousov     int interp_name_len, int32_t *osrel)
2595fe3ed62SJake Burkholder {
26032c01de2SDmitry Chagin 	const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
261af582aaeSKonstantin Belousov 	Elf_Brandinfo *bi, *bi_m;
26232c01de2SDmitry Chagin 	boolean_t ret;
2635fe3ed62SJake Burkholder 	int i;
2645fe3ed62SJake Burkholder 
2655fe3ed62SJake Burkholder 	/*
26632c01de2SDmitry Chagin 	 * We support four types of branding -- (1) the ELF EI_OSABI field
2675fe3ed62SJake Burkholder 	 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
26832c01de2SDmitry Chagin 	 * branding w/in the ELF header, (3) path of the `interp_path'
26932c01de2SDmitry Chagin 	 * field, and (4) the ".note.ABI-tag" ELF section.
2705fe3ed62SJake Burkholder 	 */
2715fe3ed62SJake Burkholder 
27232c01de2SDmitry Chagin 	/* Look for an ".note.ABI-tag" ELF section */
273af582aaeSKonstantin Belousov 	bi_m = NULL;
27432c01de2SDmitry Chagin 	for (i = 0; i < MAX_BRANDS; i++) {
27532c01de2SDmitry Chagin 		bi = elf_brand_list[i];
276ecc2fda8SBjoern A. Zeeb 		if (bi == NULL)
277ecc2fda8SBjoern A. Zeeb 			continue;
2782274ab3dSKonstantin Belousov 		if (interp != NULL && (bi->flags & BI_BRAND_ONLY_STATIC) != 0)
2791438fe3cSKonstantin Belousov 			continue;
280ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine && (bi->flags &
281ecc2fda8SBjoern A. Zeeb 		    (BI_BRAND_NOTE|BI_BRAND_NOTE_MANDATORY)) != 0) {
28232c01de2SDmitry Chagin 			ret = __elfN(check_note)(imgp, bi->brand_note, osrel);
283f19d421aSNathan Whitehorn 			/* Give brand a chance to veto check_note's guess */
284f19d421aSNathan Whitehorn 			if (ret && bi->header_supported)
285f19d421aSNathan Whitehorn 				ret = bi->header_supported(imgp);
286af582aaeSKonstantin Belousov 			/*
287af582aaeSKonstantin Belousov 			 * If note checker claimed the binary, but the
288af582aaeSKonstantin Belousov 			 * interpreter path in the image does not
289af582aaeSKonstantin Belousov 			 * match default one for the brand, try to
290af582aaeSKonstantin Belousov 			 * search for other brands with the same
291af582aaeSKonstantin Belousov 			 * interpreter.  Either there is better brand
292af582aaeSKonstantin Belousov 			 * with the right interpreter, or, failing
293af582aaeSKonstantin Belousov 			 * this, we return first brand which accepted
294af582aaeSKonstantin Belousov 			 * our note and, optionally, header.
295af582aaeSKonstantin Belousov 			 */
2963aeacc55SKonstantin Belousov 			if (ret && bi_m == NULL && interp != NULL &&
2973aeacc55SKonstantin Belousov 			    (bi->interp_path == NULL ||
2983aeacc55SKonstantin Belousov 			    (strlen(bi->interp_path) + 1 != interp_name_len ||
2993aeacc55SKonstantin Belousov 			    strncmp(interp, bi->interp_path, interp_name_len)
3003aeacc55SKonstantin Belousov 			    != 0))) {
301af582aaeSKonstantin Belousov 				bi_m = bi;
302af582aaeSKonstantin Belousov 				ret = 0;
303af582aaeSKonstantin Belousov 			}
30432c01de2SDmitry Chagin 			if (ret)
30532c01de2SDmitry Chagin 				return (bi);
30632c01de2SDmitry Chagin 		}
30732c01de2SDmitry Chagin 	}
308af582aaeSKonstantin Belousov 	if (bi_m != NULL)
309af582aaeSKonstantin Belousov 		return (bi_m);
31032c01de2SDmitry Chagin 
3115fe3ed62SJake Burkholder 	/* If the executable has a brand, search for it in the brand list. */
3125fe3ed62SJake Burkholder 	for (i = 0; i < MAX_BRANDS; i++) {
3135fe3ed62SJake Burkholder 		bi = elf_brand_list[i];
3141438fe3cSKonstantin Belousov 		if (bi == NULL || (bi->flags & BI_BRAND_NOTE_MANDATORY) != 0 ||
3152274ab3dSKonstantin Belousov 		    (interp != NULL && (bi->flags & BI_BRAND_ONLY_STATIC) != 0))
316ecc2fda8SBjoern A. Zeeb 			continue;
317ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine &&
3185fe3ed62SJake Burkholder 		    (hdr->e_ident[EI_OSABI] == bi->brand ||
3190fe98320SEd Schouten 		    (bi->compat_3_brand != NULL &&
3203d560b4bSKonstantin Belousov 		    strcmp((const char *)&hdr->e_ident[OLD_EI_BRAND],
3210fe98320SEd Schouten 		    bi->compat_3_brand) == 0))) {
322686d2f31SNathan Whitehorn 			/* Looks good, but give brand a chance to veto */
32315a9aedfSKonstantin Belousov 			if (!bi->header_supported ||
32415a9aedfSKonstantin Belousov 			    bi->header_supported(imgp)) {
32515a9aedfSKonstantin Belousov 				/*
32615a9aedfSKonstantin Belousov 				 * Again, prefer strictly matching
32715a9aedfSKonstantin Belousov 				 * interpreter path.
32815a9aedfSKonstantin Belousov 				 */
3297aab7a80SKonstantin Belousov 				if (interp_name_len == 0 &&
3307aab7a80SKonstantin Belousov 				    bi->interp_path == NULL)
3317aab7a80SKonstantin Belousov 					return (bi);
3327aab7a80SKonstantin Belousov 				if (bi->interp_path != NULL &&
3337aab7a80SKonstantin Belousov 				    strlen(bi->interp_path) + 1 ==
33415a9aedfSKonstantin Belousov 				    interp_name_len && strncmp(interp,
33515a9aedfSKonstantin Belousov 				    bi->interp_path, interp_name_len) == 0)
3365fe3ed62SJake Burkholder 					return (bi);
33715a9aedfSKonstantin Belousov 				if (bi_m == NULL)
33815a9aedfSKonstantin Belousov 					bi_m = bi;
3395fe3ed62SJake Burkholder 			}
340686d2f31SNathan Whitehorn 		}
34115a9aedfSKonstantin Belousov 	}
34215a9aedfSKonstantin Belousov 	if (bi_m != NULL)
34315a9aedfSKonstantin Belousov 		return (bi_m);
3445fe3ed62SJake Burkholder 
345817dc004SWarner Losh 	/* No known brand, see if the header is recognized by any brand */
346817dc004SWarner Losh 	for (i = 0; i < MAX_BRANDS; i++) {
347817dc004SWarner Losh 		bi = elf_brand_list[i];
348817dc004SWarner Losh 		if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY ||
349817dc004SWarner Losh 		    bi->header_supported == NULL)
350817dc004SWarner Losh 			continue;
351817dc004SWarner Losh 		if (hdr->e_machine == bi->machine) {
352817dc004SWarner Losh 			ret = bi->header_supported(imgp);
353817dc004SWarner Losh 			if (ret)
354817dc004SWarner Losh 				return (bi);
355817dc004SWarner Losh 		}
356817dc004SWarner Losh 	}
357817dc004SWarner Losh 
3585fe3ed62SJake Burkholder 	/* Lacking a known brand, search for a recognized interpreter. */
3595fe3ed62SJake Burkholder 	if (interp != NULL) {
3605fe3ed62SJake Burkholder 		for (i = 0; i < MAX_BRANDS; i++) {
3615fe3ed62SJake Burkholder 			bi = elf_brand_list[i];
3622274ab3dSKonstantin Belousov 			if (bi == NULL || (bi->flags &
3632274ab3dSKonstantin Belousov 			    (BI_BRAND_NOTE_MANDATORY | BI_BRAND_ONLY_STATIC))
3642274ab3dSKonstantin Belousov 			    != 0)
365ecc2fda8SBjoern A. Zeeb 				continue;
366ecc2fda8SBjoern A. Zeeb 			if (hdr->e_machine == bi->machine &&
3673aeacc55SKonstantin Belousov 			    bi->interp_path != NULL &&
368d1ae5c83SKonstantin Belousov 			    /* ELF image p_filesz includes terminating zero */
369d1ae5c83SKonstantin Belousov 			    strlen(bi->interp_path) + 1 == interp_name_len &&
370d1ae5c83SKonstantin Belousov 			    strncmp(interp, bi->interp_path, interp_name_len)
371d1ae5c83SKonstantin Belousov 			    == 0)
3725fe3ed62SJake Burkholder 				return (bi);
3735fe3ed62SJake Burkholder 		}
3745fe3ed62SJake Burkholder 	}
3755fe3ed62SJake Burkholder 
3765fe3ed62SJake Burkholder 	/* Lacking a recognized interpreter, try the default brand */
3775fe3ed62SJake Burkholder 	for (i = 0; i < MAX_BRANDS; i++) {
3785fe3ed62SJake Burkholder 		bi = elf_brand_list[i];
3791438fe3cSKonstantin Belousov 		if (bi == NULL || (bi->flags & BI_BRAND_NOTE_MANDATORY) != 0 ||
3802274ab3dSKonstantin Belousov 		    (interp != NULL && (bi->flags & BI_BRAND_ONLY_STATIC) != 0))
381ecc2fda8SBjoern A. Zeeb 			continue;
382ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine &&
383e548a1d4SJake Burkholder 		    __elfN(fallback_brand) == bi->brand)
3845fe3ed62SJake Burkholder 			return (bi);
3855fe3ed62SJake Burkholder 	}
3865fe3ed62SJake Burkholder 	return (NULL);
3875fe3ed62SJake Burkholder }
3885fe3ed62SJake Burkholder 
389e1743d02SSøren Schmidt static int
3903ebc1248SPeter Wemm __elfN(check_header)(const Elf_Ehdr *hdr)
391e1743d02SSøren Schmidt {
392d0ca7c29SPeter Wemm 	Elf_Brandinfo *bi;
3933ebc1248SPeter Wemm 	int i;
3943ebc1248SPeter Wemm 
39552c24af7SPeter Wemm 	if (!IS_ELF(*hdr) ||
39652c24af7SPeter Wemm 	    hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
39752c24af7SPeter Wemm 	    hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
3983dc19c46SJacques Vidrine 	    hdr->e_ident[EI_VERSION] != EV_CURRENT ||
3993dc19c46SJacques Vidrine 	    hdr->e_phentsize != sizeof(Elf_Phdr) ||
4003dc19c46SJacques Vidrine 	    hdr->e_version != ELF_TARG_VER)
401a7cddfedSJake Burkholder 		return (ENOEXEC);
402e1743d02SSøren Schmidt 
4033ebc1248SPeter Wemm 	/*
4043ebc1248SPeter Wemm 	 * Make sure we have at least one brand for this machine.
4053ebc1248SPeter Wemm 	 */
4063ebc1248SPeter Wemm 
4073ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
408d0ca7c29SPeter Wemm 		bi = elf_brand_list[i];
409d0ca7c29SPeter Wemm 		if (bi != NULL && bi->machine == hdr->e_machine)
4103ebc1248SPeter Wemm 			break;
4113ebc1248SPeter Wemm 	}
4123ebc1248SPeter Wemm 	if (i == MAX_BRANDS)
413a7cddfedSJake Burkholder 		return (ENOEXEC);
414e1743d02SSøren Schmidt 
415a7cddfedSJake Burkholder 	return (0);
416e1743d02SSøren Schmidt }
417e1743d02SSøren Schmidt 
418e1743d02SSøren Schmidt static int
4193ebc1248SPeter Wemm __elfN(map_partial)(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
420ff6f03c7SAlan Cox     vm_offset_t start, vm_offset_t end, vm_prot_t prot)
4213ebc1248SPeter Wemm {
422da61b9a6SAlan Cox 	struct sf_buf *sf;
423da61b9a6SAlan Cox 	int error;
4243ebc1248SPeter Wemm 	vm_offset_t off;
4253ebc1248SPeter Wemm 
4263ebc1248SPeter Wemm 	/*
4273ebc1248SPeter Wemm 	 * Create the page if it doesn't exist yet. Ignore errors.
4283ebc1248SPeter Wemm 	 */
429aaadc41fSKonstantin Belousov 	vm_map_fixed(map, NULL, 0, trunc_page(start), round_page(end) -
430aaadc41fSKonstantin Belousov 	    trunc_page(start), VM_PROT_ALL, VM_PROT_ALL, MAP_CHECK_EXCL);
4313ebc1248SPeter Wemm 
4323ebc1248SPeter Wemm 	/*
4333ebc1248SPeter Wemm 	 * Find the page from the underlying object.
4343ebc1248SPeter Wemm 	 */
43528e8da65SAlan Cox 	if (object != NULL) {
436da61b9a6SAlan Cox 		sf = vm_imgact_map_page(object, offset);
437da61b9a6SAlan Cox 		if (sf == NULL)
438da61b9a6SAlan Cox 			return (KERN_FAILURE);
4393ebc1248SPeter Wemm 		off = offset - trunc_page(offset);
440da61b9a6SAlan Cox 		error = copyout((caddr_t)sf_buf_kva(sf) + off, (caddr_t)start,
441ca0387efSJake Burkholder 		    end - start);
442be996836SAttilio Rao 		vm_imgact_unmap_page(sf);
443fe0a8a39SKonstantin Belousov 		if (error != 0)
444a7cddfedSJake Burkholder 			return (KERN_FAILURE);
4453ebc1248SPeter Wemm 	}
4463ebc1248SPeter Wemm 
447a7cddfedSJake Burkholder 	return (KERN_SUCCESS);
4483ebc1248SPeter Wemm }
4493ebc1248SPeter Wemm 
4503ebc1248SPeter Wemm static int
451e3d8f8feSKonstantin Belousov __elfN(map_insert)(struct image_params *imgp, vm_map_t map, vm_object_t object,
452e3d8f8feSKonstantin Belousov     vm_ooffset_t offset, vm_offset_t start, vm_offset_t end, vm_prot_t prot,
453e3d8f8feSKonstantin Belousov     int cow)
4543ebc1248SPeter Wemm {
455da61b9a6SAlan Cox 	struct sf_buf *sf;
456da61b9a6SAlan Cox 	vm_offset_t off;
457a063facbSMarcel Moolenaar 	vm_size_t sz;
458e3d8f8feSKonstantin Belousov 	int error, locked, rv;
4593ebc1248SPeter Wemm 
4603ebc1248SPeter Wemm 	if (start != trunc_page(start)) {
46181f223caSJake Burkholder 		rv = __elfN(map_partial)(map, object, offset, start,
462ff6f03c7SAlan Cox 		    round_page(start), prot);
46328e8da65SAlan Cox 		if (rv != KERN_SUCCESS)
464a7cddfedSJake Burkholder 			return (rv);
4653ebc1248SPeter Wemm 		offset += round_page(start) - start;
4663ebc1248SPeter Wemm 		start = round_page(start);
4673ebc1248SPeter Wemm 	}
4683ebc1248SPeter Wemm 	if (end != round_page(end)) {
46981f223caSJake Burkholder 		rv = __elfN(map_partial)(map, object, offset +
470ff6f03c7SAlan Cox 		    trunc_page(end) - start, trunc_page(end), end, prot);
47128e8da65SAlan Cox 		if (rv != KERN_SUCCESS)
472a7cddfedSJake Burkholder 			return (rv);
4733ebc1248SPeter Wemm 		end = trunc_page(end);
4743ebc1248SPeter Wemm 	}
475e383e820SAlan Cox 	if (start >= end)
476e383e820SAlan Cox 		return (KERN_SUCCESS);
477e383e820SAlan Cox 	if ((offset & PAGE_MASK) != 0) {
4783ebc1248SPeter Wemm 		/*
479e383e820SAlan Cox 		 * The mapping is not page aligned.  This means that we have
480e383e820SAlan Cox 		 * to copy the data.
4813ebc1248SPeter Wemm 		 */
482aaadc41fSKonstantin Belousov 		rv = vm_map_fixed(map, NULL, 0, start, end - start,
483aaadc41fSKonstantin Belousov 		    prot | VM_PROT_WRITE, VM_PROT_ALL, MAP_CHECK_EXCL);
4845420f76bSKonstantin Belousov 		if (rv != KERN_SUCCESS)
485a7cddfedSJake Burkholder 			return (rv);
486da61b9a6SAlan Cox 		if (object == NULL)
487da61b9a6SAlan Cox 			return (KERN_SUCCESS);
488da61b9a6SAlan Cox 		for (; start < end; start += sz) {
489da61b9a6SAlan Cox 			sf = vm_imgact_map_page(object, offset);
490da61b9a6SAlan Cox 			if (sf == NULL)
491da61b9a6SAlan Cox 				return (KERN_FAILURE);
4923ebc1248SPeter Wemm 			off = offset - trunc_page(offset);
4933ebc1248SPeter Wemm 			sz = end - start;
494da61b9a6SAlan Cox 			if (sz > PAGE_SIZE - off)
495da61b9a6SAlan Cox 				sz = PAGE_SIZE - off;
496da61b9a6SAlan Cox 			error = copyout((caddr_t)sf_buf_kva(sf) + off,
4973ebc1248SPeter Wemm 			    (caddr_t)start, sz);
498be996836SAttilio Rao 			vm_imgact_unmap_page(sf);
4995420f76bSKonstantin Belousov 			if (error != 0)
500a7cddfedSJake Burkholder 				return (KERN_FAILURE);
501da61b9a6SAlan Cox 			offset += sz;
5023ebc1248SPeter Wemm 		}
5033ebc1248SPeter Wemm 	} else {
504e5e6093bSAlan Cox 		vm_object_reference(object);
505e383e820SAlan Cox 		rv = vm_map_fixed(map, object, offset, start, end - start,
506e383e820SAlan Cox 		    prot, VM_PROT_ALL, cow | MAP_CHECK_EXCL);
507e3d8f8feSKonstantin Belousov 		if (rv != KERN_SUCCESS) {
508e3d8f8feSKonstantin Belousov 			locked = VOP_ISLOCKED(imgp->vp);
509e3d8f8feSKonstantin Belousov 			VOP_UNLOCK(imgp->vp, 0);
510e5e6093bSAlan Cox 			vm_object_deallocate(object);
511e3d8f8feSKonstantin Belousov 			vn_lock(imgp->vp, locked | LK_RETRY);
512a7cddfedSJake Burkholder 			return (rv);
5133ebc1248SPeter Wemm 		}
5143ebc1248SPeter Wemm 	}
515e383e820SAlan Cox 	return (KERN_SUCCESS);
516e383e820SAlan Cox }
5173ebc1248SPeter Wemm 
5183ebc1248SPeter Wemm static int
5190bbee4cdSKonstantin Belousov __elfN(load_section)(struct image_params *imgp, vm_ooffset_t offset,
5203ebc1248SPeter Wemm     caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot,
5213ebc1248SPeter Wemm     size_t pagesize)
522e1743d02SSøren Schmidt {
523da61b9a6SAlan Cox 	struct sf_buf *sf;
524e1743d02SSøren Schmidt 	size_t map_len;
525292177e6SAlan Cox 	vm_map_t map;
526292177e6SAlan Cox 	vm_object_t object;
527973d67c4SKonstantin Belousov 	vm_offset_t off, map_addr;
528fa7dd9c5SMatthew Dillon 	int error, rv, cow;
529e1743d02SSøren Schmidt 	size_t copy_len;
5300bbee4cdSKonstantin Belousov 	vm_ooffset_t file_addr;
53152c24af7SPeter Wemm 
53225ead034SBrian Feldman 	/*
53325ead034SBrian Feldman 	 * It's necessary to fail if the filsz + offset taken from the
53425ead034SBrian Feldman 	 * header is greater than the actual file pager object's size.
53525ead034SBrian Feldman 	 * If we were to allow this, then the vm_map_find() below would
53625ead034SBrian Feldman 	 * walk right off the end of the file object and into the ether.
53725ead034SBrian Feldman 	 *
53825ead034SBrian Feldman 	 * While I'm here, might as well check for something else that
53925ead034SBrian Feldman 	 * is invalid: filsz cannot be greater than memsz.
54025ead034SBrian Feldman 	 */
5419bcf2f2dSKonstantin Belousov 	if ((filsz != 0 && (off_t)filsz + offset > imgp->attr->va_size) ||
5429bcf2f2dSKonstantin Belousov 	    filsz > memsz) {
54325ead034SBrian Feldman 		uprintf("elf_load_section: truncated ELF file\n");
54425ead034SBrian Feldman 		return (ENOEXEC);
54525ead034SBrian Feldman 	}
54625ead034SBrian Feldman 
547292177e6SAlan Cox 	object = imgp->object;
548292177e6SAlan Cox 	map = &imgp->proc->p_vmspace->vm_map;
5493ebc1248SPeter Wemm 	map_addr = trunc_page_ps((vm_offset_t)vmaddr, pagesize);
5503ebc1248SPeter Wemm 	file_addr = trunc_page_ps(offset, pagesize);
551e1743d02SSøren Schmidt 
552e1743d02SSøren Schmidt 	/*
55352c24af7SPeter Wemm 	 * We have two choices.  We can either clear the data in the last page
55452c24af7SPeter Wemm 	 * of an oversized mapping, or we can start the anon mapping a page
55552c24af7SPeter Wemm 	 * early and copy the initialized data into that first page.  We
55628e8da65SAlan Cox 	 * choose the second.
55752c24af7SPeter Wemm 	 */
5589bcf2f2dSKonstantin Belousov 	if (filsz == 0)
5599bcf2f2dSKonstantin Belousov 		map_len = 0;
5609bcf2f2dSKonstantin Belousov 	else if (memsz > filsz)
5613ebc1248SPeter Wemm 		map_len = trunc_page_ps(offset + filsz, pagesize) - file_addr;
56252c24af7SPeter Wemm 	else
5633ebc1248SPeter Wemm 		map_len = round_page_ps(offset + filsz, pagesize) - file_addr;
56452c24af7SPeter Wemm 
56552c24af7SPeter Wemm 	if (map_len != 0) {
566fa7dd9c5SMatthew Dillon 		/* cow flags: don't dump readonly sections in core */
567fa7dd9c5SMatthew Dillon 		cow = MAP_COPY_ON_WRITE | MAP_PREFAULT |
568fa7dd9c5SMatthew Dillon 		    (prot & VM_PROT_WRITE ? 0 : MAP_DISABLE_COREDUMP);
569fa7dd9c5SMatthew Dillon 
570e3d8f8feSKonstantin Belousov 		rv = __elfN(map_insert)(imgp, map,
57152c24af7SPeter Wemm 				      object,
57252c24af7SPeter Wemm 				      file_addr,	/* file offset */
57352c24af7SPeter Wemm 				      map_addr,		/* virtual start */
57452c24af7SPeter Wemm 				      map_addr + map_len,/* virtual end */
57552c24af7SPeter Wemm 				      prot,
576fa7dd9c5SMatthew Dillon 				      cow);
577e5e6093bSAlan Cox 		if (rv != KERN_SUCCESS)
578a7cddfedSJake Burkholder 			return (EINVAL);
57952c24af7SPeter Wemm 
58052c24af7SPeter Wemm 		/* we can stop now if we've covered it all */
581973d67c4SKonstantin Belousov 		if (memsz == filsz)
582a7cddfedSJake Burkholder 			return (0);
58352c24af7SPeter Wemm 	}
58452c24af7SPeter Wemm 
58552c24af7SPeter Wemm 
58652c24af7SPeter Wemm 	/*
58752c24af7SPeter Wemm 	 * We have to get the remaining bit of the file into the first part
58852c24af7SPeter Wemm 	 * of the oversized map segment.  This is normally because the .data
58952c24af7SPeter Wemm 	 * segment in the file is extended to provide bss.  It's a neat idea
59052c24af7SPeter Wemm 	 * to try and save a page, but it's a pain in the behind to implement.
591e1743d02SSøren Schmidt 	 */
5929bcf2f2dSKonstantin Belousov 	copy_len = filsz == 0 ? 0 : (offset + filsz) - trunc_page_ps(offset +
5939bcf2f2dSKonstantin Belousov 	    filsz, pagesize);
5943ebc1248SPeter Wemm 	map_addr = trunc_page_ps((vm_offset_t)vmaddr + filsz, pagesize);
595ca0387efSJake Burkholder 	map_len = round_page_ps((vm_offset_t)vmaddr + memsz, pagesize) -
596ca0387efSJake Burkholder 	    map_addr;
597e1743d02SSøren Schmidt 
59852c24af7SPeter Wemm 	/* This had damn well better be true! */
5998191d577SPeter Wemm 	if (map_len != 0) {
600e3d8f8feSKonstantin Belousov 		rv = __elfN(map_insert)(imgp, map, NULL, 0, map_addr,
601c547cbb4SAlan Cox 		    map_addr + map_len, prot, 0);
602973d67c4SKonstantin Belousov 		if (rv != KERN_SUCCESS)
603a7cddfedSJake Burkholder 			return (EINVAL);
6048191d577SPeter Wemm 	}
605e1743d02SSøren Schmidt 
60652c24af7SPeter Wemm 	if (copy_len != 0) {
607da61b9a6SAlan Cox 		sf = vm_imgact_map_page(object, offset + filsz);
608da61b9a6SAlan Cox 		if (sf == NULL)
609da61b9a6SAlan Cox 			return (EIO);
610e1743d02SSøren Schmidt 
61152c24af7SPeter Wemm 		/* send the page fragment to user space */
61281f223caSJake Burkholder 		off = trunc_page_ps(offset + filsz, pagesize) -
61381f223caSJake Burkholder 		    trunc_page(offset + filsz);
614da61b9a6SAlan Cox 		error = copyout((caddr_t)sf_buf_kva(sf) + off,
615da61b9a6SAlan Cox 		    (caddr_t)map_addr, copy_len);
616be996836SAttilio Rao 		vm_imgact_unmap_page(sf);
617973d67c4SKonstantin Belousov 		if (error != 0)
61852c24af7SPeter Wemm 			return (error);
61952c24af7SPeter Wemm 	}
620e1743d02SSøren Schmidt 
621e1743d02SSøren Schmidt 	/*
622c547cbb4SAlan Cox 	 * Remove write access to the page if it was only granted by map_insert
623c547cbb4SAlan Cox 	 * to allow copyout.
624e1743d02SSøren Schmidt 	 */
625c547cbb4SAlan Cox 	if ((prot & VM_PROT_WRITE) == 0)
626292177e6SAlan Cox 		vm_map_protect(map, trunc_page(map_addr), round_page(map_addr +
627292177e6SAlan Cox 		    map_len), prot, FALSE);
6288191d577SPeter Wemm 
629ff6f03c7SAlan Cox 	return (0);
630e1743d02SSøren Schmidt }
631e1743d02SSøren Schmidt 
632c33fe779SJohn Polstra /*
633c33fe779SJohn Polstra  * Load the file "file" into memory.  It may be either a shared object
634c33fe779SJohn Polstra  * or an executable.
635c33fe779SJohn Polstra  *
636c33fe779SJohn Polstra  * The "addr" reference parameter is in/out.  On entry, it specifies
637c33fe779SJohn Polstra  * the address where a shared object should be loaded.  If the file is
638c33fe779SJohn Polstra  * an executable, this value is ignored.  On exit, "addr" specifies
639c33fe779SJohn Polstra  * where the file was actually loaded.
640c33fe779SJohn Polstra  *
641c33fe779SJohn Polstra  * The "entry" reference parameter is out only.  On exit, it specifies
642c33fe779SJohn Polstra  * the entry point for the loaded file.
643c33fe779SJohn Polstra  */
644e1743d02SSøren Schmidt static int
6453ebc1248SPeter Wemm __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
6463ebc1248SPeter Wemm 	u_long *entry, size_t pagesize)
647e1743d02SSøren Schmidt {
648911c2be0SMark Peek 	struct {
649911c2be0SMark Peek 		struct nameidata nd;
650911c2be0SMark Peek 		struct vattr attr;
651911c2be0SMark Peek 		struct image_params image_params;
652911c2be0SMark Peek 	} *tempdata;
653d254af07SMatthew Dillon 	const Elf_Ehdr *hdr = NULL;
654d254af07SMatthew Dillon 	const Elf_Phdr *phdr = NULL;
655911c2be0SMark Peek 	struct nameidata *nd;
656911c2be0SMark Peek 	struct vattr *attr;
657911c2be0SMark Peek 	struct image_params *imgp;
65852c24af7SPeter Wemm 	vm_prot_t prot;
659c33fe779SJohn Polstra 	u_long rbase;
660c33fe779SJohn Polstra 	u_long base_addr = 0;
6615050aa86SKonstantin Belousov 	int error, i, numsegs;
662e1743d02SSøren Schmidt 
66312bc222eSJonathan Anderson #ifdef CAPABILITY_MODE
66412bc222eSJonathan Anderson 	/*
66512bc222eSJonathan Anderson 	 * XXXJA: This check can go away once we are sufficiently confident
66612bc222eSJonathan Anderson 	 * that the checks in namei() are correct.
66712bc222eSJonathan Anderson 	 */
66812bc222eSJonathan Anderson 	if (IN_CAPABILITY_MODE(curthread))
66912bc222eSJonathan Anderson 		return (ECAPMODE);
67012bc222eSJonathan Anderson #endif
67112bc222eSJonathan Anderson 
672a163d034SWarner Losh 	tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK);
673911c2be0SMark Peek 	nd = &tempdata->nd;
674911c2be0SMark Peek 	attr = &tempdata->attr;
675911c2be0SMark Peek 	imgp = &tempdata->image_params;
676911c2be0SMark Peek 
677c8a79999SPeter Wemm 	/*
678c8a79999SPeter Wemm 	 * Initialize part of the common data
679c8a79999SPeter Wemm 	 */
680c8a79999SPeter Wemm 	imgp->proc = p;
681911c2be0SMark Peek 	imgp->attr = attr;
682c8a79999SPeter Wemm 	imgp->firstpage = NULL;
68359c8bc40SAlan Cox 	imgp->image_header = NULL;
6840b2ed1aeSJeff Roberson 	imgp->object = NULL;
6856d7bdc8dSRobert Watson 	imgp->execlabel = NULL;
686c8a79999SPeter Wemm 
6875050aa86SKonstantin Belousov 	NDINIT(nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, file, curthread);
688911c2be0SMark Peek 	if ((error = namei(nd)) != 0) {
689911c2be0SMark Peek 		nd->ni_vp = NULL;
690e1743d02SSøren Schmidt 		goto fail;
691e1743d02SSøren Schmidt 	}
692911c2be0SMark Peek 	NDFREE(nd, NDF_ONLY_PNBUF);
693911c2be0SMark Peek 	imgp->vp = nd->ni_vp;
694c8a79999SPeter Wemm 
695e1743d02SSøren Schmidt 	/*
696e1743d02SSøren Schmidt 	 * Check permissions, modes, uid, etc on the file, and "open" it.
697e1743d02SSøren Schmidt 	 */
698c8a79999SPeter Wemm 	error = exec_check_permissions(imgp);
699373d1a3fSAlan Cox 	if (error)
700c8a79999SPeter Wemm 		goto fail;
701e1743d02SSøren Schmidt 
702c8a79999SPeter Wemm 	error = exec_map_first_page(imgp);
703373d1a3fSAlan Cox 	if (error)
704373d1a3fSAlan Cox 		goto fail;
705373d1a3fSAlan Cox 
70625ead034SBrian Feldman 	/*
70725ead034SBrian Feldman 	 * Also make certain that the interpreter stays the same, so set
708e6e370a7SJeff Roberson 	 * its VV_TEXT flag, too.
70925ead034SBrian Feldman 	 */
710877d24acSKonstantin Belousov 	VOP_SET_TEXT(nd->ni_vp);
711e6e370a7SJeff Roberson 
7128516dd18SPoul-Henning Kamp 	imgp->object = nd->ni_vp->v_object;
713e1743d02SSøren Schmidt 
714d254af07SMatthew Dillon 	hdr = (const Elf_Ehdr *)imgp->image_header;
7153ebc1248SPeter Wemm 	if ((error = __elfN(check_header)(hdr)) != 0)
716e1743d02SSøren Schmidt 		goto fail;
717c33fe779SJohn Polstra 	if (hdr->e_type == ET_DYN)
718c33fe779SJohn Polstra 		rbase = *addr;
719c33fe779SJohn Polstra 	else if (hdr->e_type == ET_EXEC)
720c33fe779SJohn Polstra 		rbase = 0;
721c33fe779SJohn Polstra 	else {
722c33fe779SJohn Polstra 		error = ENOEXEC;
723c33fe779SJohn Polstra 		goto fail;
724c33fe779SJohn Polstra 	}
725e1743d02SSøren Schmidt 
726c8a79999SPeter Wemm 	/* Only support headers that fit within first page for now      */
72752c24af7SPeter Wemm 	if ((hdr->e_phoff > PAGE_SIZE) ||
728d19d5bf4STijl Coosemans 	    (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) {
729c8a79999SPeter Wemm 		error = ENOEXEC;
730e1743d02SSøren Schmidt 		goto fail;
731c8a79999SPeter Wemm 	}
732c8a79999SPeter Wemm 
733d254af07SMatthew Dillon 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
73493d1c728SKonstantin Belousov 	if (!aligned(phdr, Elf_Addr)) {
73593d1c728SKonstantin Belousov 		error = ENOEXEC;
73693d1c728SKonstantin Belousov 		goto fail;
73793d1c728SKonstantin Belousov 	}
738e1743d02SSøren Schmidt 
739c33fe779SJohn Polstra 	for (i = 0, numsegs = 0; i < hdr->e_phnum; i++) {
7405b33842aSKonstantin Belousov 		if (phdr[i].p_type == PT_LOAD && phdr[i].p_memsz != 0) {
7415b33842aSKonstantin Belousov 			/* Loadable segment */
742ed167eaaSKonstantin Belousov 			prot = __elfN(trans_prot)(phdr[i].p_flags);
743292177e6SAlan Cox 			error = __elfN(load_section)(imgp, phdr[i].p_offset,
74481f223caSJake Burkholder 			    (caddr_t)(uintptr_t)phdr[i].p_vaddr + rbase,
745292177e6SAlan Cox 			    phdr[i].p_memsz, phdr[i].p_filesz, prot, pagesize);
746292177e6SAlan Cox 			if (error != 0)
747e1743d02SSøren Schmidt 				goto fail;
748e1743d02SSøren Schmidt 			/*
749c33fe779SJohn Polstra 			 * Establish the base address if this is the
750c33fe779SJohn Polstra 			 * first segment.
751e1743d02SSøren Schmidt 			 */
752c33fe779SJohn Polstra 			if (numsegs == 0)
753ca0387efSJake Burkholder   				base_addr = trunc_page(phdr[i].p_vaddr +
754ca0387efSJake Burkholder 				    rbase);
755c33fe779SJohn Polstra 			numsegs++;
756e1743d02SSøren Schmidt 		}
757e1743d02SSøren Schmidt 	}
758c33fe779SJohn Polstra 	*addr = base_addr;
759c33fe779SJohn Polstra 	*entry = (unsigned long)hdr->e_entry + rbase;
760e1743d02SSøren Schmidt 
761e1743d02SSøren Schmidt fail:
762c8a79999SPeter Wemm 	if (imgp->firstpage)
763c8a79999SPeter Wemm 		exec_unmap_first_page(imgp);
7640b2ed1aeSJeff Roberson 
765911c2be0SMark Peek 	if (nd->ni_vp)
766373d1a3fSAlan Cox 		vput(nd->ni_vp);
767911c2be0SMark Peek 
768911c2be0SMark Peek 	free(tempdata, M_TEMP);
769e1743d02SSøren Schmidt 
770a7cddfedSJake Burkholder 	return (error);
771e1743d02SSøren Schmidt }
772e1743d02SSøren Schmidt 
773303b270bSEivind Eklund static int
7743ebc1248SPeter Wemm __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
775e1743d02SSøren Schmidt {
7766c775eb6SKonstantin Belousov 	struct thread *td;
7776c775eb6SKonstantin Belousov 	const Elf_Ehdr *hdr;
77832c01de2SDmitry Chagin 	const Elf_Phdr *phdr;
779e5e6093bSAlan Cox 	Elf_Auxargs *elf_auxargs;
7805856e12eSJohn Dyson 	struct vmspace *vmspace;
7816c775eb6SKonstantin Belousov 	const char *err_str, *newinterp;
7826c775eb6SKonstantin Belousov 	char *interp, *interp_buf, *path;
783d1dbc694SJohn Polstra 	Elf_Brandinfo *brand_info;
7845fe3ed62SJake Burkholder 	struct sysentvec *sv;
7856c775eb6SKonstantin Belousov 	vm_prot_t prot;
7866c775eb6SKonstantin Belousov 	u_long text_size, data_size, total_size, text_addr, data_addr;
7876c775eb6SKonstantin Belousov 	u_long seg_size, seg_addr, addr, baddr, et_dyn_addr, entry, proghdr;
7886c775eb6SKonstantin Belousov 	int32_t osrel;
7896c775eb6SKonstantin Belousov 	int error, i, n, interp_name_len, have_interp;
7906c775eb6SKonstantin Belousov 
7916c775eb6SKonstantin Belousov 	hdr = (const Elf_Ehdr *)imgp->image_header;
792e1743d02SSøren Schmidt 
793e1743d02SSøren Schmidt 	/*
794e1743d02SSøren Schmidt 	 * Do we have a valid ELF header ?
795900b28f9SMaxim Sobolev 	 *
796900b28f9SMaxim Sobolev 	 * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later
797900b28f9SMaxim Sobolev 	 * if particular brand doesn't support it.
798e1743d02SSøren Schmidt 	 */
799900b28f9SMaxim Sobolev 	if (__elfN(check_header)(hdr) != 0 ||
800900b28f9SMaxim Sobolev 	    (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN))
801a7cddfedSJake Burkholder 		return (-1);
802e1743d02SSøren Schmidt 
803e1743d02SSøren Schmidt 	/*
804e1743d02SSøren Schmidt 	 * From here on down, we return an errno, not -1, as we've
805e1743d02SSøren Schmidt 	 * detected an ELF file.
806e1743d02SSøren Schmidt 	 */
807e1743d02SSøren Schmidt 
808e1743d02SSøren Schmidt 	if ((hdr->e_phoff > PAGE_SIZE) ||
809d19d5bf4STijl Coosemans 	    (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) {
810c8a79999SPeter Wemm 		/* Only support headers in first page for now */
8116b16d664SEd Maste 		uprintf("Program headers not in the first page\n");
812a7cddfedSJake Burkholder 		return (ENOEXEC);
813e1743d02SSøren Schmidt 	}
81452c24af7SPeter Wemm 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
8156b16d664SEd Maste 	if (!aligned(phdr, Elf_Addr)) {
8166b16d664SEd Maste 		uprintf("Unaligned program headers\n");
81793d1c728SKonstantin Belousov 		return (ENOEXEC);
8186b16d664SEd Maste 	}
8196c775eb6SKonstantin Belousov 
8206c775eb6SKonstantin Belousov 	n = error = 0;
8217564c4adSKonstantin Belousov 	baddr = 0;
8226c775eb6SKonstantin Belousov 	osrel = 0;
8236c775eb6SKonstantin Belousov 	text_size = data_size = total_size = text_addr = data_addr = 0;
8246c775eb6SKonstantin Belousov 	entry = proghdr = 0;
8256c775eb6SKonstantin Belousov 	interp_name_len = 0;
8266c775eb6SKonstantin Belousov 	err_str = newinterp = NULL;
8276c775eb6SKonstantin Belousov 	interp = interp_buf = NULL;
8286c775eb6SKonstantin Belousov 	td = curthread;
8296c775eb6SKonstantin Belousov 
8305fe3ed62SJake Burkholder 	for (i = 0; i < hdr->e_phnum; i++) {
831291c06a1SKonstantin Belousov 		switch (phdr[i].p_type) {
832291c06a1SKonstantin Belousov 		case PT_LOAD:
8337564c4adSKonstantin Belousov 			if (n == 0)
8347564c4adSKonstantin Belousov 				baddr = phdr[i].p_vaddr;
8357564c4adSKonstantin Belousov 			n++;
836291c06a1SKonstantin Belousov 			break;
837291c06a1SKonstantin Belousov 		case PT_INTERP:
838e5e6093bSAlan Cox 			/* Path to interpreter */
8396c775eb6SKonstantin Belousov 			if (phdr[i].p_filesz > MAXPATHLEN) {
8406b16d664SEd Maste 				uprintf("Invalid PT_INTERP\n");
8416c775eb6SKonstantin Belousov 				error = ENOEXEC;
8426c775eb6SKonstantin Belousov 				goto ret;
8436b16d664SEd Maste 			}
844d3ee0a15SJonathan T. Looney 			if (interp != NULL) {
845d3ee0a15SJonathan T. Looney 				uprintf("Multiple PT_INTERP headers\n");
846d3ee0a15SJonathan T. Looney 				error = ENOEXEC;
847d3ee0a15SJonathan T. Looney 				goto ret;
848d3ee0a15SJonathan T. Looney 			}
849d1ae5c83SKonstantin Belousov 			interp_name_len = phdr[i].p_filesz;
8506c775eb6SKonstantin Belousov 			if (phdr[i].p_offset > PAGE_SIZE ||
8516c775eb6SKonstantin Belousov 			    interp_name_len > PAGE_SIZE - phdr[i].p_offset) {
8526c775eb6SKonstantin Belousov 				VOP_UNLOCK(imgp->vp, 0);
8536c775eb6SKonstantin Belousov 				interp_buf = malloc(interp_name_len + 1, M_TEMP,
8546c775eb6SKonstantin Belousov 				    M_WAITOK);
8556c775eb6SKonstantin Belousov 				vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
8566c775eb6SKonstantin Belousov 				error = vn_rdwr(UIO_READ, imgp->vp, interp_buf,
8576c775eb6SKonstantin Belousov 				    interp_name_len, phdr[i].p_offset,
8586c775eb6SKonstantin Belousov 				    UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred,
8596c775eb6SKonstantin Belousov 				    NOCRED, NULL, td);
8606c775eb6SKonstantin Belousov 				if (error != 0) {
8616c775eb6SKonstantin Belousov 					uprintf("i/o error PT_INTERP\n");
8626c775eb6SKonstantin Belousov 					goto ret;
8636c775eb6SKonstantin Belousov 				}
8646c775eb6SKonstantin Belousov 				interp_buf[interp_name_len] = '\0';
8656c775eb6SKonstantin Belousov 				interp = interp_buf;
8666c775eb6SKonstantin Belousov 			} else {
8676c775eb6SKonstantin Belousov 				interp = __DECONST(char *, imgp->image_header) +
8686c775eb6SKonstantin Belousov 				    phdr[i].p_offset;
8696c775eb6SKonstantin Belousov 			}
870291c06a1SKonstantin Belousov 			break;
871291c06a1SKonstantin Belousov 		case PT_GNU_STACK:
872291c06a1SKonstantin Belousov 			if (__elfN(nxstack))
873291c06a1SKonstantin Belousov 				imgp->stack_prot =
874291c06a1SKonstantin Belousov 				    __elfN(trans_prot)(phdr[i].p_flags);
875316b3843SKonstantin Belousov 			imgp->stack_sz = phdr[i].p_memsz;
876291c06a1SKonstantin Belousov 			break;
8773ebc1248SPeter Wemm 		}
8783ebc1248SPeter Wemm 	}
8793ebc1248SPeter Wemm 
880d1ae5c83SKonstantin Belousov 	brand_info = __elfN(get_brandinfo)(imgp, interp, interp_name_len,
881d1ae5c83SKonstantin Belousov 	    &osrel);
8825fe3ed62SJake Burkholder 	if (brand_info == NULL) {
8835fe3ed62SJake Burkholder 		uprintf("ELF binary type \"%u\" not known.\n",
8845fe3ed62SJake Burkholder 		    hdr->e_ident[EI_OSABI]);
8856c775eb6SKonstantin Belousov 		error = ENOEXEC;
8866c775eb6SKonstantin Belousov 		goto ret;
8873ebc1248SPeter Wemm 	}
88877ebe276SEd Maste 	et_dyn_addr = 0;
889ab02d85fSKonstantin Belousov 	if (hdr->e_type == ET_DYN) {
8906b16d664SEd Maste 		if ((brand_info->flags & BI_CAN_EXEC_DYN) == 0) {
8916b16d664SEd Maste 			uprintf("Cannot execute shared object\n");
8926c775eb6SKonstantin Belousov 			error = ENOEXEC;
8936c775eb6SKonstantin Belousov 			goto ret;
8946b16d664SEd Maste 		}
8957564c4adSKonstantin Belousov 		/*
8967564c4adSKonstantin Belousov 		 * Honour the base load address from the dso if it is
8977564c4adSKonstantin Belousov 		 * non-zero for some reason.
8987564c4adSKonstantin Belousov 		 */
8997564c4adSKonstantin Belousov 		if (baddr == 0)
900ab02d85fSKonstantin Belousov 			et_dyn_addr = ET_DYN_LOAD_ADDR;
90177ebe276SEd Maste 	}
9025fe3ed62SJake Burkholder 	sv = brand_info->sysvec;
9039b68618dSPeter Wemm 	if (interp != NULL && brand_info->interp_newpath != NULL)
9044113f8d7SPeter Wemm 		newinterp = brand_info->interp_newpath;
9053ebc1248SPeter Wemm 
90660bb3943SAlan Cox 	/*
90760bb3943SAlan Cox 	 * Avoid a possible deadlock if the current address space is destroyed
90860bb3943SAlan Cox 	 * and that address space maps the locked vnode.  In the common case,
90960bb3943SAlan Cox 	 * the locked vnode's v_usecount is decremented but remains greater
91060bb3943SAlan Cox 	 * than zero.  Consequently, the vnode lock is not needed by vrele().
91160bb3943SAlan Cox 	 * However, in cases where the vnode lock is external, such as nullfs,
91260bb3943SAlan Cox 	 * v_usecount may become zero.
9131dfab802SAlan Cox 	 *
9141dfab802SAlan Cox 	 * The VV_TEXT flag prevents modifications to the executable while
9151dfab802SAlan Cox 	 * the vnode is unlocked.
91660bb3943SAlan Cox 	 */
91722db15c0SAttilio Rao 	VOP_UNLOCK(imgp->vp, 0);
91860bb3943SAlan Cox 
91989b57fcfSKonstantin Belousov 	error = exec_new_vmspace(imgp, sv);
92019059a13SJohn Baldwin 	imgp->proc->p_sysent = sv;
921e1743d02SSøren Schmidt 
922cb05b60aSAttilio Rao 	vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
9236c775eb6SKonstantin Belousov 	if (error != 0)
9246c775eb6SKonstantin Belousov 		goto ret;
92560bb3943SAlan Cox 
926e1743d02SSøren Schmidt 	for (i = 0; i < hdr->e_phnum; i++) {
927e1743d02SSøren Schmidt 		switch (phdr[i].p_type) {
928e1743d02SSøren Schmidt 		case PT_LOAD:	/* Loadable segment */
9295b33842aSKonstantin Belousov 			if (phdr[i].p_memsz == 0)
9305b33842aSKonstantin Belousov 				break;
931ed167eaaSKonstantin Belousov 			prot = __elfN(trans_prot)(phdr[i].p_flags);
932292177e6SAlan Cox 			error = __elfN(load_section)(imgp, phdr[i].p_offset,
933ab02d85fSKonstantin Belousov 			    (caddr_t)(uintptr_t)phdr[i].p_vaddr + et_dyn_addr,
93481f223caSJake Burkholder 			    phdr[i].p_memsz, phdr[i].p_filesz, prot,
935292177e6SAlan Cox 			    sv->sv_pagesize);
936292177e6SAlan Cox 			if (error != 0)
9376c775eb6SKonstantin Belousov 				goto ret;
938e1743d02SSøren Schmidt 
939cfaf7e60SDoug Rabson 			/*
940cfaf7e60SDoug Rabson 			 * If this segment contains the program headers,
941cfaf7e60SDoug Rabson 			 * remember their virtual address for the AT_PHDR
942cfaf7e60SDoug Rabson 			 * aux entry. Static binaries don't usually include
943cfaf7e60SDoug Rabson 			 * a PT_PHDR entry.
944cfaf7e60SDoug Rabson 			 */
945cfaf7e60SDoug Rabson 			if (phdr[i].p_offset == 0 &&
946cfaf7e60SDoug Rabson 			    hdr->e_phoff + hdr->e_phnum * hdr->e_phentsize
947cfaf7e60SDoug Rabson 				<= phdr[i].p_filesz)
948ab02d85fSKonstantin Belousov 				proghdr = phdr[i].p_vaddr + hdr->e_phoff +
949ab02d85fSKonstantin Belousov 				    et_dyn_addr;
950cfaf7e60SDoug Rabson 
951ab02d85fSKonstantin Belousov 			seg_addr = trunc_page(phdr[i].p_vaddr + et_dyn_addr);
952cac45152SMatthew Dillon 			seg_size = round_page(phdr[i].p_memsz +
953ab02d85fSKonstantin Belousov 			    phdr[i].p_vaddr + et_dyn_addr - seg_addr);
954cac45152SMatthew Dillon 
955e1743d02SSøren Schmidt 			/*
956920acedbSNathan Whitehorn 			 * Make the largest executable segment the official
957920acedbSNathan Whitehorn 			 * text segment and all others data.
95821c2d047SMatthew Dillon 			 *
95921c2d047SMatthew Dillon 			 * Note that obreak() assumes that data_addr +
96021c2d047SMatthew Dillon 			 * data_size == end of data load area, and the ELF
96121c2d047SMatthew Dillon 			 * file format expects segments to be sorted by
96221c2d047SMatthew Dillon 			 * address.  If multiple data segments exist, the
96321c2d047SMatthew Dillon 			 * last one will be used.
964e1743d02SSøren Schmidt 			 */
965920acedbSNathan Whitehorn 
966920acedbSNathan Whitehorn 			if (phdr[i].p_flags & PF_X && text_size < seg_size) {
9679782ecbaSPeter Wemm 				text_size = seg_size;
9689782ecbaSPeter Wemm 				text_addr = seg_addr;
9699782ecbaSPeter Wemm 			} else {
97021c2d047SMatthew Dillon 				data_size = seg_size;
971cac45152SMatthew Dillon 				data_addr = seg_addr;
972cac45152SMatthew Dillon 			}
97321c2d047SMatthew Dillon 			total_size += seg_size;
97496725dd0SAlexander Kabaev 			break;
97596725dd0SAlexander Kabaev 		case PT_PHDR: 	/* Program header table info */
976ab02d85fSKonstantin Belousov 			proghdr = phdr[i].p_vaddr + et_dyn_addr;
97796725dd0SAlexander Kabaev 			break;
97896725dd0SAlexander Kabaev 		default:
97996725dd0SAlexander Kabaev 			break;
98096725dd0SAlexander Kabaev 		}
98196725dd0SAlexander Kabaev 	}
98296725dd0SAlexander Kabaev 
98396725dd0SAlexander Kabaev 	if (data_addr == 0 && data_size == 0) {
98496725dd0SAlexander Kabaev 		data_addr = text_addr;
98596725dd0SAlexander Kabaev 		data_size = text_size;
98696725dd0SAlexander Kabaev 	}
987cac45152SMatthew Dillon 
988920acedbSNathan Whitehorn 	entry = (u_long)hdr->e_entry + et_dyn_addr;
989920acedbSNathan Whitehorn 
990cac45152SMatthew Dillon 	/*
991cac45152SMatthew Dillon 	 * Check limits.  It should be safe to check the
99296725dd0SAlexander Kabaev 	 * limits after loading the segments since we do
99396725dd0SAlexander Kabaev 	 * not actually fault in all the segments pages.
994cac45152SMatthew Dillon 	 */
99591d5354aSJohn Baldwin 	PROC_LOCK(imgp->proc);
996f6f6d240SMateusz Guzik 	if (data_size > lim_cur_proc(imgp->proc, RLIMIT_DATA))
9976b16d664SEd Maste 		err_str = "Data segment size exceeds process limit";
9986b16d664SEd Maste 	else if (text_size > maxtsiz)
9996b16d664SEd Maste 		err_str = "Text segment size exceeds system limit";
1000f6f6d240SMateusz Guzik 	else if (total_size > lim_cur_proc(imgp->proc, RLIMIT_VMEM))
10016b16d664SEd Maste 		err_str = "Total segment size exceeds process limit";
10026b16d664SEd Maste 	else if (racct_set(imgp->proc, RACCT_DATA, data_size) != 0)
10036b16d664SEd Maste 		err_str = "Data segment size exceeds resource limit";
10046b16d664SEd Maste 	else if (racct_set(imgp->proc, RACCT_VMEM, total_size) != 0)
10056b16d664SEd Maste 		err_str = "Total segment size exceeds resource limit";
10066b16d664SEd Maste 	if (err_str != NULL) {
100791d5354aSJohn Baldwin 		PROC_UNLOCK(imgp->proc);
10086b16d664SEd Maste 		uprintf("%s\n", err_str);
10096c775eb6SKonstantin Belousov 		error = ENOMEM;
10106c775eb6SKonstantin Belousov 		goto ret;
1011cac45152SMatthew Dillon 	}
1012e1743d02SSøren Schmidt 
1013292177e6SAlan Cox 	vmspace = imgp->proc->p_vmspace;
1014e1743d02SSøren Schmidt 	vmspace->vm_tsize = text_size >> PAGE_SHIFT;
10157cd99438SBruce Evans 	vmspace->vm_taddr = (caddr_t)(uintptr_t)text_addr;
1016e1743d02SSøren Schmidt 	vmspace->vm_dsize = data_size >> PAGE_SHIFT;
10177cd99438SBruce Evans 	vmspace->vm_daddr = (caddr_t)(uintptr_t)data_addr;
1018e1743d02SSøren Schmidt 
1019c460ac3aSPeter Wemm 	/*
1020c460ac3aSPeter Wemm 	 * We load the dynamic linker where a userland call
1021c460ac3aSPeter Wemm 	 * to mmap(0, ...) would put it.  The rationale behind this
1022c460ac3aSPeter Wemm 	 * calculation is that it leaves room for the heap to grow to
1023c460ac3aSPeter Wemm 	 * its maximum allowed size.
1024c460ac3aSPeter Wemm 	 */
10256c775eb6SKonstantin Belousov 	addr = round_page((vm_offset_t)vmspace->vm_daddr + lim_max(td,
1026292177e6SAlan Cox 	    RLIMIT_DATA));
102791d5354aSJohn Baldwin 	PROC_UNLOCK(imgp->proc);
1028e1743d02SSøren Schmidt 
1029ea5a2b2eSSøren Schmidt 	imgp->entry_addr = entry;
1030ea5a2b2eSSøren Schmidt 
103160bb3943SAlan Cox 	if (interp != NULL) {
10326c775eb6SKonstantin Belousov 		have_interp = FALSE;
103322db15c0SAttilio Rao 		VOP_UNLOCK(imgp->vp, 0);
103460bb3943SAlan Cox 		if (brand_info->emul_path != NULL &&
10359b68618dSPeter Wemm 		    brand_info->emul_path[0] != '\0') {
1036a163d034SWarner Losh 			path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
103760bb3943SAlan Cox 			snprintf(path, MAXPATHLEN, "%s%s",
103860bb3943SAlan Cox 			    brand_info->emul_path, interp);
10399b68618dSPeter Wemm 			error = __elfN(load_file)(imgp->proc, path, &addr,
10409b68618dSPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
1041911c2be0SMark Peek 			free(path, M_TEMP);
10429b68618dSPeter Wemm 			if (error == 0)
10434113f8d7SPeter Wemm 				have_interp = TRUE;
10449b68618dSPeter Wemm 		}
104518995077SKonstantin Belousov 		if (!have_interp && newinterp != NULL &&
104618995077SKonstantin Belousov 		    (brand_info->interp_path == NULL ||
104718995077SKonstantin Belousov 		    strcmp(interp, brand_info->interp_path) == 0)) {
10484113f8d7SPeter Wemm 			error = __elfN(load_file)(imgp->proc, newinterp, &addr,
10494113f8d7SPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
1050387ad998SKonstantin Belousov 			if (error == 0)
10514113f8d7SPeter Wemm 				have_interp = TRUE;
10524113f8d7SPeter Wemm 		}
10534113f8d7SPeter Wemm 		if (!have_interp) {
10549b68618dSPeter Wemm 			error = __elfN(load_file)(imgp->proc, interp, &addr,
10559b68618dSPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
105660bb3943SAlan Cox 		}
1057cb05b60aSAttilio Rao 		vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
10589b68618dSPeter Wemm 		if (error != 0) {
1059d943fa35SKonstantin Belousov 			uprintf("ELF interpreter %s not found, error %d\n",
1060d943fa35SKonstantin Belousov 			    interp, error);
10616c775eb6SKonstantin Belousov 			goto ret;
1062e1743d02SSøren Schmidt 		}
106395c807cfSRobert Watson 	} else
10647564c4adSKonstantin Belousov 		addr = et_dyn_addr;
1065ea5a2b2eSSøren Schmidt 
1066e1743d02SSøren Schmidt 	/*
1067e1743d02SSøren Schmidt 	 * Construct auxargs table (used by the fixup routine)
1068e1743d02SSøren Schmidt 	 */
1069a163d034SWarner Losh 	elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, M_WAITOK);
1070e1743d02SSøren Schmidt 	elf_auxargs->execfd = -1;
1071e1743d02SSøren Schmidt 	elf_auxargs->phdr = proghdr;
1072e1743d02SSøren Schmidt 	elf_auxargs->phent = hdr->e_phentsize;
1073e1743d02SSøren Schmidt 	elf_auxargs->phnum = hdr->e_phnum;
1074e1743d02SSøren Schmidt 	elf_auxargs->pagesz = PAGE_SIZE;
1075e1743d02SSøren Schmidt 	elf_auxargs->base = addr;
1076e1743d02SSøren Schmidt 	elf_auxargs->flags = 0;
1077e1743d02SSøren Schmidt 	elf_auxargs->entry = entry;
1078d36eec69SWarner Losh 	elf_auxargs->hdr_eflags = hdr->e_flags;
1079e1743d02SSøren Schmidt 
1080e1743d02SSøren Schmidt 	imgp->auxargs = elf_auxargs;
1081e1743d02SSøren Schmidt 	imgp->interpreted = 0;
1082a0ea661fSNathan Whitehorn 	imgp->reloc_base = addr;
108332c01de2SDmitry Chagin 	imgp->proc->p_osrel = osrel;
1084885f13dcSJohn Baldwin 	imgp->proc->p_elf_machine = hdr->e_machine;
1085885f13dcSJohn Baldwin 	imgp->proc->p_elf_flags = hdr->e_flags;
1086f231de47SKonstantin Belousov 
10876c775eb6SKonstantin Belousov ret:
10886c775eb6SKonstantin Belousov 	free(interp_buf, M_TEMP);
1089a7cddfedSJake Burkholder 	return (error);
1090e1743d02SSøren Schmidt }
1091e1743d02SSøren Schmidt 
1092a360a43dSJake Burkholder #define	suword __CONCAT(suword, __ELF_WORD_SIZE)
10933ebc1248SPeter Wemm 
10943ebc1248SPeter Wemm int
10953ebc1248SPeter Wemm __elfN(freebsd_fixup)(register_t **stack_base, struct image_params *imgp)
1096e1743d02SSøren Schmidt {
1097ecbb00a2SDoug Rabson 	Elf_Auxargs *args = (Elf_Auxargs *)imgp->auxargs;
1098a360a43dSJake Burkholder 	Elf_Addr *base;
1099a360a43dSJake Burkholder 	Elf_Addr *pos;
1100e1743d02SSøren Schmidt 
1101a360a43dSJake Burkholder 	base = (Elf_Addr *)*stack_base;
1102610ecfe0SMaxim Sobolev 	pos = base + (imgp->args->argc + imgp->args->envc + 2);
1103e1743d02SSøren Schmidt 
110435c2a5a8SWarner Losh 	if (args->execfd != -1)
1105e1743d02SSøren Schmidt 		AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
1106e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
1107e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
1108e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
1109e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
1110e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
1111e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
1112e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_BASE, args->base);
1113d36eec69SWarner Losh 	AUXARGS_ENTRY(pos, AT_EHDRFLAGS, args->hdr_eflags);
11143ff06357SKonstantin Belousov 	if (imgp->execpathp != 0)
11153ff06357SKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_EXECPATH, imgp->execpathp);
1116b96bd95bSIan Lepore 	AUXARGS_ENTRY(pos, AT_OSRELDATE,
1117b96bd95bSIan Lepore 	    imgp->proc->p_ucred->cr_prison->pr_osreldate);
1118ee235befSKonstantin Belousov 	if (imgp->canary != 0) {
1119ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_CANARY, imgp->canary);
1120ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_CANARYLEN, imgp->canarylen);
1121ee235befSKonstantin Belousov 	}
1122ee235befSKonstantin Belousov 	AUXARGS_ENTRY(pos, AT_NCPUS, mp_ncpus);
1123ee235befSKonstantin Belousov 	if (imgp->pagesizes != 0) {
1124ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_PAGESIZES, imgp->pagesizes);
1125ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_PAGESIZESLEN, imgp->pagesizeslen);
1126ee235befSKonstantin Belousov 	}
1127aea81038SKonstantin Belousov 	if (imgp->sysent->sv_timekeep_base != 0) {
1128aea81038SKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_TIMEKEEP,
1129aea81038SKonstantin Belousov 		    imgp->sysent->sv_timekeep_base);
1130aea81038SKonstantin Belousov 	}
113126d8f3e1SKonstantin Belousov 	AUXARGS_ENTRY(pos, AT_STACKPROT, imgp->sysent->sv_shared_page_obj
113226d8f3e1SKonstantin Belousov 	    != NULL && imgp->stack_prot != 0 ? imgp->stack_prot :
113326d8f3e1SKonstantin Belousov 	    imgp->sysent->sv_stackprot);
1134*c2f37b92SJohn Baldwin 	if (imgp->sysent->sv_hwcap != NULL)
1135*c2f37b92SJohn Baldwin 		AUXARGS_ENTRY(pos, AT_HWCAP, *imgp->sysent->sv_hwcap);
1136e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_NULL, 0);
1137e1743d02SSøren Schmidt 
1138e1743d02SSøren Schmidt 	free(imgp->auxargs, M_TEMP);
1139e1743d02SSøren Schmidt 	imgp->auxargs = NULL;
1140e1743d02SSøren Schmidt 
11413ebc1248SPeter Wemm 	base--;
1142610ecfe0SMaxim Sobolev 	suword(base, (long)imgp->args->argc);
11433ebc1248SPeter Wemm 	*stack_base = (register_t *)base;
1144a7cddfedSJake Burkholder 	return (0);
1145e1743d02SSøren Schmidt }
1146e1743d02SSøren Schmidt 
1147e1743d02SSøren Schmidt /*
11488c64af4fSJohn Polstra  * Code for generating ELF core dumps.
11498c64af4fSJohn Polstra  */
11508c64af4fSJohn Polstra 
11514d77a549SAlfred Perlstein typedef void (*segment_callback)(vm_map_entry_t, void *);
11520ff27d31SJohn Polstra 
11530ff27d31SJohn Polstra /* Closure for cb_put_phdr(). */
11540ff27d31SJohn Polstra struct phdr_closure {
11550ff27d31SJohn Polstra 	Elf_Phdr *phdr;		/* Program header to fill in */
11560ff27d31SJohn Polstra 	Elf_Off offset;		/* Offset of segment in core file */
11570ff27d31SJohn Polstra };
11580ff27d31SJohn Polstra 
11590ff27d31SJohn Polstra /* Closure for cb_size_segment(). */
11600ff27d31SJohn Polstra struct sseg_closure {
11610ff27d31SJohn Polstra 	int count;		/* Count of writable segments. */
11620ff27d31SJohn Polstra 	size_t size;		/* Total size of all writable segments. */
11630ff27d31SJohn Polstra };
11640ff27d31SJohn Polstra 
1165bd390213SMikolaj Golub typedef void (*outfunc_t)(void *, struct sbuf *, size_t *);
1166bd390213SMikolaj Golub 
1167bd390213SMikolaj Golub struct note_info {
1168bd390213SMikolaj Golub 	int		type;		/* Note type. */
1169bd390213SMikolaj Golub 	outfunc_t 	outfunc; 	/* Output function. */
1170bd390213SMikolaj Golub 	void		*outarg;	/* Argument for the output function. */
1171bd390213SMikolaj Golub 	size_t		outsize;	/* Output size. */
1172bd390213SMikolaj Golub 	TAILQ_ENTRY(note_info) link;	/* Link to the next note info. */
1173bd390213SMikolaj Golub };
1174bd390213SMikolaj Golub 
1175bd390213SMikolaj Golub TAILQ_HEAD(note_info_list, note_info);
1176bd390213SMikolaj Golub 
1177aa14e9b7SMark Johnston /* Coredump output parameters. */
1178aa14e9b7SMark Johnston struct coredump_params {
1179aa14e9b7SMark Johnston 	off_t		offset;
1180aa14e9b7SMark Johnston 	struct ucred	*active_cred;
1181aa14e9b7SMark Johnston 	struct ucred	*file_cred;
1182aa14e9b7SMark Johnston 	struct thread	*td;
1183aa14e9b7SMark Johnston 	struct vnode	*vp;
1184aa14e9b7SMark Johnston 	struct gzio_stream *gzs;
1185aa14e9b7SMark Johnston };
1186aa14e9b7SMark Johnston 
11874d77a549SAlfred Perlstein static void cb_put_phdr(vm_map_entry_t, void *);
11884d77a549SAlfred Perlstein static void cb_size_segment(vm_map_entry_t, void *);
1189c468ff88SAndriy Gapon static int core_write(struct coredump_params *, const void *, size_t, off_t,
1190aa14e9b7SMark Johnston     enum uio_seg);
11911005d8afSConrad Meyer static void each_dumpable_segment(struct thread *, segment_callback, void *);
1192aa14e9b7SMark Johnston static int __elfN(corehdr)(struct coredump_params *, int, void *, size_t,
1193aa14e9b7SMark Johnston     struct note_info_list *, size_t);
1194bd390213SMikolaj Golub static void __elfN(prepare_notes)(struct thread *, struct note_info_list *,
1195bd390213SMikolaj Golub     size_t *);
1196bd390213SMikolaj Golub static void __elfN(puthdr)(struct thread *, void *, size_t, int, size_t);
1197bd390213SMikolaj Golub static void __elfN(putnote)(struct note_info *, struct sbuf *);
1198bd390213SMikolaj Golub static size_t register_note(struct note_info_list *, int, outfunc_t, void *);
1199bd390213SMikolaj Golub static int sbuf_drain_core_output(void *, const char *, int);
1200f1fca82eSMikolaj Golub static int sbuf_drain_count(void *arg, const char *data, int len);
1201bd390213SMikolaj Golub 
1202bd390213SMikolaj Golub static void __elfN(note_fpregset)(void *, struct sbuf *, size_t *);
1203bd390213SMikolaj Golub static void __elfN(note_prpsinfo)(void *, struct sbuf *, size_t *);
1204bd390213SMikolaj Golub static void __elfN(note_prstatus)(void *, struct sbuf *, size_t *);
1205bd390213SMikolaj Golub static void __elfN(note_threadmd)(void *, struct sbuf *, size_t *);
1206bd390213SMikolaj Golub static void __elfN(note_thrmisc)(void *, struct sbuf *, size_t *);
120786be94fcSTycho Nightingale static void __elfN(note_ptlwpinfo)(void *, struct sbuf *, size_t *);
1208f1fca82eSMikolaj Golub static void __elfN(note_procstat_auxv)(void *, struct sbuf *, size_t *);
1209f1fca82eSMikolaj Golub static void __elfN(note_procstat_proc)(void *, struct sbuf *, size_t *);
1210f1fca82eSMikolaj Golub static void __elfN(note_procstat_psstrings)(void *, struct sbuf *, size_t *);
1211f1fca82eSMikolaj Golub static void note_procstat_files(void *, struct sbuf *, size_t *);
1212f1fca82eSMikolaj Golub static void note_procstat_groups(void *, struct sbuf *, size_t *);
1213f1fca82eSMikolaj Golub static void note_procstat_osrel(void *, struct sbuf *, size_t *);
1214f1fca82eSMikolaj Golub static void note_procstat_rlimit(void *, struct sbuf *, size_t *);
1215f1fca82eSMikolaj Golub static void note_procstat_umask(void *, struct sbuf *, size_t *);
1216f1fca82eSMikolaj Golub static void note_procstat_vmmap(void *, struct sbuf *, size_t *);
12178c64af4fSJohn Polstra 
1218aa14e9b7SMark Johnston #ifdef GZIO
1219e7228204SAlfred Perlstein extern int compress_user_cores_gzlevel;
1220e7228204SAlfred Perlstein 
1221aa14e9b7SMark Johnston /*
1222aa14e9b7SMark Johnston  * Write out a core segment to the compression stream.
1223aa14e9b7SMark Johnston  */
1224e7228204SAlfred Perlstein static int
1225aa14e9b7SMark Johnston compress_chunk(struct coredump_params *p, char *base, char *buf, u_int len)
1226aa14e9b7SMark Johnston {
1227aa14e9b7SMark Johnston 	u_int chunk_len;
1228e7228204SAlfred Perlstein 	int error;
1229aa14e9b7SMark Johnston 
1230aa14e9b7SMark Johnston 	while (len > 0) {
1231aa14e9b7SMark Johnston 		chunk_len = MIN(len, CORE_BUF_SIZE);
1232c468ff88SAndriy Gapon 
1233c468ff88SAndriy Gapon 		/*
1234c468ff88SAndriy Gapon 		 * We can get EFAULT error here.
1235c468ff88SAndriy Gapon 		 * In that case zero out the current chunk of the segment.
1236c468ff88SAndriy Gapon 		 */
1237c468ff88SAndriy Gapon 		error = copyin(base, buf, chunk_len);
1238c468ff88SAndriy Gapon 		if (error != 0)
1239c468ff88SAndriy Gapon 			bzero(buf, chunk_len);
1240aa14e9b7SMark Johnston 		error = gzio_write(p->gzs, buf, chunk_len);
1241aa14e9b7SMark Johnston 		if (error != 0)
1242aa14e9b7SMark Johnston 			break;
1243aa14e9b7SMark Johnston 		base += chunk_len;
1244aa14e9b7SMark Johnston 		len -= chunk_len;
1245e7228204SAlfred Perlstein 	}
1246e7228204SAlfred Perlstein 	return (error);
1247e7228204SAlfred Perlstein }
1248e7228204SAlfred Perlstein 
1249aa14e9b7SMark Johnston static int
1250aa14e9b7SMark Johnston core_gz_write(void *base, size_t len, off_t offset, void *arg)
1251aa14e9b7SMark Johnston {
1252aa14e9b7SMark Johnston 
1253aa14e9b7SMark Johnston 	return (core_write((struct coredump_params *)arg, base, len, offset,
1254aa14e9b7SMark Johnston 	    UIO_SYSSPACE));
1255aa14e9b7SMark Johnston }
1256aa14e9b7SMark Johnston #endif /* GZIO */
1257aa14e9b7SMark Johnston 
1258aa14e9b7SMark Johnston static int
1259c468ff88SAndriy Gapon core_write(struct coredump_params *p, const void *base, size_t len,
1260c468ff88SAndriy Gapon     off_t offset, enum uio_seg seg)
1261aa14e9b7SMark Johnston {
1262aa14e9b7SMark Johnston 
1263c468ff88SAndriy Gapon 	return (vn_rdwr_inchunks(UIO_WRITE, p->vp, __DECONST(void *, base),
1264c468ff88SAndriy Gapon 	    len, offset, seg, IO_UNIT | IO_DIRECT | IO_RANGELOCKED,
1265aa14e9b7SMark Johnston 	    p->active_cred, p->file_cred, NULL, p->td));
1266aa14e9b7SMark Johnston }
1267aa14e9b7SMark Johnston 
1268aa14e9b7SMark Johnston static int
1269aa14e9b7SMark Johnston core_output(void *base, size_t len, off_t offset, struct coredump_params *p,
1270aa14e9b7SMark Johnston     void *tmpbuf)
1271aa14e9b7SMark Johnston {
1272c468ff88SAndriy Gapon 	int error;
1273aa14e9b7SMark Johnston 
1274aa14e9b7SMark Johnston #ifdef GZIO
1275aa14e9b7SMark Johnston 	if (p->gzs != NULL)
1276aa14e9b7SMark Johnston 		return (compress_chunk(p, base, tmpbuf, len));
1277bd390213SMikolaj Golub #endif
1278c468ff88SAndriy Gapon 	/*
1279c468ff88SAndriy Gapon 	 * EFAULT is a non-fatal error that we can get, for example,
1280c468ff88SAndriy Gapon 	 * if the segment is backed by a file but extends beyond its
1281c468ff88SAndriy Gapon 	 * end.
1282c468ff88SAndriy Gapon 	 */
1283c468ff88SAndriy Gapon 	error = core_write(p, base, len, offset, UIO_USERSPACE);
1284c468ff88SAndriy Gapon 	if (error == EFAULT) {
1285c468ff88SAndriy Gapon 		log(LOG_WARNING, "Failed to fully fault in a core file segment "
1286c468ff88SAndriy Gapon 		    "at VA %p with size 0x%zx to be written at offset 0x%jx "
1287c468ff88SAndriy Gapon 		    "for process %s\n", base, len, offset, curproc->p_comm);
1288c468ff88SAndriy Gapon 
1289c468ff88SAndriy Gapon 		/*
1290c468ff88SAndriy Gapon 		 * Write a "real" zero byte at the end of the target region
1291c468ff88SAndriy Gapon 		 * in the case this is the last segment.
1292c468ff88SAndriy Gapon 		 * The intermediate space will be implicitly zero-filled.
1293c468ff88SAndriy Gapon 		 */
1294c468ff88SAndriy Gapon 		error = core_write(p, zero_region, 1, offset + len - 1,
1295c468ff88SAndriy Gapon 		    UIO_SYSSPACE);
1296c468ff88SAndriy Gapon 	}
1297c468ff88SAndriy Gapon 	return (error);
1298aa14e9b7SMark Johnston }
1299bd390213SMikolaj Golub 
1300bd390213SMikolaj Golub /*
1301bd390213SMikolaj Golub  * Drain into a core file.
1302bd390213SMikolaj Golub  */
1303bd390213SMikolaj Golub static int
1304bd390213SMikolaj Golub sbuf_drain_core_output(void *arg, const char *data, int len)
1305bd390213SMikolaj Golub {
1306aa14e9b7SMark Johnston 	struct coredump_params *p;
1307f1fca82eSMikolaj Golub 	int error, locked;
1308bd390213SMikolaj Golub 
1309aa14e9b7SMark Johnston 	p = (struct coredump_params *)arg;
1310f1fca82eSMikolaj Golub 
1311f1fca82eSMikolaj Golub 	/*
1312f1fca82eSMikolaj Golub 	 * Some kern_proc out routines that print to this sbuf may
1313f1fca82eSMikolaj Golub 	 * call us with the process lock held. Draining with the
1314f1fca82eSMikolaj Golub 	 * non-sleepable lock held is unsafe. The lock is needed for
1315f1fca82eSMikolaj Golub 	 * those routines when dumping a live process. In our case we
1316f1fca82eSMikolaj Golub 	 * can safely release the lock before draining and acquire
1317f1fca82eSMikolaj Golub 	 * again after.
1318f1fca82eSMikolaj Golub 	 */
1319f1fca82eSMikolaj Golub 	locked = PROC_LOCKED(p->td->td_proc);
1320f1fca82eSMikolaj Golub 	if (locked)
1321f1fca82eSMikolaj Golub 		PROC_UNLOCK(p->td->td_proc);
1322aa14e9b7SMark Johnston #ifdef GZIO
1323aa14e9b7SMark Johnston 	if (p->gzs != NULL)
1324aa14e9b7SMark Johnston 		error = gzio_write(p->gzs, __DECONST(char *, data), len);
1325bd390213SMikolaj Golub 	else
1326bd390213SMikolaj Golub #endif
1327aa14e9b7SMark Johnston 		error = core_write(p, __DECONST(void *, data), len, p->offset,
1328aa14e9b7SMark Johnston 		    UIO_SYSSPACE);
1329f1fca82eSMikolaj Golub 	if (locked)
1330f1fca82eSMikolaj Golub 		PROC_LOCK(p->td->td_proc);
1331bd390213SMikolaj Golub 	if (error != 0)
1332bd390213SMikolaj Golub 		return (-error);
1333bd390213SMikolaj Golub 	p->offset += len;
1334bd390213SMikolaj Golub 	return (len);
1335bd390213SMikolaj Golub }
1336bd390213SMikolaj Golub 
1337f1fca82eSMikolaj Golub /*
1338f1fca82eSMikolaj Golub  * Drain into a counter.
1339f1fca82eSMikolaj Golub  */
1340f1fca82eSMikolaj Golub static int
1341f1fca82eSMikolaj Golub sbuf_drain_count(void *arg, const char *data __unused, int len)
1342f1fca82eSMikolaj Golub {
1343f1fca82eSMikolaj Golub 	size_t *sizep;
1344f1fca82eSMikolaj Golub 
1345f1fca82eSMikolaj Golub 	sizep = (size_t *)arg;
1346f1fca82eSMikolaj Golub 	*sizep += len;
1347f1fca82eSMikolaj Golub 	return (len);
1348f1fca82eSMikolaj Golub }
1349f1fca82eSMikolaj Golub 
13508c64af4fSJohn Polstra int
1351e7228204SAlfred Perlstein __elfN(coredump)(struct thread *td, struct vnode *vp, off_t limit, int flags)
1352fca666a1SJulian Elischer {
1353247aba24SMarcel Moolenaar 	struct ucred *cred = td->td_ucred;
1354fca666a1SJulian Elischer 	int error = 0;
13550ff27d31SJohn Polstra 	struct sseg_closure seginfo;
1356bd390213SMikolaj Golub 	struct note_info_list notelst;
1357aa14e9b7SMark Johnston 	struct coredump_params params;
1358bd390213SMikolaj Golub 	struct note_info *ninfo;
1359aa14e9b7SMark Johnston 	void *hdr, *tmpbuf;
1360bd390213SMikolaj Golub 	size_t hdrsize, notesz, coresize;
13619a12e282SEnji Cooper #ifdef GZIO
1362aa14e9b7SMark Johnston 	boolean_t compress;
13638c64af4fSJohn Polstra 
1364aa14e9b7SMark Johnston 	compress = (flags & IMGACT_CORE_COMPRESS) != 0;
13659a12e282SEnji Cooper #endif
1366e7228204SAlfred Perlstein 	hdr = NULL;
136702d131adSMark Johnston 	tmpbuf = NULL;
1368bd390213SMikolaj Golub 	TAILQ_INIT(&notelst);
1369e7228204SAlfred Perlstein 
13700ff27d31SJohn Polstra 	/* Size the program segments. */
13710ff27d31SJohn Polstra 	seginfo.count = 0;
13720ff27d31SJohn Polstra 	seginfo.size = 0;
13731005d8afSConrad Meyer 	each_dumpable_segment(td, cb_size_segment, &seginfo);
13740ff27d31SJohn Polstra 
13750ff27d31SJohn Polstra 	/*
1376bd390213SMikolaj Golub 	 * Collect info about the core file header area.
13770ff27d31SJohn Polstra 	 */
1378bd390213SMikolaj Golub 	hdrsize = sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * (1 + seginfo.count);
1379c17b0bd2SConrad Meyer 	if (seginfo.count + 1 >= PN_XNUM)
1380c17b0bd2SConrad Meyer 		hdrsize += sizeof(Elf_Shdr);
1381bd390213SMikolaj Golub 	__elfN(prepare_notes)(td, &notelst, &notesz);
1382bd390213SMikolaj Golub 	coresize = round_page(hdrsize + notesz) + seginfo.size;
13830ff27d31SJohn Polstra 
138402d131adSMark Johnston 	/* Set up core dump parameters. */
138502d131adSMark Johnston 	params.offset = 0;
138602d131adSMark Johnston 	params.active_cred = cred;
138702d131adSMark Johnston 	params.file_cred = NOCRED;
138802d131adSMark Johnston 	params.td = td;
138902d131adSMark Johnston 	params.vp = vp;
139002d131adSMark Johnston 	params.gzs = NULL;
139102d131adSMark Johnston 
1392afcc55f3SEdward Tomasz Napierala #ifdef RACCT
13934b5c9cf6SEdward Tomasz Napierala 	if (racct_enable) {
13941ba5ad42SEdward Tomasz Napierala 		PROC_LOCK(td->td_proc);
1395bd390213SMikolaj Golub 		error = racct_add(td->td_proc, RACCT_CORE, coresize);
13961ba5ad42SEdward Tomasz Napierala 		PROC_UNLOCK(td->td_proc);
13971ba5ad42SEdward Tomasz Napierala 		if (error != 0) {
13981ba5ad42SEdward Tomasz Napierala 			error = EFAULT;
13991ba5ad42SEdward Tomasz Napierala 			goto done;
14001ba5ad42SEdward Tomasz Napierala 		}
14014b5c9cf6SEdward Tomasz Napierala 	}
1402afcc55f3SEdward Tomasz Napierala #endif
1403bd390213SMikolaj Golub 	if (coresize >= limit) {
1404fba6b1afSAlfred Perlstein 		error = EFAULT;
1405fba6b1afSAlfred Perlstein 		goto done;
1406fba6b1afSAlfred Perlstein 	}
14070ff27d31SJohn Polstra 
1408aa14e9b7SMark Johnston #ifdef GZIO
1409aa14e9b7SMark Johnston 	/* Create a compression stream if necessary. */
1410aa14e9b7SMark Johnston 	if (compress) {
1411aa14e9b7SMark Johnston 		params.gzs = gzio_init(core_gz_write, GZIO_DEFLATE,
1412aa14e9b7SMark Johnston 		    CORE_BUF_SIZE, compress_user_cores_gzlevel, &params);
1413aa14e9b7SMark Johnston 		if (params.gzs == NULL) {
1414aa14e9b7SMark Johnston 			error = EFAULT;
1415aa14e9b7SMark Johnston 			goto done;
1416aa14e9b7SMark Johnston 		}
1417aa14e9b7SMark Johnston 		tmpbuf = malloc(CORE_BUF_SIZE, M_TEMP, M_WAITOK | M_ZERO);
1418aa14e9b7SMark Johnston         }
1419aa14e9b7SMark Johnston #endif
1420aa14e9b7SMark Johnston 
14210ff27d31SJohn Polstra 	/*
14220ff27d31SJohn Polstra 	 * Allocate memory for building the header, fill it up,
1423bd390213SMikolaj Golub 	 * and write it out following the notes.
14240ff27d31SJohn Polstra 	 */
1425a163d034SWarner Losh 	hdr = malloc(hdrsize, M_TEMP, M_WAITOK);
1426aa14e9b7SMark Johnston 	error = __elfN(corehdr)(&params, seginfo.count, hdr, hdrsize, &notelst,
1427aa14e9b7SMark Johnston 	    notesz);
14280ff27d31SJohn Polstra 
14290ff27d31SJohn Polstra 	/* Write the contents of all of the writable segments. */
14300ff27d31SJohn Polstra 	if (error == 0) {
14310ff27d31SJohn Polstra 		Elf_Phdr *php;
14322b471bc6STim J. Robbins 		off_t offset;
14330ff27d31SJohn Polstra 		int i;
14340ff27d31SJohn Polstra 
14350ff27d31SJohn Polstra 		php = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr)) + 1;
1436bd390213SMikolaj Golub 		offset = round_page(hdrsize + notesz);
14370ff27d31SJohn Polstra 		for (i = 0; i < seginfo.count; i++) {
1438aa14e9b7SMark Johnston 			error = core_output((caddr_t)(uintptr_t)php->p_vaddr,
1439aa14e9b7SMark Johnston 			    php->p_filesz, offset, &params, tmpbuf);
14400ff27d31SJohn Polstra 			if (error != 0)
14412b471bc6STim J. Robbins 				break;
14420ff27d31SJohn Polstra 			offset += php->p_filesz;
14430ff27d31SJohn Polstra 			php++;
14440ff27d31SJohn Polstra 		}
1445aa14e9b7SMark Johnston #ifdef GZIO
1446aa14e9b7SMark Johnston 		if (error == 0 && compress)
1447aa14e9b7SMark Johnston 			error = gzio_flush(params.gzs);
1448aa14e9b7SMark Johnston #endif
14490ff27d31SJohn Polstra 	}
1450e7228204SAlfred Perlstein 	if (error) {
1451e7228204SAlfred Perlstein 		log(LOG_WARNING,
1452e7228204SAlfred Perlstein 		    "Failed to write core file for process %s (error %d)\n",
1453e7228204SAlfred Perlstein 		    curproc->p_comm, error);
1454e7228204SAlfred Perlstein 	}
1455e7228204SAlfred Perlstein 
1456e7228204SAlfred Perlstein done:
1457aa14e9b7SMark Johnston #ifdef GZIO
1458aa14e9b7SMark Johnston 	if (compress) {
1459aa14e9b7SMark Johnston 		free(tmpbuf, M_TEMP);
146002d131adSMark Johnston 		if (params.gzs != NULL)
1461aa14e9b7SMark Johnston 			gzio_fini(params.gzs);
1462aa14e9b7SMark Johnston 	}
14638b325009SAlfred Perlstein #endif
1464bd390213SMikolaj Golub 	while ((ninfo = TAILQ_FIRST(&notelst)) != NULL) {
1465bd390213SMikolaj Golub 		TAILQ_REMOVE(&notelst, ninfo, link);
1466bd390213SMikolaj Golub 		free(ninfo, M_TEMP);
1467bd390213SMikolaj Golub 	}
1468bd390213SMikolaj Golub 	if (hdr != NULL)
14690ff27d31SJohn Polstra 		free(hdr, M_TEMP);
14700ff27d31SJohn Polstra 
1471a7cddfedSJake Burkholder 	return (error);
14728c64af4fSJohn Polstra }
14738c64af4fSJohn Polstra 
14740ff27d31SJohn Polstra /*
14751005d8afSConrad Meyer  * A callback for each_dumpable_segment() to write out the segment's
14760ff27d31SJohn Polstra  * program header entry.
14770ff27d31SJohn Polstra  */
14780ff27d31SJohn Polstra static void
14790ff27d31SJohn Polstra cb_put_phdr(entry, closure)
14800ff27d31SJohn Polstra 	vm_map_entry_t entry;
14810ff27d31SJohn Polstra 	void *closure;
14820ff27d31SJohn Polstra {
14830ff27d31SJohn Polstra 	struct phdr_closure *phc = (struct phdr_closure *)closure;
14840ff27d31SJohn Polstra 	Elf_Phdr *phdr = phc->phdr;
14850ff27d31SJohn Polstra 
14860ff27d31SJohn Polstra 	phc->offset = round_page(phc->offset);
14870ff27d31SJohn Polstra 
14880ff27d31SJohn Polstra 	phdr->p_type = PT_LOAD;
14890ff27d31SJohn Polstra 	phdr->p_offset = phc->offset;
14900ff27d31SJohn Polstra 	phdr->p_vaddr = entry->start;
14910ff27d31SJohn Polstra 	phdr->p_paddr = 0;
14920ff27d31SJohn Polstra 	phdr->p_filesz = phdr->p_memsz = entry->end - entry->start;
14930ff27d31SJohn Polstra 	phdr->p_align = PAGE_SIZE;
1494ed167eaaSKonstantin Belousov 	phdr->p_flags = __elfN(untrans_prot)(entry->protection);
14950ff27d31SJohn Polstra 
14960ff27d31SJohn Polstra 	phc->offset += phdr->p_filesz;
14970ff27d31SJohn Polstra 	phc->phdr++;
14980ff27d31SJohn Polstra }
14990ff27d31SJohn Polstra 
15000ff27d31SJohn Polstra /*
15011005d8afSConrad Meyer  * A callback for each_dumpable_segment() to gather information about
15020ff27d31SJohn Polstra  * the number of segments and their total size.
15030ff27d31SJohn Polstra  */
15040ff27d31SJohn Polstra static void
1505f3325003SConrad Meyer cb_size_segment(vm_map_entry_t entry, void *closure)
15060ff27d31SJohn Polstra {
15070ff27d31SJohn Polstra 	struct sseg_closure *ssc = (struct sseg_closure *)closure;
15080ff27d31SJohn Polstra 
15090ff27d31SJohn Polstra 	ssc->count++;
15100ff27d31SJohn Polstra 	ssc->size += entry->end - entry->start;
15110ff27d31SJohn Polstra }
15120ff27d31SJohn Polstra 
15130ff27d31SJohn Polstra /*
15140ff27d31SJohn Polstra  * For each writable segment in the process's memory map, call the given
15150ff27d31SJohn Polstra  * function with a pointer to the map entry and some arbitrary
15160ff27d31SJohn Polstra  * caller-supplied data.
15170ff27d31SJohn Polstra  */
15180ff27d31SJohn Polstra static void
15191005d8afSConrad Meyer each_dumpable_segment(struct thread *td, segment_callback func, void *closure)
15200ff27d31SJohn Polstra {
1521247aba24SMarcel Moolenaar 	struct proc *p = td->td_proc;
15220ff27d31SJohn Polstra 	vm_map_t map = &p->p_vmspace->vm_map;
15230ff27d31SJohn Polstra 	vm_map_entry_t entry;
1524976a87a2SAlan Cox 	vm_object_t backing_object, object;
1525976a87a2SAlan Cox 	boolean_t ignore_entry;
15260ff27d31SJohn Polstra 
1527976a87a2SAlan Cox 	vm_map_lock_read(map);
15280ff27d31SJohn Polstra 	for (entry = map->header.next; entry != &map->header;
15290ff27d31SJohn Polstra 	    entry = entry->next) {
1530fa7dd9c5SMatthew Dillon 		/*
1531fa7dd9c5SMatthew Dillon 		 * Don't dump inaccessible mappings, deal with legacy
1532fa7dd9c5SMatthew Dillon 		 * coredump mode.
1533fa7dd9c5SMatthew Dillon 		 *
1534fa7dd9c5SMatthew Dillon 		 * Note that read-only segments related to the elf binary
1535fa7dd9c5SMatthew Dillon 		 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1536fa7dd9c5SMatthew Dillon 		 * need to arbitrarily ignore such segments.
1537fa7dd9c5SMatthew Dillon 		 */
1538fa7dd9c5SMatthew Dillon 		if (elf_legacy_coredump) {
1539fa7dd9c5SMatthew Dillon 			if ((entry->protection & VM_PROT_RW) != VM_PROT_RW)
15400ff27d31SJohn Polstra 				continue;
1541fa7dd9c5SMatthew Dillon 		} else {
1542fa7dd9c5SMatthew Dillon 			if ((entry->protection & VM_PROT_ALL) == 0)
1543fa7dd9c5SMatthew Dillon 				continue;
1544fa7dd9c5SMatthew Dillon 		}
15450ff27d31SJohn Polstra 
15469730a5daSPaul Saab 		/*
1547fa7dd9c5SMatthew Dillon 		 * Dont include memory segment in the coredump if
1548fa7dd9c5SMatthew Dillon 		 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1549fa7dd9c5SMatthew Dillon 		 * madvise(2).  Do not dump submaps (i.e. parts of the
1550fa7dd9c5SMatthew Dillon 		 * kernel map).
15519730a5daSPaul Saab 		 */
1552fa7dd9c5SMatthew Dillon 		if (entry->eflags & (MAP_ENTRY_NOCOREDUMP|MAP_ENTRY_IS_SUB_MAP))
15539730a5daSPaul Saab 			continue;
15549730a5daSPaul Saab 
1555976a87a2SAlan Cox 		if ((object = entry->object.vm_object) == NULL)
15560ff27d31SJohn Polstra 			continue;
15570ff27d31SJohn Polstra 
15580ff27d31SJohn Polstra 		/* Ignore memory-mapped devices and such things. */
1559bc403f03SAttilio Rao 		VM_OBJECT_RLOCK(object);
1560976a87a2SAlan Cox 		while ((backing_object = object->backing_object) != NULL) {
1561bc403f03SAttilio Rao 			VM_OBJECT_RLOCK(backing_object);
1562bc403f03SAttilio Rao 			VM_OBJECT_RUNLOCK(object);
1563976a87a2SAlan Cox 			object = backing_object;
1564976a87a2SAlan Cox 		}
1565976a87a2SAlan Cox 		ignore_entry = object->type != OBJT_DEFAULT &&
1566bc411bc2SJohn Baldwin 		    object->type != OBJT_SWAP && object->type != OBJT_VNODE &&
1567bc411bc2SJohn Baldwin 		    object->type != OBJT_PHYS;
1568bc403f03SAttilio Rao 		VM_OBJECT_RUNLOCK(object);
1569976a87a2SAlan Cox 		if (ignore_entry)
15700ff27d31SJohn Polstra 			continue;
15710ff27d31SJohn Polstra 
15720ff27d31SJohn Polstra 		(*func)(entry, closure);
15730ff27d31SJohn Polstra 	}
1574976a87a2SAlan Cox 	vm_map_unlock_read(map);
15750ff27d31SJohn Polstra }
15760ff27d31SJohn Polstra 
15770ff27d31SJohn Polstra /*
15780ff27d31SJohn Polstra  * Write the core file header to the file, including padding up to
15790ff27d31SJohn Polstra  * the page boundary.
15800ff27d31SJohn Polstra  */
15818c64af4fSJohn Polstra static int
1582aa14e9b7SMark Johnston __elfN(corehdr)(struct coredump_params *p, int numsegs, void *hdr,
1583aa14e9b7SMark Johnston     size_t hdrsize, struct note_info_list *notelst, size_t notesz)
15848c64af4fSJohn Polstra {
1585bd390213SMikolaj Golub 	struct note_info *ninfo;
1586bd390213SMikolaj Golub 	struct sbuf *sb;
1587bd390213SMikolaj Golub 	int error;
15888c64af4fSJohn Polstra 
15898c64af4fSJohn Polstra 	/* Fill in the header. */
15900ff27d31SJohn Polstra 	bzero(hdr, hdrsize);
1591aa14e9b7SMark Johnston 	__elfN(puthdr)(p->td, hdr, hdrsize, numsegs, notesz);
15928c64af4fSJohn Polstra 
1593bd390213SMikolaj Golub 	sb = sbuf_new(NULL, NULL, CORE_BUF_SIZE, SBUF_FIXEDLEN);
1594aa14e9b7SMark Johnston 	sbuf_set_drain(sb, sbuf_drain_core_output, p);
1595bd390213SMikolaj Golub 	sbuf_start_section(sb, NULL);
1596bd390213SMikolaj Golub 	sbuf_bcat(sb, hdr, hdrsize);
1597bd390213SMikolaj Golub 	TAILQ_FOREACH(ninfo, notelst, link)
1598bd390213SMikolaj Golub 	    __elfN(putnote)(ninfo, sb);
1599bd390213SMikolaj Golub 	/* Align up to a page boundary for the program segments. */
1600bd390213SMikolaj Golub 	sbuf_end_section(sb, -1, PAGE_SIZE, 0);
1601bd390213SMikolaj Golub 	error = sbuf_finish(sb);
1602bd390213SMikolaj Golub 	sbuf_delete(sb);
1603bd390213SMikolaj Golub 
1604bd390213SMikolaj Golub 	return (error);
1605e7228204SAlfred Perlstein }
1606bd390213SMikolaj Golub 
1607bd390213SMikolaj Golub static void
1608bd390213SMikolaj Golub __elfN(prepare_notes)(struct thread *td, struct note_info_list *list,
1609bd390213SMikolaj Golub     size_t *sizep)
1610bd390213SMikolaj Golub {
1611bd390213SMikolaj Golub 	struct proc *p;
1612bd390213SMikolaj Golub 	struct thread *thr;
1613bd390213SMikolaj Golub 	size_t size;
1614bd390213SMikolaj Golub 
1615bd390213SMikolaj Golub 	p = td->td_proc;
1616bd390213SMikolaj Golub 	size = 0;
1617bd390213SMikolaj Golub 
1618bd390213SMikolaj Golub 	size += register_note(list, NT_PRPSINFO, __elfN(note_prpsinfo), p);
1619bd390213SMikolaj Golub 
1620bd390213SMikolaj Golub 	/*
1621bd390213SMikolaj Golub 	 * To have the debugger select the right thread (LWP) as the initial
1622bd390213SMikolaj Golub 	 * thread, we dump the state of the thread passed to us in td first.
1623bd390213SMikolaj Golub 	 * This is the thread that causes the core dump and thus likely to
1624bd390213SMikolaj Golub 	 * be the right thread one wants to have selected in the debugger.
1625bd390213SMikolaj Golub 	 */
1626bd390213SMikolaj Golub 	thr = td;
1627bd390213SMikolaj Golub 	while (thr != NULL) {
1628bd390213SMikolaj Golub 		size += register_note(list, NT_PRSTATUS,
1629bd390213SMikolaj Golub 		    __elfN(note_prstatus), thr);
1630bd390213SMikolaj Golub 		size += register_note(list, NT_FPREGSET,
1631bd390213SMikolaj Golub 		    __elfN(note_fpregset), thr);
1632bd390213SMikolaj Golub 		size += register_note(list, NT_THRMISC,
1633bd390213SMikolaj Golub 		    __elfN(note_thrmisc), thr);
163486be94fcSTycho Nightingale 		size += register_note(list, NT_PTLWPINFO,
163586be94fcSTycho Nightingale 		    __elfN(note_ptlwpinfo), thr);
1636bd390213SMikolaj Golub 		size += register_note(list, -1,
1637bd390213SMikolaj Golub 		    __elfN(note_threadmd), thr);
1638bd390213SMikolaj Golub 
1639bd390213SMikolaj Golub 		thr = (thr == td) ? TAILQ_FIRST(&p->p_threads) :
1640bd390213SMikolaj Golub 		    TAILQ_NEXT(thr, td_plist);
1641bd390213SMikolaj Golub 		if (thr == td)
1642bd390213SMikolaj Golub 			thr = TAILQ_NEXT(thr, td_plist);
1643dada0278SJohn Polstra 	}
1644dada0278SJohn Polstra 
1645f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_PROC,
1646f1fca82eSMikolaj Golub 	    __elfN(note_procstat_proc), p);
1647f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_FILES,
1648f1fca82eSMikolaj Golub 	    note_procstat_files, p);
1649f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_VMMAP,
1650f1fca82eSMikolaj Golub 	    note_procstat_vmmap, p);
1651f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_GROUPS,
1652f1fca82eSMikolaj Golub 	    note_procstat_groups, p);
1653f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_UMASK,
1654f1fca82eSMikolaj Golub 	    note_procstat_umask, p);
1655f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_RLIMIT,
1656f1fca82eSMikolaj Golub 	    note_procstat_rlimit, p);
1657f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_OSREL,
1658f1fca82eSMikolaj Golub 	    note_procstat_osrel, p);
1659f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_PSSTRINGS,
1660f1fca82eSMikolaj Golub 	    __elfN(note_procstat_psstrings), p);
1661f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_AUXV,
1662f1fca82eSMikolaj Golub 	    __elfN(note_procstat_auxv), p);
1663f1fca82eSMikolaj Golub 
1664bd390213SMikolaj Golub 	*sizep = size;
1665bd390213SMikolaj Golub }
1666bd390213SMikolaj Golub 
1667bd390213SMikolaj Golub static void
1668bd390213SMikolaj Golub __elfN(puthdr)(struct thread *td, void *hdr, size_t hdrsize, int numsegs,
1669bd390213SMikolaj Golub     size_t notesz)
1670bd390213SMikolaj Golub {
1671bd390213SMikolaj Golub 	Elf_Ehdr *ehdr;
1672bd390213SMikolaj Golub 	Elf_Phdr *phdr;
1673c17b0bd2SConrad Meyer 	Elf_Shdr *shdr;
1674bd390213SMikolaj Golub 	struct phdr_closure phc;
1675bd390213SMikolaj Golub 
1676bd390213SMikolaj Golub 	ehdr = (Elf_Ehdr *)hdr;
1677bd390213SMikolaj Golub 
1678bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG0] = ELFMAG0;
1679bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG1] = ELFMAG1;
1680bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG2] = ELFMAG2;
1681bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG3] = ELFMAG3;
1682bd390213SMikolaj Golub 	ehdr->e_ident[EI_CLASS] = ELF_CLASS;
1683bd390213SMikolaj Golub 	ehdr->e_ident[EI_DATA] = ELF_DATA;
1684bd390213SMikolaj Golub 	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
1685bd390213SMikolaj Golub 	ehdr->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1686bd390213SMikolaj Golub 	ehdr->e_ident[EI_ABIVERSION] = 0;
1687bd390213SMikolaj Golub 	ehdr->e_ident[EI_PAD] = 0;
1688bd390213SMikolaj Golub 	ehdr->e_type = ET_CORE;
1689885f13dcSJohn Baldwin 	ehdr->e_machine = td->td_proc->p_elf_machine;
1690bd390213SMikolaj Golub 	ehdr->e_version = EV_CURRENT;
1691bd390213SMikolaj Golub 	ehdr->e_entry = 0;
1692bd390213SMikolaj Golub 	ehdr->e_phoff = sizeof(Elf_Ehdr);
1693885f13dcSJohn Baldwin 	ehdr->e_flags = td->td_proc->p_elf_flags;
1694bd390213SMikolaj Golub 	ehdr->e_ehsize = sizeof(Elf_Ehdr);
1695bd390213SMikolaj Golub 	ehdr->e_phentsize = sizeof(Elf_Phdr);
1696bd390213SMikolaj Golub 	ehdr->e_shentsize = sizeof(Elf_Shdr);
1697bd390213SMikolaj Golub 	ehdr->e_shstrndx = SHN_UNDEF;
1698c17b0bd2SConrad Meyer 	if (numsegs + 1 < PN_XNUM) {
1699c17b0bd2SConrad Meyer 		ehdr->e_phnum = numsegs + 1;
1700c17b0bd2SConrad Meyer 		ehdr->e_shnum = 0;
1701c17b0bd2SConrad Meyer 	} else {
1702c17b0bd2SConrad Meyer 		ehdr->e_phnum = PN_XNUM;
1703c17b0bd2SConrad Meyer 		ehdr->e_shnum = 1;
1704c17b0bd2SConrad Meyer 
1705c17b0bd2SConrad Meyer 		ehdr->e_shoff = ehdr->e_phoff +
1706c17b0bd2SConrad Meyer 		    (numsegs + 1) * ehdr->e_phentsize;
1707c17b0bd2SConrad Meyer 		KASSERT(ehdr->e_shoff == hdrsize - sizeof(Elf_Shdr),
1708c17b0bd2SConrad Meyer 		    ("e_shoff: %zu, hdrsize - shdr: %zu",
170907f825e8SConrad Meyer 		     (size_t)ehdr->e_shoff, hdrsize - sizeof(Elf_Shdr)));
1710c17b0bd2SConrad Meyer 
1711c17b0bd2SConrad Meyer 		shdr = (Elf_Shdr *)((char *)hdr + ehdr->e_shoff);
1712c17b0bd2SConrad Meyer 		memset(shdr, 0, sizeof(*shdr));
1713c17b0bd2SConrad Meyer 		/*
1714c17b0bd2SConrad Meyer 		 * A special first section is used to hold large segment and
1715c17b0bd2SConrad Meyer 		 * section counts.  This was proposed by Sun Microsystems in
1716c17b0bd2SConrad Meyer 		 * Solaris and has been adopted by Linux; the standard ELF
1717c17b0bd2SConrad Meyer 		 * tools are already familiar with the technique.
1718c17b0bd2SConrad Meyer 		 *
1719c17b0bd2SConrad Meyer 		 * See table 7-7 of the Solaris "Linker and Libraries Guide"
1720c17b0bd2SConrad Meyer 		 * (or 12-7 depending on the version of the document) for more
1721c17b0bd2SConrad Meyer 		 * details.
1722c17b0bd2SConrad Meyer 		 */
1723c17b0bd2SConrad Meyer 		shdr->sh_type = SHT_NULL;
1724c17b0bd2SConrad Meyer 		shdr->sh_size = ehdr->e_shnum;
1725c17b0bd2SConrad Meyer 		shdr->sh_link = ehdr->e_shstrndx;
1726c17b0bd2SConrad Meyer 		shdr->sh_info = numsegs + 1;
1727c17b0bd2SConrad Meyer 	}
1728bd390213SMikolaj Golub 
1729bd390213SMikolaj Golub 	/*
1730bd390213SMikolaj Golub 	 * Fill in the program header entries.
1731bd390213SMikolaj Golub 	 */
1732c17b0bd2SConrad Meyer 	phdr = (Elf_Phdr *)((char *)hdr + ehdr->e_phoff);
1733bd390213SMikolaj Golub 
1734bd390213SMikolaj Golub 	/* The note segement. */
1735bd390213SMikolaj Golub 	phdr->p_type = PT_NOTE;
1736bd390213SMikolaj Golub 	phdr->p_offset = hdrsize;
1737bd390213SMikolaj Golub 	phdr->p_vaddr = 0;
1738bd390213SMikolaj Golub 	phdr->p_paddr = 0;
1739bd390213SMikolaj Golub 	phdr->p_filesz = notesz;
1740bd390213SMikolaj Golub 	phdr->p_memsz = 0;
1741bd390213SMikolaj Golub 	phdr->p_flags = PF_R;
17421b8388cdSMikolaj Golub 	phdr->p_align = ELF_NOTE_ROUNDSIZE;
1743bd390213SMikolaj Golub 	phdr++;
1744bd390213SMikolaj Golub 
1745bd390213SMikolaj Golub 	/* All the writable segments from the program. */
1746bd390213SMikolaj Golub 	phc.phdr = phdr;
1747bd390213SMikolaj Golub 	phc.offset = round_page(hdrsize + notesz);
17481005d8afSConrad Meyer 	each_dumpable_segment(td, cb_put_phdr, &phc);
1749bd390213SMikolaj Golub }
1750bd390213SMikolaj Golub 
1751bd390213SMikolaj Golub static size_t
1752bd390213SMikolaj Golub register_note(struct note_info_list *list, int type, outfunc_t out, void *arg)
1753bd390213SMikolaj Golub {
1754bd390213SMikolaj Golub 	struct note_info *ninfo;
1755bd390213SMikolaj Golub 	size_t size, notesize;
1756bd390213SMikolaj Golub 
1757bd390213SMikolaj Golub 	size = 0;
1758bd390213SMikolaj Golub 	out(arg, NULL, &size);
1759bd390213SMikolaj Golub 	ninfo = malloc(sizeof(*ninfo), M_TEMP, M_ZERO | M_WAITOK);
1760bd390213SMikolaj Golub 	ninfo->type = type;
1761bd390213SMikolaj Golub 	ninfo->outfunc = out;
1762bd390213SMikolaj Golub 	ninfo->outarg = arg;
1763bd390213SMikolaj Golub 	ninfo->outsize = size;
1764bd390213SMikolaj Golub 	TAILQ_INSERT_TAIL(list, ninfo, link);
1765bd390213SMikolaj Golub 
1766bd390213SMikolaj Golub 	if (type == -1)
1767bd390213SMikolaj Golub 		return (size);
1768bd390213SMikolaj Golub 
1769bd390213SMikolaj Golub 	notesize = sizeof(Elf_Note) +		/* note header */
1770180e57e5SJohn Baldwin 	    roundup2(sizeof(FREEBSD_ABI_VENDOR), ELF_NOTE_ROUNDSIZE) +
1771180e57e5SJohn Baldwin 						/* note name */
1772180e57e5SJohn Baldwin 	    roundup2(size, ELF_NOTE_ROUNDSIZE);	/* note description */
1773180e57e5SJohn Baldwin 
1774180e57e5SJohn Baldwin 	return (notesize);
1775180e57e5SJohn Baldwin }
1776180e57e5SJohn Baldwin 
1777180e57e5SJohn Baldwin static size_t
1778180e57e5SJohn Baldwin append_note_data(const void *src, void *dst, size_t len)
1779180e57e5SJohn Baldwin {
1780180e57e5SJohn Baldwin 	size_t padded_len;
1781180e57e5SJohn Baldwin 
1782180e57e5SJohn Baldwin 	padded_len = roundup2(len, ELF_NOTE_ROUNDSIZE);
1783180e57e5SJohn Baldwin 	if (dst != NULL) {
1784180e57e5SJohn Baldwin 		bcopy(src, dst, len);
1785180e57e5SJohn Baldwin 		bzero((char *)dst + len, padded_len - len);
1786180e57e5SJohn Baldwin 	}
1787180e57e5SJohn Baldwin 	return (padded_len);
1788180e57e5SJohn Baldwin }
1789180e57e5SJohn Baldwin 
1790180e57e5SJohn Baldwin size_t
1791180e57e5SJohn Baldwin __elfN(populate_note)(int type, void *src, void *dst, size_t size, void **descp)
1792180e57e5SJohn Baldwin {
1793180e57e5SJohn Baldwin 	Elf_Note *note;
1794180e57e5SJohn Baldwin 	char *buf;
1795180e57e5SJohn Baldwin 	size_t notesize;
1796180e57e5SJohn Baldwin 
1797180e57e5SJohn Baldwin 	buf = dst;
1798180e57e5SJohn Baldwin 	if (buf != NULL) {
1799180e57e5SJohn Baldwin 		note = (Elf_Note *)buf;
1800180e57e5SJohn Baldwin 		note->n_namesz = sizeof(FREEBSD_ABI_VENDOR);
1801180e57e5SJohn Baldwin 		note->n_descsz = size;
1802180e57e5SJohn Baldwin 		note->n_type = type;
1803180e57e5SJohn Baldwin 		buf += sizeof(*note);
1804180e57e5SJohn Baldwin 		buf += append_note_data(FREEBSD_ABI_VENDOR, buf,
1805180e57e5SJohn Baldwin 		    sizeof(FREEBSD_ABI_VENDOR));
1806180e57e5SJohn Baldwin 		append_note_data(src, buf, size);
1807180e57e5SJohn Baldwin 		if (descp != NULL)
1808180e57e5SJohn Baldwin 			*descp = buf;
1809180e57e5SJohn Baldwin 	}
1810180e57e5SJohn Baldwin 
1811180e57e5SJohn Baldwin 	notesize = sizeof(Elf_Note) +		/* note header */
1812180e57e5SJohn Baldwin 	    roundup2(sizeof(FREEBSD_ABI_VENDOR), ELF_NOTE_ROUNDSIZE) +
1813180e57e5SJohn Baldwin 						/* note name */
18141b8388cdSMikolaj Golub 	    roundup2(size, ELF_NOTE_ROUNDSIZE);	/* note description */
1815bd390213SMikolaj Golub 
1816bd390213SMikolaj Golub 	return (notesize);
1817bd390213SMikolaj Golub }
1818bd390213SMikolaj Golub 
1819bd390213SMikolaj Golub static void
1820bd390213SMikolaj Golub __elfN(putnote)(struct note_info *ninfo, struct sbuf *sb)
1821bd390213SMikolaj Golub {
1822bd390213SMikolaj Golub 	Elf_Note note;
182314bdbaf2SConrad Meyer 	ssize_t old_len, sect_len;
182414bdbaf2SConrad Meyer 	size_t new_len, descsz, i;
1825bd390213SMikolaj Golub 
1826bd390213SMikolaj Golub 	if (ninfo->type == -1) {
1827bd390213SMikolaj Golub 		ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize);
1828bd390213SMikolaj Golub 		return;
1829bd390213SMikolaj Golub 	}
1830bd390213SMikolaj Golub 
1831180e57e5SJohn Baldwin 	note.n_namesz = sizeof(FREEBSD_ABI_VENDOR);
1832bd390213SMikolaj Golub 	note.n_descsz = ninfo->outsize;
1833bd390213SMikolaj Golub 	note.n_type = ninfo->type;
1834bd390213SMikolaj Golub 
1835bd390213SMikolaj Golub 	sbuf_bcat(sb, &note, sizeof(note));
1836bd390213SMikolaj Golub 	sbuf_start_section(sb, &old_len);
1837180e57e5SJohn Baldwin 	sbuf_bcat(sb, FREEBSD_ABI_VENDOR, sizeof(FREEBSD_ABI_VENDOR));
18381b8388cdSMikolaj Golub 	sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0);
1839bd390213SMikolaj Golub 	if (note.n_descsz == 0)
1840bd390213SMikolaj Golub 		return;
1841bd390213SMikolaj Golub 	sbuf_start_section(sb, &old_len);
1842bd390213SMikolaj Golub 	ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize);
184314bdbaf2SConrad Meyer 	sect_len = sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0);
184414bdbaf2SConrad Meyer 	if (sect_len < 0)
184514bdbaf2SConrad Meyer 		return;
184614bdbaf2SConrad Meyer 
184714bdbaf2SConrad Meyer 	new_len = (size_t)sect_len;
184814bdbaf2SConrad Meyer 	descsz = roundup(note.n_descsz, ELF_NOTE_ROUNDSIZE);
184914bdbaf2SConrad Meyer 	if (new_len < descsz) {
185014bdbaf2SConrad Meyer 		/*
185114bdbaf2SConrad Meyer 		 * It is expected that individual note emitters will correctly
185214bdbaf2SConrad Meyer 		 * predict their expected output size and fill up to that size
185314bdbaf2SConrad Meyer 		 * themselves, padding in a format-specific way if needed.
185414bdbaf2SConrad Meyer 		 * However, in case they don't, just do it here with zeros.
185514bdbaf2SConrad Meyer 		 */
185614bdbaf2SConrad Meyer 		for (i = 0; i < descsz - new_len; i++)
185714bdbaf2SConrad Meyer 			sbuf_putc(sb, 0);
185814bdbaf2SConrad Meyer 	} else if (new_len > descsz) {
185914bdbaf2SConrad Meyer 		/*
186014bdbaf2SConrad Meyer 		 * We can't always truncate sb -- we may have drained some
186114bdbaf2SConrad Meyer 		 * of it already.
186214bdbaf2SConrad Meyer 		 */
186314bdbaf2SConrad Meyer 		KASSERT(new_len == descsz, ("%s: Note type %u changed as we "
186414bdbaf2SConrad Meyer 		    "read it (%zu > %zu).  Since it is longer than "
186514bdbaf2SConrad Meyer 		    "expected, this coredump's notes are corrupt.  THIS "
186614bdbaf2SConrad Meyer 		    "IS A BUG in the note_procstat routine for type %u.\n",
186714bdbaf2SConrad Meyer 		    __func__, (unsigned)note.n_type, new_len, descsz,
186814bdbaf2SConrad Meyer 		    (unsigned)note.n_type));
186914bdbaf2SConrad Meyer 	}
1870bd390213SMikolaj Golub }
1871bd390213SMikolaj Golub 
1872bd390213SMikolaj Golub /*
1873bd390213SMikolaj Golub  * Miscellaneous note out functions.
1874bd390213SMikolaj Golub  */
1875bd390213SMikolaj Golub 
1876841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1877841c0c7eSNathan Whitehorn #include <compat/freebsd32/freebsd32.h>
187851645e83SJohn Baldwin #include <compat/freebsd32/freebsd32_signal.h>
1879841c0c7eSNathan Whitehorn 
188062919d78SPeter Wemm typedef struct prstatus32 elf_prstatus_t;
188162919d78SPeter Wemm typedef struct prpsinfo32 elf_prpsinfo_t;
188262919d78SPeter Wemm typedef struct fpreg32 elf_prfpregset_t;
188362919d78SPeter Wemm typedef struct fpreg32 elf_fpregset_t;
188462919d78SPeter Wemm typedef struct reg32 elf_gregset_t;
18857f08176eSAttilio Rao typedef struct thrmisc32 elf_thrmisc_t;
1886f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK	KERN_PROC_MASK32
1887f1fca82eSMikolaj Golub typedef struct kinfo_proc32 elf_kinfo_proc_t;
1888f1fca82eSMikolaj Golub typedef uint32_t elf_ps_strings_t;
188962919d78SPeter Wemm #else
189062919d78SPeter Wemm typedef prstatus_t elf_prstatus_t;
189162919d78SPeter Wemm typedef prpsinfo_t elf_prpsinfo_t;
189262919d78SPeter Wemm typedef prfpregset_t elf_prfpregset_t;
189362919d78SPeter Wemm typedef prfpregset_t elf_fpregset_t;
189462919d78SPeter Wemm typedef gregset_t elf_gregset_t;
18957f08176eSAttilio Rao typedef thrmisc_t elf_thrmisc_t;
1896f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK	0
1897f1fca82eSMikolaj Golub typedef struct kinfo_proc elf_kinfo_proc_t;
1898f1fca82eSMikolaj Golub typedef vm_offset_t elf_ps_strings_t;
189962919d78SPeter Wemm #endif
190062919d78SPeter Wemm 
19018c64af4fSJohn Polstra static void
1902bd390213SMikolaj Golub __elfN(note_prpsinfo)(void *arg, struct sbuf *sb, size_t *sizep)
19038c64af4fSJohn Polstra {
1904c77547d2SJohn Baldwin 	struct sbuf sbarg;
1905c77547d2SJohn Baldwin 	size_t len;
1906c77547d2SJohn Baldwin 	char *cp, *end;
1907247aba24SMarcel Moolenaar 	struct proc *p;
1908bd390213SMikolaj Golub 	elf_prpsinfo_t *psinfo;
1909c77547d2SJohn Baldwin 	int error;
19108c64af4fSJohn Polstra 
1911bd390213SMikolaj Golub 	p = (struct proc *)arg;
1912bd390213SMikolaj Golub 	if (sb != NULL) {
1913bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*psinfo), ("invalid size"));
1914bd390213SMikolaj Golub 		psinfo = malloc(sizeof(*psinfo), M_TEMP, M_ZERO | M_WAITOK);
19158c9b7b2cSMarcel Moolenaar 		psinfo->pr_version = PRPSINFO_VERSION;
191662919d78SPeter Wemm 		psinfo->pr_psinfosz = sizeof(elf_prpsinfo_t);
1917ccd3953eSJohn Baldwin 		strlcpy(psinfo->pr_fname, p->p_comm, sizeof(psinfo->pr_fname));
1918c77547d2SJohn Baldwin 		PROC_LOCK(p);
1919c77547d2SJohn Baldwin 		if (p->p_args != NULL) {
1920c77547d2SJohn Baldwin 			len = sizeof(psinfo->pr_psargs) - 1;
1921c77547d2SJohn Baldwin 			if (len > p->p_args->ar_length)
1922c77547d2SJohn Baldwin 				len = p->p_args->ar_length;
1923c77547d2SJohn Baldwin 			memcpy(psinfo->pr_psargs, p->p_args->ar_args, len);
1924c77547d2SJohn Baldwin 			PROC_UNLOCK(p);
1925c77547d2SJohn Baldwin 			error = 0;
1926c77547d2SJohn Baldwin 		} else {
1927c77547d2SJohn Baldwin 			_PHOLD(p);
1928c77547d2SJohn Baldwin 			PROC_UNLOCK(p);
1929c77547d2SJohn Baldwin 			sbuf_new(&sbarg, psinfo->pr_psargs,
1930c77547d2SJohn Baldwin 			    sizeof(psinfo->pr_psargs), SBUF_FIXEDLEN);
1931c77547d2SJohn Baldwin 			error = proc_getargv(curthread, p, &sbarg);
1932c77547d2SJohn Baldwin 			PRELE(p);
1933c77547d2SJohn Baldwin 			if (sbuf_finish(&sbarg) == 0)
1934c77547d2SJohn Baldwin 				len = sbuf_len(&sbarg) - 1;
1935c77547d2SJohn Baldwin 			else
1936c77547d2SJohn Baldwin 				len = sizeof(psinfo->pr_psargs) - 1;
1937c77547d2SJohn Baldwin 			sbuf_delete(&sbarg);
1938c77547d2SJohn Baldwin 		}
1939c77547d2SJohn Baldwin 		if (error || len == 0)
1940ccd3953eSJohn Baldwin 			strlcpy(psinfo->pr_psargs, p->p_comm,
19418c9b7b2cSMarcel Moolenaar 			    sizeof(psinfo->pr_psargs));
1942c77547d2SJohn Baldwin 		else {
1943c77547d2SJohn Baldwin 			KASSERT(len < sizeof(psinfo->pr_psargs),
1944c77547d2SJohn Baldwin 			    ("len is too long: %zu vs %zu", len,
1945c77547d2SJohn Baldwin 			    sizeof(psinfo->pr_psargs)));
1946c77547d2SJohn Baldwin 			cp = psinfo->pr_psargs;
1947c77547d2SJohn Baldwin 			end = cp + len - 1;
1948c77547d2SJohn Baldwin 			for (;;) {
1949c77547d2SJohn Baldwin 				cp = memchr(cp, '\0', end - cp);
1950c77547d2SJohn Baldwin 				if (cp == NULL)
1951c77547d2SJohn Baldwin 					break;
1952c77547d2SJohn Baldwin 				*cp = ' ';
1953c77547d2SJohn Baldwin 			}
1954c77547d2SJohn Baldwin 		}
1955ccb83afdSJohn Baldwin 		psinfo->pr_pid = p->p_pid;
1956bd390213SMikolaj Golub 		sbuf_bcat(sb, psinfo, sizeof(*psinfo));
1957bd390213SMikolaj Golub 		free(psinfo, M_TEMP);
1958bd390213SMikolaj Golub 	}
1959bd390213SMikolaj Golub 	*sizep = sizeof(*psinfo);
1960bd390213SMikolaj Golub }
1961bd390213SMikolaj Golub 
1962bd390213SMikolaj Golub static void
1963bd390213SMikolaj Golub __elfN(note_prstatus)(void *arg, struct sbuf *sb, size_t *sizep)
1964bd390213SMikolaj Golub {
1965bd390213SMikolaj Golub 	struct thread *td;
1966bd390213SMikolaj Golub 	elf_prstatus_t *status;
1967bd390213SMikolaj Golub 
1968bd390213SMikolaj Golub 	td = (struct thread *)arg;
1969bd390213SMikolaj Golub 	if (sb != NULL) {
1970bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*status), ("invalid size"));
1971bd390213SMikolaj Golub 		status = malloc(sizeof(*status), M_TEMP, M_ZERO | M_WAITOK);
19728c9b7b2cSMarcel Moolenaar 		status->pr_version = PRSTATUS_VERSION;
197362919d78SPeter Wemm 		status->pr_statussz = sizeof(elf_prstatus_t);
197462919d78SPeter Wemm 		status->pr_gregsetsz = sizeof(elf_gregset_t);
197562919d78SPeter Wemm 		status->pr_fpregsetsz = sizeof(elf_fpregset_t);
19768c9b7b2cSMarcel Moolenaar 		status->pr_osreldate = osreldate;
1977bd390213SMikolaj Golub 		status->pr_cursig = td->td_proc->p_sig;
1978bd390213SMikolaj Golub 		status->pr_pid = td->td_tid;
1979841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1980bd390213SMikolaj Golub 		fill_regs32(td, &status->pr_reg);
198162919d78SPeter Wemm #else
1982bd390213SMikolaj Golub 		fill_regs(td, &status->pr_reg);
198362919d78SPeter Wemm #endif
1984bd390213SMikolaj Golub 		sbuf_bcat(sb, status, sizeof(*status));
1985bd390213SMikolaj Golub 		free(status, M_TEMP);
19868c9b7b2cSMarcel Moolenaar 	}
1987bd390213SMikolaj Golub 	*sizep = sizeof(*status);
1988bd390213SMikolaj Golub }
1989bd390213SMikolaj Golub 
1990bd390213SMikolaj Golub static void
1991bd390213SMikolaj Golub __elfN(note_fpregset)(void *arg, struct sbuf *sb, size_t *sizep)
1992bd390213SMikolaj Golub {
1993bd390213SMikolaj Golub 	struct thread *td;
1994bd390213SMikolaj Golub 	elf_prfpregset_t *fpregset;
1995bd390213SMikolaj Golub 
1996bd390213SMikolaj Golub 	td = (struct thread *)arg;
1997bd390213SMikolaj Golub 	if (sb != NULL) {
1998bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*fpregset), ("invalid size"));
1999bd390213SMikolaj Golub 		fpregset = malloc(sizeof(*fpregset), M_TEMP, M_ZERO | M_WAITOK);
2000bd390213SMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
2001bd390213SMikolaj Golub 		fill_fpregs32(td, fpregset);
2002bd390213SMikolaj Golub #else
2003bd390213SMikolaj Golub 		fill_fpregs(td, fpregset);
2004bd390213SMikolaj Golub #endif
2005bd390213SMikolaj Golub 		sbuf_bcat(sb, fpregset, sizeof(*fpregset));
2006bd390213SMikolaj Golub 		free(fpregset, M_TEMP);
2007bd390213SMikolaj Golub 	}
2008bd390213SMikolaj Golub 	*sizep = sizeof(*fpregset);
2009bd390213SMikolaj Golub }
2010bd390213SMikolaj Golub 
2011bd390213SMikolaj Golub static void
2012bd390213SMikolaj Golub __elfN(note_thrmisc)(void *arg, struct sbuf *sb, size_t *sizep)
2013bd390213SMikolaj Golub {
2014bd390213SMikolaj Golub 	struct thread *td;
2015bd390213SMikolaj Golub 	elf_thrmisc_t thrmisc;
2016bd390213SMikolaj Golub 
2017bd390213SMikolaj Golub 	td = (struct thread *)arg;
2018bd390213SMikolaj Golub 	if (sb != NULL) {
2019bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(thrmisc), ("invalid size"));
2020bd390213SMikolaj Golub 		bzero(&thrmisc._pad, sizeof(thrmisc._pad));
2021bd390213SMikolaj Golub 		strcpy(thrmisc.pr_tname, td->td_name);
2022bd390213SMikolaj Golub 		sbuf_bcat(sb, &thrmisc, sizeof(thrmisc));
2023bd390213SMikolaj Golub 	}
2024bd390213SMikolaj Golub 	*sizep = sizeof(thrmisc);
2025bd390213SMikolaj Golub }
2026bd390213SMikolaj Golub 
202786be94fcSTycho Nightingale static void
202886be94fcSTycho Nightingale __elfN(note_ptlwpinfo)(void *arg, struct sbuf *sb, size_t *sizep)
202986be94fcSTycho Nightingale {
203086be94fcSTycho Nightingale 	struct thread *td;
203186be94fcSTycho Nightingale 	size_t size;
203286be94fcSTycho Nightingale 	int structsize;
203351645e83SJohn Baldwin #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
203451645e83SJohn Baldwin 	struct ptrace_lwpinfo32 pl;
203551645e83SJohn Baldwin #else
203686be94fcSTycho Nightingale 	struct ptrace_lwpinfo pl;
203751645e83SJohn Baldwin #endif
203886be94fcSTycho Nightingale 
203986be94fcSTycho Nightingale 	td = (struct thread *)arg;
204051645e83SJohn Baldwin 	size = sizeof(structsize) + sizeof(pl);
204186be94fcSTycho Nightingale 	if (sb != NULL) {
204286be94fcSTycho Nightingale 		KASSERT(*sizep == size, ("invalid size"));
204351645e83SJohn Baldwin 		structsize = sizeof(pl);
204486be94fcSTycho Nightingale 		sbuf_bcat(sb, &structsize, sizeof(structsize));
204586be94fcSTycho Nightingale 		bzero(&pl, sizeof(pl));
204686be94fcSTycho Nightingale 		pl.pl_lwpid = td->td_tid;
204786be94fcSTycho Nightingale 		pl.pl_event = PL_EVENT_NONE;
204886be94fcSTycho Nightingale 		pl.pl_sigmask = td->td_sigmask;
204986be94fcSTycho Nightingale 		pl.pl_siglist = td->td_siglist;
205086be94fcSTycho Nightingale 		if (td->td_si.si_signo != 0) {
205186be94fcSTycho Nightingale 			pl.pl_event = PL_EVENT_SIGNAL;
205286be94fcSTycho Nightingale 			pl.pl_flags |= PL_FLAG_SI;
205351645e83SJohn Baldwin #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
205451645e83SJohn Baldwin 			siginfo_to_siginfo32(&td->td_si, &pl.pl_siginfo);
205551645e83SJohn Baldwin #else
205686be94fcSTycho Nightingale 			pl.pl_siginfo = td->td_si;
205751645e83SJohn Baldwin #endif
205886be94fcSTycho Nightingale 		}
205986be94fcSTycho Nightingale 		strcpy(pl.pl_tdname, td->td_name);
206086be94fcSTycho Nightingale 		/* XXX TODO: supply more information in struct ptrace_lwpinfo*/
206151645e83SJohn Baldwin 		sbuf_bcat(sb, &pl, sizeof(pl));
206286be94fcSTycho Nightingale 	}
206386be94fcSTycho Nightingale 	*sizep = size;
206486be94fcSTycho Nightingale }
206586be94fcSTycho Nightingale 
20664da47b2fSMarcel Moolenaar /*
20674da47b2fSMarcel Moolenaar  * Allow for MD specific notes, as well as any MD
20684da47b2fSMarcel Moolenaar  * specific preparations for writing MI notes.
20694da47b2fSMarcel Moolenaar  */
20708c64af4fSJohn Polstra static void
2071bd390213SMikolaj Golub __elfN(note_threadmd)(void *arg, struct sbuf *sb, size_t *sizep)
20728c64af4fSJohn Polstra {
2073bd390213SMikolaj Golub 	struct thread *td;
2074bd390213SMikolaj Golub 	void *buf;
2075bd390213SMikolaj Golub 	size_t size;
20768c64af4fSJohn Polstra 
2077bd390213SMikolaj Golub 	td = (struct thread *)arg;
2078bd390213SMikolaj Golub 	size = *sizep;
2079bd390213SMikolaj Golub 	if (size != 0 && sb != NULL)
2080bd390213SMikolaj Golub 		buf = malloc(size, M_TEMP, M_ZERO | M_WAITOK);
208183a396ceSChristian Brueffer 	else
208283a396ceSChristian Brueffer 		buf = NULL;
2083bd390213SMikolaj Golub 	size = 0;
2084bd390213SMikolaj Golub 	__elfN(dump_thread)(td, buf, &size);
208564779280SKonstantin Belousov 	KASSERT(sb == NULL || *sizep == size, ("invalid size"));
208683a396ceSChristian Brueffer 	if (size != 0 && sb != NULL)
2087bd390213SMikolaj Golub 		sbuf_bcat(sb, buf, size);
2088a1761d73SChristian Brueffer 	free(buf, M_TEMP);
2089bd390213SMikolaj Golub 	*sizep = size;
20908c64af4fSJohn Polstra }
20918c64af4fSJohn Polstra 
2092f1fca82eSMikolaj Golub #ifdef KINFO_PROC_SIZE
2093f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
2094f1fca82eSMikolaj Golub #endif
2095f1fca82eSMikolaj Golub 
2096f1fca82eSMikolaj Golub static void
2097f1fca82eSMikolaj Golub __elfN(note_procstat_proc)(void *arg, struct sbuf *sb, size_t *sizep)
2098f1fca82eSMikolaj Golub {
2099f1fca82eSMikolaj Golub 	struct proc *p;
2100f1fca82eSMikolaj Golub 	size_t size;
2101f1fca82eSMikolaj Golub 	int structsize;
2102f1fca82eSMikolaj Golub 
2103f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2104f1fca82eSMikolaj Golub 	size = sizeof(structsize) + p->p_numthreads *
2105f1fca82eSMikolaj Golub 	    sizeof(elf_kinfo_proc_t);
2106f1fca82eSMikolaj Golub 
2107f1fca82eSMikolaj Golub 	if (sb != NULL) {
2108f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2109f1fca82eSMikolaj Golub 		structsize = sizeof(elf_kinfo_proc_t);
2110f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
21116662ce5aSMateusz Guzik 		sx_slock(&proctree_lock);
2112f1fca82eSMikolaj Golub 		PROC_LOCK(p);
2113f1fca82eSMikolaj Golub 		kern_proc_out(p, sb, ELF_KERN_PROC_MASK);
21146662ce5aSMateusz Guzik 		sx_sunlock(&proctree_lock);
2115f1fca82eSMikolaj Golub 	}
2116f1fca82eSMikolaj Golub 	*sizep = size;
2117f1fca82eSMikolaj Golub }
2118f1fca82eSMikolaj Golub 
2119f1fca82eSMikolaj Golub #ifdef KINFO_FILE_SIZE
2120f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE);
2121f1fca82eSMikolaj Golub #endif
2122f1fca82eSMikolaj Golub 
2123f1fca82eSMikolaj Golub static void
2124f1fca82eSMikolaj Golub note_procstat_files(void *arg, struct sbuf *sb, size_t *sizep)
2125f1fca82eSMikolaj Golub {
2126f1fca82eSMikolaj Golub 	struct proc *p;
212714bdbaf2SConrad Meyer 	size_t size, sect_sz, i;
212814bdbaf2SConrad Meyer 	ssize_t start_len, sect_len;
212914bdbaf2SConrad Meyer 	int structsize, filedesc_flags;
213014bdbaf2SConrad Meyer 
2131bcb60d52SConrad Meyer 	if (coredump_pack_fileinfo)
213214bdbaf2SConrad Meyer 		filedesc_flags = KERN_FILEDESC_PACK_KINFO;
213314bdbaf2SConrad Meyer 	else
213414bdbaf2SConrad Meyer 		filedesc_flags = 0;
2135f1fca82eSMikolaj Golub 
2136f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
213714bdbaf2SConrad Meyer 	structsize = sizeof(struct kinfo_file);
2138f1fca82eSMikolaj Golub 	if (sb == NULL) {
2139f1fca82eSMikolaj Golub 		size = 0;
2140f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
2141f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
2142f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2143f1fca82eSMikolaj Golub 		PROC_LOCK(p);
214414bdbaf2SConrad Meyer 		kern_proc_filedesc_out(p, sb, -1, filedesc_flags);
2145f1fca82eSMikolaj Golub 		sbuf_finish(sb);
2146f1fca82eSMikolaj Golub 		sbuf_delete(sb);
2147f1fca82eSMikolaj Golub 		*sizep = size;
2148f1fca82eSMikolaj Golub 	} else {
214914bdbaf2SConrad Meyer 		sbuf_start_section(sb, &start_len);
215014bdbaf2SConrad Meyer 
2151f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2152f1fca82eSMikolaj Golub 		PROC_LOCK(p);
215314bdbaf2SConrad Meyer 		kern_proc_filedesc_out(p, sb, *sizep - sizeof(structsize),
215414bdbaf2SConrad Meyer 		    filedesc_flags);
215514bdbaf2SConrad Meyer 
215614bdbaf2SConrad Meyer 		sect_len = sbuf_end_section(sb, start_len, 0, 0);
215714bdbaf2SConrad Meyer 		if (sect_len < 0)
215814bdbaf2SConrad Meyer 			return;
215914bdbaf2SConrad Meyer 		sect_sz = sect_len;
216014bdbaf2SConrad Meyer 
216114bdbaf2SConrad Meyer 		KASSERT(sect_sz <= *sizep,
216214bdbaf2SConrad Meyer 		    ("kern_proc_filedesc_out did not respect maxlen; "
216314bdbaf2SConrad Meyer 		     "requested %zu, got %zu", *sizep - sizeof(structsize),
216414bdbaf2SConrad Meyer 		     sect_sz - sizeof(structsize)));
216514bdbaf2SConrad Meyer 
216614bdbaf2SConrad Meyer 		for (i = 0; i < *sizep - sect_sz && sb->s_error == 0; i++)
216714bdbaf2SConrad Meyer 			sbuf_putc(sb, 0);
2168f1fca82eSMikolaj Golub 	}
2169f1fca82eSMikolaj Golub }
2170f1fca82eSMikolaj Golub 
2171f1fca82eSMikolaj Golub #ifdef KINFO_VMENTRY_SIZE
2172f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
2173f1fca82eSMikolaj Golub #endif
2174f1fca82eSMikolaj Golub 
2175f1fca82eSMikolaj Golub static void
2176f1fca82eSMikolaj Golub note_procstat_vmmap(void *arg, struct sbuf *sb, size_t *sizep)
2177f1fca82eSMikolaj Golub {
2178f1fca82eSMikolaj Golub 	struct proc *p;
2179f1fca82eSMikolaj Golub 	size_t size;
2180e6b95927SConrad Meyer 	int structsize, vmmap_flags;
2181e6b95927SConrad Meyer 
2182e6b95927SConrad Meyer 	if (coredump_pack_vmmapinfo)
2183e6b95927SConrad Meyer 		vmmap_flags = KERN_VMMAP_PACK_KINFO;
2184e6b95927SConrad Meyer 	else
2185e6b95927SConrad Meyer 		vmmap_flags = 0;
2186f1fca82eSMikolaj Golub 
2187f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2188e6b95927SConrad Meyer 	structsize = sizeof(struct kinfo_vmentry);
2189f1fca82eSMikolaj Golub 	if (sb == NULL) {
2190f1fca82eSMikolaj Golub 		size = 0;
2191f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
2192f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
2193f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2194f1fca82eSMikolaj Golub 		PROC_LOCK(p);
2195e6b95927SConrad Meyer 		kern_proc_vmmap_out(p, sb, -1, vmmap_flags);
2196f1fca82eSMikolaj Golub 		sbuf_finish(sb);
2197f1fca82eSMikolaj Golub 		sbuf_delete(sb);
2198f1fca82eSMikolaj Golub 		*sizep = size;
2199f1fca82eSMikolaj Golub 	} else {
2200f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2201f1fca82eSMikolaj Golub 		PROC_LOCK(p);
2202e6b95927SConrad Meyer 		kern_proc_vmmap_out(p, sb, *sizep - sizeof(structsize),
2203e6b95927SConrad Meyer 		    vmmap_flags);
2204f1fca82eSMikolaj Golub 	}
2205f1fca82eSMikolaj Golub }
2206f1fca82eSMikolaj Golub 
2207f1fca82eSMikolaj Golub static void
2208f1fca82eSMikolaj Golub note_procstat_groups(void *arg, struct sbuf *sb, size_t *sizep)
2209f1fca82eSMikolaj Golub {
2210f1fca82eSMikolaj Golub 	struct proc *p;
2211f1fca82eSMikolaj Golub 	size_t size;
2212f1fca82eSMikolaj Golub 	int structsize;
2213f1fca82eSMikolaj Golub 
2214f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2215f1fca82eSMikolaj Golub 	size = sizeof(structsize) + p->p_ucred->cr_ngroups * sizeof(gid_t);
2216f1fca82eSMikolaj Golub 	if (sb != NULL) {
2217f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2218f1fca82eSMikolaj Golub 		structsize = sizeof(gid_t);
2219f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2220f1fca82eSMikolaj Golub 		sbuf_bcat(sb, p->p_ucred->cr_groups, p->p_ucred->cr_ngroups *
2221f1fca82eSMikolaj Golub 		    sizeof(gid_t));
2222f1fca82eSMikolaj Golub 	}
2223f1fca82eSMikolaj Golub 	*sizep = size;
2224f1fca82eSMikolaj Golub }
2225f1fca82eSMikolaj Golub 
2226f1fca82eSMikolaj Golub static void
2227f1fca82eSMikolaj Golub note_procstat_umask(void *arg, struct sbuf *sb, size_t *sizep)
2228f1fca82eSMikolaj Golub {
2229f1fca82eSMikolaj Golub 	struct proc *p;
2230f1fca82eSMikolaj Golub 	size_t size;
2231f1fca82eSMikolaj Golub 	int structsize;
2232f1fca82eSMikolaj Golub 
2233f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2234f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(p->p_fd->fd_cmask);
2235f1fca82eSMikolaj Golub 	if (sb != NULL) {
2236f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2237f1fca82eSMikolaj Golub 		structsize = sizeof(p->p_fd->fd_cmask);
2238f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2239f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &p->p_fd->fd_cmask, sizeof(p->p_fd->fd_cmask));
2240f1fca82eSMikolaj Golub 	}
2241f1fca82eSMikolaj Golub 	*sizep = size;
2242f1fca82eSMikolaj Golub }
2243f1fca82eSMikolaj Golub 
2244f1fca82eSMikolaj Golub static void
2245f1fca82eSMikolaj Golub note_procstat_rlimit(void *arg, struct sbuf *sb, size_t *sizep)
2246f1fca82eSMikolaj Golub {
2247f1fca82eSMikolaj Golub 	struct proc *p;
2248f1fca82eSMikolaj Golub 	struct rlimit rlim[RLIM_NLIMITS];
2249f1fca82eSMikolaj Golub 	size_t size;
2250f1fca82eSMikolaj Golub 	int structsize, i;
2251f1fca82eSMikolaj Golub 
2252f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2253f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(rlim);
2254f1fca82eSMikolaj Golub 	if (sb != NULL) {
2255f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2256f1fca82eSMikolaj Golub 		structsize = sizeof(rlim);
2257f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2258f1fca82eSMikolaj Golub 		PROC_LOCK(p);
2259f1fca82eSMikolaj Golub 		for (i = 0; i < RLIM_NLIMITS; i++)
2260f6f6d240SMateusz Guzik 			lim_rlimit_proc(p, i, &rlim[i]);
2261f1fca82eSMikolaj Golub 		PROC_UNLOCK(p);
2262f1fca82eSMikolaj Golub 		sbuf_bcat(sb, rlim, sizeof(rlim));
2263f1fca82eSMikolaj Golub 	}
2264f1fca82eSMikolaj Golub 	*sizep = size;
2265f1fca82eSMikolaj Golub }
2266f1fca82eSMikolaj Golub 
2267f1fca82eSMikolaj Golub static void
2268f1fca82eSMikolaj Golub note_procstat_osrel(void *arg, struct sbuf *sb, size_t *sizep)
2269f1fca82eSMikolaj Golub {
2270f1fca82eSMikolaj Golub 	struct proc *p;
2271f1fca82eSMikolaj Golub 	size_t size;
2272f1fca82eSMikolaj Golub 	int structsize;
2273f1fca82eSMikolaj Golub 
2274f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2275f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(p->p_osrel);
2276f1fca82eSMikolaj Golub 	if (sb != NULL) {
2277f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2278f1fca82eSMikolaj Golub 		structsize = sizeof(p->p_osrel);
2279f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2280f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &p->p_osrel, sizeof(p->p_osrel));
2281f1fca82eSMikolaj Golub 	}
2282f1fca82eSMikolaj Golub 	*sizep = size;
2283f1fca82eSMikolaj Golub }
2284f1fca82eSMikolaj Golub 
2285f1fca82eSMikolaj Golub static void
2286f1fca82eSMikolaj Golub __elfN(note_procstat_psstrings)(void *arg, struct sbuf *sb, size_t *sizep)
2287f1fca82eSMikolaj Golub {
2288f1fca82eSMikolaj Golub 	struct proc *p;
2289f1fca82eSMikolaj Golub 	elf_ps_strings_t ps_strings;
2290f1fca82eSMikolaj Golub 	size_t size;
2291f1fca82eSMikolaj Golub 	int structsize;
2292f1fca82eSMikolaj Golub 
2293f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2294f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(ps_strings);
2295f1fca82eSMikolaj Golub 	if (sb != NULL) {
2296f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
2297f1fca82eSMikolaj Golub 		structsize = sizeof(ps_strings);
2298f1fca82eSMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
2299f1fca82eSMikolaj Golub 		ps_strings = PTROUT(p->p_sysent->sv_psstrings);
2300f1fca82eSMikolaj Golub #else
2301f1fca82eSMikolaj Golub 		ps_strings = p->p_sysent->sv_psstrings;
2302f1fca82eSMikolaj Golub #endif
2303f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2304f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &ps_strings, sizeof(ps_strings));
2305f1fca82eSMikolaj Golub 	}
2306f1fca82eSMikolaj Golub 	*sizep = size;
2307f1fca82eSMikolaj Golub }
2308f1fca82eSMikolaj Golub 
2309f1fca82eSMikolaj Golub static void
2310f1fca82eSMikolaj Golub __elfN(note_procstat_auxv)(void *arg, struct sbuf *sb, size_t *sizep)
2311f1fca82eSMikolaj Golub {
2312f1fca82eSMikolaj Golub 	struct proc *p;
2313f1fca82eSMikolaj Golub 	size_t size;
2314f1fca82eSMikolaj Golub 	int structsize;
2315f1fca82eSMikolaj Golub 
2316f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
2317f1fca82eSMikolaj Golub 	if (sb == NULL) {
2318f1fca82eSMikolaj Golub 		size = 0;
2319f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
2320f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
2321f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2322f1fca82eSMikolaj Golub 		PHOLD(p);
2323f1fca82eSMikolaj Golub 		proc_getauxv(curthread, p, sb);
2324f1fca82eSMikolaj Golub 		PRELE(p);
2325f1fca82eSMikolaj Golub 		sbuf_finish(sb);
2326f1fca82eSMikolaj Golub 		sbuf_delete(sb);
2327f1fca82eSMikolaj Golub 		*sizep = size;
2328f1fca82eSMikolaj Golub 	} else {
2329f1fca82eSMikolaj Golub 		structsize = sizeof(Elf_Auxinfo);
2330f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
2331f1fca82eSMikolaj Golub 		PHOLD(p);
2332f1fca82eSMikolaj Golub 		proc_getauxv(curthread, p, sb);
2333f1fca82eSMikolaj Golub 		PRELE(p);
2334f1fca82eSMikolaj Golub 	}
2335f1fca82eSMikolaj Golub }
2336f1fca82eSMikolaj Golub 
233732c01de2SDmitry Chagin static boolean_t
23381a9c7decSKonstantin Belousov __elfN(parse_notes)(struct image_params *imgp, Elf_Brandnote *checknote,
23391a9c7decSKonstantin Belousov     int32_t *osrel, const Elf_Phdr *pnote)
234032c01de2SDmitry Chagin {
2341267c52fcSKonstantin Belousov 	const Elf_Note *note, *note0, *note_end;
234232c01de2SDmitry Chagin 	const char *note_name;
23436c775eb6SKonstantin Belousov 	char *buf;
23446c775eb6SKonstantin Belousov 	int i, error;
23456c775eb6SKonstantin Belousov 	boolean_t res;
234632c01de2SDmitry Chagin 
23476c775eb6SKonstantin Belousov 	/* We need some limit, might as well use PAGE_SIZE. */
23486c775eb6SKonstantin Belousov 	if (pnote == NULL || pnote->p_filesz > PAGE_SIZE)
234932c01de2SDmitry Chagin 		return (FALSE);
23506c775eb6SKonstantin Belousov 	ASSERT_VOP_LOCKED(imgp->vp, "parse_notes");
23516c775eb6SKonstantin Belousov 	if (pnote->p_offset > PAGE_SIZE ||
23526c775eb6SKonstantin Belousov 	    pnote->p_filesz > PAGE_SIZE - pnote->p_offset) {
23536c775eb6SKonstantin Belousov 		VOP_UNLOCK(imgp->vp, 0);
23546c775eb6SKonstantin Belousov 		buf = malloc(pnote->p_filesz, M_TEMP, M_WAITOK);
23556c775eb6SKonstantin Belousov 		vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
23566c775eb6SKonstantin Belousov 		error = vn_rdwr(UIO_READ, imgp->vp, buf, pnote->p_filesz,
23576c775eb6SKonstantin Belousov 		    pnote->p_offset, UIO_SYSSPACE, IO_NODELOCKED,
23586c775eb6SKonstantin Belousov 		    curthread->td_ucred, NOCRED, NULL, curthread);
23596c775eb6SKonstantin Belousov 		if (error != 0) {
23606c775eb6SKonstantin Belousov 			uprintf("i/o error PT_NOTE\n");
23616c775eb6SKonstantin Belousov 			res = FALSE;
23626c775eb6SKonstantin Belousov 			goto ret;
23636c775eb6SKonstantin Belousov 		}
23646c775eb6SKonstantin Belousov 		note = note0 = (const Elf_Note *)buf;
23656c775eb6SKonstantin Belousov 		note_end = (const Elf_Note *)(buf + pnote->p_filesz);
23666c775eb6SKonstantin Belousov 	} else {
23676c775eb6SKonstantin Belousov 		note = note0 = (const Elf_Note *)(imgp->image_header +
23686c775eb6SKonstantin Belousov 		    pnote->p_offset);
236932c01de2SDmitry Chagin 		note_end = (const Elf_Note *)(imgp->image_header +
237032c01de2SDmitry Chagin 		    pnote->p_offset + pnote->p_filesz);
23716c775eb6SKonstantin Belousov 		buf = NULL;
23726c775eb6SKonstantin Belousov 	}
2373267c52fcSKonstantin Belousov 	for (i = 0; i < 100 && note >= note0 && note < note_end; i++) {
2374d1ae5c83SKonstantin Belousov 		if (!aligned(note, Elf32_Addr) || (const char *)note_end -
23756c775eb6SKonstantin Belousov 		    (const char *)note < sizeof(Elf_Note)) {
23766c775eb6SKonstantin Belousov 			res = FALSE;
23776c775eb6SKonstantin Belousov 			goto ret;
23786c775eb6SKonstantin Belousov 		}
237932c01de2SDmitry Chagin 		if (note->n_namesz != checknote->hdr.n_namesz ||
238032c01de2SDmitry Chagin 		    note->n_descsz != checknote->hdr.n_descsz ||
238132c01de2SDmitry Chagin 		    note->n_type != checknote->hdr.n_type)
238232c01de2SDmitry Chagin 			goto nextnote;
238332c01de2SDmitry Chagin 		note_name = (const char *)(note + 1);
2384d1ae5c83SKonstantin Belousov 		if (note_name + checknote->hdr.n_namesz >=
2385d1ae5c83SKonstantin Belousov 		    (const char *)note_end || strncmp(checknote->vendor,
2386d1ae5c83SKonstantin Belousov 		    note_name, checknote->hdr.n_namesz) != 0)
238732c01de2SDmitry Chagin 			goto nextnote;
238832c01de2SDmitry Chagin 
238932c01de2SDmitry Chagin 		/*
239032c01de2SDmitry Chagin 		 * Fetch the osreldate for binary
239132c01de2SDmitry Chagin 		 * from the ELF OSABI-note if necessary.
239232c01de2SDmitry Chagin 		 */
239389ffc202SBjoern A. Zeeb 		if ((checknote->flags & BN_TRANSLATE_OSREL) != 0 &&
23946c775eb6SKonstantin Belousov 		    checknote->trans_osrel != NULL) {
23956c775eb6SKonstantin Belousov 			res = checknote->trans_osrel(note, osrel);
23966c775eb6SKonstantin Belousov 			goto ret;
23976c775eb6SKonstantin Belousov 		}
23986c775eb6SKonstantin Belousov 		res = TRUE;
23996c775eb6SKonstantin Belousov 		goto ret;
240032c01de2SDmitry Chagin nextnote:
240132c01de2SDmitry Chagin 		note = (const Elf_Note *)((const char *)(note + 1) +
24021b8388cdSMikolaj Golub 		    roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE) +
24031b8388cdSMikolaj Golub 		    roundup2(note->n_descsz, ELF_NOTE_ROUNDSIZE));
240432c01de2SDmitry Chagin 	}
24056c775eb6SKonstantin Belousov 	res = FALSE;
24066c775eb6SKonstantin Belousov ret:
24076c775eb6SKonstantin Belousov 	free(buf, M_TEMP);
24086c775eb6SKonstantin Belousov 	return (res);
240932c01de2SDmitry Chagin }
241032c01de2SDmitry Chagin 
241132c01de2SDmitry Chagin /*
24121a9c7decSKonstantin Belousov  * Try to find the appropriate ABI-note section for checknote,
24131a9c7decSKonstantin Belousov  * fetch the osreldate for binary from the ELF OSABI-note. Only the
24141a9c7decSKonstantin Belousov  * first page of the image is searched, the same as for headers.
24151a9c7decSKonstantin Belousov  */
24161a9c7decSKonstantin Belousov static boolean_t
24171a9c7decSKonstantin Belousov __elfN(check_note)(struct image_params *imgp, Elf_Brandnote *checknote,
24181a9c7decSKonstantin Belousov     int32_t *osrel)
24191a9c7decSKonstantin Belousov {
24201a9c7decSKonstantin Belousov 	const Elf_Phdr *phdr;
24211a9c7decSKonstantin Belousov 	const Elf_Ehdr *hdr;
24221a9c7decSKonstantin Belousov 	int i;
24231a9c7decSKonstantin Belousov 
24241a9c7decSKonstantin Belousov 	hdr = (const Elf_Ehdr *)imgp->image_header;
24251a9c7decSKonstantin Belousov 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
24261a9c7decSKonstantin Belousov 
24271a9c7decSKonstantin Belousov 	for (i = 0; i < hdr->e_phnum; i++) {
24281a9c7decSKonstantin Belousov 		if (phdr[i].p_type == PT_NOTE &&
24291a9c7decSKonstantin Belousov 		    __elfN(parse_notes)(imgp, checknote, osrel, &phdr[i]))
24301a9c7decSKonstantin Belousov 			return (TRUE);
24311a9c7decSKonstantin Belousov 	}
24321a9c7decSKonstantin Belousov 	return (FALSE);
24331a9c7decSKonstantin Belousov 
24341a9c7decSKonstantin Belousov }
24351a9c7decSKonstantin Belousov 
24361a9c7decSKonstantin Belousov /*
2437e1743d02SSøren Schmidt  * Tell kern_execve.c about it, with a little help from the linker.
2438e1743d02SSøren Schmidt  */
2439a360a43dSJake Burkholder static struct execsw __elfN(execsw) = {
2440a360a43dSJake Burkholder 	__CONCAT(exec_, __elfN(imgact)),
2441a360a43dSJake Burkholder 	__XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE))
2442a360a43dSJake Burkholder };
2443a360a43dSJake Burkholder EXEC_SET(__CONCAT(elf, __ELF_WORD_SIZE), __elfN(execsw));
2444e7228204SAlfred Perlstein 
2445ed167eaaSKonstantin Belousov static vm_prot_t
2446ed167eaaSKonstantin Belousov __elfN(trans_prot)(Elf_Word flags)
2447ed167eaaSKonstantin Belousov {
2448ed167eaaSKonstantin Belousov 	vm_prot_t prot;
2449ed167eaaSKonstantin Belousov 
2450ed167eaaSKonstantin Belousov 	prot = 0;
2451ed167eaaSKonstantin Belousov 	if (flags & PF_X)
2452ed167eaaSKonstantin Belousov 		prot |= VM_PROT_EXECUTE;
2453ed167eaaSKonstantin Belousov 	if (flags & PF_W)
2454ed167eaaSKonstantin Belousov 		prot |= VM_PROT_WRITE;
2455ed167eaaSKonstantin Belousov 	if (flags & PF_R)
2456ed167eaaSKonstantin Belousov 		prot |= VM_PROT_READ;
2457676eda08SMarcel Moolenaar #if __ELF_WORD_SIZE == 32
2458e7d939bdSMarcel Moolenaar #if defined(__amd64__)
2459126b36a2SKonstantin Belousov 	if (i386_read_exec && (flags & PF_R))
2460676eda08SMarcel Moolenaar 		prot |= VM_PROT_EXECUTE;
2461676eda08SMarcel Moolenaar #endif
2462676eda08SMarcel Moolenaar #endif
2463ed167eaaSKonstantin Belousov 	return (prot);
2464ed167eaaSKonstantin Belousov }
2465ed167eaaSKonstantin Belousov 
2466ed167eaaSKonstantin Belousov static Elf_Word
2467ed167eaaSKonstantin Belousov __elfN(untrans_prot)(vm_prot_t prot)
2468ed167eaaSKonstantin Belousov {
2469ed167eaaSKonstantin Belousov 	Elf_Word flags;
2470ed167eaaSKonstantin Belousov 
2471ed167eaaSKonstantin Belousov 	flags = 0;
2472ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_EXECUTE)
2473ed167eaaSKonstantin Belousov 		flags |= PF_X;
2474ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_READ)
2475ed167eaaSKonstantin Belousov 		flags |= PF_R;
2476ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_WRITE)
2477ed167eaaSKonstantin Belousov 		flags |= PF_W;
2478ed167eaaSKonstantin Belousov 	return (flags);
2479ed167eaaSKonstantin Belousov }
2480