xref: /freebsd/sys/kern/imgact_elf.c (revision 83a396ce95a79b56ffffacb10ddf78184f28e3f8)
1e1743d02SSøren Schmidt /*-
221a3ee0eSDavid E. O'Brien  * Copyright (c) 2000 David O'Brien
39a14aa01SUlrich Spörlein  * Copyright (c) 1995-1996 Søren Schmidt
4e1743d02SSøren Schmidt  * Copyright (c) 1996 Peter Wemm
5e1743d02SSøren Schmidt  * All rights reserved.
6e1743d02SSøren Schmidt  *
7e1743d02SSøren Schmidt  * Redistribution and use in source and binary forms, with or without
8e1743d02SSøren Schmidt  * modification, are permitted provided that the following conditions
9e1743d02SSøren Schmidt  * are met:
10e1743d02SSøren Schmidt  * 1. Redistributions of source code must retain the above copyright
11e1743d02SSøren Schmidt  *    notice, this list of conditions and the following disclaimer
12e1743d02SSøren Schmidt  *    in this position and unchanged.
13e1743d02SSøren Schmidt  * 2. Redistributions in binary form must reproduce the above copyright
14e1743d02SSøren Schmidt  *    notice, this list of conditions and the following disclaimer in the
15e1743d02SSøren Schmidt  *    documentation and/or other materials provided with the distribution.
16e1743d02SSøren Schmidt  * 3. The name of the author may not be used to endorse or promote products
1721dc7d4fSJens Schweikhardt  *    derived from this software without specific prior written permission
18e1743d02SSøren Schmidt  *
19e1743d02SSøren Schmidt  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20e1743d02SSøren Schmidt  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21e1743d02SSøren Schmidt  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22e1743d02SSøren Schmidt  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23e1743d02SSøren Schmidt  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24e1743d02SSøren Schmidt  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25e1743d02SSøren Schmidt  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26e1743d02SSøren Schmidt  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27e1743d02SSøren Schmidt  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28e1743d02SSøren Schmidt  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29e1743d02SSøren Schmidt  */
30e1743d02SSøren Schmidt 
31677b542eSDavid E. O'Brien #include <sys/cdefs.h>
32677b542eSDavid E. O'Brien __FBSDID("$FreeBSD$");
33677b542eSDavid E. O'Brien 
3412bc222eSJonathan Anderson #include "opt_capsicum.h"
3562919d78SPeter Wemm #include "opt_compat.h"
36e7228204SAlfred Perlstein #include "opt_core.h"
3762919d78SPeter Wemm 
38e1743d02SSøren Schmidt #include <sys/param.h>
394a144410SRobert Watson #include <sys/capsicum.h>
40e1743d02SSøren Schmidt #include <sys/exec.h>
418c64af4fSJohn Polstra #include <sys/fcntl.h>
42e1743d02SSøren Schmidt #include <sys/imgact.h>
43e1743d02SSøren Schmidt #include <sys/imgact_elf.h>
44e1743d02SSøren Schmidt #include <sys/kernel.h>
45f34fa851SJohn Baldwin #include <sys/lock.h>
46e1743d02SSøren Schmidt #include <sys/malloc.h>
4768ff2a43SChristian S.J. Peron #include <sys/mount.h>
488c64af4fSJohn Polstra #include <sys/mman.h>
49a794e791SBruce Evans #include <sys/namei.h>
508c64af4fSJohn Polstra #include <sys/pioctl.h>
51a794e791SBruce Evans #include <sys/proc.h>
528c64af4fSJohn Polstra #include <sys/procfs.h>
531ba5ad42SEdward Tomasz Napierala #include <sys/racct.h>
548c64af4fSJohn Polstra #include <sys/resourcevar.h>
5589f6b863SAttilio Rao #include <sys/rwlock.h>
56bd390213SMikolaj Golub #include <sys/sbuf.h>
57da61b9a6SAlan Cox #include <sys/sf_buf.h>
58ee235befSKonstantin Belousov #include <sys/smp.h>
5936240ea5SDoug Rabson #include <sys/systm.h>
60e1743d02SSøren Schmidt #include <sys/signalvar.h>
618c64af4fSJohn Polstra #include <sys/stat.h>
621005a129SJohn Baldwin #include <sys/sx.h>
638c64af4fSJohn Polstra #include <sys/syscall.h>
64e1743d02SSøren Schmidt #include <sys/sysctl.h>
658c64af4fSJohn Polstra #include <sys/sysent.h>
66a794e791SBruce Evans #include <sys/vnode.h>
67e7228204SAlfred Perlstein #include <sys/syslog.h>
68e7228204SAlfred Perlstein #include <sys/eventhandler.h>
69f1fca82eSMikolaj Golub #include <sys/user.h>
70e7228204SAlfred Perlstein 
71e7228204SAlfred Perlstein #include <net/zlib.h>
72e1743d02SSøren Schmidt 
73e1743d02SSøren Schmidt #include <vm/vm.h>
74e1743d02SSøren Schmidt #include <vm/vm_kern.h>
75e1743d02SSøren Schmidt #include <vm/vm_param.h>
76e1743d02SSøren Schmidt #include <vm/pmap.h>
77e1743d02SSøren Schmidt #include <vm/vm_map.h>
780ff27d31SJohn Polstra #include <vm/vm_object.h>
79e1743d02SSøren Schmidt #include <vm/vm_extern.h>
80e1743d02SSøren Schmidt 
8152c24af7SPeter Wemm #include <machine/elf.h>
82e1743d02SSøren Schmidt #include <machine/md_var.h>
83e1743d02SSøren Schmidt 
841b8388cdSMikolaj Golub #define ELF_NOTE_ROUNDSIZE	4
85c815a20cSDavid E. O'Brien #define OLD_EI_BRAND	8
86c815a20cSDavid E. O'Brien 
873ebc1248SPeter Wemm static int __elfN(check_header)(const Elf_Ehdr *hdr);
8832c01de2SDmitry Chagin static Elf_Brandinfo *__elfN(get_brandinfo)(struct image_params *imgp,
89d1ae5c83SKonstantin Belousov     const char *interp, int interp_name_len, int32_t *osrel);
903ebc1248SPeter Wemm static int __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
913ebc1248SPeter Wemm     u_long *entry, size_t pagesize);
92292177e6SAlan Cox static int __elfN(load_section)(struct image_params *imgp, vm_offset_t offset,
93292177e6SAlan Cox     caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot,
94292177e6SAlan Cox     size_t pagesize);
953ebc1248SPeter Wemm static int __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp);
9689ffc202SBjoern A. Zeeb static boolean_t __elfN(freebsd_trans_osrel)(const Elf_Note *note,
9789ffc202SBjoern A. Zeeb     int32_t *osrel);
9889ffc202SBjoern A. Zeeb static boolean_t kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel);
9932c01de2SDmitry Chagin static boolean_t __elfN(check_note)(struct image_params *imgp,
10032c01de2SDmitry Chagin     Elf_Brandnote *checknote, int32_t *osrel);
101ed167eaaSKonstantin Belousov static vm_prot_t __elfN(trans_prot)(Elf_Word);
102ed167eaaSKonstantin Belousov static Elf_Word __elfN(untrans_prot)(vm_prot_t);
103e1743d02SSøren Schmidt 
104a360a43dSJake Burkholder SYSCTL_NODE(_kern, OID_AUTO, __CONCAT(elf, __ELF_WORD_SIZE), CTLFLAG_RW, 0,
105a360a43dSJake Burkholder     "");
106a360a43dSJake Burkholder 
107e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
108e7228204SAlfred Perlstein static int compress_core(gzFile, char *, char *, unsigned int,
109e7228204SAlfred Perlstein     struct thread * td);
110e7228204SAlfred Perlstein #endif
111bd390213SMikolaj Golub #define CORE_BUF_SIZE	(16 * 1024)
112e7228204SAlfred Perlstein 
113e548a1d4SJake Burkholder int __elfN(fallback_brand) = -1;
114e548a1d4SJake Burkholder SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
115e548a1d4SJake Burkholder     fallback_brand, CTLFLAG_RW, &__elfN(fallback_brand), 0,
116a360a43dSJake Burkholder     __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) " brand of last resort");
117a360a43dSJake Burkholder TUNABLE_INT("kern.elf" __XSTRING(__ELF_WORD_SIZE) ".fallback_brand",
118e548a1d4SJake Burkholder     &__elfN(fallback_brand));
119a360a43dSJake Burkholder 
120551d79e1SMarcel Moolenaar static int elf_legacy_coredump = 0;
121a360a43dSJake Burkholder SYSCTL_INT(_debug, OID_AUTO, __elfN(legacy_coredump), CTLFLAG_RW,
122551d79e1SMarcel Moolenaar     &elf_legacy_coredump, 0, "");
123e1743d02SSøren Schmidt 
12462c625fdSKonstantin Belousov int __elfN(nxstack) =
12562c625fdSKonstantin Belousov #if defined(__amd64__) || defined(__powerpc64__) /* both 64 and 32 bit */
12662c625fdSKonstantin Belousov 	1;
12762c625fdSKonstantin Belousov #else
12862c625fdSKonstantin Belousov 	0;
12962c625fdSKonstantin Belousov #endif
130291c06a1SKonstantin Belousov SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
131291c06a1SKonstantin Belousov     nxstack, CTLFLAG_RW, &__elfN(nxstack), 0,
132291c06a1SKonstantin Belousov     __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) ": enable non-executable stack");
133291c06a1SKonstantin Belousov 
134126b36a2SKonstantin Belousov #if __ELF_WORD_SIZE == 32
135126b36a2SKonstantin Belousov #if defined(__amd64__) || defined(__ia64__)
136126b36a2SKonstantin Belousov int i386_read_exec = 0;
137126b36a2SKonstantin Belousov SYSCTL_INT(_kern_elf32, OID_AUTO, read_exec, CTLFLAG_RW, &i386_read_exec, 0,
138126b36a2SKonstantin Belousov     "enable execution from readable segments");
139126b36a2SKonstantin Belousov #endif
140126b36a2SKonstantin Belousov #endif
141126b36a2SKonstantin Belousov 
1423ebc1248SPeter Wemm static Elf_Brandinfo *elf_brand_list[MAX_BRANDS];
143e1743d02SSøren Schmidt 
14493d1c728SKonstantin Belousov #define	trunc_page_ps(va, ps)	((va) & ~(ps - 1))
14593d1c728SKonstantin Belousov #define	round_page_ps(va, ps)	(((va) + (ps - 1)) & ~(ps - 1))
14693d1c728SKonstantin Belousov #define	aligned(a, t)	(trunc_page_ps((u_long)(a), sizeof(t)) == (u_long)(a))
14793d1c728SKonstantin Belousov 
14832c01de2SDmitry Chagin static const char FREEBSD_ABI_VENDOR[] = "FreeBSD";
14932c01de2SDmitry Chagin 
15032c01de2SDmitry Chagin Elf_Brandnote __elfN(freebsd_brandnote) = {
15132c01de2SDmitry Chagin 	.hdr.n_namesz	= sizeof(FREEBSD_ABI_VENDOR),
15232c01de2SDmitry Chagin 	.hdr.n_descsz	= sizeof(int32_t),
15332c01de2SDmitry Chagin 	.hdr.n_type	= 1,
15432c01de2SDmitry Chagin 	.vendor		= FREEBSD_ABI_VENDOR,
15589ffc202SBjoern A. Zeeb 	.flags		= BN_TRANSLATE_OSREL,
15689ffc202SBjoern A. Zeeb 	.trans_osrel	= __elfN(freebsd_trans_osrel)
15732c01de2SDmitry Chagin };
15832c01de2SDmitry Chagin 
15989ffc202SBjoern A. Zeeb static boolean_t
16089ffc202SBjoern A. Zeeb __elfN(freebsd_trans_osrel)(const Elf_Note *note, int32_t *osrel)
16189ffc202SBjoern A. Zeeb {
16289ffc202SBjoern A. Zeeb 	uintptr_t p;
16389ffc202SBjoern A. Zeeb 
16489ffc202SBjoern A. Zeeb 	p = (uintptr_t)(note + 1);
1651b8388cdSMikolaj Golub 	p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE);
16689ffc202SBjoern A. Zeeb 	*osrel = *(const int32_t *)(p);
16789ffc202SBjoern A. Zeeb 
16889ffc202SBjoern A. Zeeb 	return (TRUE);
16989ffc202SBjoern A. Zeeb }
17089ffc202SBjoern A. Zeeb 
17189ffc202SBjoern A. Zeeb static const char GNU_ABI_VENDOR[] = "GNU";
17289ffc202SBjoern A. Zeeb static int GNU_KFREEBSD_ABI_DESC = 3;
17389ffc202SBjoern A. Zeeb 
17489ffc202SBjoern A. Zeeb Elf_Brandnote __elfN(kfreebsd_brandnote) = {
17589ffc202SBjoern A. Zeeb 	.hdr.n_namesz	= sizeof(GNU_ABI_VENDOR),
17689ffc202SBjoern A. Zeeb 	.hdr.n_descsz	= 16,	/* XXX at least 16 */
17789ffc202SBjoern A. Zeeb 	.hdr.n_type	= 1,
17889ffc202SBjoern A. Zeeb 	.vendor		= GNU_ABI_VENDOR,
17989ffc202SBjoern A. Zeeb 	.flags		= BN_TRANSLATE_OSREL,
18089ffc202SBjoern A. Zeeb 	.trans_osrel	= kfreebsd_trans_osrel
18189ffc202SBjoern A. Zeeb };
18289ffc202SBjoern A. Zeeb 
18389ffc202SBjoern A. Zeeb static boolean_t
18489ffc202SBjoern A. Zeeb kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel)
18589ffc202SBjoern A. Zeeb {
18689ffc202SBjoern A. Zeeb 	const Elf32_Word *desc;
18789ffc202SBjoern A. Zeeb 	uintptr_t p;
18889ffc202SBjoern A. Zeeb 
18989ffc202SBjoern A. Zeeb 	p = (uintptr_t)(note + 1);
1901b8388cdSMikolaj Golub 	p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE);
19189ffc202SBjoern A. Zeeb 
19289ffc202SBjoern A. Zeeb 	desc = (const Elf32_Word *)p;
19389ffc202SBjoern A. Zeeb 	if (desc[0] != GNU_KFREEBSD_ABI_DESC)
19489ffc202SBjoern A. Zeeb 		return (FALSE);
19589ffc202SBjoern A. Zeeb 
19689ffc202SBjoern A. Zeeb 	/*
19789ffc202SBjoern A. Zeeb 	 * Debian GNU/kFreeBSD embed the earliest compatible kernel version
19889ffc202SBjoern A. Zeeb 	 * (__FreeBSD_version: <major><two digit minor>Rxx) in the LSB way.
19989ffc202SBjoern A. Zeeb 	 */
20089ffc202SBjoern A. Zeeb 	*osrel = desc[1] * 100000 + desc[2] * 1000 + desc[3];
20189ffc202SBjoern A. Zeeb 
20289ffc202SBjoern A. Zeeb 	return (TRUE);
20389ffc202SBjoern A. Zeeb }
20489ffc202SBjoern A. Zeeb 
205e1743d02SSøren Schmidt int
2063ebc1248SPeter Wemm __elfN(insert_brand_entry)(Elf_Brandinfo *entry)
207e1743d02SSøren Schmidt {
208e1743d02SSøren Schmidt 	int i;
209e1743d02SSøren Schmidt 
2103ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
211ea5a2b2eSSøren Schmidt 		if (elf_brand_list[i] == NULL) {
212ea5a2b2eSSøren Schmidt 			elf_brand_list[i] = entry;
213e1743d02SSøren Schmidt 			break;
214e1743d02SSøren Schmidt 		}
215e1743d02SSøren Schmidt 	}
216925c8b5bSBjoern A. Zeeb 	if (i == MAX_BRANDS) {
217925c8b5bSBjoern A. Zeeb 		printf("WARNING: %s: could not insert brandinfo entry: %p\n",
218925c8b5bSBjoern A. Zeeb 			__func__, entry);
219a7cddfedSJake Burkholder 		return (-1);
220925c8b5bSBjoern A. Zeeb 	}
221a7cddfedSJake Burkholder 	return (0);
222e1743d02SSøren Schmidt }
223e1743d02SSøren Schmidt 
224e1743d02SSøren Schmidt int
2253ebc1248SPeter Wemm __elfN(remove_brand_entry)(Elf_Brandinfo *entry)
226e1743d02SSøren Schmidt {
227e1743d02SSøren Schmidt 	int i;
228e1743d02SSøren Schmidt 
2293ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
230ea5a2b2eSSøren Schmidt 		if (elf_brand_list[i] == entry) {
231ea5a2b2eSSøren Schmidt 			elf_brand_list[i] = NULL;
232e1743d02SSøren Schmidt 			break;
233e1743d02SSøren Schmidt 		}
234e1743d02SSøren Schmidt 	}
235ea5a2b2eSSøren Schmidt 	if (i == MAX_BRANDS)
236a7cddfedSJake Burkholder 		return (-1);
237a7cddfedSJake Burkholder 	return (0);
238e1743d02SSøren Schmidt }
239e1743d02SSøren Schmidt 
240096977faSMark Newton int
2413ebc1248SPeter Wemm __elfN(brand_inuse)(Elf_Brandinfo *entry)
242096977faSMark Newton {
243096977faSMark Newton 	struct proc *p;
244553629ebSJake Burkholder 	int rval = FALSE;
245096977faSMark Newton 
2461005a129SJohn Baldwin 	sx_slock(&allproc_lock);
2474f506694SXin LI 	FOREACH_PROC_IN_SYSTEM(p) {
248553629ebSJake Burkholder 		if (p->p_sysent == entry->sysvec) {
249553629ebSJake Burkholder 			rval = TRUE;
250553629ebSJake Burkholder 			break;
251096977faSMark Newton 		}
252553629ebSJake Burkholder 	}
2531005a129SJohn Baldwin 	sx_sunlock(&allproc_lock);
254096977faSMark Newton 
255553629ebSJake Burkholder 	return (rval);
256096977faSMark Newton }
257096977faSMark Newton 
2585fe3ed62SJake Burkholder static Elf_Brandinfo *
25932c01de2SDmitry Chagin __elfN(get_brandinfo)(struct image_params *imgp, const char *interp,
260d1ae5c83SKonstantin Belousov     int interp_name_len, int32_t *osrel)
2615fe3ed62SJake Burkholder {
26232c01de2SDmitry Chagin 	const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
2635fe3ed62SJake Burkholder 	Elf_Brandinfo *bi;
26432c01de2SDmitry Chagin 	boolean_t ret;
2655fe3ed62SJake Burkholder 	int i;
2665fe3ed62SJake Burkholder 
2675fe3ed62SJake Burkholder 	/*
26832c01de2SDmitry Chagin 	 * We support four types of branding -- (1) the ELF EI_OSABI field
2695fe3ed62SJake Burkholder 	 * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
27032c01de2SDmitry Chagin 	 * branding w/in the ELF header, (3) path of the `interp_path'
27132c01de2SDmitry Chagin 	 * field, and (4) the ".note.ABI-tag" ELF section.
2725fe3ed62SJake Burkholder 	 */
2735fe3ed62SJake Burkholder 
27432c01de2SDmitry Chagin 	/* Look for an ".note.ABI-tag" ELF section */
27532c01de2SDmitry Chagin 	for (i = 0; i < MAX_BRANDS; i++) {
27632c01de2SDmitry Chagin 		bi = elf_brand_list[i];
277ecc2fda8SBjoern A. Zeeb 		if (bi == NULL)
278ecc2fda8SBjoern A. Zeeb 			continue;
279ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine && (bi->flags &
280ecc2fda8SBjoern A. Zeeb 		    (BI_BRAND_NOTE|BI_BRAND_NOTE_MANDATORY)) != 0) {
28132c01de2SDmitry Chagin 			ret = __elfN(check_note)(imgp, bi->brand_note, osrel);
28232c01de2SDmitry Chagin 			if (ret)
28332c01de2SDmitry Chagin 				return (bi);
28432c01de2SDmitry Chagin 		}
28532c01de2SDmitry Chagin 	}
28632c01de2SDmitry Chagin 
2875fe3ed62SJake Burkholder 	/* If the executable has a brand, search for it in the brand list. */
2885fe3ed62SJake Burkholder 	for (i = 0; i < MAX_BRANDS; i++) {
2895fe3ed62SJake Burkholder 		bi = elf_brand_list[i];
290ecc2fda8SBjoern A. Zeeb 		if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
291ecc2fda8SBjoern A. Zeeb 			continue;
292ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine &&
2935fe3ed62SJake Burkholder 		    (hdr->e_ident[EI_OSABI] == bi->brand ||
2945fe3ed62SJake Burkholder 		    strncmp((const char *)&hdr->e_ident[OLD_EI_BRAND],
2955fe3ed62SJake Burkholder 		    bi->compat_3_brand, strlen(bi->compat_3_brand)) == 0))
2965fe3ed62SJake Burkholder 			return (bi);
2975fe3ed62SJake Burkholder 	}
2985fe3ed62SJake Burkholder 
2995fe3ed62SJake Burkholder 	/* Lacking a known brand, search for a recognized interpreter. */
3005fe3ed62SJake Burkholder 	if (interp != NULL) {
3015fe3ed62SJake Burkholder 		for (i = 0; i < MAX_BRANDS; i++) {
3025fe3ed62SJake Burkholder 			bi = elf_brand_list[i];
303ecc2fda8SBjoern A. Zeeb 			if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
304ecc2fda8SBjoern A. Zeeb 				continue;
305ecc2fda8SBjoern A. Zeeb 			if (hdr->e_machine == bi->machine &&
306d1ae5c83SKonstantin Belousov 			    /* ELF image p_filesz includes terminating zero */
307d1ae5c83SKonstantin Belousov 			    strlen(bi->interp_path) + 1 == interp_name_len &&
308d1ae5c83SKonstantin Belousov 			    strncmp(interp, bi->interp_path, interp_name_len)
309d1ae5c83SKonstantin Belousov 			    == 0)
3105fe3ed62SJake Burkholder 				return (bi);
3115fe3ed62SJake Burkholder 		}
3125fe3ed62SJake Burkholder 	}
3135fe3ed62SJake Burkholder 
3145fe3ed62SJake Burkholder 	/* Lacking a recognized interpreter, try the default brand */
3155fe3ed62SJake Burkholder 	for (i = 0; i < MAX_BRANDS; i++) {
3165fe3ed62SJake Burkholder 		bi = elf_brand_list[i];
317ecc2fda8SBjoern A. Zeeb 		if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
318ecc2fda8SBjoern A. Zeeb 			continue;
319ecc2fda8SBjoern A. Zeeb 		if (hdr->e_machine == bi->machine &&
320e548a1d4SJake Burkholder 		    __elfN(fallback_brand) == bi->brand)
3215fe3ed62SJake Burkholder 			return (bi);
3225fe3ed62SJake Burkholder 	}
3235fe3ed62SJake Burkholder 	return (NULL);
3245fe3ed62SJake Burkholder }
3255fe3ed62SJake Burkholder 
326e1743d02SSøren Schmidt static int
3273ebc1248SPeter Wemm __elfN(check_header)(const Elf_Ehdr *hdr)
328e1743d02SSøren Schmidt {
329d0ca7c29SPeter Wemm 	Elf_Brandinfo *bi;
3303ebc1248SPeter Wemm 	int i;
3313ebc1248SPeter Wemm 
33252c24af7SPeter Wemm 	if (!IS_ELF(*hdr) ||
33352c24af7SPeter Wemm 	    hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
33452c24af7SPeter Wemm 	    hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
3353dc19c46SJacques Vidrine 	    hdr->e_ident[EI_VERSION] != EV_CURRENT ||
3363dc19c46SJacques Vidrine 	    hdr->e_phentsize != sizeof(Elf_Phdr) ||
3373dc19c46SJacques Vidrine 	    hdr->e_version != ELF_TARG_VER)
338a7cddfedSJake Burkholder 		return (ENOEXEC);
339e1743d02SSøren Schmidt 
3403ebc1248SPeter Wemm 	/*
3413ebc1248SPeter Wemm 	 * Make sure we have at least one brand for this machine.
3423ebc1248SPeter Wemm 	 */
3433ebc1248SPeter Wemm 
3443ebc1248SPeter Wemm 	for (i = 0; i < MAX_BRANDS; i++) {
345d0ca7c29SPeter Wemm 		bi = elf_brand_list[i];
346d0ca7c29SPeter Wemm 		if (bi != NULL && bi->machine == hdr->e_machine)
3473ebc1248SPeter Wemm 			break;
3483ebc1248SPeter Wemm 	}
3493ebc1248SPeter Wemm 	if (i == MAX_BRANDS)
350a7cddfedSJake Burkholder 		return (ENOEXEC);
351e1743d02SSøren Schmidt 
352a7cddfedSJake Burkholder 	return (0);
353e1743d02SSøren Schmidt }
354e1743d02SSøren Schmidt 
355e1743d02SSøren Schmidt static int
3563ebc1248SPeter Wemm __elfN(map_partial)(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
357ff6f03c7SAlan Cox     vm_offset_t start, vm_offset_t end, vm_prot_t prot)
3583ebc1248SPeter Wemm {
359da61b9a6SAlan Cox 	struct sf_buf *sf;
360da61b9a6SAlan Cox 	int error;
3613ebc1248SPeter Wemm 	vm_offset_t off;
3623ebc1248SPeter Wemm 
3633ebc1248SPeter Wemm 	/*
3643ebc1248SPeter Wemm 	 * Create the page if it doesn't exist yet. Ignore errors.
3653ebc1248SPeter Wemm 	 */
3663ebc1248SPeter Wemm 	vm_map_lock(map);
367ff6f03c7SAlan Cox 	vm_map_insert(map, NULL, 0, trunc_page(start), round_page(end),
368ff6f03c7SAlan Cox 	    VM_PROT_ALL, VM_PROT_ALL, 0);
3693ebc1248SPeter Wemm 	vm_map_unlock(map);
3703ebc1248SPeter Wemm 
3713ebc1248SPeter Wemm 	/*
3723ebc1248SPeter Wemm 	 * Find the page from the underlying object.
3733ebc1248SPeter Wemm 	 */
3743ebc1248SPeter Wemm 	if (object) {
375da61b9a6SAlan Cox 		sf = vm_imgact_map_page(object, offset);
376da61b9a6SAlan Cox 		if (sf == NULL)
377da61b9a6SAlan Cox 			return (KERN_FAILURE);
3783ebc1248SPeter Wemm 		off = offset - trunc_page(offset);
379da61b9a6SAlan Cox 		error = copyout((caddr_t)sf_buf_kva(sf) + off, (caddr_t)start,
380ca0387efSJake Burkholder 		    end - start);
381be996836SAttilio Rao 		vm_imgact_unmap_page(sf);
3823ebc1248SPeter Wemm 		if (error) {
383a7cddfedSJake Burkholder 			return (KERN_FAILURE);
3843ebc1248SPeter Wemm 		}
3853ebc1248SPeter Wemm 	}
3863ebc1248SPeter Wemm 
387a7cddfedSJake Burkholder 	return (KERN_SUCCESS);
3883ebc1248SPeter Wemm }
3893ebc1248SPeter Wemm 
3903ebc1248SPeter Wemm static int
3913ebc1248SPeter Wemm __elfN(map_insert)(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
392ff6f03c7SAlan Cox     vm_offset_t start, vm_offset_t end, vm_prot_t prot, int cow)
3933ebc1248SPeter Wemm {
394da61b9a6SAlan Cox 	struct sf_buf *sf;
395da61b9a6SAlan Cox 	vm_offset_t off;
396a063facbSMarcel Moolenaar 	vm_size_t sz;
397a063facbSMarcel Moolenaar 	int error, rv;
3983ebc1248SPeter Wemm 
3993ebc1248SPeter Wemm 	if (start != trunc_page(start)) {
40081f223caSJake Burkholder 		rv = __elfN(map_partial)(map, object, offset, start,
401ff6f03c7SAlan Cox 		    round_page(start), prot);
4023ebc1248SPeter Wemm 		if (rv)
403a7cddfedSJake Burkholder 			return (rv);
4043ebc1248SPeter Wemm 		offset += round_page(start) - start;
4053ebc1248SPeter Wemm 		start = round_page(start);
4063ebc1248SPeter Wemm 	}
4073ebc1248SPeter Wemm 	if (end != round_page(end)) {
40881f223caSJake Burkholder 		rv = __elfN(map_partial)(map, object, offset +
409ff6f03c7SAlan Cox 		    trunc_page(end) - start, trunc_page(end), end, prot);
4103ebc1248SPeter Wemm 		if (rv)
411a7cddfedSJake Burkholder 			return (rv);
4123ebc1248SPeter Wemm 		end = trunc_page(end);
4133ebc1248SPeter Wemm 	}
4143ebc1248SPeter Wemm 	if (end > start) {
4153ebc1248SPeter Wemm 		if (offset & PAGE_MASK) {
4163ebc1248SPeter Wemm 			/*
4173ebc1248SPeter Wemm 			 * The mapping is not page aligned. This means we have
4183ebc1248SPeter Wemm 			 * to copy the data. Sigh.
4193ebc1248SPeter Wemm 			 */
420edb572a3SJohn Baldwin 			rv = vm_map_find(map, NULL, 0, &start, end - start, 0,
421edb572a3SJohn Baldwin 			    VMFS_NO_SPACE, prot | VM_PROT_WRITE, VM_PROT_ALL,
422edb572a3SJohn Baldwin 			    0);
4233ebc1248SPeter Wemm 			if (rv)
424a7cddfedSJake Burkholder 				return (rv);
425da61b9a6SAlan Cox 			if (object == NULL)
426da61b9a6SAlan Cox 				return (KERN_SUCCESS);
427da61b9a6SAlan Cox 			for (; start < end; start += sz) {
428da61b9a6SAlan Cox 				sf = vm_imgact_map_page(object, offset);
429da61b9a6SAlan Cox 				if (sf == NULL)
430da61b9a6SAlan Cox 					return (KERN_FAILURE);
4313ebc1248SPeter Wemm 				off = offset - trunc_page(offset);
4323ebc1248SPeter Wemm 				sz = end - start;
433da61b9a6SAlan Cox 				if (sz > PAGE_SIZE - off)
434da61b9a6SAlan Cox 					sz = PAGE_SIZE - off;
435da61b9a6SAlan Cox 				error = copyout((caddr_t)sf_buf_kva(sf) + off,
4363ebc1248SPeter Wemm 				    (caddr_t)start, sz);
437be996836SAttilio Rao 				vm_imgact_unmap_page(sf);
4383ebc1248SPeter Wemm 				if (error) {
439a7cddfedSJake Burkholder 					return (KERN_FAILURE);
4403ebc1248SPeter Wemm 				}
441da61b9a6SAlan Cox 				offset += sz;
4423ebc1248SPeter Wemm 			}
4433ebc1248SPeter Wemm 			rv = KERN_SUCCESS;
4443ebc1248SPeter Wemm 		} else {
445e5e6093bSAlan Cox 			vm_object_reference(object);
4463ebc1248SPeter Wemm 			vm_map_lock(map);
4473ebc1248SPeter Wemm 			rv = vm_map_insert(map, object, offset, start, end,
448ff6f03c7SAlan Cox 			    prot, VM_PROT_ALL, cow);
4493ebc1248SPeter Wemm 			vm_map_unlock(map);
450e5e6093bSAlan Cox 			if (rv != KERN_SUCCESS)
451e5e6093bSAlan Cox 				vm_object_deallocate(object);
4523ebc1248SPeter Wemm 		}
453a7cddfedSJake Burkholder 		return (rv);
4543ebc1248SPeter Wemm 	} else {
455a7cddfedSJake Burkholder 		return (KERN_SUCCESS);
4563ebc1248SPeter Wemm 	}
4573ebc1248SPeter Wemm }
4583ebc1248SPeter Wemm 
4593ebc1248SPeter Wemm static int
460292177e6SAlan Cox __elfN(load_section)(struct image_params *imgp, vm_offset_t offset,
4613ebc1248SPeter Wemm     caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot,
4623ebc1248SPeter Wemm     size_t pagesize)
463e1743d02SSøren Schmidt {
464da61b9a6SAlan Cox 	struct sf_buf *sf;
465e1743d02SSøren Schmidt 	size_t map_len;
466292177e6SAlan Cox 	vm_map_t map;
467292177e6SAlan Cox 	vm_object_t object;
468e1743d02SSøren Schmidt 	vm_offset_t map_addr;
469fa7dd9c5SMatthew Dillon 	int error, rv, cow;
470e1743d02SSøren Schmidt 	size_t copy_len;
47152c24af7SPeter Wemm 	vm_offset_t file_addr;
47252c24af7SPeter Wemm 
47325ead034SBrian Feldman 	/*
47425ead034SBrian Feldman 	 * It's necessary to fail if the filsz + offset taken from the
47525ead034SBrian Feldman 	 * header is greater than the actual file pager object's size.
47625ead034SBrian Feldman 	 * If we were to allow this, then the vm_map_find() below would
47725ead034SBrian Feldman 	 * walk right off the end of the file object and into the ether.
47825ead034SBrian Feldman 	 *
47925ead034SBrian Feldman 	 * While I'm here, might as well check for something else that
48025ead034SBrian Feldman 	 * is invalid: filsz cannot be greater than memsz.
48125ead034SBrian Feldman 	 */
482292177e6SAlan Cox 	if ((off_t)filsz + offset > imgp->attr->va_size || filsz > memsz) {
48325ead034SBrian Feldman 		uprintf("elf_load_section: truncated ELF file\n");
48425ead034SBrian Feldman 		return (ENOEXEC);
48525ead034SBrian Feldman 	}
48625ead034SBrian Feldman 
487292177e6SAlan Cox 	object = imgp->object;
488292177e6SAlan Cox 	map = &imgp->proc->p_vmspace->vm_map;
4893ebc1248SPeter Wemm 	map_addr = trunc_page_ps((vm_offset_t)vmaddr, pagesize);
4903ebc1248SPeter Wemm 	file_addr = trunc_page_ps(offset, pagesize);
491e1743d02SSøren Schmidt 
492e1743d02SSøren Schmidt 	/*
49352c24af7SPeter Wemm 	 * We have two choices.  We can either clear the data in the last page
49452c24af7SPeter Wemm 	 * of an oversized mapping, or we can start the anon mapping a page
49552c24af7SPeter Wemm 	 * early and copy the initialized data into that first page.  We
49652c24af7SPeter Wemm 	 * choose the second..
49752c24af7SPeter Wemm 	 */
49852c24af7SPeter Wemm 	if (memsz > filsz)
4993ebc1248SPeter Wemm 		map_len = trunc_page_ps(offset + filsz, pagesize) - file_addr;
50052c24af7SPeter Wemm 	else
5013ebc1248SPeter Wemm 		map_len = round_page_ps(offset + filsz, pagesize) - file_addr;
50252c24af7SPeter Wemm 
50352c24af7SPeter Wemm 	if (map_len != 0) {
504fa7dd9c5SMatthew Dillon 		/* cow flags: don't dump readonly sections in core */
505fa7dd9c5SMatthew Dillon 		cow = MAP_COPY_ON_WRITE | MAP_PREFAULT |
506fa7dd9c5SMatthew Dillon 		    (prot & VM_PROT_WRITE ? 0 : MAP_DISABLE_COREDUMP);
507fa7dd9c5SMatthew Dillon 
508292177e6SAlan Cox 		rv = __elfN(map_insert)(map,
50952c24af7SPeter Wemm 				      object,
51052c24af7SPeter Wemm 				      file_addr,	/* file offset */
51152c24af7SPeter Wemm 				      map_addr,		/* virtual start */
51252c24af7SPeter Wemm 				      map_addr + map_len,/* virtual end */
51352c24af7SPeter Wemm 				      prot,
514fa7dd9c5SMatthew Dillon 				      cow);
515e5e6093bSAlan Cox 		if (rv != KERN_SUCCESS)
516a7cddfedSJake Burkholder 			return (EINVAL);
51752c24af7SPeter Wemm 
51852c24af7SPeter Wemm 		/* we can stop now if we've covered it all */
51923955314SAlfred Perlstein 		if (memsz == filsz) {
520a7cddfedSJake Burkholder 			return (0);
52152c24af7SPeter Wemm 		}
52223955314SAlfred Perlstein 	}
52352c24af7SPeter Wemm 
52452c24af7SPeter Wemm 
52552c24af7SPeter Wemm 	/*
52652c24af7SPeter Wemm 	 * We have to get the remaining bit of the file into the first part
52752c24af7SPeter Wemm 	 * of the oversized map segment.  This is normally because the .data
52852c24af7SPeter Wemm 	 * segment in the file is extended to provide bss.  It's a neat idea
52952c24af7SPeter Wemm 	 * to try and save a page, but it's a pain in the behind to implement.
530e1743d02SSøren Schmidt 	 */
5313ebc1248SPeter Wemm 	copy_len = (offset + filsz) - trunc_page_ps(offset + filsz, pagesize);
5323ebc1248SPeter Wemm 	map_addr = trunc_page_ps((vm_offset_t)vmaddr + filsz, pagesize);
533ca0387efSJake Burkholder 	map_len = round_page_ps((vm_offset_t)vmaddr + memsz, pagesize) -
534ca0387efSJake Burkholder 	    map_addr;
535e1743d02SSøren Schmidt 
53652c24af7SPeter Wemm 	/* This had damn well better be true! */
5378191d577SPeter Wemm 	if (map_len != 0) {
538292177e6SAlan Cox 		rv = __elfN(map_insert)(map, NULL, 0, map_addr, map_addr +
539292177e6SAlan Cox 		    map_len, VM_PROT_ALL, 0);
54023955314SAlfred Perlstein 		if (rv != KERN_SUCCESS) {
541a7cddfedSJake Burkholder 			return (EINVAL);
5428191d577SPeter Wemm 		}
54323955314SAlfred Perlstein 	}
544e1743d02SSøren Schmidt 
54552c24af7SPeter Wemm 	if (copy_len != 0) {
5463ebc1248SPeter Wemm 		vm_offset_t off;
547da61b9a6SAlan Cox 
548da61b9a6SAlan Cox 		sf = vm_imgact_map_page(object, offset + filsz);
549da61b9a6SAlan Cox 		if (sf == NULL)
550da61b9a6SAlan Cox 			return (EIO);
551e1743d02SSøren Schmidt 
55252c24af7SPeter Wemm 		/* send the page fragment to user space */
55381f223caSJake Burkholder 		off = trunc_page_ps(offset + filsz, pagesize) -
55481f223caSJake Burkholder 		    trunc_page(offset + filsz);
555da61b9a6SAlan Cox 		error = copyout((caddr_t)sf_buf_kva(sf) + off,
556da61b9a6SAlan Cox 		    (caddr_t)map_addr, copy_len);
557be996836SAttilio Rao 		vm_imgact_unmap_page(sf);
55823955314SAlfred Perlstein 		if (error) {
55952c24af7SPeter Wemm 			return (error);
56052c24af7SPeter Wemm 		}
56123955314SAlfred Perlstein 	}
562e1743d02SSøren Schmidt 
563e1743d02SSøren Schmidt 	/*
5643ebc1248SPeter Wemm 	 * set it to the specified protection.
5653ebc1248SPeter Wemm 	 * XXX had better undo the damage from pasting over the cracks here!
566e1743d02SSøren Schmidt 	 */
567292177e6SAlan Cox 	vm_map_protect(map, trunc_page(map_addr), round_page(map_addr +
568292177e6SAlan Cox 	    map_len), prot, FALSE);
5698191d577SPeter Wemm 
570ff6f03c7SAlan Cox 	return (0);
571e1743d02SSøren Schmidt }
572e1743d02SSøren Schmidt 
573c33fe779SJohn Polstra /*
574c33fe779SJohn Polstra  * Load the file "file" into memory.  It may be either a shared object
575c33fe779SJohn Polstra  * or an executable.
576c33fe779SJohn Polstra  *
577c33fe779SJohn Polstra  * The "addr" reference parameter is in/out.  On entry, it specifies
578c33fe779SJohn Polstra  * the address where a shared object should be loaded.  If the file is
579c33fe779SJohn Polstra  * an executable, this value is ignored.  On exit, "addr" specifies
580c33fe779SJohn Polstra  * where the file was actually loaded.
581c33fe779SJohn Polstra  *
582c33fe779SJohn Polstra  * The "entry" reference parameter is out only.  On exit, it specifies
583c33fe779SJohn Polstra  * the entry point for the loaded file.
584c33fe779SJohn Polstra  */
585e1743d02SSøren Schmidt static int
5863ebc1248SPeter Wemm __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
5873ebc1248SPeter Wemm 	u_long *entry, size_t pagesize)
588e1743d02SSøren Schmidt {
589911c2be0SMark Peek 	struct {
590911c2be0SMark Peek 		struct nameidata nd;
591911c2be0SMark Peek 		struct vattr attr;
592911c2be0SMark Peek 		struct image_params image_params;
593911c2be0SMark Peek 	} *tempdata;
594d254af07SMatthew Dillon 	const Elf_Ehdr *hdr = NULL;
595d254af07SMatthew Dillon 	const Elf_Phdr *phdr = NULL;
596911c2be0SMark Peek 	struct nameidata *nd;
597911c2be0SMark Peek 	struct vattr *attr;
598911c2be0SMark Peek 	struct image_params *imgp;
59952c24af7SPeter Wemm 	vm_prot_t prot;
600c33fe779SJohn Polstra 	u_long rbase;
601c33fe779SJohn Polstra 	u_long base_addr = 0;
6025050aa86SKonstantin Belousov 	int error, i, numsegs;
603e1743d02SSøren Schmidt 
60412bc222eSJonathan Anderson #ifdef CAPABILITY_MODE
60512bc222eSJonathan Anderson 	/*
60612bc222eSJonathan Anderson 	 * XXXJA: This check can go away once we are sufficiently confident
60712bc222eSJonathan Anderson 	 * that the checks in namei() are correct.
60812bc222eSJonathan Anderson 	 */
60912bc222eSJonathan Anderson 	if (IN_CAPABILITY_MODE(curthread))
61012bc222eSJonathan Anderson 		return (ECAPMODE);
61112bc222eSJonathan Anderson #endif
61212bc222eSJonathan Anderson 
613a163d034SWarner Losh 	tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK);
614911c2be0SMark Peek 	nd = &tempdata->nd;
615911c2be0SMark Peek 	attr = &tempdata->attr;
616911c2be0SMark Peek 	imgp = &tempdata->image_params;
617911c2be0SMark Peek 
618c8a79999SPeter Wemm 	/*
619c8a79999SPeter Wemm 	 * Initialize part of the common data
620c8a79999SPeter Wemm 	 */
621c8a79999SPeter Wemm 	imgp->proc = p;
622911c2be0SMark Peek 	imgp->attr = attr;
623c8a79999SPeter Wemm 	imgp->firstpage = NULL;
62459c8bc40SAlan Cox 	imgp->image_header = NULL;
6250b2ed1aeSJeff Roberson 	imgp->object = NULL;
6266d7bdc8dSRobert Watson 	imgp->execlabel = NULL;
627c8a79999SPeter Wemm 
6285050aa86SKonstantin Belousov 	NDINIT(nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, file, curthread);
629911c2be0SMark Peek 	if ((error = namei(nd)) != 0) {
630911c2be0SMark Peek 		nd->ni_vp = NULL;
631e1743d02SSøren Schmidt 		goto fail;
632e1743d02SSøren Schmidt 	}
633911c2be0SMark Peek 	NDFREE(nd, NDF_ONLY_PNBUF);
634911c2be0SMark Peek 	imgp->vp = nd->ni_vp;
635c8a79999SPeter Wemm 
636e1743d02SSøren Schmidt 	/*
637e1743d02SSøren Schmidt 	 * Check permissions, modes, uid, etc on the file, and "open" it.
638e1743d02SSøren Schmidt 	 */
639c8a79999SPeter Wemm 	error = exec_check_permissions(imgp);
640373d1a3fSAlan Cox 	if (error)
641c8a79999SPeter Wemm 		goto fail;
642e1743d02SSøren Schmidt 
643c8a79999SPeter Wemm 	error = exec_map_first_page(imgp);
644373d1a3fSAlan Cox 	if (error)
645373d1a3fSAlan Cox 		goto fail;
646373d1a3fSAlan Cox 
64725ead034SBrian Feldman 	/*
64825ead034SBrian Feldman 	 * Also make certain that the interpreter stays the same, so set
649e6e370a7SJeff Roberson 	 * its VV_TEXT flag, too.
65025ead034SBrian Feldman 	 */
651877d24acSKonstantin Belousov 	VOP_SET_TEXT(nd->ni_vp);
652e6e370a7SJeff Roberson 
6538516dd18SPoul-Henning Kamp 	imgp->object = nd->ni_vp->v_object;
654e1743d02SSøren Schmidt 
655d254af07SMatthew Dillon 	hdr = (const Elf_Ehdr *)imgp->image_header;
6563ebc1248SPeter Wemm 	if ((error = __elfN(check_header)(hdr)) != 0)
657e1743d02SSøren Schmidt 		goto fail;
658c33fe779SJohn Polstra 	if (hdr->e_type == ET_DYN)
659c33fe779SJohn Polstra 		rbase = *addr;
660c33fe779SJohn Polstra 	else if (hdr->e_type == ET_EXEC)
661c33fe779SJohn Polstra 		rbase = 0;
662c33fe779SJohn Polstra 	else {
663c33fe779SJohn Polstra 		error = ENOEXEC;
664c33fe779SJohn Polstra 		goto fail;
665c33fe779SJohn Polstra 	}
666e1743d02SSøren Schmidt 
667c8a79999SPeter Wemm 	/* Only support headers that fit within first page for now      */
66852c24af7SPeter Wemm 	if ((hdr->e_phoff > PAGE_SIZE) ||
669d19d5bf4STijl Coosemans 	    (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) {
670c8a79999SPeter Wemm 		error = ENOEXEC;
671e1743d02SSøren Schmidt 		goto fail;
672c8a79999SPeter Wemm 	}
673c8a79999SPeter Wemm 
674d254af07SMatthew Dillon 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
67593d1c728SKonstantin Belousov 	if (!aligned(phdr, Elf_Addr)) {
67693d1c728SKonstantin Belousov 		error = ENOEXEC;
67793d1c728SKonstantin Belousov 		goto fail;
67893d1c728SKonstantin Belousov 	}
679e1743d02SSøren Schmidt 
680c33fe779SJohn Polstra 	for (i = 0, numsegs = 0; i < hdr->e_phnum; i++) {
6815b33842aSKonstantin Belousov 		if (phdr[i].p_type == PT_LOAD && phdr[i].p_memsz != 0) {
6825b33842aSKonstantin Belousov 			/* Loadable segment */
683ed167eaaSKonstantin Belousov 			prot = __elfN(trans_prot)(phdr[i].p_flags);
684292177e6SAlan Cox 			error = __elfN(load_section)(imgp, phdr[i].p_offset,
68581f223caSJake Burkholder 			    (caddr_t)(uintptr_t)phdr[i].p_vaddr + rbase,
686292177e6SAlan Cox 			    phdr[i].p_memsz, phdr[i].p_filesz, prot, pagesize);
687292177e6SAlan Cox 			if (error != 0)
688e1743d02SSøren Schmidt 				goto fail;
689e1743d02SSøren Schmidt 			/*
690c33fe779SJohn Polstra 			 * Establish the base address if this is the
691c33fe779SJohn Polstra 			 * first segment.
692e1743d02SSøren Schmidt 			 */
693c33fe779SJohn Polstra 			if (numsegs == 0)
694ca0387efSJake Burkholder   				base_addr = trunc_page(phdr[i].p_vaddr +
695ca0387efSJake Burkholder 				    rbase);
696c33fe779SJohn Polstra 			numsegs++;
697e1743d02SSøren Schmidt 		}
698e1743d02SSøren Schmidt 	}
699c33fe779SJohn Polstra 	*addr = base_addr;
700c33fe779SJohn Polstra 	*entry = (unsigned long)hdr->e_entry + rbase;
701e1743d02SSøren Schmidt 
702e1743d02SSøren Schmidt fail:
703c8a79999SPeter Wemm 	if (imgp->firstpage)
704c8a79999SPeter Wemm 		exec_unmap_first_page(imgp);
7050b2ed1aeSJeff Roberson 
706911c2be0SMark Peek 	if (nd->ni_vp)
707373d1a3fSAlan Cox 		vput(nd->ni_vp);
708911c2be0SMark Peek 
709911c2be0SMark Peek 	free(tempdata, M_TEMP);
710e1743d02SSøren Schmidt 
711a7cddfedSJake Burkholder 	return (error);
712e1743d02SSøren Schmidt }
713e1743d02SSøren Schmidt 
714303b270bSEivind Eklund static int
7153ebc1248SPeter Wemm __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
716e1743d02SSøren Schmidt {
717ecbb00a2SDoug Rabson 	const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
71832c01de2SDmitry Chagin 	const Elf_Phdr *phdr;
719e5e6093bSAlan Cox 	Elf_Auxargs *elf_auxargs;
7205856e12eSJohn Dyson 	struct vmspace *vmspace;
72152c24af7SPeter Wemm 	vm_prot_t prot;
72221c2d047SMatthew Dillon 	u_long text_size = 0, data_size = 0, total_size = 0;
723e1743d02SSøren Schmidt 	u_long text_addr = 0, data_addr = 0;
724cac45152SMatthew Dillon 	u_long seg_size, seg_addr;
7257564c4adSKonstantin Belousov 	u_long addr, baddr, et_dyn_addr, entry = 0, proghdr = 0;
72632c01de2SDmitry Chagin 	int32_t osrel = 0;
727d1ae5c83SKonstantin Belousov 	int error = 0, i, n, interp_name_len = 0;
7284113f8d7SPeter Wemm 	const char *interp = NULL, *newinterp = NULL;
729d1dbc694SJohn Polstra 	Elf_Brandinfo *brand_info;
730911c2be0SMark Peek 	char *path;
7315fe3ed62SJake Burkholder 	struct sysentvec *sv;
732e1743d02SSøren Schmidt 
733e1743d02SSøren Schmidt 	/*
734e1743d02SSøren Schmidt 	 * Do we have a valid ELF header ?
735900b28f9SMaxim Sobolev 	 *
736900b28f9SMaxim Sobolev 	 * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later
737900b28f9SMaxim Sobolev 	 * if particular brand doesn't support it.
738e1743d02SSøren Schmidt 	 */
739900b28f9SMaxim Sobolev 	if (__elfN(check_header)(hdr) != 0 ||
740900b28f9SMaxim Sobolev 	    (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN))
741a7cddfedSJake Burkholder 		return (-1);
742e1743d02SSøren Schmidt 
743e1743d02SSøren Schmidt 	/*
744e1743d02SSøren Schmidt 	 * From here on down, we return an errno, not -1, as we've
745e1743d02SSøren Schmidt 	 * detected an ELF file.
746e1743d02SSøren Schmidt 	 */
747e1743d02SSøren Schmidt 
748e1743d02SSøren Schmidt 	if ((hdr->e_phoff > PAGE_SIZE) ||
749d19d5bf4STijl Coosemans 	    (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) {
750c8a79999SPeter Wemm 		/* Only support headers in first page for now */
751a7cddfedSJake Burkholder 		return (ENOEXEC);
752e1743d02SSøren Schmidt 	}
75352c24af7SPeter Wemm 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
75493d1c728SKonstantin Belousov 	if (!aligned(phdr, Elf_Addr))
75593d1c728SKonstantin Belousov 		return (ENOEXEC);
7567564c4adSKonstantin Belousov 	n = 0;
7577564c4adSKonstantin Belousov 	baddr = 0;
7585fe3ed62SJake Burkholder 	for (i = 0; i < hdr->e_phnum; i++) {
759291c06a1SKonstantin Belousov 		switch (phdr[i].p_type) {
760291c06a1SKonstantin Belousov 		case PT_LOAD:
7617564c4adSKonstantin Belousov 			if (n == 0)
7627564c4adSKonstantin Belousov 				baddr = phdr[i].p_vaddr;
7637564c4adSKonstantin Belousov 			n++;
764291c06a1SKonstantin Belousov 			break;
765291c06a1SKonstantin Belousov 		case PT_INTERP:
766e5e6093bSAlan Cox 			/* Path to interpreter */
7675fe3ed62SJake Burkholder 			if (phdr[i].p_filesz > MAXPATHLEN ||
768d19d5bf4STijl Coosemans 			    phdr[i].p_offset > PAGE_SIZE ||
769d19d5bf4STijl Coosemans 			    phdr[i].p_filesz > PAGE_SIZE - phdr[i].p_offset)
77060bb3943SAlan Cox 				return (ENOEXEC);
7715fe3ed62SJake Burkholder 			interp = imgp->image_header + phdr[i].p_offset;
772d1ae5c83SKonstantin Belousov 			interp_name_len = phdr[i].p_filesz;
773291c06a1SKonstantin Belousov 			break;
774291c06a1SKonstantin Belousov 		case PT_GNU_STACK:
775291c06a1SKonstantin Belousov 			if (__elfN(nxstack))
776291c06a1SKonstantin Belousov 				imgp->stack_prot =
777291c06a1SKonstantin Belousov 				    __elfN(trans_prot)(phdr[i].p_flags);
778291c06a1SKonstantin Belousov 			break;
7793ebc1248SPeter Wemm 		}
7803ebc1248SPeter Wemm 	}
7813ebc1248SPeter Wemm 
782d1ae5c83SKonstantin Belousov 	brand_info = __elfN(get_brandinfo)(imgp, interp, interp_name_len,
783d1ae5c83SKonstantin Belousov 	    &osrel);
7845fe3ed62SJake Burkholder 	if (brand_info == NULL) {
7855fe3ed62SJake Burkholder 		uprintf("ELF binary type \"%u\" not known.\n",
7865fe3ed62SJake Burkholder 		    hdr->e_ident[EI_OSABI]);
78760bb3943SAlan Cox 		return (ENOEXEC);
7883ebc1248SPeter Wemm 	}
789ab02d85fSKonstantin Belousov 	if (hdr->e_type == ET_DYN) {
790ab02d85fSKonstantin Belousov 		if ((brand_info->flags & BI_CAN_EXEC_DYN) == 0)
791d49b2109SMaxim Sobolev 			return (ENOEXEC);
7927564c4adSKonstantin Belousov 		/*
7937564c4adSKonstantin Belousov 		 * Honour the base load address from the dso if it is
7947564c4adSKonstantin Belousov 		 * non-zero for some reason.
7957564c4adSKonstantin Belousov 		 */
7967564c4adSKonstantin Belousov 		if (baddr == 0)
797ab02d85fSKonstantin Belousov 			et_dyn_addr = ET_DYN_LOAD_ADDR;
7987564c4adSKonstantin Belousov 		else
7997564c4adSKonstantin Belousov 			et_dyn_addr = 0;
800ab02d85fSKonstantin Belousov 	} else
801ab02d85fSKonstantin Belousov 		et_dyn_addr = 0;
8025fe3ed62SJake Burkholder 	sv = brand_info->sysvec;
8039b68618dSPeter Wemm 	if (interp != NULL && brand_info->interp_newpath != NULL)
8044113f8d7SPeter Wemm 		newinterp = brand_info->interp_newpath;
8053ebc1248SPeter Wemm 
80660bb3943SAlan Cox 	/*
80760bb3943SAlan Cox 	 * Avoid a possible deadlock if the current address space is destroyed
80860bb3943SAlan Cox 	 * and that address space maps the locked vnode.  In the common case,
80960bb3943SAlan Cox 	 * the locked vnode's v_usecount is decremented but remains greater
81060bb3943SAlan Cox 	 * than zero.  Consequently, the vnode lock is not needed by vrele().
81160bb3943SAlan Cox 	 * However, in cases where the vnode lock is external, such as nullfs,
81260bb3943SAlan Cox 	 * v_usecount may become zero.
8131dfab802SAlan Cox 	 *
8141dfab802SAlan Cox 	 * The VV_TEXT flag prevents modifications to the executable while
8151dfab802SAlan Cox 	 * the vnode is unlocked.
81660bb3943SAlan Cox 	 */
81722db15c0SAttilio Rao 	VOP_UNLOCK(imgp->vp, 0);
81860bb3943SAlan Cox 
81989b57fcfSKonstantin Belousov 	error = exec_new_vmspace(imgp, sv);
82019059a13SJohn Baldwin 	imgp->proc->p_sysent = sv;
821e1743d02SSøren Schmidt 
822cb05b60aSAttilio Rao 	vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
82389b57fcfSKonstantin Belousov 	if (error)
82489b57fcfSKonstantin Belousov 		return (error);
82560bb3943SAlan Cox 
826e1743d02SSøren Schmidt 	for (i = 0; i < hdr->e_phnum; i++) {
827e1743d02SSøren Schmidt 		switch (phdr[i].p_type) {
828e1743d02SSøren Schmidt 		case PT_LOAD:	/* Loadable segment */
8295b33842aSKonstantin Belousov 			if (phdr[i].p_memsz == 0)
8305b33842aSKonstantin Belousov 				break;
831ed167eaaSKonstantin Belousov 			prot = __elfN(trans_prot)(phdr[i].p_flags);
832292177e6SAlan Cox 			error = __elfN(load_section)(imgp, phdr[i].p_offset,
833ab02d85fSKonstantin Belousov 			    (caddr_t)(uintptr_t)phdr[i].p_vaddr + et_dyn_addr,
83481f223caSJake Burkholder 			    phdr[i].p_memsz, phdr[i].p_filesz, prot,
835292177e6SAlan Cox 			    sv->sv_pagesize);
836292177e6SAlan Cox 			if (error != 0)
83760bb3943SAlan Cox 				return (error);
838e1743d02SSøren Schmidt 
839cfaf7e60SDoug Rabson 			/*
840cfaf7e60SDoug Rabson 			 * If this segment contains the program headers,
841cfaf7e60SDoug Rabson 			 * remember their virtual address for the AT_PHDR
842cfaf7e60SDoug Rabson 			 * aux entry. Static binaries don't usually include
843cfaf7e60SDoug Rabson 			 * a PT_PHDR entry.
844cfaf7e60SDoug Rabson 			 */
845cfaf7e60SDoug Rabson 			if (phdr[i].p_offset == 0 &&
846cfaf7e60SDoug Rabson 			    hdr->e_phoff + hdr->e_phnum * hdr->e_phentsize
847cfaf7e60SDoug Rabson 				<= phdr[i].p_filesz)
848ab02d85fSKonstantin Belousov 				proghdr = phdr[i].p_vaddr + hdr->e_phoff +
849ab02d85fSKonstantin Belousov 				    et_dyn_addr;
850cfaf7e60SDoug Rabson 
851ab02d85fSKonstantin Belousov 			seg_addr = trunc_page(phdr[i].p_vaddr + et_dyn_addr);
852cac45152SMatthew Dillon 			seg_size = round_page(phdr[i].p_memsz +
853ab02d85fSKonstantin Belousov 			    phdr[i].p_vaddr + et_dyn_addr - seg_addr);
854cac45152SMatthew Dillon 
855e1743d02SSøren Schmidt 			/*
856920acedbSNathan Whitehorn 			 * Make the largest executable segment the official
857920acedbSNathan Whitehorn 			 * text segment and all others data.
85821c2d047SMatthew Dillon 			 *
85921c2d047SMatthew Dillon 			 * Note that obreak() assumes that data_addr +
86021c2d047SMatthew Dillon 			 * data_size == end of data load area, and the ELF
86121c2d047SMatthew Dillon 			 * file format expects segments to be sorted by
86221c2d047SMatthew Dillon 			 * address.  If multiple data segments exist, the
86321c2d047SMatthew Dillon 			 * last one will be used.
864e1743d02SSøren Schmidt 			 */
865920acedbSNathan Whitehorn 
866920acedbSNathan Whitehorn 			if (phdr[i].p_flags & PF_X && text_size < seg_size) {
8679782ecbaSPeter Wemm 				text_size = seg_size;
8689782ecbaSPeter Wemm 				text_addr = seg_addr;
8699782ecbaSPeter Wemm 			} else {
87021c2d047SMatthew Dillon 				data_size = seg_size;
871cac45152SMatthew Dillon 				data_addr = seg_addr;
872cac45152SMatthew Dillon 			}
87321c2d047SMatthew Dillon 			total_size += seg_size;
87496725dd0SAlexander Kabaev 			break;
87596725dd0SAlexander Kabaev 		case PT_PHDR: 	/* Program header table info */
876ab02d85fSKonstantin Belousov 			proghdr = phdr[i].p_vaddr + et_dyn_addr;
87796725dd0SAlexander Kabaev 			break;
87896725dd0SAlexander Kabaev 		default:
87996725dd0SAlexander Kabaev 			break;
88096725dd0SAlexander Kabaev 		}
88196725dd0SAlexander Kabaev 	}
88296725dd0SAlexander Kabaev 
88396725dd0SAlexander Kabaev 	if (data_addr == 0 && data_size == 0) {
88496725dd0SAlexander Kabaev 		data_addr = text_addr;
88596725dd0SAlexander Kabaev 		data_size = text_size;
88696725dd0SAlexander Kabaev 	}
887cac45152SMatthew Dillon 
888920acedbSNathan Whitehorn 	entry = (u_long)hdr->e_entry + et_dyn_addr;
889920acedbSNathan Whitehorn 
890cac45152SMatthew Dillon 	/*
891cac45152SMatthew Dillon 	 * Check limits.  It should be safe to check the
89296725dd0SAlexander Kabaev 	 * limits after loading the segments since we do
89396725dd0SAlexander Kabaev 	 * not actually fault in all the segments pages.
894cac45152SMatthew Dillon 	 */
89591d5354aSJohn Baldwin 	PROC_LOCK(imgp->proc);
89691d5354aSJohn Baldwin 	if (data_size > lim_cur(imgp->proc, RLIMIT_DATA) ||
897cac45152SMatthew Dillon 	    text_size > maxtsiz ||
8981ba5ad42SEdward Tomasz Napierala 	    total_size > lim_cur(imgp->proc, RLIMIT_VMEM) ||
8991ba5ad42SEdward Tomasz Napierala 	    racct_set(imgp->proc, RACCT_DATA, data_size) != 0 ||
9001ba5ad42SEdward Tomasz Napierala 	    racct_set(imgp->proc, RACCT_VMEM, total_size) != 0) {
90191d5354aSJohn Baldwin 		PROC_UNLOCK(imgp->proc);
90260bb3943SAlan Cox 		return (ENOMEM);
903cac45152SMatthew Dillon 	}
904e1743d02SSøren Schmidt 
905292177e6SAlan Cox 	vmspace = imgp->proc->p_vmspace;
906e1743d02SSøren Schmidt 	vmspace->vm_tsize = text_size >> PAGE_SHIFT;
9077cd99438SBruce Evans 	vmspace->vm_taddr = (caddr_t)(uintptr_t)text_addr;
908e1743d02SSøren Schmidt 	vmspace->vm_dsize = data_size >> PAGE_SHIFT;
9097cd99438SBruce Evans 	vmspace->vm_daddr = (caddr_t)(uintptr_t)data_addr;
910e1743d02SSøren Schmidt 
911c460ac3aSPeter Wemm 	/*
912c460ac3aSPeter Wemm 	 * We load the dynamic linker where a userland call
913c460ac3aSPeter Wemm 	 * to mmap(0, ...) would put it.  The rationale behind this
914c460ac3aSPeter Wemm 	 * calculation is that it leaves room for the heap to grow to
915c460ac3aSPeter Wemm 	 * its maximum allowed size.
916c460ac3aSPeter Wemm 	 */
917292177e6SAlan Cox 	addr = round_page((vm_offset_t)vmspace->vm_daddr + lim_max(imgp->proc,
918292177e6SAlan Cox 	    RLIMIT_DATA));
91991d5354aSJohn Baldwin 	PROC_UNLOCK(imgp->proc);
920e1743d02SSøren Schmidt 
921ea5a2b2eSSøren Schmidt 	imgp->entry_addr = entry;
922ea5a2b2eSSøren Schmidt 
92360bb3943SAlan Cox 	if (interp != NULL) {
9244113f8d7SPeter Wemm 		int have_interp = FALSE;
92522db15c0SAttilio Rao 		VOP_UNLOCK(imgp->vp, 0);
92660bb3943SAlan Cox 		if (brand_info->emul_path != NULL &&
9279b68618dSPeter Wemm 		    brand_info->emul_path[0] != '\0') {
928a163d034SWarner Losh 			path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
92960bb3943SAlan Cox 			snprintf(path, MAXPATHLEN, "%s%s",
93060bb3943SAlan Cox 			    brand_info->emul_path, interp);
9319b68618dSPeter Wemm 			error = __elfN(load_file)(imgp->proc, path, &addr,
9329b68618dSPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
933911c2be0SMark Peek 			free(path, M_TEMP);
9349b68618dSPeter Wemm 			if (error == 0)
9354113f8d7SPeter Wemm 				have_interp = TRUE;
9369b68618dSPeter Wemm 		}
9374113f8d7SPeter Wemm 		if (!have_interp && newinterp != NULL) {
9384113f8d7SPeter Wemm 			error = __elfN(load_file)(imgp->proc, newinterp, &addr,
9394113f8d7SPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
940387ad998SKonstantin Belousov 			if (error == 0)
9414113f8d7SPeter Wemm 				have_interp = TRUE;
9424113f8d7SPeter Wemm 		}
9434113f8d7SPeter Wemm 		if (!have_interp) {
9449b68618dSPeter Wemm 			error = __elfN(load_file)(imgp->proc, interp, &addr,
9459b68618dSPeter Wemm 			    &imgp->entry_addr, sv->sv_pagesize);
94660bb3943SAlan Cox 		}
947cb05b60aSAttilio Rao 		vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
9489b68618dSPeter Wemm 		if (error != 0) {
9499b68618dSPeter Wemm 			uprintf("ELF interpreter %s not found\n", interp);
95060bb3943SAlan Cox 			return (error);
951e1743d02SSøren Schmidt 		}
95295c807cfSRobert Watson 	} else
9537564c4adSKonstantin Belousov 		addr = et_dyn_addr;
954ea5a2b2eSSøren Schmidt 
955e1743d02SSøren Schmidt 	/*
956e1743d02SSøren Schmidt 	 * Construct auxargs table (used by the fixup routine)
957e1743d02SSøren Schmidt 	 */
958a163d034SWarner Losh 	elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, M_WAITOK);
959e1743d02SSøren Schmidt 	elf_auxargs->execfd = -1;
960e1743d02SSøren Schmidt 	elf_auxargs->phdr = proghdr;
961e1743d02SSøren Schmidt 	elf_auxargs->phent = hdr->e_phentsize;
962e1743d02SSøren Schmidt 	elf_auxargs->phnum = hdr->e_phnum;
963e1743d02SSøren Schmidt 	elf_auxargs->pagesz = PAGE_SIZE;
964e1743d02SSøren Schmidt 	elf_auxargs->base = addr;
965e1743d02SSøren Schmidt 	elf_auxargs->flags = 0;
966e1743d02SSøren Schmidt 	elf_auxargs->entry = entry;
967e1743d02SSøren Schmidt 
968e1743d02SSøren Schmidt 	imgp->auxargs = elf_auxargs;
969e1743d02SSøren Schmidt 	imgp->interpreted = 0;
970a0ea661fSNathan Whitehorn 	imgp->reloc_base = addr;
97132c01de2SDmitry Chagin 	imgp->proc->p_osrel = osrel;
972f231de47SKonstantin Belousov 
973a7cddfedSJake Burkholder 	return (error);
974e1743d02SSøren Schmidt }
975e1743d02SSøren Schmidt 
976a360a43dSJake Burkholder #define	suword __CONCAT(suword, __ELF_WORD_SIZE)
9773ebc1248SPeter Wemm 
9783ebc1248SPeter Wemm int
9793ebc1248SPeter Wemm __elfN(freebsd_fixup)(register_t **stack_base, struct image_params *imgp)
980e1743d02SSøren Schmidt {
981ecbb00a2SDoug Rabson 	Elf_Auxargs *args = (Elf_Auxargs *)imgp->auxargs;
982a360a43dSJake Burkholder 	Elf_Addr *base;
983a360a43dSJake Burkholder 	Elf_Addr *pos;
984e1743d02SSøren Schmidt 
985a360a43dSJake Burkholder 	base = (Elf_Addr *)*stack_base;
986610ecfe0SMaxim Sobolev 	pos = base + (imgp->args->argc + imgp->args->envc + 2);
987e1743d02SSøren Schmidt 
98835c2a5a8SWarner Losh 	if (args->execfd != -1)
989e1743d02SSøren Schmidt 		AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
990e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
991e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
992e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
993e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
994e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
995e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
996e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_BASE, args->base);
9973ff06357SKonstantin Belousov 	if (imgp->execpathp != 0)
9983ff06357SKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_EXECPATH, imgp->execpathp);
999ee235befSKonstantin Belousov 	AUXARGS_ENTRY(pos, AT_OSRELDATE, osreldate);
1000ee235befSKonstantin Belousov 	if (imgp->canary != 0) {
1001ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_CANARY, imgp->canary);
1002ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_CANARYLEN, imgp->canarylen);
1003ee235befSKonstantin Belousov 	}
1004ee235befSKonstantin Belousov 	AUXARGS_ENTRY(pos, AT_NCPUS, mp_ncpus);
1005ee235befSKonstantin Belousov 	if (imgp->pagesizes != 0) {
1006ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_PAGESIZES, imgp->pagesizes);
1007ee235befSKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_PAGESIZESLEN, imgp->pagesizeslen);
1008ee235befSKonstantin Belousov 	}
1009aea81038SKonstantin Belousov 	if (imgp->sysent->sv_timekeep_base != 0) {
1010aea81038SKonstantin Belousov 		AUXARGS_ENTRY(pos, AT_TIMEKEEP,
1011aea81038SKonstantin Belousov 		    imgp->sysent->sv_timekeep_base);
1012aea81038SKonstantin Belousov 	}
101326d8f3e1SKonstantin Belousov 	AUXARGS_ENTRY(pos, AT_STACKPROT, imgp->sysent->sv_shared_page_obj
101426d8f3e1SKonstantin Belousov 	    != NULL && imgp->stack_prot != 0 ? imgp->stack_prot :
101526d8f3e1SKonstantin Belousov 	    imgp->sysent->sv_stackprot);
1016e1743d02SSøren Schmidt 	AUXARGS_ENTRY(pos, AT_NULL, 0);
1017e1743d02SSøren Schmidt 
1018e1743d02SSøren Schmidt 	free(imgp->auxargs, M_TEMP);
1019e1743d02SSøren Schmidt 	imgp->auxargs = NULL;
1020e1743d02SSøren Schmidt 
10213ebc1248SPeter Wemm 	base--;
1022610ecfe0SMaxim Sobolev 	suword(base, (long)imgp->args->argc);
10233ebc1248SPeter Wemm 	*stack_base = (register_t *)base;
1024a7cddfedSJake Burkholder 	return (0);
1025e1743d02SSøren Schmidt }
1026e1743d02SSøren Schmidt 
1027e1743d02SSøren Schmidt /*
10288c64af4fSJohn Polstra  * Code for generating ELF core dumps.
10298c64af4fSJohn Polstra  */
10308c64af4fSJohn Polstra 
10314d77a549SAlfred Perlstein typedef void (*segment_callback)(vm_map_entry_t, void *);
10320ff27d31SJohn Polstra 
10330ff27d31SJohn Polstra /* Closure for cb_put_phdr(). */
10340ff27d31SJohn Polstra struct phdr_closure {
10350ff27d31SJohn Polstra 	Elf_Phdr *phdr;		/* Program header to fill in */
10360ff27d31SJohn Polstra 	Elf_Off offset;		/* Offset of segment in core file */
10370ff27d31SJohn Polstra };
10380ff27d31SJohn Polstra 
10390ff27d31SJohn Polstra /* Closure for cb_size_segment(). */
10400ff27d31SJohn Polstra struct sseg_closure {
10410ff27d31SJohn Polstra 	int count;		/* Count of writable segments. */
10420ff27d31SJohn Polstra 	size_t size;		/* Total size of all writable segments. */
10430ff27d31SJohn Polstra };
10440ff27d31SJohn Polstra 
1045bd390213SMikolaj Golub typedef void (*outfunc_t)(void *, struct sbuf *, size_t *);
1046bd390213SMikolaj Golub 
1047bd390213SMikolaj Golub struct note_info {
1048bd390213SMikolaj Golub 	int		type;		/* Note type. */
1049bd390213SMikolaj Golub 	outfunc_t 	outfunc; 	/* Output function. */
1050bd390213SMikolaj Golub 	void		*outarg;	/* Argument for the output function. */
1051bd390213SMikolaj Golub 	size_t		outsize;	/* Output size. */
1052bd390213SMikolaj Golub 	TAILQ_ENTRY(note_info) link;	/* Link to the next note info. */
1053bd390213SMikolaj Golub };
1054bd390213SMikolaj Golub 
1055bd390213SMikolaj Golub TAILQ_HEAD(note_info_list, note_info);
1056bd390213SMikolaj Golub 
10574d77a549SAlfred Perlstein static void cb_put_phdr(vm_map_entry_t, void *);
10584d77a549SAlfred Perlstein static void cb_size_segment(vm_map_entry_t, void *);
1059247aba24SMarcel Moolenaar static void each_writable_segment(struct thread *, segment_callback, void *);
10603ebc1248SPeter Wemm static int __elfN(corehdr)(struct thread *, struct vnode *, struct ucred *,
1061bd390213SMikolaj Golub     int, void *, size_t, struct note_info_list *, size_t, gzFile);
1062bd390213SMikolaj Golub static void __elfN(prepare_notes)(struct thread *, struct note_info_list *,
1063bd390213SMikolaj Golub     size_t *);
1064bd390213SMikolaj Golub static void __elfN(puthdr)(struct thread *, void *, size_t, int, size_t);
1065bd390213SMikolaj Golub static void __elfN(putnote)(struct note_info *, struct sbuf *);
1066bd390213SMikolaj Golub static size_t register_note(struct note_info_list *, int, outfunc_t, void *);
1067bd390213SMikolaj Golub static int sbuf_drain_core_output(void *, const char *, int);
1068f1fca82eSMikolaj Golub static int sbuf_drain_count(void *arg, const char *data, int len);
1069bd390213SMikolaj Golub 
1070bd390213SMikolaj Golub static void __elfN(note_fpregset)(void *, struct sbuf *, size_t *);
1071bd390213SMikolaj Golub static void __elfN(note_prpsinfo)(void *, struct sbuf *, size_t *);
1072bd390213SMikolaj Golub static void __elfN(note_prstatus)(void *, struct sbuf *, size_t *);
1073bd390213SMikolaj Golub static void __elfN(note_threadmd)(void *, struct sbuf *, size_t *);
1074bd390213SMikolaj Golub static void __elfN(note_thrmisc)(void *, struct sbuf *, size_t *);
1075f1fca82eSMikolaj Golub static void __elfN(note_procstat_auxv)(void *, struct sbuf *, size_t *);
1076f1fca82eSMikolaj Golub static void __elfN(note_procstat_proc)(void *, struct sbuf *, size_t *);
1077f1fca82eSMikolaj Golub static void __elfN(note_procstat_psstrings)(void *, struct sbuf *, size_t *);
1078f1fca82eSMikolaj Golub static void note_procstat_files(void *, struct sbuf *, size_t *);
1079f1fca82eSMikolaj Golub static void note_procstat_groups(void *, struct sbuf *, size_t *);
1080f1fca82eSMikolaj Golub static void note_procstat_osrel(void *, struct sbuf *, size_t *);
1081f1fca82eSMikolaj Golub static void note_procstat_rlimit(void *, struct sbuf *, size_t *);
1082f1fca82eSMikolaj Golub static void note_procstat_umask(void *, struct sbuf *, size_t *);
1083f1fca82eSMikolaj Golub static void note_procstat_vmmap(void *, struct sbuf *, size_t *);
10848c64af4fSJohn Polstra 
1085e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
1086e7228204SAlfred Perlstein extern int compress_user_cores;
1087e7228204SAlfred Perlstein extern int compress_user_cores_gzlevel;
1088e7228204SAlfred Perlstein #endif
1089e7228204SAlfred Perlstein 
1090e7228204SAlfred Perlstein static int
1091e7228204SAlfred Perlstein core_output(struct vnode *vp, void *base, size_t len, off_t offset,
1092e7228204SAlfred Perlstein     struct ucred *active_cred, struct ucred *file_cred,
1093e7228204SAlfred Perlstein     struct thread *td, char *core_buf, gzFile gzfile) {
1094e7228204SAlfred Perlstein 
1095e7228204SAlfred Perlstein 	int error;
1096e7228204SAlfred Perlstein 	if (gzfile) {
1097e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
1098e7228204SAlfred Perlstein 		error = compress_core(gzfile, base, core_buf, len, td);
1099e7228204SAlfred Perlstein #else
1100e7228204SAlfred Perlstein 		panic("shouldn't be here");
1101e7228204SAlfred Perlstein #endif
1102e7228204SAlfred Perlstein 	} else {
1103e7228204SAlfred Perlstein 		error = vn_rdwr_inchunks(UIO_WRITE, vp, base, len, offset,
1104e7228204SAlfred Perlstein 		    UIO_USERSPACE, IO_UNIT | IO_DIRECT, active_cred, file_cred,
1105e7228204SAlfred Perlstein 		    NULL, td);
1106e7228204SAlfred Perlstein 	}
1107e7228204SAlfred Perlstein 	return (error);
1108e7228204SAlfred Perlstein }
1109e7228204SAlfred Perlstein 
1110bd390213SMikolaj Golub /* Coredump output parameters for sbuf drain routine. */
1111bd390213SMikolaj Golub struct sbuf_drain_core_params {
1112bd390213SMikolaj Golub 	off_t		offset;
1113bd390213SMikolaj Golub 	struct ucred	*active_cred;
1114bd390213SMikolaj Golub 	struct ucred	*file_cred;
1115bd390213SMikolaj Golub 	struct thread	*td;
1116bd390213SMikolaj Golub 	struct vnode	*vp;
1117bd390213SMikolaj Golub #ifdef COMPRESS_USER_CORES
1118bd390213SMikolaj Golub 	gzFile		gzfile;
1119bd390213SMikolaj Golub #endif
1120bd390213SMikolaj Golub };
1121bd390213SMikolaj Golub 
1122bd390213SMikolaj Golub /*
1123bd390213SMikolaj Golub  * Drain into a core file.
1124bd390213SMikolaj Golub  */
1125bd390213SMikolaj Golub static int
1126bd390213SMikolaj Golub sbuf_drain_core_output(void *arg, const char *data, int len)
1127bd390213SMikolaj Golub {
1128bd390213SMikolaj Golub 	struct sbuf_drain_core_params *p;
1129f1fca82eSMikolaj Golub 	int error, locked;
1130bd390213SMikolaj Golub 
1131bd390213SMikolaj Golub 	p = (struct sbuf_drain_core_params *)arg;
1132f1fca82eSMikolaj Golub 
1133f1fca82eSMikolaj Golub 	/*
1134f1fca82eSMikolaj Golub 	 * Some kern_proc out routines that print to this sbuf may
1135f1fca82eSMikolaj Golub 	 * call us with the process lock held. Draining with the
1136f1fca82eSMikolaj Golub 	 * non-sleepable lock held is unsafe. The lock is needed for
1137f1fca82eSMikolaj Golub 	 * those routines when dumping a live process. In our case we
1138f1fca82eSMikolaj Golub 	 * can safely release the lock before draining and acquire
1139f1fca82eSMikolaj Golub 	 * again after.
1140f1fca82eSMikolaj Golub 	 */
1141f1fca82eSMikolaj Golub 	locked = PROC_LOCKED(p->td->td_proc);
1142f1fca82eSMikolaj Golub 	if (locked)
1143f1fca82eSMikolaj Golub 		PROC_UNLOCK(p->td->td_proc);
1144bd390213SMikolaj Golub #ifdef COMPRESS_USER_CORES
1145bd390213SMikolaj Golub 	if (p->gzfile != Z_NULL)
1146bd390213SMikolaj Golub 		error = compress_core(p->gzfile, NULL, __DECONST(char *, data),
1147bd390213SMikolaj Golub 		    len, p->td);
1148bd390213SMikolaj Golub 	else
1149bd390213SMikolaj Golub #endif
1150bd390213SMikolaj Golub 		error = vn_rdwr_inchunks(UIO_WRITE, p->vp,
1151bd390213SMikolaj Golub 		    __DECONST(void *, data), len, p->offset, UIO_SYSSPACE,
1152bd390213SMikolaj Golub 		    IO_UNIT | IO_DIRECT, p->active_cred, p->file_cred, NULL,
1153bd390213SMikolaj Golub 		    p->td);
1154f1fca82eSMikolaj Golub 	if (locked)
1155f1fca82eSMikolaj Golub 		PROC_LOCK(p->td->td_proc);
1156bd390213SMikolaj Golub 	if (error != 0)
1157bd390213SMikolaj Golub 		return (-error);
1158bd390213SMikolaj Golub 	p->offset += len;
1159bd390213SMikolaj Golub 	return (len);
1160bd390213SMikolaj Golub }
1161bd390213SMikolaj Golub 
1162f1fca82eSMikolaj Golub /*
1163f1fca82eSMikolaj Golub  * Drain into a counter.
1164f1fca82eSMikolaj Golub  */
1165f1fca82eSMikolaj Golub static int
1166f1fca82eSMikolaj Golub sbuf_drain_count(void *arg, const char *data __unused, int len)
1167f1fca82eSMikolaj Golub {
1168f1fca82eSMikolaj Golub 	size_t *sizep;
1169f1fca82eSMikolaj Golub 
1170f1fca82eSMikolaj Golub 	sizep = (size_t *)arg;
1171f1fca82eSMikolaj Golub 	*sizep += len;
1172f1fca82eSMikolaj Golub 	return (len);
1173f1fca82eSMikolaj Golub }
1174f1fca82eSMikolaj Golub 
11758c64af4fSJohn Polstra int
1176e7228204SAlfred Perlstein __elfN(coredump)(struct thread *td, struct vnode *vp, off_t limit, int flags)
1177fca666a1SJulian Elischer {
1178247aba24SMarcel Moolenaar 	struct ucred *cred = td->td_ucred;
1179fca666a1SJulian Elischer 	int error = 0;
11800ff27d31SJohn Polstra 	struct sseg_closure seginfo;
1181bd390213SMikolaj Golub 	struct note_info_list notelst;
1182bd390213SMikolaj Golub 	struct note_info *ninfo;
11830ff27d31SJohn Polstra 	void *hdr;
1184bd390213SMikolaj Golub 	size_t hdrsize, notesz, coresize;
11858c64af4fSJohn Polstra 
1186e7228204SAlfred Perlstein 	gzFile gzfile = Z_NULL;
1187e7228204SAlfred Perlstein 	char *core_buf = NULL;
1188e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
1189e7228204SAlfred Perlstein 	char gzopen_flags[8];
1190e7228204SAlfred Perlstein 	char *p;
1191e7228204SAlfred Perlstein 	int doing_compress = flags & IMGACT_CORE_COMPRESS;
1192e7228204SAlfred Perlstein #endif
1193e7228204SAlfred Perlstein 
1194e7228204SAlfred Perlstein 	hdr = NULL;
1195bd390213SMikolaj Golub 	TAILQ_INIT(&notelst);
1196e7228204SAlfred Perlstein 
1197e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
1198e7228204SAlfred Perlstein         if (doing_compress) {
1199e7228204SAlfred Perlstein                 p = gzopen_flags;
1200e7228204SAlfred Perlstein                 *p++ = 'w';
1201e7228204SAlfred Perlstein                 if (compress_user_cores_gzlevel >= 0 &&
1202e7228204SAlfred Perlstein                     compress_user_cores_gzlevel <= 9)
1203e7228204SAlfred Perlstein                         *p++ = '0' + compress_user_cores_gzlevel;
1204e7228204SAlfred Perlstein                 *p = 0;
1205e7228204SAlfred Perlstein                 gzfile = gz_open("", gzopen_flags, vp);
1206e7228204SAlfred Perlstein                 if (gzfile == Z_NULL) {
1207e7228204SAlfred Perlstein                         error = EFAULT;
1208e7228204SAlfred Perlstein                         goto done;
1209e7228204SAlfred Perlstein                 }
1210e7228204SAlfred Perlstein                 core_buf = malloc(CORE_BUF_SIZE, M_TEMP, M_WAITOK | M_ZERO);
1211e7228204SAlfred Perlstein                 if (!core_buf) {
1212e7228204SAlfred Perlstein                         error = ENOMEM;
1213e7228204SAlfred Perlstein                         goto done;
1214e7228204SAlfred Perlstein                 }
1215e7228204SAlfred Perlstein         }
1216e7228204SAlfred Perlstein #endif
1217e7228204SAlfred Perlstein 
12180ff27d31SJohn Polstra 	/* Size the program segments. */
12190ff27d31SJohn Polstra 	seginfo.count = 0;
12200ff27d31SJohn Polstra 	seginfo.size = 0;
1221247aba24SMarcel Moolenaar 	each_writable_segment(td, cb_size_segment, &seginfo);
12220ff27d31SJohn Polstra 
12230ff27d31SJohn Polstra 	/*
1224bd390213SMikolaj Golub 	 * Collect info about the core file header area.
12250ff27d31SJohn Polstra 	 */
1226bd390213SMikolaj Golub 	hdrsize = sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * (1 + seginfo.count);
1227bd390213SMikolaj Golub 	__elfN(prepare_notes)(td, &notelst, &notesz);
1228bd390213SMikolaj Golub 	coresize = round_page(hdrsize + notesz) + seginfo.size;
12290ff27d31SJohn Polstra 
1230afcc55f3SEdward Tomasz Napierala #ifdef RACCT
12311ba5ad42SEdward Tomasz Napierala 	PROC_LOCK(td->td_proc);
1232bd390213SMikolaj Golub 	error = racct_add(td->td_proc, RACCT_CORE, coresize);
12331ba5ad42SEdward Tomasz Napierala 	PROC_UNLOCK(td->td_proc);
12341ba5ad42SEdward Tomasz Napierala 	if (error != 0) {
12351ba5ad42SEdward Tomasz Napierala 		error = EFAULT;
12361ba5ad42SEdward Tomasz Napierala 		goto done;
12371ba5ad42SEdward Tomasz Napierala 	}
1238afcc55f3SEdward Tomasz Napierala #endif
1239bd390213SMikolaj Golub 	if (coresize >= limit) {
1240fba6b1afSAlfred Perlstein 		error = EFAULT;
1241fba6b1afSAlfred Perlstein 		goto done;
1242fba6b1afSAlfred Perlstein 	}
12430ff27d31SJohn Polstra 
12440ff27d31SJohn Polstra 	/*
12450ff27d31SJohn Polstra 	 * Allocate memory for building the header, fill it up,
1246bd390213SMikolaj Golub 	 * and write it out following the notes.
12470ff27d31SJohn Polstra 	 */
1248a163d034SWarner Losh 	hdr = malloc(hdrsize, M_TEMP, M_WAITOK);
12490ff27d31SJohn Polstra 	if (hdr == NULL) {
1250fba6b1afSAlfred Perlstein 		error = EINVAL;
1251fba6b1afSAlfred Perlstein 		goto done;
12520ff27d31SJohn Polstra 	}
1253e7228204SAlfred Perlstein 	error = __elfN(corehdr)(td, vp, cred, seginfo.count, hdr, hdrsize,
1254bd390213SMikolaj Golub 	    &notelst, notesz, gzfile);
12550ff27d31SJohn Polstra 
12560ff27d31SJohn Polstra 	/* Write the contents of all of the writable segments. */
12570ff27d31SJohn Polstra 	if (error == 0) {
12580ff27d31SJohn Polstra 		Elf_Phdr *php;
12592b471bc6STim J. Robbins 		off_t offset;
12600ff27d31SJohn Polstra 		int i;
12610ff27d31SJohn Polstra 
12620ff27d31SJohn Polstra 		php = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr)) + 1;
1263bd390213SMikolaj Golub 		offset = round_page(hdrsize + notesz);
12640ff27d31SJohn Polstra 		for (i = 0; i < seginfo.count; i++) {
1265e7228204SAlfred Perlstein 			error = core_output(vp, (caddr_t)(uintptr_t)php->p_vaddr,
1266e7228204SAlfred Perlstein 			    php->p_filesz, offset, cred, NOCRED, curthread, core_buf, gzfile);
12670ff27d31SJohn Polstra 			if (error != 0)
12682b471bc6STim J. Robbins 				break;
12690ff27d31SJohn Polstra 			offset += php->p_filesz;
12700ff27d31SJohn Polstra 			php++;
12710ff27d31SJohn Polstra 		}
12720ff27d31SJohn Polstra 	}
1273e7228204SAlfred Perlstein 	if (error) {
1274e7228204SAlfred Perlstein 		log(LOG_WARNING,
1275e7228204SAlfred Perlstein 		    "Failed to write core file for process %s (error %d)\n",
1276e7228204SAlfred Perlstein 		    curproc->p_comm, error);
1277e7228204SAlfred Perlstein 	}
1278e7228204SAlfred Perlstein 
1279e7228204SAlfred Perlstein done:
1280fba6b1afSAlfred Perlstein #ifdef COMPRESS_USER_CORES
1281e7228204SAlfred Perlstein 	if (core_buf)
1282e7228204SAlfred Perlstein 		free(core_buf, M_TEMP);
1283e7228204SAlfred Perlstein 	if (gzfile)
1284e7228204SAlfred Perlstein 		gzclose(gzfile);
12858b325009SAlfred Perlstein #endif
1286bd390213SMikolaj Golub 	while ((ninfo = TAILQ_FIRST(&notelst)) != NULL) {
1287bd390213SMikolaj Golub 		TAILQ_REMOVE(&notelst, ninfo, link);
1288bd390213SMikolaj Golub 		free(ninfo, M_TEMP);
1289bd390213SMikolaj Golub 	}
1290bd390213SMikolaj Golub 	if (hdr != NULL)
12910ff27d31SJohn Polstra 		free(hdr, M_TEMP);
12920ff27d31SJohn Polstra 
1293a7cddfedSJake Burkholder 	return (error);
12948c64af4fSJohn Polstra }
12958c64af4fSJohn Polstra 
12960ff27d31SJohn Polstra /*
12970ff27d31SJohn Polstra  * A callback for each_writable_segment() to write out the segment's
12980ff27d31SJohn Polstra  * program header entry.
12990ff27d31SJohn Polstra  */
13000ff27d31SJohn Polstra static void
13010ff27d31SJohn Polstra cb_put_phdr(entry, closure)
13020ff27d31SJohn Polstra 	vm_map_entry_t entry;
13030ff27d31SJohn Polstra 	void *closure;
13040ff27d31SJohn Polstra {
13050ff27d31SJohn Polstra 	struct phdr_closure *phc = (struct phdr_closure *)closure;
13060ff27d31SJohn Polstra 	Elf_Phdr *phdr = phc->phdr;
13070ff27d31SJohn Polstra 
13080ff27d31SJohn Polstra 	phc->offset = round_page(phc->offset);
13090ff27d31SJohn Polstra 
13100ff27d31SJohn Polstra 	phdr->p_type = PT_LOAD;
13110ff27d31SJohn Polstra 	phdr->p_offset = phc->offset;
13120ff27d31SJohn Polstra 	phdr->p_vaddr = entry->start;
13130ff27d31SJohn Polstra 	phdr->p_paddr = 0;
13140ff27d31SJohn Polstra 	phdr->p_filesz = phdr->p_memsz = entry->end - entry->start;
13150ff27d31SJohn Polstra 	phdr->p_align = PAGE_SIZE;
1316ed167eaaSKonstantin Belousov 	phdr->p_flags = __elfN(untrans_prot)(entry->protection);
13170ff27d31SJohn Polstra 
13180ff27d31SJohn Polstra 	phc->offset += phdr->p_filesz;
13190ff27d31SJohn Polstra 	phc->phdr++;
13200ff27d31SJohn Polstra }
13210ff27d31SJohn Polstra 
13220ff27d31SJohn Polstra /*
13230ff27d31SJohn Polstra  * A callback for each_writable_segment() to gather information about
13240ff27d31SJohn Polstra  * the number of segments and their total size.
13250ff27d31SJohn Polstra  */
13260ff27d31SJohn Polstra static void
13270ff27d31SJohn Polstra cb_size_segment(entry, closure)
13280ff27d31SJohn Polstra 	vm_map_entry_t entry;
13290ff27d31SJohn Polstra 	void *closure;
13300ff27d31SJohn Polstra {
13310ff27d31SJohn Polstra 	struct sseg_closure *ssc = (struct sseg_closure *)closure;
13320ff27d31SJohn Polstra 
13330ff27d31SJohn Polstra 	ssc->count++;
13340ff27d31SJohn Polstra 	ssc->size += entry->end - entry->start;
13350ff27d31SJohn Polstra }
13360ff27d31SJohn Polstra 
13370ff27d31SJohn Polstra /*
13380ff27d31SJohn Polstra  * For each writable segment in the process's memory map, call the given
13390ff27d31SJohn Polstra  * function with a pointer to the map entry and some arbitrary
13400ff27d31SJohn Polstra  * caller-supplied data.
13410ff27d31SJohn Polstra  */
13420ff27d31SJohn Polstra static void
1343247aba24SMarcel Moolenaar each_writable_segment(td, func, closure)
1344247aba24SMarcel Moolenaar 	struct thread *td;
13450ff27d31SJohn Polstra 	segment_callback func;
13460ff27d31SJohn Polstra 	void *closure;
13470ff27d31SJohn Polstra {
1348247aba24SMarcel Moolenaar 	struct proc *p = td->td_proc;
13490ff27d31SJohn Polstra 	vm_map_t map = &p->p_vmspace->vm_map;
13500ff27d31SJohn Polstra 	vm_map_entry_t entry;
1351976a87a2SAlan Cox 	vm_object_t backing_object, object;
1352976a87a2SAlan Cox 	boolean_t ignore_entry;
13530ff27d31SJohn Polstra 
1354976a87a2SAlan Cox 	vm_map_lock_read(map);
13550ff27d31SJohn Polstra 	for (entry = map->header.next; entry != &map->header;
13560ff27d31SJohn Polstra 	    entry = entry->next) {
1357fa7dd9c5SMatthew Dillon 		/*
1358fa7dd9c5SMatthew Dillon 		 * Don't dump inaccessible mappings, deal with legacy
1359fa7dd9c5SMatthew Dillon 		 * coredump mode.
1360fa7dd9c5SMatthew Dillon 		 *
1361fa7dd9c5SMatthew Dillon 		 * Note that read-only segments related to the elf binary
1362fa7dd9c5SMatthew Dillon 		 * are marked MAP_ENTRY_NOCOREDUMP now so we no longer
1363fa7dd9c5SMatthew Dillon 		 * need to arbitrarily ignore such segments.
1364fa7dd9c5SMatthew Dillon 		 */
1365fa7dd9c5SMatthew Dillon 		if (elf_legacy_coredump) {
1366fa7dd9c5SMatthew Dillon 			if ((entry->protection & VM_PROT_RW) != VM_PROT_RW)
13670ff27d31SJohn Polstra 				continue;
1368fa7dd9c5SMatthew Dillon 		} else {
1369fa7dd9c5SMatthew Dillon 			if ((entry->protection & VM_PROT_ALL) == 0)
1370fa7dd9c5SMatthew Dillon 				continue;
1371fa7dd9c5SMatthew Dillon 		}
13720ff27d31SJohn Polstra 
13739730a5daSPaul Saab 		/*
1374fa7dd9c5SMatthew Dillon 		 * Dont include memory segment in the coredump if
1375fa7dd9c5SMatthew Dillon 		 * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
1376fa7dd9c5SMatthew Dillon 		 * madvise(2).  Do not dump submaps (i.e. parts of the
1377fa7dd9c5SMatthew Dillon 		 * kernel map).
13789730a5daSPaul Saab 		 */
1379fa7dd9c5SMatthew Dillon 		if (entry->eflags & (MAP_ENTRY_NOCOREDUMP|MAP_ENTRY_IS_SUB_MAP))
13809730a5daSPaul Saab 			continue;
13819730a5daSPaul Saab 
1382976a87a2SAlan Cox 		if ((object = entry->object.vm_object) == NULL)
13830ff27d31SJohn Polstra 			continue;
13840ff27d31SJohn Polstra 
13850ff27d31SJohn Polstra 		/* Ignore memory-mapped devices and such things. */
1386bc403f03SAttilio Rao 		VM_OBJECT_RLOCK(object);
1387976a87a2SAlan Cox 		while ((backing_object = object->backing_object) != NULL) {
1388bc403f03SAttilio Rao 			VM_OBJECT_RLOCK(backing_object);
1389bc403f03SAttilio Rao 			VM_OBJECT_RUNLOCK(object);
1390976a87a2SAlan Cox 			object = backing_object;
1391976a87a2SAlan Cox 		}
1392976a87a2SAlan Cox 		ignore_entry = object->type != OBJT_DEFAULT &&
1393976a87a2SAlan Cox 		    object->type != OBJT_SWAP && object->type != OBJT_VNODE;
1394bc403f03SAttilio Rao 		VM_OBJECT_RUNLOCK(object);
1395976a87a2SAlan Cox 		if (ignore_entry)
13960ff27d31SJohn Polstra 			continue;
13970ff27d31SJohn Polstra 
13980ff27d31SJohn Polstra 		(*func)(entry, closure);
13990ff27d31SJohn Polstra 	}
1400976a87a2SAlan Cox 	vm_map_unlock_read(map);
14010ff27d31SJohn Polstra }
14020ff27d31SJohn Polstra 
14030ff27d31SJohn Polstra /*
14040ff27d31SJohn Polstra  * Write the core file header to the file, including padding up to
14050ff27d31SJohn Polstra  * the page boundary.
14060ff27d31SJohn Polstra  */
14078c64af4fSJohn Polstra static int
1408bd390213SMikolaj Golub __elfN(corehdr)(struct thread *td, struct vnode *vp, struct ucred *cred,
1409bd390213SMikolaj Golub     int numsegs, void *hdr, size_t hdrsize, struct note_info_list *notelst,
1410bd390213SMikolaj Golub     size_t notesz, gzFile gzfile)
14118c64af4fSJohn Polstra {
1412bd390213SMikolaj Golub 	struct sbuf_drain_core_params params;
1413bd390213SMikolaj Golub 	struct note_info *ninfo;
1414bd390213SMikolaj Golub 	struct sbuf *sb;
1415bd390213SMikolaj Golub 	int error;
14168c64af4fSJohn Polstra 
14178c64af4fSJohn Polstra 	/* Fill in the header. */
14180ff27d31SJohn Polstra 	bzero(hdr, hdrsize);
1419bd390213SMikolaj Golub 	__elfN(puthdr)(td, hdr, hdrsize, numsegs, notesz);
14208c64af4fSJohn Polstra 
1421bd390213SMikolaj Golub 	params.offset = 0;
1422bd390213SMikolaj Golub 	params.active_cred = cred;
1423bd390213SMikolaj Golub 	params.file_cred = NOCRED;
1424bd390213SMikolaj Golub 	params.td = td;
1425bd390213SMikolaj Golub 	params.vp = vp;
1426e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
1427bd390213SMikolaj Golub 	params.gzfile = gzfile;
1428e7228204SAlfred Perlstein #endif
1429bd390213SMikolaj Golub 	sb = sbuf_new(NULL, NULL, CORE_BUF_SIZE, SBUF_FIXEDLEN);
1430bd390213SMikolaj Golub 	sbuf_set_drain(sb, sbuf_drain_core_output, &params);
1431bd390213SMikolaj Golub 	sbuf_start_section(sb, NULL);
1432bd390213SMikolaj Golub 	sbuf_bcat(sb, hdr, hdrsize);
1433bd390213SMikolaj Golub 	TAILQ_FOREACH(ninfo, notelst, link)
1434bd390213SMikolaj Golub 	    __elfN(putnote)(ninfo, sb);
1435bd390213SMikolaj Golub 	/* Align up to a page boundary for the program segments. */
1436bd390213SMikolaj Golub 	sbuf_end_section(sb, -1, PAGE_SIZE, 0);
1437bd390213SMikolaj Golub 	error = sbuf_finish(sb);
1438bd390213SMikolaj Golub 	sbuf_delete(sb);
1439bd390213SMikolaj Golub 
1440bd390213SMikolaj Golub 	return (error);
1441e7228204SAlfred Perlstein }
1442bd390213SMikolaj Golub 
1443bd390213SMikolaj Golub static void
1444bd390213SMikolaj Golub __elfN(prepare_notes)(struct thread *td, struct note_info_list *list,
1445bd390213SMikolaj Golub     size_t *sizep)
1446bd390213SMikolaj Golub {
1447bd390213SMikolaj Golub 	struct proc *p;
1448bd390213SMikolaj Golub 	struct thread *thr;
1449bd390213SMikolaj Golub 	size_t size;
1450bd390213SMikolaj Golub 
1451bd390213SMikolaj Golub 	p = td->td_proc;
1452bd390213SMikolaj Golub 	size = 0;
1453bd390213SMikolaj Golub 
1454bd390213SMikolaj Golub 	size += register_note(list, NT_PRPSINFO, __elfN(note_prpsinfo), p);
1455bd390213SMikolaj Golub 
1456bd390213SMikolaj Golub 	/*
1457bd390213SMikolaj Golub 	 * To have the debugger select the right thread (LWP) as the initial
1458bd390213SMikolaj Golub 	 * thread, we dump the state of the thread passed to us in td first.
1459bd390213SMikolaj Golub 	 * This is the thread that causes the core dump and thus likely to
1460bd390213SMikolaj Golub 	 * be the right thread one wants to have selected in the debugger.
1461bd390213SMikolaj Golub 	 */
1462bd390213SMikolaj Golub 	thr = td;
1463bd390213SMikolaj Golub 	while (thr != NULL) {
1464bd390213SMikolaj Golub 		size += register_note(list, NT_PRSTATUS,
1465bd390213SMikolaj Golub 		    __elfN(note_prstatus), thr);
1466bd390213SMikolaj Golub 		size += register_note(list, NT_FPREGSET,
1467bd390213SMikolaj Golub 		    __elfN(note_fpregset), thr);
1468bd390213SMikolaj Golub 		size += register_note(list, NT_THRMISC,
1469bd390213SMikolaj Golub 		    __elfN(note_thrmisc), thr);
1470bd390213SMikolaj Golub 		size += register_note(list, -1,
1471bd390213SMikolaj Golub 		    __elfN(note_threadmd), thr);
1472bd390213SMikolaj Golub 
1473bd390213SMikolaj Golub 		thr = (thr == td) ? TAILQ_FIRST(&p->p_threads) :
1474bd390213SMikolaj Golub 		    TAILQ_NEXT(thr, td_plist);
1475bd390213SMikolaj Golub 		if (thr == td)
1476bd390213SMikolaj Golub 			thr = TAILQ_NEXT(thr, td_plist);
1477dada0278SJohn Polstra 	}
1478dada0278SJohn Polstra 
1479f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_PROC,
1480f1fca82eSMikolaj Golub 	    __elfN(note_procstat_proc), p);
1481f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_FILES,
1482f1fca82eSMikolaj Golub 	    note_procstat_files, p);
1483f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_VMMAP,
1484f1fca82eSMikolaj Golub 	    note_procstat_vmmap, p);
1485f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_GROUPS,
1486f1fca82eSMikolaj Golub 	    note_procstat_groups, p);
1487f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_UMASK,
1488f1fca82eSMikolaj Golub 	    note_procstat_umask, p);
1489f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_RLIMIT,
1490f1fca82eSMikolaj Golub 	    note_procstat_rlimit, p);
1491f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_OSREL,
1492f1fca82eSMikolaj Golub 	    note_procstat_osrel, p);
1493f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_PSSTRINGS,
1494f1fca82eSMikolaj Golub 	    __elfN(note_procstat_psstrings), p);
1495f1fca82eSMikolaj Golub 	size += register_note(list, NT_PROCSTAT_AUXV,
1496f1fca82eSMikolaj Golub 	    __elfN(note_procstat_auxv), p);
1497f1fca82eSMikolaj Golub 
1498bd390213SMikolaj Golub 	*sizep = size;
1499bd390213SMikolaj Golub }
1500bd390213SMikolaj Golub 
1501bd390213SMikolaj Golub static void
1502bd390213SMikolaj Golub __elfN(puthdr)(struct thread *td, void *hdr, size_t hdrsize, int numsegs,
1503bd390213SMikolaj Golub     size_t notesz)
1504bd390213SMikolaj Golub {
1505bd390213SMikolaj Golub 	Elf_Ehdr *ehdr;
1506bd390213SMikolaj Golub 	Elf_Phdr *phdr;
1507bd390213SMikolaj Golub 	struct phdr_closure phc;
1508bd390213SMikolaj Golub 
1509bd390213SMikolaj Golub 	ehdr = (Elf_Ehdr *)hdr;
1510bd390213SMikolaj Golub 	phdr = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr));
1511bd390213SMikolaj Golub 
1512bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG0] = ELFMAG0;
1513bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG1] = ELFMAG1;
1514bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG2] = ELFMAG2;
1515bd390213SMikolaj Golub 	ehdr->e_ident[EI_MAG3] = ELFMAG3;
1516bd390213SMikolaj Golub 	ehdr->e_ident[EI_CLASS] = ELF_CLASS;
1517bd390213SMikolaj Golub 	ehdr->e_ident[EI_DATA] = ELF_DATA;
1518bd390213SMikolaj Golub 	ehdr->e_ident[EI_VERSION] = EV_CURRENT;
1519bd390213SMikolaj Golub 	ehdr->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
1520bd390213SMikolaj Golub 	ehdr->e_ident[EI_ABIVERSION] = 0;
1521bd390213SMikolaj Golub 	ehdr->e_ident[EI_PAD] = 0;
1522bd390213SMikolaj Golub 	ehdr->e_type = ET_CORE;
1523bd390213SMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1524bd390213SMikolaj Golub 	ehdr->e_machine = ELF_ARCH32;
1525bd390213SMikolaj Golub #else
1526bd390213SMikolaj Golub 	ehdr->e_machine = ELF_ARCH;
1527bd390213SMikolaj Golub #endif
1528bd390213SMikolaj Golub 	ehdr->e_version = EV_CURRENT;
1529bd390213SMikolaj Golub 	ehdr->e_entry = 0;
1530bd390213SMikolaj Golub 	ehdr->e_phoff = sizeof(Elf_Ehdr);
1531bd390213SMikolaj Golub 	ehdr->e_flags = 0;
1532bd390213SMikolaj Golub 	ehdr->e_ehsize = sizeof(Elf_Ehdr);
1533bd390213SMikolaj Golub 	ehdr->e_phentsize = sizeof(Elf_Phdr);
1534bd390213SMikolaj Golub 	ehdr->e_phnum = numsegs + 1;
1535bd390213SMikolaj Golub 	ehdr->e_shentsize = sizeof(Elf_Shdr);
1536bd390213SMikolaj Golub 	ehdr->e_shnum = 0;
1537bd390213SMikolaj Golub 	ehdr->e_shstrndx = SHN_UNDEF;
1538bd390213SMikolaj Golub 
1539bd390213SMikolaj Golub 	/*
1540bd390213SMikolaj Golub 	 * Fill in the program header entries.
1541bd390213SMikolaj Golub 	 */
1542bd390213SMikolaj Golub 
1543bd390213SMikolaj Golub 	/* The note segement. */
1544bd390213SMikolaj Golub 	phdr->p_type = PT_NOTE;
1545bd390213SMikolaj Golub 	phdr->p_offset = hdrsize;
1546bd390213SMikolaj Golub 	phdr->p_vaddr = 0;
1547bd390213SMikolaj Golub 	phdr->p_paddr = 0;
1548bd390213SMikolaj Golub 	phdr->p_filesz = notesz;
1549bd390213SMikolaj Golub 	phdr->p_memsz = 0;
1550bd390213SMikolaj Golub 	phdr->p_flags = PF_R;
15511b8388cdSMikolaj Golub 	phdr->p_align = ELF_NOTE_ROUNDSIZE;
1552bd390213SMikolaj Golub 	phdr++;
1553bd390213SMikolaj Golub 
1554bd390213SMikolaj Golub 	/* All the writable segments from the program. */
1555bd390213SMikolaj Golub 	phc.phdr = phdr;
1556bd390213SMikolaj Golub 	phc.offset = round_page(hdrsize + notesz);
1557bd390213SMikolaj Golub 	each_writable_segment(td, cb_put_phdr, &phc);
1558bd390213SMikolaj Golub }
1559bd390213SMikolaj Golub 
1560bd390213SMikolaj Golub static size_t
1561bd390213SMikolaj Golub register_note(struct note_info_list *list, int type, outfunc_t out, void *arg)
1562bd390213SMikolaj Golub {
1563bd390213SMikolaj Golub 	struct note_info *ninfo;
1564bd390213SMikolaj Golub 	size_t size, notesize;
1565bd390213SMikolaj Golub 
1566bd390213SMikolaj Golub 	size = 0;
1567bd390213SMikolaj Golub 	out(arg, NULL, &size);
1568bd390213SMikolaj Golub 	ninfo = malloc(sizeof(*ninfo), M_TEMP, M_ZERO | M_WAITOK);
1569bd390213SMikolaj Golub 	ninfo->type = type;
1570bd390213SMikolaj Golub 	ninfo->outfunc = out;
1571bd390213SMikolaj Golub 	ninfo->outarg = arg;
1572bd390213SMikolaj Golub 	ninfo->outsize = size;
1573bd390213SMikolaj Golub 	TAILQ_INSERT_TAIL(list, ninfo, link);
1574bd390213SMikolaj Golub 
1575bd390213SMikolaj Golub 	if (type == -1)
1576bd390213SMikolaj Golub 		return (size);
1577bd390213SMikolaj Golub 
1578bd390213SMikolaj Golub 	notesize = sizeof(Elf_Note) +		/* note header */
15791b8388cdSMikolaj Golub 	    roundup2(8, ELF_NOTE_ROUNDSIZE) +	/* note name ("FreeBSD") */
15801b8388cdSMikolaj Golub 	    roundup2(size, ELF_NOTE_ROUNDSIZE);	/* note description */
1581bd390213SMikolaj Golub 
1582bd390213SMikolaj Golub 	return (notesize);
1583bd390213SMikolaj Golub }
1584bd390213SMikolaj Golub 
1585bd390213SMikolaj Golub static void
1586bd390213SMikolaj Golub __elfN(putnote)(struct note_info *ninfo, struct sbuf *sb)
1587bd390213SMikolaj Golub {
1588bd390213SMikolaj Golub 	Elf_Note note;
1589bd390213SMikolaj Golub 	ssize_t old_len;
1590bd390213SMikolaj Golub 
1591bd390213SMikolaj Golub 	if (ninfo->type == -1) {
1592bd390213SMikolaj Golub 		ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize);
1593bd390213SMikolaj Golub 		return;
1594bd390213SMikolaj Golub 	}
1595bd390213SMikolaj Golub 
1596bd390213SMikolaj Golub 	note.n_namesz = 8; /* strlen("FreeBSD") + 1 */
1597bd390213SMikolaj Golub 	note.n_descsz = ninfo->outsize;
1598bd390213SMikolaj Golub 	note.n_type = ninfo->type;
1599bd390213SMikolaj Golub 
1600bd390213SMikolaj Golub 	sbuf_bcat(sb, &note, sizeof(note));
1601bd390213SMikolaj Golub 	sbuf_start_section(sb, &old_len);
1602bd390213SMikolaj Golub 	sbuf_bcat(sb, "FreeBSD", note.n_namesz);
16031b8388cdSMikolaj Golub 	sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0);
1604bd390213SMikolaj Golub 	if (note.n_descsz == 0)
1605bd390213SMikolaj Golub 		return;
1606bd390213SMikolaj Golub 	sbuf_start_section(sb, &old_len);
1607bd390213SMikolaj Golub 	ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize);
16081b8388cdSMikolaj Golub 	sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0);
1609bd390213SMikolaj Golub }
1610bd390213SMikolaj Golub 
1611bd390213SMikolaj Golub /*
1612bd390213SMikolaj Golub  * Miscellaneous note out functions.
1613bd390213SMikolaj Golub  */
1614bd390213SMikolaj Golub 
1615841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1616841c0c7eSNathan Whitehorn #include <compat/freebsd32/freebsd32.h>
1617841c0c7eSNathan Whitehorn 
161862919d78SPeter Wemm typedef struct prstatus32 elf_prstatus_t;
161962919d78SPeter Wemm typedef struct prpsinfo32 elf_prpsinfo_t;
162062919d78SPeter Wemm typedef struct fpreg32 elf_prfpregset_t;
162162919d78SPeter Wemm typedef struct fpreg32 elf_fpregset_t;
162262919d78SPeter Wemm typedef struct reg32 elf_gregset_t;
16237f08176eSAttilio Rao typedef struct thrmisc32 elf_thrmisc_t;
1624f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK	KERN_PROC_MASK32
1625f1fca82eSMikolaj Golub typedef struct kinfo_proc32 elf_kinfo_proc_t;
1626f1fca82eSMikolaj Golub typedef uint32_t elf_ps_strings_t;
162762919d78SPeter Wemm #else
162862919d78SPeter Wemm typedef prstatus_t elf_prstatus_t;
162962919d78SPeter Wemm typedef prpsinfo_t elf_prpsinfo_t;
163062919d78SPeter Wemm typedef prfpregset_t elf_prfpregset_t;
163162919d78SPeter Wemm typedef prfpregset_t elf_fpregset_t;
163262919d78SPeter Wemm typedef gregset_t elf_gregset_t;
16337f08176eSAttilio Rao typedef thrmisc_t elf_thrmisc_t;
1634f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK	0
1635f1fca82eSMikolaj Golub typedef struct kinfo_proc elf_kinfo_proc_t;
1636f1fca82eSMikolaj Golub typedef vm_offset_t elf_ps_strings_t;
163762919d78SPeter Wemm #endif
163862919d78SPeter Wemm 
16398c64af4fSJohn Polstra static void
1640bd390213SMikolaj Golub __elfN(note_prpsinfo)(void *arg, struct sbuf *sb, size_t *sizep)
16418c64af4fSJohn Polstra {
1642247aba24SMarcel Moolenaar 	struct proc *p;
1643bd390213SMikolaj Golub 	elf_prpsinfo_t *psinfo;
16448c64af4fSJohn Polstra 
1645bd390213SMikolaj Golub 	p = (struct proc *)arg;
1646bd390213SMikolaj Golub 	if (sb != NULL) {
1647bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*psinfo), ("invalid size"));
1648bd390213SMikolaj Golub 		psinfo = malloc(sizeof(*psinfo), M_TEMP, M_ZERO | M_WAITOK);
16498c9b7b2cSMarcel Moolenaar 		psinfo->pr_version = PRPSINFO_VERSION;
165062919d78SPeter Wemm 		psinfo->pr_psinfosz = sizeof(elf_prpsinfo_t);
1651ccd3953eSJohn Baldwin 		strlcpy(psinfo->pr_fname, p->p_comm, sizeof(psinfo->pr_fname));
16528c9b7b2cSMarcel Moolenaar 		/*
16538c9b7b2cSMarcel Moolenaar 		 * XXX - We don't fill in the command line arguments properly
16548c9b7b2cSMarcel Moolenaar 		 * yet.
16558c9b7b2cSMarcel Moolenaar 		 */
1656ccd3953eSJohn Baldwin 		strlcpy(psinfo->pr_psargs, p->p_comm,
16578c9b7b2cSMarcel Moolenaar 		    sizeof(psinfo->pr_psargs));
16588c9b7b2cSMarcel Moolenaar 
1659bd390213SMikolaj Golub 		sbuf_bcat(sb, psinfo, sizeof(*psinfo));
1660bd390213SMikolaj Golub 		free(psinfo, M_TEMP);
1661bd390213SMikolaj Golub 	}
1662bd390213SMikolaj Golub 	*sizep = sizeof(*psinfo);
1663bd390213SMikolaj Golub }
1664bd390213SMikolaj Golub 
1665bd390213SMikolaj Golub static void
1666bd390213SMikolaj Golub __elfN(note_prstatus)(void *arg, struct sbuf *sb, size_t *sizep)
1667bd390213SMikolaj Golub {
1668bd390213SMikolaj Golub 	struct thread *td;
1669bd390213SMikolaj Golub 	elf_prstatus_t *status;
1670bd390213SMikolaj Golub 
1671bd390213SMikolaj Golub 	td = (struct thread *)arg;
1672bd390213SMikolaj Golub 	if (sb != NULL) {
1673bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*status), ("invalid size"));
1674bd390213SMikolaj Golub 		status = malloc(sizeof(*status), M_TEMP, M_ZERO | M_WAITOK);
16758c9b7b2cSMarcel Moolenaar 		status->pr_version = PRSTATUS_VERSION;
167662919d78SPeter Wemm 		status->pr_statussz = sizeof(elf_prstatus_t);
167762919d78SPeter Wemm 		status->pr_gregsetsz = sizeof(elf_gregset_t);
167862919d78SPeter Wemm 		status->pr_fpregsetsz = sizeof(elf_fpregset_t);
16798c9b7b2cSMarcel Moolenaar 		status->pr_osreldate = osreldate;
1680bd390213SMikolaj Golub 		status->pr_cursig = td->td_proc->p_sig;
1681bd390213SMikolaj Golub 		status->pr_pid = td->td_tid;
1682841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1683bd390213SMikolaj Golub 		fill_regs32(td, &status->pr_reg);
168462919d78SPeter Wemm #else
1685bd390213SMikolaj Golub 		fill_regs(td, &status->pr_reg);
168662919d78SPeter Wemm #endif
1687bd390213SMikolaj Golub 		sbuf_bcat(sb, status, sizeof(*status));
1688bd390213SMikolaj Golub 		free(status, M_TEMP);
16898c9b7b2cSMarcel Moolenaar 	}
1690bd390213SMikolaj Golub 	*sizep = sizeof(*status);
1691bd390213SMikolaj Golub }
1692bd390213SMikolaj Golub 
1693bd390213SMikolaj Golub static void
1694bd390213SMikolaj Golub __elfN(note_fpregset)(void *arg, struct sbuf *sb, size_t *sizep)
1695bd390213SMikolaj Golub {
1696bd390213SMikolaj Golub 	struct thread *td;
1697bd390213SMikolaj Golub 	elf_prfpregset_t *fpregset;
1698bd390213SMikolaj Golub 
1699bd390213SMikolaj Golub 	td = (struct thread *)arg;
1700bd390213SMikolaj Golub 	if (sb != NULL) {
1701bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(*fpregset), ("invalid size"));
1702bd390213SMikolaj Golub 		fpregset = malloc(sizeof(*fpregset), M_TEMP, M_ZERO | M_WAITOK);
1703bd390213SMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1704bd390213SMikolaj Golub 		fill_fpregs32(td, fpregset);
1705bd390213SMikolaj Golub #else
1706bd390213SMikolaj Golub 		fill_fpregs(td, fpregset);
1707bd390213SMikolaj Golub #endif
1708bd390213SMikolaj Golub 		sbuf_bcat(sb, fpregset, sizeof(*fpregset));
1709bd390213SMikolaj Golub 		free(fpregset, M_TEMP);
1710bd390213SMikolaj Golub 	}
1711bd390213SMikolaj Golub 	*sizep = sizeof(*fpregset);
1712bd390213SMikolaj Golub }
1713bd390213SMikolaj Golub 
1714bd390213SMikolaj Golub static void
1715bd390213SMikolaj Golub __elfN(note_thrmisc)(void *arg, struct sbuf *sb, size_t *sizep)
1716bd390213SMikolaj Golub {
1717bd390213SMikolaj Golub 	struct thread *td;
1718bd390213SMikolaj Golub 	elf_thrmisc_t thrmisc;
1719bd390213SMikolaj Golub 
1720bd390213SMikolaj Golub 	td = (struct thread *)arg;
1721bd390213SMikolaj Golub 	if (sb != NULL) {
1722bd390213SMikolaj Golub 		KASSERT(*sizep == sizeof(thrmisc), ("invalid size"));
1723bd390213SMikolaj Golub 		bzero(&thrmisc._pad, sizeof(thrmisc._pad));
1724bd390213SMikolaj Golub 		strcpy(thrmisc.pr_tname, td->td_name);
1725bd390213SMikolaj Golub 		sbuf_bcat(sb, &thrmisc, sizeof(thrmisc));
1726bd390213SMikolaj Golub 	}
1727bd390213SMikolaj Golub 	*sizep = sizeof(thrmisc);
1728bd390213SMikolaj Golub }
1729bd390213SMikolaj Golub 
17304da47b2fSMarcel Moolenaar /*
17314da47b2fSMarcel Moolenaar  * Allow for MD specific notes, as well as any MD
17324da47b2fSMarcel Moolenaar  * specific preparations for writing MI notes.
17334da47b2fSMarcel Moolenaar  */
17348c64af4fSJohn Polstra static void
1735bd390213SMikolaj Golub __elfN(note_threadmd)(void *arg, struct sbuf *sb, size_t *sizep)
17368c64af4fSJohn Polstra {
1737bd390213SMikolaj Golub 	struct thread *td;
1738bd390213SMikolaj Golub 	void *buf;
1739bd390213SMikolaj Golub 	size_t size;
17408c64af4fSJohn Polstra 
1741bd390213SMikolaj Golub 	td = (struct thread *)arg;
1742bd390213SMikolaj Golub 	size = *sizep;
1743bd390213SMikolaj Golub 	if (size != 0 && sb != NULL)
1744bd390213SMikolaj Golub 		buf = malloc(size, M_TEMP, M_ZERO | M_WAITOK);
1745*83a396ceSChristian Brueffer 	else
1746*83a396ceSChristian Brueffer 		buf = NULL;
1747bd390213SMikolaj Golub 	size = 0;
1748bd390213SMikolaj Golub 	__elfN(dump_thread)(td, buf, &size);
1749bd390213SMikolaj Golub 	KASSERT(*sizep == size, ("invalid size"));
1750*83a396ceSChristian Brueffer 	if (size != 0 && sb != NULL)
1751bd390213SMikolaj Golub 		sbuf_bcat(sb, buf, size);
1752a1761d73SChristian Brueffer 	free(buf, M_TEMP);
1753bd390213SMikolaj Golub 	*sizep = size;
17548c64af4fSJohn Polstra }
17558c64af4fSJohn Polstra 
1756f1fca82eSMikolaj Golub #ifdef KINFO_PROC_SIZE
1757f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE);
1758f1fca82eSMikolaj Golub #endif
1759f1fca82eSMikolaj Golub 
1760f1fca82eSMikolaj Golub static void
1761f1fca82eSMikolaj Golub __elfN(note_procstat_proc)(void *arg, struct sbuf *sb, size_t *sizep)
1762f1fca82eSMikolaj Golub {
1763f1fca82eSMikolaj Golub 	struct proc *p;
1764f1fca82eSMikolaj Golub 	size_t size;
1765f1fca82eSMikolaj Golub 	int structsize;
1766f1fca82eSMikolaj Golub 
1767f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1768f1fca82eSMikolaj Golub 	size = sizeof(structsize) + p->p_numthreads *
1769f1fca82eSMikolaj Golub 	    sizeof(elf_kinfo_proc_t);
1770f1fca82eSMikolaj Golub 
1771f1fca82eSMikolaj Golub 	if (sb != NULL) {
1772f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1773f1fca82eSMikolaj Golub 		structsize = sizeof(elf_kinfo_proc_t);
1774f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1775f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1776f1fca82eSMikolaj Golub 		kern_proc_out(p, sb, ELF_KERN_PROC_MASK);
1777f1fca82eSMikolaj Golub 	}
1778f1fca82eSMikolaj Golub 	*sizep = size;
1779f1fca82eSMikolaj Golub }
1780f1fca82eSMikolaj Golub 
1781f1fca82eSMikolaj Golub #ifdef KINFO_FILE_SIZE
1782f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE);
1783f1fca82eSMikolaj Golub #endif
1784f1fca82eSMikolaj Golub 
1785f1fca82eSMikolaj Golub static void
1786f1fca82eSMikolaj Golub note_procstat_files(void *arg, struct sbuf *sb, size_t *sizep)
1787f1fca82eSMikolaj Golub {
1788f1fca82eSMikolaj Golub 	struct proc *p;
1789f1fca82eSMikolaj Golub 	size_t size;
1790f1fca82eSMikolaj Golub 	int structsize;
1791f1fca82eSMikolaj Golub 
1792f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1793f1fca82eSMikolaj Golub 	if (sb == NULL) {
1794f1fca82eSMikolaj Golub 		size = 0;
1795f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
1796f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
1797f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1798f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1799f1fca82eSMikolaj Golub 		kern_proc_filedesc_out(p, sb, -1);
1800f1fca82eSMikolaj Golub 		sbuf_finish(sb);
1801f1fca82eSMikolaj Golub 		sbuf_delete(sb);
1802f1fca82eSMikolaj Golub 		*sizep = size;
1803f1fca82eSMikolaj Golub 	} else {
1804f1fca82eSMikolaj Golub 		structsize = sizeof(struct kinfo_file);
1805f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1806f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1807f1fca82eSMikolaj Golub 		kern_proc_filedesc_out(p, sb, -1);
1808f1fca82eSMikolaj Golub 	}
1809f1fca82eSMikolaj Golub }
1810f1fca82eSMikolaj Golub 
1811f1fca82eSMikolaj Golub #ifdef KINFO_VMENTRY_SIZE
1812f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE);
1813f1fca82eSMikolaj Golub #endif
1814f1fca82eSMikolaj Golub 
1815f1fca82eSMikolaj Golub static void
1816f1fca82eSMikolaj Golub note_procstat_vmmap(void *arg, struct sbuf *sb, size_t *sizep)
1817f1fca82eSMikolaj Golub {
1818f1fca82eSMikolaj Golub 	struct proc *p;
1819f1fca82eSMikolaj Golub 	size_t size;
1820f1fca82eSMikolaj Golub 	int structsize;
1821f1fca82eSMikolaj Golub 
1822f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1823f1fca82eSMikolaj Golub 	if (sb == NULL) {
1824f1fca82eSMikolaj Golub 		size = 0;
1825f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
1826f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
1827f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1828f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1829f1fca82eSMikolaj Golub 		kern_proc_vmmap_out(p, sb);
1830f1fca82eSMikolaj Golub 		sbuf_finish(sb);
1831f1fca82eSMikolaj Golub 		sbuf_delete(sb);
1832f1fca82eSMikolaj Golub 		*sizep = size;
1833f1fca82eSMikolaj Golub 	} else {
1834f1fca82eSMikolaj Golub 		structsize = sizeof(struct kinfo_vmentry);
1835f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1836f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1837f1fca82eSMikolaj Golub 		kern_proc_vmmap_out(p, sb);
1838f1fca82eSMikolaj Golub 	}
1839f1fca82eSMikolaj Golub }
1840f1fca82eSMikolaj Golub 
1841f1fca82eSMikolaj Golub static void
1842f1fca82eSMikolaj Golub note_procstat_groups(void *arg, struct sbuf *sb, size_t *sizep)
1843f1fca82eSMikolaj Golub {
1844f1fca82eSMikolaj Golub 	struct proc *p;
1845f1fca82eSMikolaj Golub 	size_t size;
1846f1fca82eSMikolaj Golub 	int structsize;
1847f1fca82eSMikolaj Golub 
1848f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1849f1fca82eSMikolaj Golub 	size = sizeof(structsize) + p->p_ucred->cr_ngroups * sizeof(gid_t);
1850f1fca82eSMikolaj Golub 	if (sb != NULL) {
1851f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1852f1fca82eSMikolaj Golub 		structsize = sizeof(gid_t);
1853f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1854f1fca82eSMikolaj Golub 		sbuf_bcat(sb, p->p_ucred->cr_groups, p->p_ucred->cr_ngroups *
1855f1fca82eSMikolaj Golub 		    sizeof(gid_t));
1856f1fca82eSMikolaj Golub 	}
1857f1fca82eSMikolaj Golub 	*sizep = size;
1858f1fca82eSMikolaj Golub }
1859f1fca82eSMikolaj Golub 
1860f1fca82eSMikolaj Golub static void
1861f1fca82eSMikolaj Golub note_procstat_umask(void *arg, struct sbuf *sb, size_t *sizep)
1862f1fca82eSMikolaj Golub {
1863f1fca82eSMikolaj Golub 	struct proc *p;
1864f1fca82eSMikolaj Golub 	size_t size;
1865f1fca82eSMikolaj Golub 	int structsize;
1866f1fca82eSMikolaj Golub 
1867f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1868f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(p->p_fd->fd_cmask);
1869f1fca82eSMikolaj Golub 	if (sb != NULL) {
1870f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1871f1fca82eSMikolaj Golub 		structsize = sizeof(p->p_fd->fd_cmask);
1872f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1873f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &p->p_fd->fd_cmask, sizeof(p->p_fd->fd_cmask));
1874f1fca82eSMikolaj Golub 	}
1875f1fca82eSMikolaj Golub 	*sizep = size;
1876f1fca82eSMikolaj Golub }
1877f1fca82eSMikolaj Golub 
1878f1fca82eSMikolaj Golub static void
1879f1fca82eSMikolaj Golub note_procstat_rlimit(void *arg, struct sbuf *sb, size_t *sizep)
1880f1fca82eSMikolaj Golub {
1881f1fca82eSMikolaj Golub 	struct proc *p;
1882f1fca82eSMikolaj Golub 	struct rlimit rlim[RLIM_NLIMITS];
1883f1fca82eSMikolaj Golub 	size_t size;
1884f1fca82eSMikolaj Golub 	int structsize, i;
1885f1fca82eSMikolaj Golub 
1886f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1887f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(rlim);
1888f1fca82eSMikolaj Golub 	if (sb != NULL) {
1889f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1890f1fca82eSMikolaj Golub 		structsize = sizeof(rlim);
1891f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1892f1fca82eSMikolaj Golub 		PROC_LOCK(p);
1893f1fca82eSMikolaj Golub 		for (i = 0; i < RLIM_NLIMITS; i++)
1894f1fca82eSMikolaj Golub 			lim_rlimit(p, i, &rlim[i]);
1895f1fca82eSMikolaj Golub 		PROC_UNLOCK(p);
1896f1fca82eSMikolaj Golub 		sbuf_bcat(sb, rlim, sizeof(rlim));
1897f1fca82eSMikolaj Golub 	}
1898f1fca82eSMikolaj Golub 	*sizep = size;
1899f1fca82eSMikolaj Golub }
1900f1fca82eSMikolaj Golub 
1901f1fca82eSMikolaj Golub static void
1902f1fca82eSMikolaj Golub note_procstat_osrel(void *arg, struct sbuf *sb, size_t *sizep)
1903f1fca82eSMikolaj Golub {
1904f1fca82eSMikolaj Golub 	struct proc *p;
1905f1fca82eSMikolaj Golub 	size_t size;
1906f1fca82eSMikolaj Golub 	int structsize;
1907f1fca82eSMikolaj Golub 
1908f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1909f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(p->p_osrel);
1910f1fca82eSMikolaj Golub 	if (sb != NULL) {
1911f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1912f1fca82eSMikolaj Golub 		structsize = sizeof(p->p_osrel);
1913f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1914f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &p->p_osrel, sizeof(p->p_osrel));
1915f1fca82eSMikolaj Golub 	}
1916f1fca82eSMikolaj Golub 	*sizep = size;
1917f1fca82eSMikolaj Golub }
1918f1fca82eSMikolaj Golub 
1919f1fca82eSMikolaj Golub static void
1920f1fca82eSMikolaj Golub __elfN(note_procstat_psstrings)(void *arg, struct sbuf *sb, size_t *sizep)
1921f1fca82eSMikolaj Golub {
1922f1fca82eSMikolaj Golub 	struct proc *p;
1923f1fca82eSMikolaj Golub 	elf_ps_strings_t ps_strings;
1924f1fca82eSMikolaj Golub 	size_t size;
1925f1fca82eSMikolaj Golub 	int structsize;
1926f1fca82eSMikolaj Golub 
1927f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1928f1fca82eSMikolaj Golub 	size = sizeof(structsize) + sizeof(ps_strings);
1929f1fca82eSMikolaj Golub 	if (sb != NULL) {
1930f1fca82eSMikolaj Golub 		KASSERT(*sizep == size, ("invalid size"));
1931f1fca82eSMikolaj Golub 		structsize = sizeof(ps_strings);
1932f1fca82eSMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
1933f1fca82eSMikolaj Golub 		ps_strings = PTROUT(p->p_sysent->sv_psstrings);
1934f1fca82eSMikolaj Golub #else
1935f1fca82eSMikolaj Golub 		ps_strings = p->p_sysent->sv_psstrings;
1936f1fca82eSMikolaj Golub #endif
1937f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1938f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &ps_strings, sizeof(ps_strings));
1939f1fca82eSMikolaj Golub 	}
1940f1fca82eSMikolaj Golub 	*sizep = size;
1941f1fca82eSMikolaj Golub }
1942f1fca82eSMikolaj Golub 
1943f1fca82eSMikolaj Golub static void
1944f1fca82eSMikolaj Golub __elfN(note_procstat_auxv)(void *arg, struct sbuf *sb, size_t *sizep)
1945f1fca82eSMikolaj Golub {
1946f1fca82eSMikolaj Golub 	struct proc *p;
1947f1fca82eSMikolaj Golub 	size_t size;
1948f1fca82eSMikolaj Golub 	int structsize;
1949f1fca82eSMikolaj Golub 
1950f1fca82eSMikolaj Golub 	p = (struct proc *)arg;
1951f1fca82eSMikolaj Golub 	if (sb == NULL) {
1952f1fca82eSMikolaj Golub 		size = 0;
1953f1fca82eSMikolaj Golub 		sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN);
1954f1fca82eSMikolaj Golub 		sbuf_set_drain(sb, sbuf_drain_count, &size);
1955f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1956f1fca82eSMikolaj Golub 		PHOLD(p);
1957f1fca82eSMikolaj Golub 		proc_getauxv(curthread, p, sb);
1958f1fca82eSMikolaj Golub 		PRELE(p);
1959f1fca82eSMikolaj Golub 		sbuf_finish(sb);
1960f1fca82eSMikolaj Golub 		sbuf_delete(sb);
1961f1fca82eSMikolaj Golub 		*sizep = size;
1962f1fca82eSMikolaj Golub 	} else {
1963f1fca82eSMikolaj Golub 		structsize = sizeof(Elf_Auxinfo);
1964f1fca82eSMikolaj Golub 		sbuf_bcat(sb, &structsize, sizeof(structsize));
1965f1fca82eSMikolaj Golub 		PHOLD(p);
1966f1fca82eSMikolaj Golub 		proc_getauxv(curthread, p, sb);
1967f1fca82eSMikolaj Golub 		PRELE(p);
1968f1fca82eSMikolaj Golub 	}
1969f1fca82eSMikolaj Golub }
1970f1fca82eSMikolaj Golub 
197132c01de2SDmitry Chagin static boolean_t
19721a9c7decSKonstantin Belousov __elfN(parse_notes)(struct image_params *imgp, Elf_Brandnote *checknote,
19731a9c7decSKonstantin Belousov     int32_t *osrel, const Elf_Phdr *pnote)
197432c01de2SDmitry Chagin {
1975267c52fcSKonstantin Belousov 	const Elf_Note *note, *note0, *note_end;
197632c01de2SDmitry Chagin 	const char *note_name;
197732c01de2SDmitry Chagin 	int i;
197832c01de2SDmitry Chagin 
1979d19d5bf4STijl Coosemans 	if (pnote == NULL || pnote->p_offset > PAGE_SIZE ||
1980d19d5bf4STijl Coosemans 	    pnote->p_filesz > PAGE_SIZE - pnote->p_offset)
198132c01de2SDmitry Chagin 		return (FALSE);
198232c01de2SDmitry Chagin 
1983267c52fcSKonstantin Belousov 	note = note0 = (const Elf_Note *)(imgp->image_header + pnote->p_offset);
198432c01de2SDmitry Chagin 	note_end = (const Elf_Note *)(imgp->image_header +
198532c01de2SDmitry Chagin 	    pnote->p_offset + pnote->p_filesz);
1986267c52fcSKonstantin Belousov 	for (i = 0; i < 100 && note >= note0 && note < note_end; i++) {
1987d1ae5c83SKonstantin Belousov 		if (!aligned(note, Elf32_Addr) || (const char *)note_end -
1988d1ae5c83SKonstantin Belousov 		    (const char *)note < sizeof(Elf_Note))
1989267c52fcSKonstantin Belousov 			return (FALSE);
199032c01de2SDmitry Chagin 		if (note->n_namesz != checknote->hdr.n_namesz ||
199132c01de2SDmitry Chagin 		    note->n_descsz != checknote->hdr.n_descsz ||
199232c01de2SDmitry Chagin 		    note->n_type != checknote->hdr.n_type)
199332c01de2SDmitry Chagin 			goto nextnote;
199432c01de2SDmitry Chagin 		note_name = (const char *)(note + 1);
1995d1ae5c83SKonstantin Belousov 		if (note_name + checknote->hdr.n_namesz >=
1996d1ae5c83SKonstantin Belousov 		    (const char *)note_end || strncmp(checknote->vendor,
1997d1ae5c83SKonstantin Belousov 		    note_name, checknote->hdr.n_namesz) != 0)
199832c01de2SDmitry Chagin 			goto nextnote;
199932c01de2SDmitry Chagin 
200032c01de2SDmitry Chagin 		/*
200132c01de2SDmitry Chagin 		 * Fetch the osreldate for binary
200232c01de2SDmitry Chagin 		 * from the ELF OSABI-note if necessary.
200332c01de2SDmitry Chagin 		 */
200489ffc202SBjoern A. Zeeb 		if ((checknote->flags & BN_TRANSLATE_OSREL) != 0 &&
200589ffc202SBjoern A. Zeeb 		    checknote->trans_osrel != NULL)
200689ffc202SBjoern A. Zeeb 			return (checknote->trans_osrel(note, osrel));
200732c01de2SDmitry Chagin 		return (TRUE);
200832c01de2SDmitry Chagin 
200932c01de2SDmitry Chagin nextnote:
201032c01de2SDmitry Chagin 		note = (const Elf_Note *)((const char *)(note + 1) +
20111b8388cdSMikolaj Golub 		    roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE) +
20121b8388cdSMikolaj Golub 		    roundup2(note->n_descsz, ELF_NOTE_ROUNDSIZE));
201332c01de2SDmitry Chagin 	}
201432c01de2SDmitry Chagin 
201532c01de2SDmitry Chagin 	return (FALSE);
201632c01de2SDmitry Chagin }
201732c01de2SDmitry Chagin 
201832c01de2SDmitry Chagin /*
20191a9c7decSKonstantin Belousov  * Try to find the appropriate ABI-note section for checknote,
20201a9c7decSKonstantin Belousov  * fetch the osreldate for binary from the ELF OSABI-note. Only the
20211a9c7decSKonstantin Belousov  * first page of the image is searched, the same as for headers.
20221a9c7decSKonstantin Belousov  */
20231a9c7decSKonstantin Belousov static boolean_t
20241a9c7decSKonstantin Belousov __elfN(check_note)(struct image_params *imgp, Elf_Brandnote *checknote,
20251a9c7decSKonstantin Belousov     int32_t *osrel)
20261a9c7decSKonstantin Belousov {
20271a9c7decSKonstantin Belousov 	const Elf_Phdr *phdr;
20281a9c7decSKonstantin Belousov 	const Elf_Ehdr *hdr;
20291a9c7decSKonstantin Belousov 	int i;
20301a9c7decSKonstantin Belousov 
20311a9c7decSKonstantin Belousov 	hdr = (const Elf_Ehdr *)imgp->image_header;
20321a9c7decSKonstantin Belousov 	phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
20331a9c7decSKonstantin Belousov 
20341a9c7decSKonstantin Belousov 	for (i = 0; i < hdr->e_phnum; i++) {
20351a9c7decSKonstantin Belousov 		if (phdr[i].p_type == PT_NOTE &&
20361a9c7decSKonstantin Belousov 		    __elfN(parse_notes)(imgp, checknote, osrel, &phdr[i]))
20371a9c7decSKonstantin Belousov 			return (TRUE);
20381a9c7decSKonstantin Belousov 	}
20391a9c7decSKonstantin Belousov 	return (FALSE);
20401a9c7decSKonstantin Belousov 
20411a9c7decSKonstantin Belousov }
20421a9c7decSKonstantin Belousov 
20431a9c7decSKonstantin Belousov /*
2044e1743d02SSøren Schmidt  * Tell kern_execve.c about it, with a little help from the linker.
2045e1743d02SSøren Schmidt  */
2046a360a43dSJake Burkholder static struct execsw __elfN(execsw) = {
2047a360a43dSJake Burkholder 	__CONCAT(exec_, __elfN(imgact)),
2048a360a43dSJake Burkholder 	__XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE))
2049a360a43dSJake Burkholder };
2050a360a43dSJake Burkholder EXEC_SET(__CONCAT(elf, __ELF_WORD_SIZE), __elfN(execsw));
2051e7228204SAlfred Perlstein 
2052e7228204SAlfred Perlstein #ifdef COMPRESS_USER_CORES
2053e7228204SAlfred Perlstein /*
2054e7228204SAlfred Perlstein  * Compress and write out a core segment for a user process.
2055e7228204SAlfred Perlstein  *
2056e7228204SAlfred Perlstein  * 'inbuf' is the starting address of a VM segment in the process' address
2057e7228204SAlfred Perlstein  * space that is to be compressed and written out to the core file.  'dest_buf'
2058e7228204SAlfred Perlstein  * is a buffer in the kernel's address space.  The segment is copied from
2059e7228204SAlfred Perlstein  * 'inbuf' to 'dest_buf' first before being processed by the compression
2060e7228204SAlfred Perlstein  * routine gzwrite().  This copying is necessary because the content of the VM
2061e7228204SAlfred Perlstein  * segment may change between the compression pass and the crc-computation pass
2062e7228204SAlfred Perlstein  * in gzwrite().  This is because realtime threads may preempt the UNIX kernel.
2063bd390213SMikolaj Golub  *
2064bd390213SMikolaj Golub  * If inbuf is NULL it is assumed that data is already copied to 'dest_buf'.
2065e7228204SAlfred Perlstein  */
2066e7228204SAlfred Perlstein static int
2067e7228204SAlfred Perlstein compress_core (gzFile file, char *inbuf, char *dest_buf, unsigned int len,
2068e7228204SAlfred Perlstein     struct thread *td)
2069e7228204SAlfred Perlstein {
2070e7228204SAlfred Perlstein 	int len_compressed;
2071e7228204SAlfred Perlstein 	int error = 0;
2072e7228204SAlfred Perlstein 	unsigned int chunk_len;
2073e7228204SAlfred Perlstein 
2074e7228204SAlfred Perlstein 	while (len) {
2075bd390213SMikolaj Golub 		if (inbuf != NULL) {
2076e7228204SAlfred Perlstein 			chunk_len = (len > CORE_BUF_SIZE) ? CORE_BUF_SIZE : len;
2077e7228204SAlfred Perlstein 			copyin(inbuf, dest_buf, chunk_len);
2078bd390213SMikolaj Golub 			inbuf += chunk_len;
2079bd390213SMikolaj Golub 		} else {
2080bd390213SMikolaj Golub 			chunk_len = len;
2081bd390213SMikolaj Golub 		}
2082e7228204SAlfred Perlstein 		len_compressed = gzwrite(file, dest_buf, chunk_len);
2083e7228204SAlfred Perlstein 
2084e7228204SAlfred Perlstein 		EVENTHANDLER_INVOKE(app_coredump_progress, td, len_compressed);
2085e7228204SAlfred Perlstein 
2086e7228204SAlfred Perlstein 		if ((unsigned int)len_compressed != chunk_len) {
2087e7228204SAlfred Perlstein 			log(LOG_WARNING,
2088e7228204SAlfred Perlstein 			    "compress_core: length mismatch (0x%x returned, "
2089e7228204SAlfred Perlstein 			    "0x%x expected)\n", len_compressed, chunk_len);
2090e7228204SAlfred Perlstein 			EVENTHANDLER_INVOKE(app_coredump_error, td,
2091e7228204SAlfred Perlstein 			    "compress_core: length mismatch %x -> %x",
2092e7228204SAlfred Perlstein 			    chunk_len, len_compressed);
2093e7228204SAlfred Perlstein 			error = EFAULT;
2094e7228204SAlfred Perlstein 			break;
2095e7228204SAlfred Perlstein 		}
2096e7228204SAlfred Perlstein 		len -= chunk_len;
209708b163faSMatthew D Fleming 		maybe_yield();
2098e7228204SAlfred Perlstein 	}
2099e7228204SAlfred Perlstein 
2100e7228204SAlfred Perlstein 	return (error);
2101e7228204SAlfred Perlstein }
2102e7228204SAlfred Perlstein #endif /* COMPRESS_USER_CORES */
2103ed167eaaSKonstantin Belousov 
2104ed167eaaSKonstantin Belousov static vm_prot_t
2105ed167eaaSKonstantin Belousov __elfN(trans_prot)(Elf_Word flags)
2106ed167eaaSKonstantin Belousov {
2107ed167eaaSKonstantin Belousov 	vm_prot_t prot;
2108ed167eaaSKonstantin Belousov 
2109ed167eaaSKonstantin Belousov 	prot = 0;
2110ed167eaaSKonstantin Belousov 	if (flags & PF_X)
2111ed167eaaSKonstantin Belousov 		prot |= VM_PROT_EXECUTE;
2112ed167eaaSKonstantin Belousov 	if (flags & PF_W)
2113ed167eaaSKonstantin Belousov 		prot |= VM_PROT_WRITE;
2114ed167eaaSKonstantin Belousov 	if (flags & PF_R)
2115ed167eaaSKonstantin Belousov 		prot |= VM_PROT_READ;
2116676eda08SMarcel Moolenaar #if __ELF_WORD_SIZE == 32
2117676eda08SMarcel Moolenaar #if defined(__amd64__) || defined(__ia64__)
2118126b36a2SKonstantin Belousov 	if (i386_read_exec && (flags & PF_R))
2119676eda08SMarcel Moolenaar 		prot |= VM_PROT_EXECUTE;
2120676eda08SMarcel Moolenaar #endif
2121676eda08SMarcel Moolenaar #endif
2122ed167eaaSKonstantin Belousov 	return (prot);
2123ed167eaaSKonstantin Belousov }
2124ed167eaaSKonstantin Belousov 
2125ed167eaaSKonstantin Belousov static Elf_Word
2126ed167eaaSKonstantin Belousov __elfN(untrans_prot)(vm_prot_t prot)
2127ed167eaaSKonstantin Belousov {
2128ed167eaaSKonstantin Belousov 	Elf_Word flags;
2129ed167eaaSKonstantin Belousov 
2130ed167eaaSKonstantin Belousov 	flags = 0;
2131ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_EXECUTE)
2132ed167eaaSKonstantin Belousov 		flags |= PF_X;
2133ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_READ)
2134ed167eaaSKonstantin Belousov 		flags |= PF_R;
2135ed167eaaSKonstantin Belousov 	if (prot & VM_PROT_WRITE)
2136ed167eaaSKonstantin Belousov 		flags |= PF_W;
2137ed167eaaSKonstantin Belousov 	return (flags);
2138ed167eaaSKonstantin Belousov }
2139