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" 36aa14e9b7SMark Johnston #include "opt_gzio.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> 42aa14e9b7SMark Johnston #include <sys/gzio.h> 43e1743d02SSøren Schmidt #include <sys/imgact.h> 44e1743d02SSøren Schmidt #include <sys/imgact_elf.h> 45b96bd95bSIan Lepore #include <sys/jail.h> 46e1743d02SSøren Schmidt #include <sys/kernel.h> 47f34fa851SJohn Baldwin #include <sys/lock.h> 48e1743d02SSøren Schmidt #include <sys/malloc.h> 4968ff2a43SChristian S.J. Peron #include <sys/mount.h> 508c64af4fSJohn Polstra #include <sys/mman.h> 51a794e791SBruce Evans #include <sys/namei.h> 528c64af4fSJohn Polstra #include <sys/pioctl.h> 53a794e791SBruce Evans #include <sys/proc.h> 548c64af4fSJohn Polstra #include <sys/procfs.h> 551ba5ad42SEdward Tomasz Napierala #include <sys/racct.h> 568c64af4fSJohn Polstra #include <sys/resourcevar.h> 5789f6b863SAttilio Rao #include <sys/rwlock.h> 58bd390213SMikolaj Golub #include <sys/sbuf.h> 59da61b9a6SAlan Cox #include <sys/sf_buf.h> 60ee235befSKonstantin Belousov #include <sys/smp.h> 6136240ea5SDoug Rabson #include <sys/systm.h> 62e1743d02SSøren Schmidt #include <sys/signalvar.h> 638c64af4fSJohn Polstra #include <sys/stat.h> 641005a129SJohn Baldwin #include <sys/sx.h> 658c64af4fSJohn Polstra #include <sys/syscall.h> 66e1743d02SSøren Schmidt #include <sys/sysctl.h> 678c64af4fSJohn Polstra #include <sys/sysent.h> 68a794e791SBruce Evans #include <sys/vnode.h> 69e7228204SAlfred Perlstein #include <sys/syslog.h> 70e7228204SAlfred Perlstein #include <sys/eventhandler.h> 71f1fca82eSMikolaj Golub #include <sys/user.h> 72e7228204SAlfred Perlstein 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); 920bbee4cdSKonstantin Belousov static int __elfN(load_section)(struct image_params *imgp, vm_ooffset_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 107bd390213SMikolaj Golub #define CORE_BUF_SIZE (16 * 1024) 108e7228204SAlfred Perlstein 109e548a1d4SJake Burkholder int __elfN(fallback_brand) = -1; 110e548a1d4SJake Burkholder SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO, 111af3b2549SHans Petter Selasky fallback_brand, CTLFLAG_RWTUN, &__elfN(fallback_brand), 0, 112a360a43dSJake Burkholder __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) " brand of last resort"); 113a360a43dSJake Burkholder 114551d79e1SMarcel Moolenaar static int elf_legacy_coredump = 0; 115a360a43dSJake Burkholder SYSCTL_INT(_debug, OID_AUTO, __elfN(legacy_coredump), CTLFLAG_RW, 1161cbb879dSEd Maste &elf_legacy_coredump, 0, 1171cbb879dSEd Maste "include all and only RW pages in core dumps"); 118e1743d02SSøren Schmidt 11962c625fdSKonstantin Belousov int __elfN(nxstack) = 1204d22d07aSKonstantin Belousov #if defined(__amd64__) || defined(__powerpc64__) /* both 64 and 32 bit */ || \ 1214d22d07aSKonstantin Belousov (defined(__arm__) && __ARM_ARCH >= 7) || defined(__aarch64__) 12262c625fdSKonstantin Belousov 1; 12362c625fdSKonstantin Belousov #else 12462c625fdSKonstantin Belousov 0; 12562c625fdSKonstantin Belousov #endif 126291c06a1SKonstantin Belousov SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO, 127291c06a1SKonstantin Belousov nxstack, CTLFLAG_RW, &__elfN(nxstack), 0, 128291c06a1SKonstantin Belousov __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) ": enable non-executable stack"); 129291c06a1SKonstantin Belousov 130126b36a2SKonstantin Belousov #if __ELF_WORD_SIZE == 32 131e7d939bdSMarcel Moolenaar #if defined(__amd64__) 132126b36a2SKonstantin Belousov int i386_read_exec = 0; 133126b36a2SKonstantin Belousov SYSCTL_INT(_kern_elf32, OID_AUTO, read_exec, CTLFLAG_RW, &i386_read_exec, 0, 134126b36a2SKonstantin Belousov "enable execution from readable segments"); 135126b36a2SKonstantin Belousov #endif 136126b36a2SKonstantin Belousov #endif 137126b36a2SKonstantin Belousov 1383ebc1248SPeter Wemm static Elf_Brandinfo *elf_brand_list[MAX_BRANDS]; 139e1743d02SSøren Schmidt 140d9c9c81cSPedro F. Giffuni #define trunc_page_ps(va, ps) rounddown2(va, ps) 141d9c9c81cSPedro F. Giffuni #define round_page_ps(va, ps) roundup2(va, ps) 14293d1c728SKonstantin Belousov #define aligned(a, t) (trunc_page_ps((u_long)(a), sizeof(t)) == (u_long)(a)) 14393d1c728SKonstantin Belousov 14432c01de2SDmitry Chagin static const char FREEBSD_ABI_VENDOR[] = "FreeBSD"; 14532c01de2SDmitry Chagin 14632c01de2SDmitry Chagin Elf_Brandnote __elfN(freebsd_brandnote) = { 14732c01de2SDmitry Chagin .hdr.n_namesz = sizeof(FREEBSD_ABI_VENDOR), 14832c01de2SDmitry Chagin .hdr.n_descsz = sizeof(int32_t), 1494c22b468SEd Maste .hdr.n_type = NT_FREEBSD_ABI_TAG, 15032c01de2SDmitry Chagin .vendor = FREEBSD_ABI_VENDOR, 15189ffc202SBjoern A. Zeeb .flags = BN_TRANSLATE_OSREL, 15289ffc202SBjoern A. Zeeb .trans_osrel = __elfN(freebsd_trans_osrel) 15332c01de2SDmitry Chagin }; 15432c01de2SDmitry Chagin 15589ffc202SBjoern A. Zeeb static boolean_t 15689ffc202SBjoern A. Zeeb __elfN(freebsd_trans_osrel)(const Elf_Note *note, int32_t *osrel) 15789ffc202SBjoern A. Zeeb { 15889ffc202SBjoern A. Zeeb uintptr_t p; 15989ffc202SBjoern A. Zeeb 16089ffc202SBjoern A. Zeeb p = (uintptr_t)(note + 1); 1611b8388cdSMikolaj Golub p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE); 16289ffc202SBjoern A. Zeeb *osrel = *(const int32_t *)(p); 16389ffc202SBjoern A. Zeeb 16489ffc202SBjoern A. Zeeb return (TRUE); 16589ffc202SBjoern A. Zeeb } 16689ffc202SBjoern A. Zeeb 16789ffc202SBjoern A. Zeeb static const char GNU_ABI_VENDOR[] = "GNU"; 16889ffc202SBjoern A. Zeeb static int GNU_KFREEBSD_ABI_DESC = 3; 16989ffc202SBjoern A. Zeeb 17089ffc202SBjoern A. Zeeb Elf_Brandnote __elfN(kfreebsd_brandnote) = { 17189ffc202SBjoern A. Zeeb .hdr.n_namesz = sizeof(GNU_ABI_VENDOR), 17289ffc202SBjoern A. Zeeb .hdr.n_descsz = 16, /* XXX at least 16 */ 17389ffc202SBjoern A. Zeeb .hdr.n_type = 1, 17489ffc202SBjoern A. Zeeb .vendor = GNU_ABI_VENDOR, 17589ffc202SBjoern A. Zeeb .flags = BN_TRANSLATE_OSREL, 17689ffc202SBjoern A. Zeeb .trans_osrel = kfreebsd_trans_osrel 17789ffc202SBjoern A. Zeeb }; 17889ffc202SBjoern A. Zeeb 17989ffc202SBjoern A. Zeeb static boolean_t 18089ffc202SBjoern A. Zeeb kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel) 18189ffc202SBjoern A. Zeeb { 18289ffc202SBjoern A. Zeeb const Elf32_Word *desc; 18389ffc202SBjoern A. Zeeb uintptr_t p; 18489ffc202SBjoern A. Zeeb 18589ffc202SBjoern A. Zeeb p = (uintptr_t)(note + 1); 1861b8388cdSMikolaj Golub p += roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE); 18789ffc202SBjoern A. Zeeb 18889ffc202SBjoern A. Zeeb desc = (const Elf32_Word *)p; 18989ffc202SBjoern A. Zeeb if (desc[0] != GNU_KFREEBSD_ABI_DESC) 19089ffc202SBjoern A. Zeeb return (FALSE); 19189ffc202SBjoern A. Zeeb 19289ffc202SBjoern A. Zeeb /* 19389ffc202SBjoern A. Zeeb * Debian GNU/kFreeBSD embed the earliest compatible kernel version 19489ffc202SBjoern A. Zeeb * (__FreeBSD_version: <major><two digit minor>Rxx) in the LSB way. 19589ffc202SBjoern A. Zeeb */ 19689ffc202SBjoern A. Zeeb *osrel = desc[1] * 100000 + desc[2] * 1000 + desc[3]; 19789ffc202SBjoern A. Zeeb 19889ffc202SBjoern A. Zeeb return (TRUE); 19989ffc202SBjoern A. Zeeb } 20089ffc202SBjoern A. Zeeb 201e1743d02SSøren Schmidt int 2023ebc1248SPeter Wemm __elfN(insert_brand_entry)(Elf_Brandinfo *entry) 203e1743d02SSøren Schmidt { 204e1743d02SSøren Schmidt int i; 205e1743d02SSøren Schmidt 2063ebc1248SPeter Wemm for (i = 0; i < MAX_BRANDS; i++) { 207ea5a2b2eSSøren Schmidt if (elf_brand_list[i] == NULL) { 208ea5a2b2eSSøren Schmidt elf_brand_list[i] = entry; 209e1743d02SSøren Schmidt break; 210e1743d02SSøren Schmidt } 211e1743d02SSøren Schmidt } 212925c8b5bSBjoern A. Zeeb if (i == MAX_BRANDS) { 213925c8b5bSBjoern A. Zeeb printf("WARNING: %s: could not insert brandinfo entry: %p\n", 214925c8b5bSBjoern A. Zeeb __func__, entry); 215a7cddfedSJake Burkholder return (-1); 216925c8b5bSBjoern A. Zeeb } 217a7cddfedSJake Burkholder return (0); 218e1743d02SSøren Schmidt } 219e1743d02SSøren Schmidt 220e1743d02SSøren Schmidt int 2213ebc1248SPeter Wemm __elfN(remove_brand_entry)(Elf_Brandinfo *entry) 222e1743d02SSøren Schmidt { 223e1743d02SSøren Schmidt int i; 224e1743d02SSøren Schmidt 2253ebc1248SPeter Wemm for (i = 0; i < MAX_BRANDS; i++) { 226ea5a2b2eSSøren Schmidt if (elf_brand_list[i] == entry) { 227ea5a2b2eSSøren Schmidt elf_brand_list[i] = NULL; 228e1743d02SSøren Schmidt break; 229e1743d02SSøren Schmidt } 230e1743d02SSøren Schmidt } 231ea5a2b2eSSøren Schmidt if (i == MAX_BRANDS) 232a7cddfedSJake Burkholder return (-1); 233a7cddfedSJake Burkholder return (0); 234e1743d02SSøren Schmidt } 235e1743d02SSøren Schmidt 236096977faSMark Newton int 2373ebc1248SPeter Wemm __elfN(brand_inuse)(Elf_Brandinfo *entry) 238096977faSMark Newton { 239096977faSMark Newton struct proc *p; 240553629ebSJake Burkholder int rval = FALSE; 241096977faSMark Newton 2421005a129SJohn Baldwin sx_slock(&allproc_lock); 2434f506694SXin LI FOREACH_PROC_IN_SYSTEM(p) { 244553629ebSJake Burkholder if (p->p_sysent == entry->sysvec) { 245553629ebSJake Burkholder rval = TRUE; 246553629ebSJake Burkholder break; 247096977faSMark Newton } 248553629ebSJake Burkholder } 2491005a129SJohn Baldwin sx_sunlock(&allproc_lock); 250096977faSMark Newton 251553629ebSJake Burkholder return (rval); 252096977faSMark Newton } 253096977faSMark Newton 2545fe3ed62SJake Burkholder static Elf_Brandinfo * 25532c01de2SDmitry Chagin __elfN(get_brandinfo)(struct image_params *imgp, const char *interp, 256d1ae5c83SKonstantin Belousov int interp_name_len, int32_t *osrel) 2575fe3ed62SJake Burkholder { 25832c01de2SDmitry Chagin const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header; 259af582aaeSKonstantin Belousov Elf_Brandinfo *bi, *bi_m; 26032c01de2SDmitry Chagin boolean_t ret; 2615fe3ed62SJake Burkholder int i; 2625fe3ed62SJake Burkholder 2635fe3ed62SJake Burkholder /* 26432c01de2SDmitry Chagin * We support four types of branding -- (1) the ELF EI_OSABI field 2655fe3ed62SJake Burkholder * that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string 26632c01de2SDmitry Chagin * branding w/in the ELF header, (3) path of the `interp_path' 26732c01de2SDmitry Chagin * field, and (4) the ".note.ABI-tag" ELF section. 2685fe3ed62SJake Burkholder */ 2695fe3ed62SJake Burkholder 27032c01de2SDmitry Chagin /* Look for an ".note.ABI-tag" ELF section */ 271af582aaeSKonstantin Belousov bi_m = NULL; 27232c01de2SDmitry Chagin for (i = 0; i < MAX_BRANDS; i++) { 27332c01de2SDmitry Chagin bi = elf_brand_list[i]; 274ecc2fda8SBjoern A. Zeeb if (bi == NULL) 275ecc2fda8SBjoern A. Zeeb continue; 276ecc2fda8SBjoern A. Zeeb if (hdr->e_machine == bi->machine && (bi->flags & 277ecc2fda8SBjoern A. Zeeb (BI_BRAND_NOTE|BI_BRAND_NOTE_MANDATORY)) != 0) { 27832c01de2SDmitry Chagin ret = __elfN(check_note)(imgp, bi->brand_note, osrel); 279f19d421aSNathan Whitehorn /* Give brand a chance to veto check_note's guess */ 280f19d421aSNathan Whitehorn if (ret && bi->header_supported) 281f19d421aSNathan Whitehorn ret = bi->header_supported(imgp); 282af582aaeSKonstantin Belousov /* 283af582aaeSKonstantin Belousov * If note checker claimed the binary, but the 284af582aaeSKonstantin Belousov * interpreter path in the image does not 285af582aaeSKonstantin Belousov * match default one for the brand, try to 286af582aaeSKonstantin Belousov * search for other brands with the same 287af582aaeSKonstantin Belousov * interpreter. Either there is better brand 288af582aaeSKonstantin Belousov * with the right interpreter, or, failing 289af582aaeSKonstantin Belousov * this, we return first brand which accepted 290af582aaeSKonstantin Belousov * our note and, optionally, header. 291af582aaeSKonstantin Belousov */ 292af582aaeSKonstantin Belousov if (ret && bi_m == NULL && (strlen(bi->interp_path) + 293af582aaeSKonstantin Belousov 1 != interp_name_len || strncmp(interp, 294af582aaeSKonstantin Belousov bi->interp_path, interp_name_len) != 0)) { 295af582aaeSKonstantin Belousov bi_m = bi; 296af582aaeSKonstantin Belousov ret = 0; 297af582aaeSKonstantin Belousov } 29832c01de2SDmitry Chagin if (ret) 29932c01de2SDmitry Chagin return (bi); 30032c01de2SDmitry Chagin } 30132c01de2SDmitry Chagin } 302af582aaeSKonstantin Belousov if (bi_m != NULL) 303af582aaeSKonstantin Belousov return (bi_m); 30432c01de2SDmitry Chagin 3055fe3ed62SJake Burkholder /* If the executable has a brand, search for it in the brand list. */ 3065fe3ed62SJake Burkholder for (i = 0; i < MAX_BRANDS; i++) { 3075fe3ed62SJake Burkholder bi = elf_brand_list[i]; 308ecc2fda8SBjoern A. Zeeb if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY) 309ecc2fda8SBjoern A. Zeeb continue; 310ecc2fda8SBjoern A. Zeeb if (hdr->e_machine == bi->machine && 3115fe3ed62SJake Burkholder (hdr->e_ident[EI_OSABI] == bi->brand || 3123d560b4bSKonstantin Belousov strcmp((const char *)&hdr->e_ident[OLD_EI_BRAND], 3133d560b4bSKonstantin Belousov bi->compat_3_brand) == 0)) { 314686d2f31SNathan Whitehorn /* Looks good, but give brand a chance to veto */ 31515a9aedfSKonstantin Belousov if (!bi->header_supported || 31615a9aedfSKonstantin Belousov bi->header_supported(imgp)) { 31715a9aedfSKonstantin Belousov /* 31815a9aedfSKonstantin Belousov * Again, prefer strictly matching 31915a9aedfSKonstantin Belousov * interpreter path. 32015a9aedfSKonstantin Belousov */ 321*7aab7a80SKonstantin Belousov if (interp_name_len == 0 && 322*7aab7a80SKonstantin Belousov bi->interp_path == NULL) 323*7aab7a80SKonstantin Belousov return (bi); 324*7aab7a80SKonstantin Belousov if (bi->interp_path != NULL && 325*7aab7a80SKonstantin Belousov strlen(bi->interp_path) + 1 == 32615a9aedfSKonstantin Belousov interp_name_len && strncmp(interp, 32715a9aedfSKonstantin Belousov bi->interp_path, interp_name_len) == 0) 3285fe3ed62SJake Burkholder return (bi); 32915a9aedfSKonstantin Belousov if (bi_m == NULL) 33015a9aedfSKonstantin Belousov bi_m = bi; 3315fe3ed62SJake Burkholder } 332686d2f31SNathan Whitehorn } 33315a9aedfSKonstantin Belousov } 33415a9aedfSKonstantin Belousov if (bi_m != NULL) 33515a9aedfSKonstantin Belousov return (bi_m); 3365fe3ed62SJake Burkholder 337817dc004SWarner Losh /* No known brand, see if the header is recognized by any brand */ 338817dc004SWarner Losh for (i = 0; i < MAX_BRANDS; i++) { 339817dc004SWarner Losh bi = elf_brand_list[i]; 340817dc004SWarner Losh if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY || 341817dc004SWarner Losh bi->header_supported == NULL) 342817dc004SWarner Losh continue; 343817dc004SWarner Losh if (hdr->e_machine == bi->machine) { 344817dc004SWarner Losh ret = bi->header_supported(imgp); 345817dc004SWarner Losh if (ret) 346817dc004SWarner Losh return (bi); 347817dc004SWarner Losh } 348817dc004SWarner Losh } 349817dc004SWarner Losh 3505fe3ed62SJake Burkholder /* Lacking a known brand, search for a recognized interpreter. */ 3515fe3ed62SJake Burkholder if (interp != NULL) { 3525fe3ed62SJake Burkholder for (i = 0; i < MAX_BRANDS; i++) { 3535fe3ed62SJake Burkholder bi = elf_brand_list[i]; 354ecc2fda8SBjoern A. Zeeb if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY) 355ecc2fda8SBjoern A. Zeeb continue; 356ecc2fda8SBjoern A. Zeeb if (hdr->e_machine == bi->machine && 357d1ae5c83SKonstantin Belousov /* ELF image p_filesz includes terminating zero */ 358d1ae5c83SKonstantin Belousov strlen(bi->interp_path) + 1 == interp_name_len && 359d1ae5c83SKonstantin Belousov strncmp(interp, bi->interp_path, interp_name_len) 360d1ae5c83SKonstantin Belousov == 0) 3615fe3ed62SJake Burkholder return (bi); 3625fe3ed62SJake Burkholder } 3635fe3ed62SJake Burkholder } 3645fe3ed62SJake Burkholder 3655fe3ed62SJake Burkholder /* Lacking a recognized interpreter, try the default brand */ 3665fe3ed62SJake Burkholder for (i = 0; i < MAX_BRANDS; i++) { 3675fe3ed62SJake Burkholder bi = elf_brand_list[i]; 368ecc2fda8SBjoern A. Zeeb if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY) 369ecc2fda8SBjoern A. Zeeb continue; 370ecc2fda8SBjoern A. Zeeb if (hdr->e_machine == bi->machine && 371e548a1d4SJake Burkholder __elfN(fallback_brand) == bi->brand) 3725fe3ed62SJake Burkholder return (bi); 3735fe3ed62SJake Burkholder } 3745fe3ed62SJake Burkholder return (NULL); 3755fe3ed62SJake Burkholder } 3765fe3ed62SJake Burkholder 377e1743d02SSøren Schmidt static int 3783ebc1248SPeter Wemm __elfN(check_header)(const Elf_Ehdr *hdr) 379e1743d02SSøren Schmidt { 380d0ca7c29SPeter Wemm Elf_Brandinfo *bi; 3813ebc1248SPeter Wemm int i; 3823ebc1248SPeter Wemm 38352c24af7SPeter Wemm if (!IS_ELF(*hdr) || 38452c24af7SPeter Wemm hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS || 38552c24af7SPeter Wemm hdr->e_ident[EI_DATA] != ELF_TARG_DATA || 3863dc19c46SJacques Vidrine hdr->e_ident[EI_VERSION] != EV_CURRENT || 3873dc19c46SJacques Vidrine hdr->e_phentsize != sizeof(Elf_Phdr) || 3883dc19c46SJacques Vidrine hdr->e_version != ELF_TARG_VER) 389a7cddfedSJake Burkholder return (ENOEXEC); 390e1743d02SSøren Schmidt 3913ebc1248SPeter Wemm /* 3923ebc1248SPeter Wemm * Make sure we have at least one brand for this machine. 3933ebc1248SPeter Wemm */ 3943ebc1248SPeter Wemm 3953ebc1248SPeter Wemm for (i = 0; i < MAX_BRANDS; i++) { 396d0ca7c29SPeter Wemm bi = elf_brand_list[i]; 397d0ca7c29SPeter Wemm if (bi != NULL && bi->machine == hdr->e_machine) 3983ebc1248SPeter Wemm break; 3993ebc1248SPeter Wemm } 4003ebc1248SPeter Wemm if (i == MAX_BRANDS) 401a7cddfedSJake Burkholder return (ENOEXEC); 402e1743d02SSøren Schmidt 403a7cddfedSJake Burkholder return (0); 404e1743d02SSøren Schmidt } 405e1743d02SSøren Schmidt 406e1743d02SSøren Schmidt static int 4073ebc1248SPeter Wemm __elfN(map_partial)(vm_map_t map, vm_object_t object, vm_ooffset_t offset, 408ff6f03c7SAlan Cox vm_offset_t start, vm_offset_t end, vm_prot_t prot) 4093ebc1248SPeter Wemm { 410da61b9a6SAlan Cox struct sf_buf *sf; 411da61b9a6SAlan Cox int error; 4123ebc1248SPeter Wemm vm_offset_t off; 4133ebc1248SPeter Wemm 4143ebc1248SPeter Wemm /* 4153ebc1248SPeter Wemm * Create the page if it doesn't exist yet. Ignore errors. 4163ebc1248SPeter Wemm */ 417aaadc41fSKonstantin Belousov vm_map_fixed(map, NULL, 0, trunc_page(start), round_page(end) - 418aaadc41fSKonstantin Belousov trunc_page(start), VM_PROT_ALL, VM_PROT_ALL, MAP_CHECK_EXCL); 4193ebc1248SPeter Wemm 4203ebc1248SPeter Wemm /* 4213ebc1248SPeter Wemm * Find the page from the underlying object. 4223ebc1248SPeter Wemm */ 42328e8da65SAlan Cox if (object != NULL) { 424da61b9a6SAlan Cox sf = vm_imgact_map_page(object, offset); 425da61b9a6SAlan Cox if (sf == NULL) 426da61b9a6SAlan Cox return (KERN_FAILURE); 4273ebc1248SPeter Wemm off = offset - trunc_page(offset); 428da61b9a6SAlan Cox error = copyout((caddr_t)sf_buf_kva(sf) + off, (caddr_t)start, 429ca0387efSJake Burkholder end - start); 430be996836SAttilio Rao vm_imgact_unmap_page(sf); 431fe0a8a39SKonstantin Belousov if (error != 0) 432a7cddfedSJake Burkholder return (KERN_FAILURE); 4333ebc1248SPeter Wemm } 4343ebc1248SPeter Wemm 435a7cddfedSJake Burkholder return (KERN_SUCCESS); 4363ebc1248SPeter Wemm } 4373ebc1248SPeter Wemm 4383ebc1248SPeter Wemm static int 439e3d8f8feSKonstantin Belousov __elfN(map_insert)(struct image_params *imgp, vm_map_t map, vm_object_t object, 440e3d8f8feSKonstantin Belousov vm_ooffset_t offset, vm_offset_t start, vm_offset_t end, vm_prot_t prot, 441e3d8f8feSKonstantin Belousov int cow) 4423ebc1248SPeter Wemm { 443da61b9a6SAlan Cox struct sf_buf *sf; 444da61b9a6SAlan Cox vm_offset_t off; 445a063facbSMarcel Moolenaar vm_size_t sz; 446e3d8f8feSKonstantin Belousov int error, locked, rv; 4473ebc1248SPeter Wemm 4483ebc1248SPeter Wemm if (start != trunc_page(start)) { 44981f223caSJake Burkholder rv = __elfN(map_partial)(map, object, offset, start, 450ff6f03c7SAlan Cox round_page(start), prot); 45128e8da65SAlan Cox if (rv != KERN_SUCCESS) 452a7cddfedSJake Burkholder return (rv); 4533ebc1248SPeter Wemm offset += round_page(start) - start; 4543ebc1248SPeter Wemm start = round_page(start); 4553ebc1248SPeter Wemm } 4563ebc1248SPeter Wemm if (end != round_page(end)) { 45781f223caSJake Burkholder rv = __elfN(map_partial)(map, object, offset + 458ff6f03c7SAlan Cox trunc_page(end) - start, trunc_page(end), end, prot); 45928e8da65SAlan Cox if (rv != KERN_SUCCESS) 460a7cddfedSJake Burkholder return (rv); 4613ebc1248SPeter Wemm end = trunc_page(end); 4623ebc1248SPeter Wemm } 463e383e820SAlan Cox if (start >= end) 464e383e820SAlan Cox return (KERN_SUCCESS); 465e383e820SAlan Cox if ((offset & PAGE_MASK) != 0) { 4663ebc1248SPeter Wemm /* 467e383e820SAlan Cox * The mapping is not page aligned. This means that we have 468e383e820SAlan Cox * to copy the data. 4693ebc1248SPeter Wemm */ 470aaadc41fSKonstantin Belousov rv = vm_map_fixed(map, NULL, 0, start, end - start, 471aaadc41fSKonstantin Belousov prot | VM_PROT_WRITE, VM_PROT_ALL, MAP_CHECK_EXCL); 4725420f76bSKonstantin Belousov if (rv != KERN_SUCCESS) 473a7cddfedSJake Burkholder return (rv); 474da61b9a6SAlan Cox if (object == NULL) 475da61b9a6SAlan Cox return (KERN_SUCCESS); 476da61b9a6SAlan Cox for (; start < end; start += sz) { 477da61b9a6SAlan Cox sf = vm_imgact_map_page(object, offset); 478da61b9a6SAlan Cox if (sf == NULL) 479da61b9a6SAlan Cox return (KERN_FAILURE); 4803ebc1248SPeter Wemm off = offset - trunc_page(offset); 4813ebc1248SPeter Wemm sz = end - start; 482da61b9a6SAlan Cox if (sz > PAGE_SIZE - off) 483da61b9a6SAlan Cox sz = PAGE_SIZE - off; 484da61b9a6SAlan Cox error = copyout((caddr_t)sf_buf_kva(sf) + off, 4853ebc1248SPeter Wemm (caddr_t)start, sz); 486be996836SAttilio Rao vm_imgact_unmap_page(sf); 4875420f76bSKonstantin Belousov if (error != 0) 488a7cddfedSJake Burkholder return (KERN_FAILURE); 489da61b9a6SAlan Cox offset += sz; 4903ebc1248SPeter Wemm } 4913ebc1248SPeter Wemm } else { 492e5e6093bSAlan Cox vm_object_reference(object); 493e383e820SAlan Cox rv = vm_map_fixed(map, object, offset, start, end - start, 494e383e820SAlan Cox prot, VM_PROT_ALL, cow | MAP_CHECK_EXCL); 495e3d8f8feSKonstantin Belousov if (rv != KERN_SUCCESS) { 496e3d8f8feSKonstantin Belousov locked = VOP_ISLOCKED(imgp->vp); 497e3d8f8feSKonstantin Belousov VOP_UNLOCK(imgp->vp, 0); 498e5e6093bSAlan Cox vm_object_deallocate(object); 499e3d8f8feSKonstantin Belousov vn_lock(imgp->vp, locked | LK_RETRY); 500a7cddfedSJake Burkholder return (rv); 5013ebc1248SPeter Wemm } 5023ebc1248SPeter Wemm } 503e383e820SAlan Cox return (KERN_SUCCESS); 504e383e820SAlan Cox } 5053ebc1248SPeter Wemm 5063ebc1248SPeter Wemm static int 5070bbee4cdSKonstantin Belousov __elfN(load_section)(struct image_params *imgp, vm_ooffset_t offset, 5083ebc1248SPeter Wemm caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot, 5093ebc1248SPeter Wemm size_t pagesize) 510e1743d02SSøren Schmidt { 511da61b9a6SAlan Cox struct sf_buf *sf; 512e1743d02SSøren Schmidt size_t map_len; 513292177e6SAlan Cox vm_map_t map; 514292177e6SAlan Cox vm_object_t object; 515973d67c4SKonstantin Belousov vm_offset_t off, map_addr; 516fa7dd9c5SMatthew Dillon int error, rv, cow; 517e1743d02SSøren Schmidt size_t copy_len; 5180bbee4cdSKonstantin Belousov vm_ooffset_t file_addr; 51952c24af7SPeter Wemm 52025ead034SBrian Feldman /* 52125ead034SBrian Feldman * It's necessary to fail if the filsz + offset taken from the 52225ead034SBrian Feldman * header is greater than the actual file pager object's size. 52325ead034SBrian Feldman * If we were to allow this, then the vm_map_find() below would 52425ead034SBrian Feldman * walk right off the end of the file object and into the ether. 52525ead034SBrian Feldman * 52625ead034SBrian Feldman * While I'm here, might as well check for something else that 52725ead034SBrian Feldman * is invalid: filsz cannot be greater than memsz. 52825ead034SBrian Feldman */ 5299bcf2f2dSKonstantin Belousov if ((filsz != 0 && (off_t)filsz + offset > imgp->attr->va_size) || 5309bcf2f2dSKonstantin Belousov filsz > memsz) { 53125ead034SBrian Feldman uprintf("elf_load_section: truncated ELF file\n"); 53225ead034SBrian Feldman return (ENOEXEC); 53325ead034SBrian Feldman } 53425ead034SBrian Feldman 535292177e6SAlan Cox object = imgp->object; 536292177e6SAlan Cox map = &imgp->proc->p_vmspace->vm_map; 5373ebc1248SPeter Wemm map_addr = trunc_page_ps((vm_offset_t)vmaddr, pagesize); 5383ebc1248SPeter Wemm file_addr = trunc_page_ps(offset, pagesize); 539e1743d02SSøren Schmidt 540e1743d02SSøren Schmidt /* 54152c24af7SPeter Wemm * We have two choices. We can either clear the data in the last page 54252c24af7SPeter Wemm * of an oversized mapping, or we can start the anon mapping a page 54352c24af7SPeter Wemm * early and copy the initialized data into that first page. We 54428e8da65SAlan Cox * choose the second. 54552c24af7SPeter Wemm */ 5469bcf2f2dSKonstantin Belousov if (filsz == 0) 5479bcf2f2dSKonstantin Belousov map_len = 0; 5489bcf2f2dSKonstantin Belousov else if (memsz > filsz) 5493ebc1248SPeter Wemm map_len = trunc_page_ps(offset + filsz, pagesize) - file_addr; 55052c24af7SPeter Wemm else 5513ebc1248SPeter Wemm map_len = round_page_ps(offset + filsz, pagesize) - file_addr; 55252c24af7SPeter Wemm 55352c24af7SPeter Wemm if (map_len != 0) { 554fa7dd9c5SMatthew Dillon /* cow flags: don't dump readonly sections in core */ 555fa7dd9c5SMatthew Dillon cow = MAP_COPY_ON_WRITE | MAP_PREFAULT | 556fa7dd9c5SMatthew Dillon (prot & VM_PROT_WRITE ? 0 : MAP_DISABLE_COREDUMP); 557fa7dd9c5SMatthew Dillon 558e3d8f8feSKonstantin Belousov rv = __elfN(map_insert)(imgp, map, 55952c24af7SPeter Wemm object, 56052c24af7SPeter Wemm file_addr, /* file offset */ 56152c24af7SPeter Wemm map_addr, /* virtual start */ 56252c24af7SPeter Wemm map_addr + map_len,/* virtual end */ 56352c24af7SPeter Wemm prot, 564fa7dd9c5SMatthew Dillon cow); 565e5e6093bSAlan Cox if (rv != KERN_SUCCESS) 566a7cddfedSJake Burkholder return (EINVAL); 56752c24af7SPeter Wemm 56852c24af7SPeter Wemm /* we can stop now if we've covered it all */ 569973d67c4SKonstantin Belousov if (memsz == filsz) 570a7cddfedSJake Burkholder return (0); 57152c24af7SPeter Wemm } 57252c24af7SPeter Wemm 57352c24af7SPeter Wemm 57452c24af7SPeter Wemm /* 57552c24af7SPeter Wemm * We have to get the remaining bit of the file into the first part 57652c24af7SPeter Wemm * of the oversized map segment. This is normally because the .data 57752c24af7SPeter Wemm * segment in the file is extended to provide bss. It's a neat idea 57852c24af7SPeter Wemm * to try and save a page, but it's a pain in the behind to implement. 579e1743d02SSøren Schmidt */ 5809bcf2f2dSKonstantin Belousov copy_len = filsz == 0 ? 0 : (offset + filsz) - trunc_page_ps(offset + 5819bcf2f2dSKonstantin Belousov filsz, pagesize); 5823ebc1248SPeter Wemm map_addr = trunc_page_ps((vm_offset_t)vmaddr + filsz, pagesize); 583ca0387efSJake Burkholder map_len = round_page_ps((vm_offset_t)vmaddr + memsz, pagesize) - 584ca0387efSJake Burkholder map_addr; 585e1743d02SSøren Schmidt 58652c24af7SPeter Wemm /* This had damn well better be true! */ 5878191d577SPeter Wemm if (map_len != 0) { 588e3d8f8feSKonstantin Belousov rv = __elfN(map_insert)(imgp, map, NULL, 0, map_addr, 589c547cbb4SAlan Cox map_addr + map_len, prot, 0); 590973d67c4SKonstantin Belousov if (rv != KERN_SUCCESS) 591a7cddfedSJake Burkholder return (EINVAL); 5928191d577SPeter Wemm } 593e1743d02SSøren Schmidt 59452c24af7SPeter Wemm if (copy_len != 0) { 595da61b9a6SAlan Cox sf = vm_imgact_map_page(object, offset + filsz); 596da61b9a6SAlan Cox if (sf == NULL) 597da61b9a6SAlan Cox return (EIO); 598e1743d02SSøren Schmidt 59952c24af7SPeter Wemm /* send the page fragment to user space */ 60081f223caSJake Burkholder off = trunc_page_ps(offset + filsz, pagesize) - 60181f223caSJake Burkholder trunc_page(offset + filsz); 602da61b9a6SAlan Cox error = copyout((caddr_t)sf_buf_kva(sf) + off, 603da61b9a6SAlan Cox (caddr_t)map_addr, copy_len); 604be996836SAttilio Rao vm_imgact_unmap_page(sf); 605973d67c4SKonstantin Belousov if (error != 0) 60652c24af7SPeter Wemm return (error); 60752c24af7SPeter Wemm } 608e1743d02SSøren Schmidt 609e1743d02SSøren Schmidt /* 610c547cbb4SAlan Cox * Remove write access to the page if it was only granted by map_insert 611c547cbb4SAlan Cox * to allow copyout. 612e1743d02SSøren Schmidt */ 613c547cbb4SAlan Cox if ((prot & VM_PROT_WRITE) == 0) 614292177e6SAlan Cox vm_map_protect(map, trunc_page(map_addr), round_page(map_addr + 615292177e6SAlan Cox map_len), prot, FALSE); 6168191d577SPeter Wemm 617ff6f03c7SAlan Cox return (0); 618e1743d02SSøren Schmidt } 619e1743d02SSøren Schmidt 620c33fe779SJohn Polstra /* 621c33fe779SJohn Polstra * Load the file "file" into memory. It may be either a shared object 622c33fe779SJohn Polstra * or an executable. 623c33fe779SJohn Polstra * 624c33fe779SJohn Polstra * The "addr" reference parameter is in/out. On entry, it specifies 625c33fe779SJohn Polstra * the address where a shared object should be loaded. If the file is 626c33fe779SJohn Polstra * an executable, this value is ignored. On exit, "addr" specifies 627c33fe779SJohn Polstra * where the file was actually loaded. 628c33fe779SJohn Polstra * 629c33fe779SJohn Polstra * The "entry" reference parameter is out only. On exit, it specifies 630c33fe779SJohn Polstra * the entry point for the loaded file. 631c33fe779SJohn Polstra */ 632e1743d02SSøren Schmidt static int 6333ebc1248SPeter Wemm __elfN(load_file)(struct proc *p, const char *file, u_long *addr, 6343ebc1248SPeter Wemm u_long *entry, size_t pagesize) 635e1743d02SSøren Schmidt { 636911c2be0SMark Peek struct { 637911c2be0SMark Peek struct nameidata nd; 638911c2be0SMark Peek struct vattr attr; 639911c2be0SMark Peek struct image_params image_params; 640911c2be0SMark Peek } *tempdata; 641d254af07SMatthew Dillon const Elf_Ehdr *hdr = NULL; 642d254af07SMatthew Dillon const Elf_Phdr *phdr = NULL; 643911c2be0SMark Peek struct nameidata *nd; 644911c2be0SMark Peek struct vattr *attr; 645911c2be0SMark Peek struct image_params *imgp; 64652c24af7SPeter Wemm vm_prot_t prot; 647c33fe779SJohn Polstra u_long rbase; 648c33fe779SJohn Polstra u_long base_addr = 0; 6495050aa86SKonstantin Belousov int error, i, numsegs; 650e1743d02SSøren Schmidt 65112bc222eSJonathan Anderson #ifdef CAPABILITY_MODE 65212bc222eSJonathan Anderson /* 65312bc222eSJonathan Anderson * XXXJA: This check can go away once we are sufficiently confident 65412bc222eSJonathan Anderson * that the checks in namei() are correct. 65512bc222eSJonathan Anderson */ 65612bc222eSJonathan Anderson if (IN_CAPABILITY_MODE(curthread)) 65712bc222eSJonathan Anderson return (ECAPMODE); 65812bc222eSJonathan Anderson #endif 65912bc222eSJonathan Anderson 660a163d034SWarner Losh tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK); 661911c2be0SMark Peek nd = &tempdata->nd; 662911c2be0SMark Peek attr = &tempdata->attr; 663911c2be0SMark Peek imgp = &tempdata->image_params; 664911c2be0SMark Peek 665c8a79999SPeter Wemm /* 666c8a79999SPeter Wemm * Initialize part of the common data 667c8a79999SPeter Wemm */ 668c8a79999SPeter Wemm imgp->proc = p; 669911c2be0SMark Peek imgp->attr = attr; 670c8a79999SPeter Wemm imgp->firstpage = NULL; 67159c8bc40SAlan Cox imgp->image_header = NULL; 6720b2ed1aeSJeff Roberson imgp->object = NULL; 6736d7bdc8dSRobert Watson imgp->execlabel = NULL; 674c8a79999SPeter Wemm 6755050aa86SKonstantin Belousov NDINIT(nd, LOOKUP, LOCKLEAF | FOLLOW, UIO_SYSSPACE, file, curthread); 676911c2be0SMark Peek if ((error = namei(nd)) != 0) { 677911c2be0SMark Peek nd->ni_vp = NULL; 678e1743d02SSøren Schmidt goto fail; 679e1743d02SSøren Schmidt } 680911c2be0SMark Peek NDFREE(nd, NDF_ONLY_PNBUF); 681911c2be0SMark Peek imgp->vp = nd->ni_vp; 682c8a79999SPeter Wemm 683e1743d02SSøren Schmidt /* 684e1743d02SSøren Schmidt * Check permissions, modes, uid, etc on the file, and "open" it. 685e1743d02SSøren Schmidt */ 686c8a79999SPeter Wemm error = exec_check_permissions(imgp); 687373d1a3fSAlan Cox if (error) 688c8a79999SPeter Wemm goto fail; 689e1743d02SSøren Schmidt 690c8a79999SPeter Wemm error = exec_map_first_page(imgp); 691373d1a3fSAlan Cox if (error) 692373d1a3fSAlan Cox goto fail; 693373d1a3fSAlan Cox 69425ead034SBrian Feldman /* 69525ead034SBrian Feldman * Also make certain that the interpreter stays the same, so set 696e6e370a7SJeff Roberson * its VV_TEXT flag, too. 69725ead034SBrian Feldman */ 698877d24acSKonstantin Belousov VOP_SET_TEXT(nd->ni_vp); 699e6e370a7SJeff Roberson 7008516dd18SPoul-Henning Kamp imgp->object = nd->ni_vp->v_object; 701e1743d02SSøren Schmidt 702d254af07SMatthew Dillon hdr = (const Elf_Ehdr *)imgp->image_header; 7033ebc1248SPeter Wemm if ((error = __elfN(check_header)(hdr)) != 0) 704e1743d02SSøren Schmidt goto fail; 705c33fe779SJohn Polstra if (hdr->e_type == ET_DYN) 706c33fe779SJohn Polstra rbase = *addr; 707c33fe779SJohn Polstra else if (hdr->e_type == ET_EXEC) 708c33fe779SJohn Polstra rbase = 0; 709c33fe779SJohn Polstra else { 710c33fe779SJohn Polstra error = ENOEXEC; 711c33fe779SJohn Polstra goto fail; 712c33fe779SJohn Polstra } 713e1743d02SSøren Schmidt 714c8a79999SPeter Wemm /* Only support headers that fit within first page for now */ 71552c24af7SPeter Wemm if ((hdr->e_phoff > PAGE_SIZE) || 716d19d5bf4STijl Coosemans (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) { 717c8a79999SPeter Wemm error = ENOEXEC; 718e1743d02SSøren Schmidt goto fail; 719c8a79999SPeter Wemm } 720c8a79999SPeter Wemm 721d254af07SMatthew Dillon phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff); 72293d1c728SKonstantin Belousov if (!aligned(phdr, Elf_Addr)) { 72393d1c728SKonstantin Belousov error = ENOEXEC; 72493d1c728SKonstantin Belousov goto fail; 72593d1c728SKonstantin Belousov } 726e1743d02SSøren Schmidt 727c33fe779SJohn Polstra for (i = 0, numsegs = 0; i < hdr->e_phnum; i++) { 7285b33842aSKonstantin Belousov if (phdr[i].p_type == PT_LOAD && phdr[i].p_memsz != 0) { 7295b33842aSKonstantin Belousov /* Loadable segment */ 730ed167eaaSKonstantin Belousov prot = __elfN(trans_prot)(phdr[i].p_flags); 731292177e6SAlan Cox error = __elfN(load_section)(imgp, phdr[i].p_offset, 73281f223caSJake Burkholder (caddr_t)(uintptr_t)phdr[i].p_vaddr + rbase, 733292177e6SAlan Cox phdr[i].p_memsz, phdr[i].p_filesz, prot, pagesize); 734292177e6SAlan Cox if (error != 0) 735e1743d02SSøren Schmidt goto fail; 736e1743d02SSøren Schmidt /* 737c33fe779SJohn Polstra * Establish the base address if this is the 738c33fe779SJohn Polstra * first segment. 739e1743d02SSøren Schmidt */ 740c33fe779SJohn Polstra if (numsegs == 0) 741ca0387efSJake Burkholder base_addr = trunc_page(phdr[i].p_vaddr + 742ca0387efSJake Burkholder rbase); 743c33fe779SJohn Polstra numsegs++; 744e1743d02SSøren Schmidt } 745e1743d02SSøren Schmidt } 746c33fe779SJohn Polstra *addr = base_addr; 747c33fe779SJohn Polstra *entry = (unsigned long)hdr->e_entry + rbase; 748e1743d02SSøren Schmidt 749e1743d02SSøren Schmidt fail: 750c8a79999SPeter Wemm if (imgp->firstpage) 751c8a79999SPeter Wemm exec_unmap_first_page(imgp); 7520b2ed1aeSJeff Roberson 753911c2be0SMark Peek if (nd->ni_vp) 754373d1a3fSAlan Cox vput(nd->ni_vp); 755911c2be0SMark Peek 756911c2be0SMark Peek free(tempdata, M_TEMP); 757e1743d02SSøren Schmidt 758a7cddfedSJake Burkholder return (error); 759e1743d02SSøren Schmidt } 760e1743d02SSøren Schmidt 761303b270bSEivind Eklund static int 7623ebc1248SPeter Wemm __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp) 763e1743d02SSøren Schmidt { 7646c775eb6SKonstantin Belousov struct thread *td; 7656c775eb6SKonstantin Belousov const Elf_Ehdr *hdr; 76632c01de2SDmitry Chagin const Elf_Phdr *phdr; 767e5e6093bSAlan Cox Elf_Auxargs *elf_auxargs; 7685856e12eSJohn Dyson struct vmspace *vmspace; 7696c775eb6SKonstantin Belousov const char *err_str, *newinterp; 7706c775eb6SKonstantin Belousov char *interp, *interp_buf, *path; 771d1dbc694SJohn Polstra Elf_Brandinfo *brand_info; 7725fe3ed62SJake Burkholder struct sysentvec *sv; 7736c775eb6SKonstantin Belousov vm_prot_t prot; 7746c775eb6SKonstantin Belousov u_long text_size, data_size, total_size, text_addr, data_addr; 7756c775eb6SKonstantin Belousov u_long seg_size, seg_addr, addr, baddr, et_dyn_addr, entry, proghdr; 7766c775eb6SKonstantin Belousov int32_t osrel; 7776c775eb6SKonstantin Belousov int error, i, n, interp_name_len, have_interp; 7786c775eb6SKonstantin Belousov 7796c775eb6SKonstantin Belousov hdr = (const Elf_Ehdr *)imgp->image_header; 780e1743d02SSøren Schmidt 781e1743d02SSøren Schmidt /* 782e1743d02SSøren Schmidt * Do we have a valid ELF header ? 783900b28f9SMaxim Sobolev * 784900b28f9SMaxim Sobolev * Only allow ET_EXEC & ET_DYN here, reject ET_DYN later 785900b28f9SMaxim Sobolev * if particular brand doesn't support it. 786e1743d02SSøren Schmidt */ 787900b28f9SMaxim Sobolev if (__elfN(check_header)(hdr) != 0 || 788900b28f9SMaxim Sobolev (hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN)) 789a7cddfedSJake Burkholder return (-1); 790e1743d02SSøren Schmidt 791e1743d02SSøren Schmidt /* 792e1743d02SSøren Schmidt * From here on down, we return an errno, not -1, as we've 793e1743d02SSøren Schmidt * detected an ELF file. 794e1743d02SSøren Schmidt */ 795e1743d02SSøren Schmidt 796e1743d02SSøren Schmidt if ((hdr->e_phoff > PAGE_SIZE) || 797d19d5bf4STijl Coosemans (u_int)hdr->e_phentsize * hdr->e_phnum > PAGE_SIZE - hdr->e_phoff) { 798c8a79999SPeter Wemm /* Only support headers in first page for now */ 7996b16d664SEd Maste uprintf("Program headers not in the first page\n"); 800a7cddfedSJake Burkholder return (ENOEXEC); 801e1743d02SSøren Schmidt } 80252c24af7SPeter Wemm phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff); 8036b16d664SEd Maste if (!aligned(phdr, Elf_Addr)) { 8046b16d664SEd Maste uprintf("Unaligned program headers\n"); 80593d1c728SKonstantin Belousov return (ENOEXEC); 8066b16d664SEd Maste } 8076c775eb6SKonstantin Belousov 8086c775eb6SKonstantin Belousov n = error = 0; 8097564c4adSKonstantin Belousov baddr = 0; 8106c775eb6SKonstantin Belousov osrel = 0; 8116c775eb6SKonstantin Belousov text_size = data_size = total_size = text_addr = data_addr = 0; 8126c775eb6SKonstantin Belousov entry = proghdr = 0; 8136c775eb6SKonstantin Belousov interp_name_len = 0; 8146c775eb6SKonstantin Belousov err_str = newinterp = NULL; 8156c775eb6SKonstantin Belousov interp = interp_buf = NULL; 8166c775eb6SKonstantin Belousov td = curthread; 8176c775eb6SKonstantin Belousov 8185fe3ed62SJake Burkholder for (i = 0; i < hdr->e_phnum; i++) { 819291c06a1SKonstantin Belousov switch (phdr[i].p_type) { 820291c06a1SKonstantin Belousov case PT_LOAD: 8217564c4adSKonstantin Belousov if (n == 0) 8227564c4adSKonstantin Belousov baddr = phdr[i].p_vaddr; 8237564c4adSKonstantin Belousov n++; 824291c06a1SKonstantin Belousov break; 825291c06a1SKonstantin Belousov case PT_INTERP: 826e5e6093bSAlan Cox /* Path to interpreter */ 8276c775eb6SKonstantin Belousov if (phdr[i].p_filesz > MAXPATHLEN) { 8286b16d664SEd Maste uprintf("Invalid PT_INTERP\n"); 8296c775eb6SKonstantin Belousov error = ENOEXEC; 8306c775eb6SKonstantin Belousov goto ret; 8316b16d664SEd Maste } 832d3ee0a15SJonathan T. Looney if (interp != NULL) { 833d3ee0a15SJonathan T. Looney uprintf("Multiple PT_INTERP headers\n"); 834d3ee0a15SJonathan T. Looney error = ENOEXEC; 835d3ee0a15SJonathan T. Looney goto ret; 836d3ee0a15SJonathan T. Looney } 837d1ae5c83SKonstantin Belousov interp_name_len = phdr[i].p_filesz; 8386c775eb6SKonstantin Belousov if (phdr[i].p_offset > PAGE_SIZE || 8396c775eb6SKonstantin Belousov interp_name_len > PAGE_SIZE - phdr[i].p_offset) { 8406c775eb6SKonstantin Belousov VOP_UNLOCK(imgp->vp, 0); 8416c775eb6SKonstantin Belousov interp_buf = malloc(interp_name_len + 1, M_TEMP, 8426c775eb6SKonstantin Belousov M_WAITOK); 8436c775eb6SKonstantin Belousov vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY); 8446c775eb6SKonstantin Belousov error = vn_rdwr(UIO_READ, imgp->vp, interp_buf, 8456c775eb6SKonstantin Belousov interp_name_len, phdr[i].p_offset, 8466c775eb6SKonstantin Belousov UIO_SYSSPACE, IO_NODELOCKED, td->td_ucred, 8476c775eb6SKonstantin Belousov NOCRED, NULL, td); 8486c775eb6SKonstantin Belousov if (error != 0) { 8496c775eb6SKonstantin Belousov uprintf("i/o error PT_INTERP\n"); 8506c775eb6SKonstantin Belousov goto ret; 8516c775eb6SKonstantin Belousov } 8526c775eb6SKonstantin Belousov interp_buf[interp_name_len] = '\0'; 8536c775eb6SKonstantin Belousov interp = interp_buf; 8546c775eb6SKonstantin Belousov } else { 8556c775eb6SKonstantin Belousov interp = __DECONST(char *, imgp->image_header) + 8566c775eb6SKonstantin Belousov phdr[i].p_offset; 8576c775eb6SKonstantin Belousov } 858291c06a1SKonstantin Belousov break; 859291c06a1SKonstantin Belousov case PT_GNU_STACK: 860291c06a1SKonstantin Belousov if (__elfN(nxstack)) 861291c06a1SKonstantin Belousov imgp->stack_prot = 862291c06a1SKonstantin Belousov __elfN(trans_prot)(phdr[i].p_flags); 863316b3843SKonstantin Belousov imgp->stack_sz = phdr[i].p_memsz; 864291c06a1SKonstantin Belousov break; 8653ebc1248SPeter Wemm } 8663ebc1248SPeter Wemm } 8673ebc1248SPeter Wemm 868d1ae5c83SKonstantin Belousov brand_info = __elfN(get_brandinfo)(imgp, interp, interp_name_len, 869d1ae5c83SKonstantin Belousov &osrel); 8705fe3ed62SJake Burkholder if (brand_info == NULL) { 8715fe3ed62SJake Burkholder uprintf("ELF binary type \"%u\" not known.\n", 8725fe3ed62SJake Burkholder hdr->e_ident[EI_OSABI]); 8736c775eb6SKonstantin Belousov error = ENOEXEC; 8746c775eb6SKonstantin Belousov goto ret; 8753ebc1248SPeter Wemm } 87677ebe276SEd Maste et_dyn_addr = 0; 877ab02d85fSKonstantin Belousov if (hdr->e_type == ET_DYN) { 8786b16d664SEd Maste if ((brand_info->flags & BI_CAN_EXEC_DYN) == 0) { 8796b16d664SEd Maste uprintf("Cannot execute shared object\n"); 8806c775eb6SKonstantin Belousov error = ENOEXEC; 8816c775eb6SKonstantin Belousov goto ret; 8826b16d664SEd Maste } 8837564c4adSKonstantin Belousov /* 8847564c4adSKonstantin Belousov * Honour the base load address from the dso if it is 8857564c4adSKonstantin Belousov * non-zero for some reason. 8867564c4adSKonstantin Belousov */ 8877564c4adSKonstantin Belousov if (baddr == 0) 888ab02d85fSKonstantin Belousov et_dyn_addr = ET_DYN_LOAD_ADDR; 88977ebe276SEd Maste } 8905fe3ed62SJake Burkholder sv = brand_info->sysvec; 8919b68618dSPeter Wemm if (interp != NULL && brand_info->interp_newpath != NULL) 8924113f8d7SPeter Wemm newinterp = brand_info->interp_newpath; 8933ebc1248SPeter Wemm 89460bb3943SAlan Cox /* 89560bb3943SAlan Cox * Avoid a possible deadlock if the current address space is destroyed 89660bb3943SAlan Cox * and that address space maps the locked vnode. In the common case, 89760bb3943SAlan Cox * the locked vnode's v_usecount is decremented but remains greater 89860bb3943SAlan Cox * than zero. Consequently, the vnode lock is not needed by vrele(). 89960bb3943SAlan Cox * However, in cases where the vnode lock is external, such as nullfs, 90060bb3943SAlan Cox * v_usecount may become zero. 9011dfab802SAlan Cox * 9021dfab802SAlan Cox * The VV_TEXT flag prevents modifications to the executable while 9031dfab802SAlan Cox * the vnode is unlocked. 90460bb3943SAlan Cox */ 90522db15c0SAttilio Rao VOP_UNLOCK(imgp->vp, 0); 90660bb3943SAlan Cox 90789b57fcfSKonstantin Belousov error = exec_new_vmspace(imgp, sv); 90819059a13SJohn Baldwin imgp->proc->p_sysent = sv; 909e1743d02SSøren Schmidt 910cb05b60aSAttilio Rao vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY); 9116c775eb6SKonstantin Belousov if (error != 0) 9126c775eb6SKonstantin Belousov goto ret; 91360bb3943SAlan Cox 914e1743d02SSøren Schmidt for (i = 0; i < hdr->e_phnum; i++) { 915e1743d02SSøren Schmidt switch (phdr[i].p_type) { 916e1743d02SSøren Schmidt case PT_LOAD: /* Loadable segment */ 9175b33842aSKonstantin Belousov if (phdr[i].p_memsz == 0) 9185b33842aSKonstantin Belousov break; 919ed167eaaSKonstantin Belousov prot = __elfN(trans_prot)(phdr[i].p_flags); 920292177e6SAlan Cox error = __elfN(load_section)(imgp, phdr[i].p_offset, 921ab02d85fSKonstantin Belousov (caddr_t)(uintptr_t)phdr[i].p_vaddr + et_dyn_addr, 92281f223caSJake Burkholder phdr[i].p_memsz, phdr[i].p_filesz, prot, 923292177e6SAlan Cox sv->sv_pagesize); 924292177e6SAlan Cox if (error != 0) 9256c775eb6SKonstantin Belousov goto ret; 926e1743d02SSøren Schmidt 927cfaf7e60SDoug Rabson /* 928cfaf7e60SDoug Rabson * If this segment contains the program headers, 929cfaf7e60SDoug Rabson * remember their virtual address for the AT_PHDR 930cfaf7e60SDoug Rabson * aux entry. Static binaries don't usually include 931cfaf7e60SDoug Rabson * a PT_PHDR entry. 932cfaf7e60SDoug Rabson */ 933cfaf7e60SDoug Rabson if (phdr[i].p_offset == 0 && 934cfaf7e60SDoug Rabson hdr->e_phoff + hdr->e_phnum * hdr->e_phentsize 935cfaf7e60SDoug Rabson <= phdr[i].p_filesz) 936ab02d85fSKonstantin Belousov proghdr = phdr[i].p_vaddr + hdr->e_phoff + 937ab02d85fSKonstantin Belousov et_dyn_addr; 938cfaf7e60SDoug Rabson 939ab02d85fSKonstantin Belousov seg_addr = trunc_page(phdr[i].p_vaddr + et_dyn_addr); 940cac45152SMatthew Dillon seg_size = round_page(phdr[i].p_memsz + 941ab02d85fSKonstantin Belousov phdr[i].p_vaddr + et_dyn_addr - seg_addr); 942cac45152SMatthew Dillon 943e1743d02SSøren Schmidt /* 944920acedbSNathan Whitehorn * Make the largest executable segment the official 945920acedbSNathan Whitehorn * text segment and all others data. 94621c2d047SMatthew Dillon * 94721c2d047SMatthew Dillon * Note that obreak() assumes that data_addr + 94821c2d047SMatthew Dillon * data_size == end of data load area, and the ELF 94921c2d047SMatthew Dillon * file format expects segments to be sorted by 95021c2d047SMatthew Dillon * address. If multiple data segments exist, the 95121c2d047SMatthew Dillon * last one will be used. 952e1743d02SSøren Schmidt */ 953920acedbSNathan Whitehorn 954920acedbSNathan Whitehorn if (phdr[i].p_flags & PF_X && text_size < seg_size) { 9559782ecbaSPeter Wemm text_size = seg_size; 9569782ecbaSPeter Wemm text_addr = seg_addr; 9579782ecbaSPeter Wemm } else { 95821c2d047SMatthew Dillon data_size = seg_size; 959cac45152SMatthew Dillon data_addr = seg_addr; 960cac45152SMatthew Dillon } 96121c2d047SMatthew Dillon total_size += seg_size; 96296725dd0SAlexander Kabaev break; 96396725dd0SAlexander Kabaev case PT_PHDR: /* Program header table info */ 964ab02d85fSKonstantin Belousov proghdr = phdr[i].p_vaddr + et_dyn_addr; 96596725dd0SAlexander Kabaev break; 96696725dd0SAlexander Kabaev default: 96796725dd0SAlexander Kabaev break; 96896725dd0SAlexander Kabaev } 96996725dd0SAlexander Kabaev } 97096725dd0SAlexander Kabaev 97196725dd0SAlexander Kabaev if (data_addr == 0 && data_size == 0) { 97296725dd0SAlexander Kabaev data_addr = text_addr; 97396725dd0SAlexander Kabaev data_size = text_size; 97496725dd0SAlexander Kabaev } 975cac45152SMatthew Dillon 976920acedbSNathan Whitehorn entry = (u_long)hdr->e_entry + et_dyn_addr; 977920acedbSNathan Whitehorn 978cac45152SMatthew Dillon /* 979cac45152SMatthew Dillon * Check limits. It should be safe to check the 98096725dd0SAlexander Kabaev * limits after loading the segments since we do 98196725dd0SAlexander Kabaev * not actually fault in all the segments pages. 982cac45152SMatthew Dillon */ 98391d5354aSJohn Baldwin PROC_LOCK(imgp->proc); 984f6f6d240SMateusz Guzik if (data_size > lim_cur_proc(imgp->proc, RLIMIT_DATA)) 9856b16d664SEd Maste err_str = "Data segment size exceeds process limit"; 9866b16d664SEd Maste else if (text_size > maxtsiz) 9876b16d664SEd Maste err_str = "Text segment size exceeds system limit"; 988f6f6d240SMateusz Guzik else if (total_size > lim_cur_proc(imgp->proc, RLIMIT_VMEM)) 9896b16d664SEd Maste err_str = "Total segment size exceeds process limit"; 9906b16d664SEd Maste else if (racct_set(imgp->proc, RACCT_DATA, data_size) != 0) 9916b16d664SEd Maste err_str = "Data segment size exceeds resource limit"; 9926b16d664SEd Maste else if (racct_set(imgp->proc, RACCT_VMEM, total_size) != 0) 9936b16d664SEd Maste err_str = "Total segment size exceeds resource limit"; 9946b16d664SEd Maste if (err_str != NULL) { 99591d5354aSJohn Baldwin PROC_UNLOCK(imgp->proc); 9966b16d664SEd Maste uprintf("%s\n", err_str); 9976c775eb6SKonstantin Belousov error = ENOMEM; 9986c775eb6SKonstantin Belousov goto ret; 999cac45152SMatthew Dillon } 1000e1743d02SSøren Schmidt 1001292177e6SAlan Cox vmspace = imgp->proc->p_vmspace; 1002e1743d02SSøren Schmidt vmspace->vm_tsize = text_size >> PAGE_SHIFT; 10037cd99438SBruce Evans vmspace->vm_taddr = (caddr_t)(uintptr_t)text_addr; 1004e1743d02SSøren Schmidt vmspace->vm_dsize = data_size >> PAGE_SHIFT; 10057cd99438SBruce Evans vmspace->vm_daddr = (caddr_t)(uintptr_t)data_addr; 1006e1743d02SSøren Schmidt 1007c460ac3aSPeter Wemm /* 1008c460ac3aSPeter Wemm * We load the dynamic linker where a userland call 1009c460ac3aSPeter Wemm * to mmap(0, ...) would put it. The rationale behind this 1010c460ac3aSPeter Wemm * calculation is that it leaves room for the heap to grow to 1011c460ac3aSPeter Wemm * its maximum allowed size. 1012c460ac3aSPeter Wemm */ 10136c775eb6SKonstantin Belousov addr = round_page((vm_offset_t)vmspace->vm_daddr + lim_max(td, 1014292177e6SAlan Cox RLIMIT_DATA)); 101591d5354aSJohn Baldwin PROC_UNLOCK(imgp->proc); 1016e1743d02SSøren Schmidt 1017ea5a2b2eSSøren Schmidt imgp->entry_addr = entry; 1018ea5a2b2eSSøren Schmidt 101960bb3943SAlan Cox if (interp != NULL) { 10206c775eb6SKonstantin Belousov have_interp = FALSE; 102122db15c0SAttilio Rao VOP_UNLOCK(imgp->vp, 0); 102260bb3943SAlan Cox if (brand_info->emul_path != NULL && 10239b68618dSPeter Wemm brand_info->emul_path[0] != '\0') { 1024a163d034SWarner Losh path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 102560bb3943SAlan Cox snprintf(path, MAXPATHLEN, "%s%s", 102660bb3943SAlan Cox brand_info->emul_path, interp); 10279b68618dSPeter Wemm error = __elfN(load_file)(imgp->proc, path, &addr, 10289b68618dSPeter Wemm &imgp->entry_addr, sv->sv_pagesize); 1029911c2be0SMark Peek free(path, M_TEMP); 10309b68618dSPeter Wemm if (error == 0) 10314113f8d7SPeter Wemm have_interp = TRUE; 10329b68618dSPeter Wemm } 103318995077SKonstantin Belousov if (!have_interp && newinterp != NULL && 103418995077SKonstantin Belousov (brand_info->interp_path == NULL || 103518995077SKonstantin Belousov strcmp(interp, brand_info->interp_path) == 0)) { 10364113f8d7SPeter Wemm error = __elfN(load_file)(imgp->proc, newinterp, &addr, 10374113f8d7SPeter Wemm &imgp->entry_addr, sv->sv_pagesize); 1038387ad998SKonstantin Belousov if (error == 0) 10394113f8d7SPeter Wemm have_interp = TRUE; 10404113f8d7SPeter Wemm } 10414113f8d7SPeter Wemm if (!have_interp) { 10429b68618dSPeter Wemm error = __elfN(load_file)(imgp->proc, interp, &addr, 10439b68618dSPeter Wemm &imgp->entry_addr, sv->sv_pagesize); 104460bb3943SAlan Cox } 1045cb05b60aSAttilio Rao vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY); 10469b68618dSPeter Wemm if (error != 0) { 1047d943fa35SKonstantin Belousov uprintf("ELF interpreter %s not found, error %d\n", 1048d943fa35SKonstantin Belousov interp, error); 10496c775eb6SKonstantin Belousov goto ret; 1050e1743d02SSøren Schmidt } 105195c807cfSRobert Watson } else 10527564c4adSKonstantin Belousov addr = et_dyn_addr; 1053ea5a2b2eSSøren Schmidt 1054e1743d02SSøren Schmidt /* 1055e1743d02SSøren Schmidt * Construct auxargs table (used by the fixup routine) 1056e1743d02SSøren Schmidt */ 1057a163d034SWarner Losh elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, M_WAITOK); 1058e1743d02SSøren Schmidt elf_auxargs->execfd = -1; 1059e1743d02SSøren Schmidt elf_auxargs->phdr = proghdr; 1060e1743d02SSøren Schmidt elf_auxargs->phent = hdr->e_phentsize; 1061e1743d02SSøren Schmidt elf_auxargs->phnum = hdr->e_phnum; 1062e1743d02SSøren Schmidt elf_auxargs->pagesz = PAGE_SIZE; 1063e1743d02SSøren Schmidt elf_auxargs->base = addr; 1064e1743d02SSøren Schmidt elf_auxargs->flags = 0; 1065e1743d02SSøren Schmidt elf_auxargs->entry = entry; 1066d36eec69SWarner Losh elf_auxargs->hdr_eflags = hdr->e_flags; 1067e1743d02SSøren Schmidt 1068e1743d02SSøren Schmidt imgp->auxargs = elf_auxargs; 1069e1743d02SSøren Schmidt imgp->interpreted = 0; 1070a0ea661fSNathan Whitehorn imgp->reloc_base = addr; 107132c01de2SDmitry Chagin imgp->proc->p_osrel = osrel; 1072885f13dcSJohn Baldwin imgp->proc->p_elf_machine = hdr->e_machine; 1073885f13dcSJohn Baldwin imgp->proc->p_elf_flags = hdr->e_flags; 1074f231de47SKonstantin Belousov 10756c775eb6SKonstantin Belousov ret: 10766c775eb6SKonstantin Belousov free(interp_buf, M_TEMP); 1077a7cddfedSJake Burkholder return (error); 1078e1743d02SSøren Schmidt } 1079e1743d02SSøren Schmidt 1080a360a43dSJake Burkholder #define suword __CONCAT(suword, __ELF_WORD_SIZE) 10813ebc1248SPeter Wemm 10823ebc1248SPeter Wemm int 10833ebc1248SPeter Wemm __elfN(freebsd_fixup)(register_t **stack_base, struct image_params *imgp) 1084e1743d02SSøren Schmidt { 1085ecbb00a2SDoug Rabson Elf_Auxargs *args = (Elf_Auxargs *)imgp->auxargs; 1086a360a43dSJake Burkholder Elf_Addr *base; 1087a360a43dSJake Burkholder Elf_Addr *pos; 1088e1743d02SSøren Schmidt 1089a360a43dSJake Burkholder base = (Elf_Addr *)*stack_base; 1090610ecfe0SMaxim Sobolev pos = base + (imgp->args->argc + imgp->args->envc + 2); 1091e1743d02SSøren Schmidt 109235c2a5a8SWarner Losh if (args->execfd != -1) 1093e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd); 1094e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_PHDR, args->phdr); 1095e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_PHENT, args->phent); 1096e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum); 1097e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz); 1098e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_FLAGS, args->flags); 1099e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_ENTRY, args->entry); 1100e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_BASE, args->base); 1101ee960398SWarner Losh #ifdef AT_EHDRFLAGS 1102d36eec69SWarner Losh AUXARGS_ENTRY(pos, AT_EHDRFLAGS, args->hdr_eflags); 1103d36eec69SWarner Losh #endif 11043ff06357SKonstantin Belousov if (imgp->execpathp != 0) 11053ff06357SKonstantin Belousov AUXARGS_ENTRY(pos, AT_EXECPATH, imgp->execpathp); 1106b96bd95bSIan Lepore AUXARGS_ENTRY(pos, AT_OSRELDATE, 1107b96bd95bSIan Lepore imgp->proc->p_ucred->cr_prison->pr_osreldate); 1108ee235befSKonstantin Belousov if (imgp->canary != 0) { 1109ee235befSKonstantin Belousov AUXARGS_ENTRY(pos, AT_CANARY, imgp->canary); 1110ee235befSKonstantin Belousov AUXARGS_ENTRY(pos, AT_CANARYLEN, imgp->canarylen); 1111ee235befSKonstantin Belousov } 1112ee235befSKonstantin Belousov AUXARGS_ENTRY(pos, AT_NCPUS, mp_ncpus); 1113ee235befSKonstantin Belousov if (imgp->pagesizes != 0) { 1114ee235befSKonstantin Belousov AUXARGS_ENTRY(pos, AT_PAGESIZES, imgp->pagesizes); 1115ee235befSKonstantin Belousov AUXARGS_ENTRY(pos, AT_PAGESIZESLEN, imgp->pagesizeslen); 1116ee235befSKonstantin Belousov } 1117aea81038SKonstantin Belousov if (imgp->sysent->sv_timekeep_base != 0) { 1118aea81038SKonstantin Belousov AUXARGS_ENTRY(pos, AT_TIMEKEEP, 1119aea81038SKonstantin Belousov imgp->sysent->sv_timekeep_base); 1120aea81038SKonstantin Belousov } 112126d8f3e1SKonstantin Belousov AUXARGS_ENTRY(pos, AT_STACKPROT, imgp->sysent->sv_shared_page_obj 112226d8f3e1SKonstantin Belousov != NULL && imgp->stack_prot != 0 ? imgp->stack_prot : 112326d8f3e1SKonstantin Belousov imgp->sysent->sv_stackprot); 1124e1743d02SSøren Schmidt AUXARGS_ENTRY(pos, AT_NULL, 0); 1125e1743d02SSøren Schmidt 1126e1743d02SSøren Schmidt free(imgp->auxargs, M_TEMP); 1127e1743d02SSøren Schmidt imgp->auxargs = NULL; 1128e1743d02SSøren Schmidt 11293ebc1248SPeter Wemm base--; 1130610ecfe0SMaxim Sobolev suword(base, (long)imgp->args->argc); 11313ebc1248SPeter Wemm *stack_base = (register_t *)base; 1132a7cddfedSJake Burkholder return (0); 1133e1743d02SSøren Schmidt } 1134e1743d02SSøren Schmidt 1135e1743d02SSøren Schmidt /* 11368c64af4fSJohn Polstra * Code for generating ELF core dumps. 11378c64af4fSJohn Polstra */ 11388c64af4fSJohn Polstra 11394d77a549SAlfred Perlstein typedef void (*segment_callback)(vm_map_entry_t, void *); 11400ff27d31SJohn Polstra 11410ff27d31SJohn Polstra /* Closure for cb_put_phdr(). */ 11420ff27d31SJohn Polstra struct phdr_closure { 11430ff27d31SJohn Polstra Elf_Phdr *phdr; /* Program header to fill in */ 11440ff27d31SJohn Polstra Elf_Off offset; /* Offset of segment in core file */ 11450ff27d31SJohn Polstra }; 11460ff27d31SJohn Polstra 11470ff27d31SJohn Polstra /* Closure for cb_size_segment(). */ 11480ff27d31SJohn Polstra struct sseg_closure { 11490ff27d31SJohn Polstra int count; /* Count of writable segments. */ 11500ff27d31SJohn Polstra size_t size; /* Total size of all writable segments. */ 11510ff27d31SJohn Polstra }; 11520ff27d31SJohn Polstra 1153bd390213SMikolaj Golub typedef void (*outfunc_t)(void *, struct sbuf *, size_t *); 1154bd390213SMikolaj Golub 1155bd390213SMikolaj Golub struct note_info { 1156bd390213SMikolaj Golub int type; /* Note type. */ 1157bd390213SMikolaj Golub outfunc_t outfunc; /* Output function. */ 1158bd390213SMikolaj Golub void *outarg; /* Argument for the output function. */ 1159bd390213SMikolaj Golub size_t outsize; /* Output size. */ 1160bd390213SMikolaj Golub TAILQ_ENTRY(note_info) link; /* Link to the next note info. */ 1161bd390213SMikolaj Golub }; 1162bd390213SMikolaj Golub 1163bd390213SMikolaj Golub TAILQ_HEAD(note_info_list, note_info); 1164bd390213SMikolaj Golub 1165aa14e9b7SMark Johnston /* Coredump output parameters. */ 1166aa14e9b7SMark Johnston struct coredump_params { 1167aa14e9b7SMark Johnston off_t offset; 1168aa14e9b7SMark Johnston struct ucred *active_cred; 1169aa14e9b7SMark Johnston struct ucred *file_cred; 1170aa14e9b7SMark Johnston struct thread *td; 1171aa14e9b7SMark Johnston struct vnode *vp; 1172aa14e9b7SMark Johnston struct gzio_stream *gzs; 1173aa14e9b7SMark Johnston }; 1174aa14e9b7SMark Johnston 11754d77a549SAlfred Perlstein static void cb_put_phdr(vm_map_entry_t, void *); 11764d77a549SAlfred Perlstein static void cb_size_segment(vm_map_entry_t, void *); 1177c468ff88SAndriy Gapon static int core_write(struct coredump_params *, const void *, size_t, off_t, 1178aa14e9b7SMark Johnston enum uio_seg); 11791005d8afSConrad Meyer static void each_dumpable_segment(struct thread *, segment_callback, void *); 1180aa14e9b7SMark Johnston static int __elfN(corehdr)(struct coredump_params *, int, void *, size_t, 1181aa14e9b7SMark Johnston struct note_info_list *, size_t); 1182bd390213SMikolaj Golub static void __elfN(prepare_notes)(struct thread *, struct note_info_list *, 1183bd390213SMikolaj Golub size_t *); 1184bd390213SMikolaj Golub static void __elfN(puthdr)(struct thread *, void *, size_t, int, size_t); 1185bd390213SMikolaj Golub static void __elfN(putnote)(struct note_info *, struct sbuf *); 1186bd390213SMikolaj Golub static size_t register_note(struct note_info_list *, int, outfunc_t, void *); 1187bd390213SMikolaj Golub static int sbuf_drain_core_output(void *, const char *, int); 1188f1fca82eSMikolaj Golub static int sbuf_drain_count(void *arg, const char *data, int len); 1189bd390213SMikolaj Golub 1190bd390213SMikolaj Golub static void __elfN(note_fpregset)(void *, struct sbuf *, size_t *); 1191bd390213SMikolaj Golub static void __elfN(note_prpsinfo)(void *, struct sbuf *, size_t *); 1192bd390213SMikolaj Golub static void __elfN(note_prstatus)(void *, struct sbuf *, size_t *); 1193bd390213SMikolaj Golub static void __elfN(note_threadmd)(void *, struct sbuf *, size_t *); 1194bd390213SMikolaj Golub static void __elfN(note_thrmisc)(void *, struct sbuf *, size_t *); 1195f1fca82eSMikolaj Golub static void __elfN(note_procstat_auxv)(void *, struct sbuf *, size_t *); 1196f1fca82eSMikolaj Golub static void __elfN(note_procstat_proc)(void *, struct sbuf *, size_t *); 1197f1fca82eSMikolaj Golub static void __elfN(note_procstat_psstrings)(void *, struct sbuf *, size_t *); 1198f1fca82eSMikolaj Golub static void note_procstat_files(void *, struct sbuf *, size_t *); 1199f1fca82eSMikolaj Golub static void note_procstat_groups(void *, struct sbuf *, size_t *); 1200f1fca82eSMikolaj Golub static void note_procstat_osrel(void *, struct sbuf *, size_t *); 1201f1fca82eSMikolaj Golub static void note_procstat_rlimit(void *, struct sbuf *, size_t *); 1202f1fca82eSMikolaj Golub static void note_procstat_umask(void *, struct sbuf *, size_t *); 1203f1fca82eSMikolaj Golub static void note_procstat_vmmap(void *, struct sbuf *, size_t *); 12048c64af4fSJohn Polstra 1205aa14e9b7SMark Johnston #ifdef GZIO 1206e7228204SAlfred Perlstein extern int compress_user_cores_gzlevel; 1207e7228204SAlfred Perlstein 1208aa14e9b7SMark Johnston /* 1209aa14e9b7SMark Johnston * Write out a core segment to the compression stream. 1210aa14e9b7SMark Johnston */ 1211e7228204SAlfred Perlstein static int 1212aa14e9b7SMark Johnston compress_chunk(struct coredump_params *p, char *base, char *buf, u_int len) 1213aa14e9b7SMark Johnston { 1214aa14e9b7SMark Johnston u_int chunk_len; 1215e7228204SAlfred Perlstein int error; 1216aa14e9b7SMark Johnston 1217aa14e9b7SMark Johnston while (len > 0) { 1218aa14e9b7SMark Johnston chunk_len = MIN(len, CORE_BUF_SIZE); 1219c468ff88SAndriy Gapon 1220c468ff88SAndriy Gapon /* 1221c468ff88SAndriy Gapon * We can get EFAULT error here. 1222c468ff88SAndriy Gapon * In that case zero out the current chunk of the segment. 1223c468ff88SAndriy Gapon */ 1224c468ff88SAndriy Gapon error = copyin(base, buf, chunk_len); 1225c468ff88SAndriy Gapon if (error != 0) 1226c468ff88SAndriy Gapon bzero(buf, chunk_len); 1227aa14e9b7SMark Johnston error = gzio_write(p->gzs, buf, chunk_len); 1228aa14e9b7SMark Johnston if (error != 0) 1229aa14e9b7SMark Johnston break; 1230aa14e9b7SMark Johnston base += chunk_len; 1231aa14e9b7SMark Johnston len -= chunk_len; 1232e7228204SAlfred Perlstein } 1233e7228204SAlfred Perlstein return (error); 1234e7228204SAlfred Perlstein } 1235e7228204SAlfred Perlstein 1236aa14e9b7SMark Johnston static int 1237aa14e9b7SMark Johnston core_gz_write(void *base, size_t len, off_t offset, void *arg) 1238aa14e9b7SMark Johnston { 1239aa14e9b7SMark Johnston 1240aa14e9b7SMark Johnston return (core_write((struct coredump_params *)arg, base, len, offset, 1241aa14e9b7SMark Johnston UIO_SYSSPACE)); 1242aa14e9b7SMark Johnston } 1243aa14e9b7SMark Johnston #endif /* GZIO */ 1244aa14e9b7SMark Johnston 1245aa14e9b7SMark Johnston static int 1246c468ff88SAndriy Gapon core_write(struct coredump_params *p, const void *base, size_t len, 1247c468ff88SAndriy Gapon off_t offset, enum uio_seg seg) 1248aa14e9b7SMark Johnston { 1249aa14e9b7SMark Johnston 1250c468ff88SAndriy Gapon return (vn_rdwr_inchunks(UIO_WRITE, p->vp, __DECONST(void *, base), 1251c468ff88SAndriy Gapon len, offset, seg, IO_UNIT | IO_DIRECT | IO_RANGELOCKED, 1252aa14e9b7SMark Johnston p->active_cred, p->file_cred, NULL, p->td)); 1253aa14e9b7SMark Johnston } 1254aa14e9b7SMark Johnston 1255aa14e9b7SMark Johnston static int 1256aa14e9b7SMark Johnston core_output(void *base, size_t len, off_t offset, struct coredump_params *p, 1257aa14e9b7SMark Johnston void *tmpbuf) 1258aa14e9b7SMark Johnston { 1259c468ff88SAndriy Gapon int error; 1260aa14e9b7SMark Johnston 1261aa14e9b7SMark Johnston #ifdef GZIO 1262aa14e9b7SMark Johnston if (p->gzs != NULL) 1263aa14e9b7SMark Johnston return (compress_chunk(p, base, tmpbuf, len)); 1264bd390213SMikolaj Golub #endif 1265c468ff88SAndriy Gapon /* 1266c468ff88SAndriy Gapon * EFAULT is a non-fatal error that we can get, for example, 1267c468ff88SAndriy Gapon * if the segment is backed by a file but extends beyond its 1268c468ff88SAndriy Gapon * end. 1269c468ff88SAndriy Gapon */ 1270c468ff88SAndriy Gapon error = core_write(p, base, len, offset, UIO_USERSPACE); 1271c468ff88SAndriy Gapon if (error == EFAULT) { 1272c468ff88SAndriy Gapon log(LOG_WARNING, "Failed to fully fault in a core file segment " 1273c468ff88SAndriy Gapon "at VA %p with size 0x%zx to be written at offset 0x%jx " 1274c468ff88SAndriy Gapon "for process %s\n", base, len, offset, curproc->p_comm); 1275c468ff88SAndriy Gapon 1276c468ff88SAndriy Gapon /* 1277c468ff88SAndriy Gapon * Write a "real" zero byte at the end of the target region 1278c468ff88SAndriy Gapon * in the case this is the last segment. 1279c468ff88SAndriy Gapon * The intermediate space will be implicitly zero-filled. 1280c468ff88SAndriy Gapon */ 1281c468ff88SAndriy Gapon error = core_write(p, zero_region, 1, offset + len - 1, 1282c468ff88SAndriy Gapon UIO_SYSSPACE); 1283c468ff88SAndriy Gapon } 1284c468ff88SAndriy Gapon return (error); 1285aa14e9b7SMark Johnston } 1286bd390213SMikolaj Golub 1287bd390213SMikolaj Golub /* 1288bd390213SMikolaj Golub * Drain into a core file. 1289bd390213SMikolaj Golub */ 1290bd390213SMikolaj Golub static int 1291bd390213SMikolaj Golub sbuf_drain_core_output(void *arg, const char *data, int len) 1292bd390213SMikolaj Golub { 1293aa14e9b7SMark Johnston struct coredump_params *p; 1294f1fca82eSMikolaj Golub int error, locked; 1295bd390213SMikolaj Golub 1296aa14e9b7SMark Johnston p = (struct coredump_params *)arg; 1297f1fca82eSMikolaj Golub 1298f1fca82eSMikolaj Golub /* 1299f1fca82eSMikolaj Golub * Some kern_proc out routines that print to this sbuf may 1300f1fca82eSMikolaj Golub * call us with the process lock held. Draining with the 1301f1fca82eSMikolaj Golub * non-sleepable lock held is unsafe. The lock is needed for 1302f1fca82eSMikolaj Golub * those routines when dumping a live process. In our case we 1303f1fca82eSMikolaj Golub * can safely release the lock before draining and acquire 1304f1fca82eSMikolaj Golub * again after. 1305f1fca82eSMikolaj Golub */ 1306f1fca82eSMikolaj Golub locked = PROC_LOCKED(p->td->td_proc); 1307f1fca82eSMikolaj Golub if (locked) 1308f1fca82eSMikolaj Golub PROC_UNLOCK(p->td->td_proc); 1309aa14e9b7SMark Johnston #ifdef GZIO 1310aa14e9b7SMark Johnston if (p->gzs != NULL) 1311aa14e9b7SMark Johnston error = gzio_write(p->gzs, __DECONST(char *, data), len); 1312bd390213SMikolaj Golub else 1313bd390213SMikolaj Golub #endif 1314aa14e9b7SMark Johnston error = core_write(p, __DECONST(void *, data), len, p->offset, 1315aa14e9b7SMark Johnston UIO_SYSSPACE); 1316f1fca82eSMikolaj Golub if (locked) 1317f1fca82eSMikolaj Golub PROC_LOCK(p->td->td_proc); 1318bd390213SMikolaj Golub if (error != 0) 1319bd390213SMikolaj Golub return (-error); 1320bd390213SMikolaj Golub p->offset += len; 1321bd390213SMikolaj Golub return (len); 1322bd390213SMikolaj Golub } 1323bd390213SMikolaj Golub 1324f1fca82eSMikolaj Golub /* 1325f1fca82eSMikolaj Golub * Drain into a counter. 1326f1fca82eSMikolaj Golub */ 1327f1fca82eSMikolaj Golub static int 1328f1fca82eSMikolaj Golub sbuf_drain_count(void *arg, const char *data __unused, int len) 1329f1fca82eSMikolaj Golub { 1330f1fca82eSMikolaj Golub size_t *sizep; 1331f1fca82eSMikolaj Golub 1332f1fca82eSMikolaj Golub sizep = (size_t *)arg; 1333f1fca82eSMikolaj Golub *sizep += len; 1334f1fca82eSMikolaj Golub return (len); 1335f1fca82eSMikolaj Golub } 1336f1fca82eSMikolaj Golub 13378c64af4fSJohn Polstra int 1338e7228204SAlfred Perlstein __elfN(coredump)(struct thread *td, struct vnode *vp, off_t limit, int flags) 1339fca666a1SJulian Elischer { 1340247aba24SMarcel Moolenaar struct ucred *cred = td->td_ucred; 1341fca666a1SJulian Elischer int error = 0; 13420ff27d31SJohn Polstra struct sseg_closure seginfo; 1343bd390213SMikolaj Golub struct note_info_list notelst; 1344aa14e9b7SMark Johnston struct coredump_params params; 1345bd390213SMikolaj Golub struct note_info *ninfo; 1346aa14e9b7SMark Johnston void *hdr, *tmpbuf; 1347bd390213SMikolaj Golub size_t hdrsize, notesz, coresize; 13489a12e282SEnji Cooper #ifdef GZIO 1349aa14e9b7SMark Johnston boolean_t compress; 13508c64af4fSJohn Polstra 1351aa14e9b7SMark Johnston compress = (flags & IMGACT_CORE_COMPRESS) != 0; 13529a12e282SEnji Cooper #endif 1353e7228204SAlfred Perlstein hdr = NULL; 135402d131adSMark Johnston tmpbuf = NULL; 1355bd390213SMikolaj Golub TAILQ_INIT(¬elst); 1356e7228204SAlfred Perlstein 13570ff27d31SJohn Polstra /* Size the program segments. */ 13580ff27d31SJohn Polstra seginfo.count = 0; 13590ff27d31SJohn Polstra seginfo.size = 0; 13601005d8afSConrad Meyer each_dumpable_segment(td, cb_size_segment, &seginfo); 13610ff27d31SJohn Polstra 13620ff27d31SJohn Polstra /* 1363bd390213SMikolaj Golub * Collect info about the core file header area. 13640ff27d31SJohn Polstra */ 1365bd390213SMikolaj Golub hdrsize = sizeof(Elf_Ehdr) + sizeof(Elf_Phdr) * (1 + seginfo.count); 1366c17b0bd2SConrad Meyer if (seginfo.count + 1 >= PN_XNUM) 1367c17b0bd2SConrad Meyer hdrsize += sizeof(Elf_Shdr); 1368bd390213SMikolaj Golub __elfN(prepare_notes)(td, ¬elst, ¬esz); 1369bd390213SMikolaj Golub coresize = round_page(hdrsize + notesz) + seginfo.size; 13700ff27d31SJohn Polstra 137102d131adSMark Johnston /* Set up core dump parameters. */ 137202d131adSMark Johnston params.offset = 0; 137302d131adSMark Johnston params.active_cred = cred; 137402d131adSMark Johnston params.file_cred = NOCRED; 137502d131adSMark Johnston params.td = td; 137602d131adSMark Johnston params.vp = vp; 137702d131adSMark Johnston params.gzs = NULL; 137802d131adSMark Johnston 1379afcc55f3SEdward Tomasz Napierala #ifdef RACCT 13804b5c9cf6SEdward Tomasz Napierala if (racct_enable) { 13811ba5ad42SEdward Tomasz Napierala PROC_LOCK(td->td_proc); 1382bd390213SMikolaj Golub error = racct_add(td->td_proc, RACCT_CORE, coresize); 13831ba5ad42SEdward Tomasz Napierala PROC_UNLOCK(td->td_proc); 13841ba5ad42SEdward Tomasz Napierala if (error != 0) { 13851ba5ad42SEdward Tomasz Napierala error = EFAULT; 13861ba5ad42SEdward Tomasz Napierala goto done; 13871ba5ad42SEdward Tomasz Napierala } 13884b5c9cf6SEdward Tomasz Napierala } 1389afcc55f3SEdward Tomasz Napierala #endif 1390bd390213SMikolaj Golub if (coresize >= limit) { 1391fba6b1afSAlfred Perlstein error = EFAULT; 1392fba6b1afSAlfred Perlstein goto done; 1393fba6b1afSAlfred Perlstein } 13940ff27d31SJohn Polstra 1395aa14e9b7SMark Johnston #ifdef GZIO 1396aa14e9b7SMark Johnston /* Create a compression stream if necessary. */ 1397aa14e9b7SMark Johnston if (compress) { 1398aa14e9b7SMark Johnston params.gzs = gzio_init(core_gz_write, GZIO_DEFLATE, 1399aa14e9b7SMark Johnston CORE_BUF_SIZE, compress_user_cores_gzlevel, ¶ms); 1400aa14e9b7SMark Johnston if (params.gzs == NULL) { 1401aa14e9b7SMark Johnston error = EFAULT; 1402aa14e9b7SMark Johnston goto done; 1403aa14e9b7SMark Johnston } 1404aa14e9b7SMark Johnston tmpbuf = malloc(CORE_BUF_SIZE, M_TEMP, M_WAITOK | M_ZERO); 1405aa14e9b7SMark Johnston } 1406aa14e9b7SMark Johnston #endif 1407aa14e9b7SMark Johnston 14080ff27d31SJohn Polstra /* 14090ff27d31SJohn Polstra * Allocate memory for building the header, fill it up, 1410bd390213SMikolaj Golub * and write it out following the notes. 14110ff27d31SJohn Polstra */ 1412a163d034SWarner Losh hdr = malloc(hdrsize, M_TEMP, M_WAITOK); 1413aa14e9b7SMark Johnston error = __elfN(corehdr)(¶ms, seginfo.count, hdr, hdrsize, ¬elst, 1414aa14e9b7SMark Johnston notesz); 14150ff27d31SJohn Polstra 14160ff27d31SJohn Polstra /* Write the contents of all of the writable segments. */ 14170ff27d31SJohn Polstra if (error == 0) { 14180ff27d31SJohn Polstra Elf_Phdr *php; 14192b471bc6STim J. Robbins off_t offset; 14200ff27d31SJohn Polstra int i; 14210ff27d31SJohn Polstra 14220ff27d31SJohn Polstra php = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr)) + 1; 1423bd390213SMikolaj Golub offset = round_page(hdrsize + notesz); 14240ff27d31SJohn Polstra for (i = 0; i < seginfo.count; i++) { 1425aa14e9b7SMark Johnston error = core_output((caddr_t)(uintptr_t)php->p_vaddr, 1426aa14e9b7SMark Johnston php->p_filesz, offset, ¶ms, tmpbuf); 14270ff27d31SJohn Polstra if (error != 0) 14282b471bc6STim J. Robbins break; 14290ff27d31SJohn Polstra offset += php->p_filesz; 14300ff27d31SJohn Polstra php++; 14310ff27d31SJohn Polstra } 1432aa14e9b7SMark Johnston #ifdef GZIO 1433aa14e9b7SMark Johnston if (error == 0 && compress) 1434aa14e9b7SMark Johnston error = gzio_flush(params.gzs); 1435aa14e9b7SMark Johnston #endif 14360ff27d31SJohn Polstra } 1437e7228204SAlfred Perlstein if (error) { 1438e7228204SAlfred Perlstein log(LOG_WARNING, 1439e7228204SAlfred Perlstein "Failed to write core file for process %s (error %d)\n", 1440e7228204SAlfred Perlstein curproc->p_comm, error); 1441e7228204SAlfred Perlstein } 1442e7228204SAlfred Perlstein 1443e7228204SAlfred Perlstein done: 1444aa14e9b7SMark Johnston #ifdef GZIO 1445aa14e9b7SMark Johnston if (compress) { 1446aa14e9b7SMark Johnston free(tmpbuf, M_TEMP); 144702d131adSMark Johnston if (params.gzs != NULL) 1448aa14e9b7SMark Johnston gzio_fini(params.gzs); 1449aa14e9b7SMark Johnston } 14508b325009SAlfred Perlstein #endif 1451bd390213SMikolaj Golub while ((ninfo = TAILQ_FIRST(¬elst)) != NULL) { 1452bd390213SMikolaj Golub TAILQ_REMOVE(¬elst, ninfo, link); 1453bd390213SMikolaj Golub free(ninfo, M_TEMP); 1454bd390213SMikolaj Golub } 1455bd390213SMikolaj Golub if (hdr != NULL) 14560ff27d31SJohn Polstra free(hdr, M_TEMP); 14570ff27d31SJohn Polstra 1458a7cddfedSJake Burkholder return (error); 14598c64af4fSJohn Polstra } 14608c64af4fSJohn Polstra 14610ff27d31SJohn Polstra /* 14621005d8afSConrad Meyer * A callback for each_dumpable_segment() to write out the segment's 14630ff27d31SJohn Polstra * program header entry. 14640ff27d31SJohn Polstra */ 14650ff27d31SJohn Polstra static void 14660ff27d31SJohn Polstra cb_put_phdr(entry, closure) 14670ff27d31SJohn Polstra vm_map_entry_t entry; 14680ff27d31SJohn Polstra void *closure; 14690ff27d31SJohn Polstra { 14700ff27d31SJohn Polstra struct phdr_closure *phc = (struct phdr_closure *)closure; 14710ff27d31SJohn Polstra Elf_Phdr *phdr = phc->phdr; 14720ff27d31SJohn Polstra 14730ff27d31SJohn Polstra phc->offset = round_page(phc->offset); 14740ff27d31SJohn Polstra 14750ff27d31SJohn Polstra phdr->p_type = PT_LOAD; 14760ff27d31SJohn Polstra phdr->p_offset = phc->offset; 14770ff27d31SJohn Polstra phdr->p_vaddr = entry->start; 14780ff27d31SJohn Polstra phdr->p_paddr = 0; 14790ff27d31SJohn Polstra phdr->p_filesz = phdr->p_memsz = entry->end - entry->start; 14800ff27d31SJohn Polstra phdr->p_align = PAGE_SIZE; 1481ed167eaaSKonstantin Belousov phdr->p_flags = __elfN(untrans_prot)(entry->protection); 14820ff27d31SJohn Polstra 14830ff27d31SJohn Polstra phc->offset += phdr->p_filesz; 14840ff27d31SJohn Polstra phc->phdr++; 14850ff27d31SJohn Polstra } 14860ff27d31SJohn Polstra 14870ff27d31SJohn Polstra /* 14881005d8afSConrad Meyer * A callback for each_dumpable_segment() to gather information about 14890ff27d31SJohn Polstra * the number of segments and their total size. 14900ff27d31SJohn Polstra */ 14910ff27d31SJohn Polstra static void 1492f3325003SConrad Meyer cb_size_segment(vm_map_entry_t entry, void *closure) 14930ff27d31SJohn Polstra { 14940ff27d31SJohn Polstra struct sseg_closure *ssc = (struct sseg_closure *)closure; 14950ff27d31SJohn Polstra 14960ff27d31SJohn Polstra ssc->count++; 14970ff27d31SJohn Polstra ssc->size += entry->end - entry->start; 14980ff27d31SJohn Polstra } 14990ff27d31SJohn Polstra 15000ff27d31SJohn Polstra /* 15010ff27d31SJohn Polstra * For each writable segment in the process's memory map, call the given 15020ff27d31SJohn Polstra * function with a pointer to the map entry and some arbitrary 15030ff27d31SJohn Polstra * caller-supplied data. 15040ff27d31SJohn Polstra */ 15050ff27d31SJohn Polstra static void 15061005d8afSConrad Meyer each_dumpable_segment(struct thread *td, segment_callback func, void *closure) 15070ff27d31SJohn Polstra { 1508247aba24SMarcel Moolenaar struct proc *p = td->td_proc; 15090ff27d31SJohn Polstra vm_map_t map = &p->p_vmspace->vm_map; 15100ff27d31SJohn Polstra vm_map_entry_t entry; 1511976a87a2SAlan Cox vm_object_t backing_object, object; 1512976a87a2SAlan Cox boolean_t ignore_entry; 15130ff27d31SJohn Polstra 1514976a87a2SAlan Cox vm_map_lock_read(map); 15150ff27d31SJohn Polstra for (entry = map->header.next; entry != &map->header; 15160ff27d31SJohn Polstra entry = entry->next) { 1517fa7dd9c5SMatthew Dillon /* 1518fa7dd9c5SMatthew Dillon * Don't dump inaccessible mappings, deal with legacy 1519fa7dd9c5SMatthew Dillon * coredump mode. 1520fa7dd9c5SMatthew Dillon * 1521fa7dd9c5SMatthew Dillon * Note that read-only segments related to the elf binary 1522fa7dd9c5SMatthew Dillon * are marked MAP_ENTRY_NOCOREDUMP now so we no longer 1523fa7dd9c5SMatthew Dillon * need to arbitrarily ignore such segments. 1524fa7dd9c5SMatthew Dillon */ 1525fa7dd9c5SMatthew Dillon if (elf_legacy_coredump) { 1526fa7dd9c5SMatthew Dillon if ((entry->protection & VM_PROT_RW) != VM_PROT_RW) 15270ff27d31SJohn Polstra continue; 1528fa7dd9c5SMatthew Dillon } else { 1529fa7dd9c5SMatthew Dillon if ((entry->protection & VM_PROT_ALL) == 0) 1530fa7dd9c5SMatthew Dillon continue; 1531fa7dd9c5SMatthew Dillon } 15320ff27d31SJohn Polstra 15339730a5daSPaul Saab /* 1534fa7dd9c5SMatthew Dillon * Dont include memory segment in the coredump if 1535fa7dd9c5SMatthew Dillon * MAP_NOCORE is set in mmap(2) or MADV_NOCORE in 1536fa7dd9c5SMatthew Dillon * madvise(2). Do not dump submaps (i.e. parts of the 1537fa7dd9c5SMatthew Dillon * kernel map). 15389730a5daSPaul Saab */ 1539fa7dd9c5SMatthew Dillon if (entry->eflags & (MAP_ENTRY_NOCOREDUMP|MAP_ENTRY_IS_SUB_MAP)) 15409730a5daSPaul Saab continue; 15419730a5daSPaul Saab 1542976a87a2SAlan Cox if ((object = entry->object.vm_object) == NULL) 15430ff27d31SJohn Polstra continue; 15440ff27d31SJohn Polstra 15450ff27d31SJohn Polstra /* Ignore memory-mapped devices and such things. */ 1546bc403f03SAttilio Rao VM_OBJECT_RLOCK(object); 1547976a87a2SAlan Cox while ((backing_object = object->backing_object) != NULL) { 1548bc403f03SAttilio Rao VM_OBJECT_RLOCK(backing_object); 1549bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(object); 1550976a87a2SAlan Cox object = backing_object; 1551976a87a2SAlan Cox } 1552976a87a2SAlan Cox ignore_entry = object->type != OBJT_DEFAULT && 1553bc411bc2SJohn Baldwin object->type != OBJT_SWAP && object->type != OBJT_VNODE && 1554bc411bc2SJohn Baldwin object->type != OBJT_PHYS; 1555bc403f03SAttilio Rao VM_OBJECT_RUNLOCK(object); 1556976a87a2SAlan Cox if (ignore_entry) 15570ff27d31SJohn Polstra continue; 15580ff27d31SJohn Polstra 15590ff27d31SJohn Polstra (*func)(entry, closure); 15600ff27d31SJohn Polstra } 1561976a87a2SAlan Cox vm_map_unlock_read(map); 15620ff27d31SJohn Polstra } 15630ff27d31SJohn Polstra 15640ff27d31SJohn Polstra /* 15650ff27d31SJohn Polstra * Write the core file header to the file, including padding up to 15660ff27d31SJohn Polstra * the page boundary. 15670ff27d31SJohn Polstra */ 15688c64af4fSJohn Polstra static int 1569aa14e9b7SMark Johnston __elfN(corehdr)(struct coredump_params *p, int numsegs, void *hdr, 1570aa14e9b7SMark Johnston size_t hdrsize, struct note_info_list *notelst, size_t notesz) 15718c64af4fSJohn Polstra { 1572bd390213SMikolaj Golub struct note_info *ninfo; 1573bd390213SMikolaj Golub struct sbuf *sb; 1574bd390213SMikolaj Golub int error; 15758c64af4fSJohn Polstra 15768c64af4fSJohn Polstra /* Fill in the header. */ 15770ff27d31SJohn Polstra bzero(hdr, hdrsize); 1578aa14e9b7SMark Johnston __elfN(puthdr)(p->td, hdr, hdrsize, numsegs, notesz); 15798c64af4fSJohn Polstra 1580bd390213SMikolaj Golub sb = sbuf_new(NULL, NULL, CORE_BUF_SIZE, SBUF_FIXEDLEN); 1581aa14e9b7SMark Johnston sbuf_set_drain(sb, sbuf_drain_core_output, p); 1582bd390213SMikolaj Golub sbuf_start_section(sb, NULL); 1583bd390213SMikolaj Golub sbuf_bcat(sb, hdr, hdrsize); 1584bd390213SMikolaj Golub TAILQ_FOREACH(ninfo, notelst, link) 1585bd390213SMikolaj Golub __elfN(putnote)(ninfo, sb); 1586bd390213SMikolaj Golub /* Align up to a page boundary for the program segments. */ 1587bd390213SMikolaj Golub sbuf_end_section(sb, -1, PAGE_SIZE, 0); 1588bd390213SMikolaj Golub error = sbuf_finish(sb); 1589bd390213SMikolaj Golub sbuf_delete(sb); 1590bd390213SMikolaj Golub 1591bd390213SMikolaj Golub return (error); 1592e7228204SAlfred Perlstein } 1593bd390213SMikolaj Golub 1594bd390213SMikolaj Golub static void 1595bd390213SMikolaj Golub __elfN(prepare_notes)(struct thread *td, struct note_info_list *list, 1596bd390213SMikolaj Golub size_t *sizep) 1597bd390213SMikolaj Golub { 1598bd390213SMikolaj Golub struct proc *p; 1599bd390213SMikolaj Golub struct thread *thr; 1600bd390213SMikolaj Golub size_t size; 1601bd390213SMikolaj Golub 1602bd390213SMikolaj Golub p = td->td_proc; 1603bd390213SMikolaj Golub size = 0; 1604bd390213SMikolaj Golub 1605bd390213SMikolaj Golub size += register_note(list, NT_PRPSINFO, __elfN(note_prpsinfo), p); 1606bd390213SMikolaj Golub 1607bd390213SMikolaj Golub /* 1608bd390213SMikolaj Golub * To have the debugger select the right thread (LWP) as the initial 1609bd390213SMikolaj Golub * thread, we dump the state of the thread passed to us in td first. 1610bd390213SMikolaj Golub * This is the thread that causes the core dump and thus likely to 1611bd390213SMikolaj Golub * be the right thread one wants to have selected in the debugger. 1612bd390213SMikolaj Golub */ 1613bd390213SMikolaj Golub thr = td; 1614bd390213SMikolaj Golub while (thr != NULL) { 1615bd390213SMikolaj Golub size += register_note(list, NT_PRSTATUS, 1616bd390213SMikolaj Golub __elfN(note_prstatus), thr); 1617bd390213SMikolaj Golub size += register_note(list, NT_FPREGSET, 1618bd390213SMikolaj Golub __elfN(note_fpregset), thr); 1619bd390213SMikolaj Golub size += register_note(list, NT_THRMISC, 1620bd390213SMikolaj Golub __elfN(note_thrmisc), thr); 1621bd390213SMikolaj Golub size += register_note(list, -1, 1622bd390213SMikolaj Golub __elfN(note_threadmd), thr); 1623bd390213SMikolaj Golub 1624bd390213SMikolaj Golub thr = (thr == td) ? TAILQ_FIRST(&p->p_threads) : 1625bd390213SMikolaj Golub TAILQ_NEXT(thr, td_plist); 1626bd390213SMikolaj Golub if (thr == td) 1627bd390213SMikolaj Golub thr = TAILQ_NEXT(thr, td_plist); 1628dada0278SJohn Polstra } 1629dada0278SJohn Polstra 1630f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_PROC, 1631f1fca82eSMikolaj Golub __elfN(note_procstat_proc), p); 1632f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_FILES, 1633f1fca82eSMikolaj Golub note_procstat_files, p); 1634f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_VMMAP, 1635f1fca82eSMikolaj Golub note_procstat_vmmap, p); 1636f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_GROUPS, 1637f1fca82eSMikolaj Golub note_procstat_groups, p); 1638f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_UMASK, 1639f1fca82eSMikolaj Golub note_procstat_umask, p); 1640f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_RLIMIT, 1641f1fca82eSMikolaj Golub note_procstat_rlimit, p); 1642f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_OSREL, 1643f1fca82eSMikolaj Golub note_procstat_osrel, p); 1644f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_PSSTRINGS, 1645f1fca82eSMikolaj Golub __elfN(note_procstat_psstrings), p); 1646f1fca82eSMikolaj Golub size += register_note(list, NT_PROCSTAT_AUXV, 1647f1fca82eSMikolaj Golub __elfN(note_procstat_auxv), p); 1648f1fca82eSMikolaj Golub 1649bd390213SMikolaj Golub *sizep = size; 1650bd390213SMikolaj Golub } 1651bd390213SMikolaj Golub 1652bd390213SMikolaj Golub static void 1653bd390213SMikolaj Golub __elfN(puthdr)(struct thread *td, void *hdr, size_t hdrsize, int numsegs, 1654bd390213SMikolaj Golub size_t notesz) 1655bd390213SMikolaj Golub { 1656bd390213SMikolaj Golub Elf_Ehdr *ehdr; 1657bd390213SMikolaj Golub Elf_Phdr *phdr; 1658c17b0bd2SConrad Meyer Elf_Shdr *shdr; 1659bd390213SMikolaj Golub struct phdr_closure phc; 1660bd390213SMikolaj Golub 1661bd390213SMikolaj Golub ehdr = (Elf_Ehdr *)hdr; 1662bd390213SMikolaj Golub 1663bd390213SMikolaj Golub ehdr->e_ident[EI_MAG0] = ELFMAG0; 1664bd390213SMikolaj Golub ehdr->e_ident[EI_MAG1] = ELFMAG1; 1665bd390213SMikolaj Golub ehdr->e_ident[EI_MAG2] = ELFMAG2; 1666bd390213SMikolaj Golub ehdr->e_ident[EI_MAG3] = ELFMAG3; 1667bd390213SMikolaj Golub ehdr->e_ident[EI_CLASS] = ELF_CLASS; 1668bd390213SMikolaj Golub ehdr->e_ident[EI_DATA] = ELF_DATA; 1669bd390213SMikolaj Golub ehdr->e_ident[EI_VERSION] = EV_CURRENT; 1670bd390213SMikolaj Golub ehdr->e_ident[EI_OSABI] = ELFOSABI_FREEBSD; 1671bd390213SMikolaj Golub ehdr->e_ident[EI_ABIVERSION] = 0; 1672bd390213SMikolaj Golub ehdr->e_ident[EI_PAD] = 0; 1673bd390213SMikolaj Golub ehdr->e_type = ET_CORE; 1674885f13dcSJohn Baldwin ehdr->e_machine = td->td_proc->p_elf_machine; 1675bd390213SMikolaj Golub ehdr->e_version = EV_CURRENT; 1676bd390213SMikolaj Golub ehdr->e_entry = 0; 1677bd390213SMikolaj Golub ehdr->e_phoff = sizeof(Elf_Ehdr); 1678885f13dcSJohn Baldwin ehdr->e_flags = td->td_proc->p_elf_flags; 1679bd390213SMikolaj Golub ehdr->e_ehsize = sizeof(Elf_Ehdr); 1680bd390213SMikolaj Golub ehdr->e_phentsize = sizeof(Elf_Phdr); 1681bd390213SMikolaj Golub ehdr->e_shentsize = sizeof(Elf_Shdr); 1682bd390213SMikolaj Golub ehdr->e_shstrndx = SHN_UNDEF; 1683c17b0bd2SConrad Meyer if (numsegs + 1 < PN_XNUM) { 1684c17b0bd2SConrad Meyer ehdr->e_phnum = numsegs + 1; 1685c17b0bd2SConrad Meyer ehdr->e_shnum = 0; 1686c17b0bd2SConrad Meyer } else { 1687c17b0bd2SConrad Meyer ehdr->e_phnum = PN_XNUM; 1688c17b0bd2SConrad Meyer ehdr->e_shnum = 1; 1689c17b0bd2SConrad Meyer 1690c17b0bd2SConrad Meyer ehdr->e_shoff = ehdr->e_phoff + 1691c17b0bd2SConrad Meyer (numsegs + 1) * ehdr->e_phentsize; 1692c17b0bd2SConrad Meyer KASSERT(ehdr->e_shoff == hdrsize - sizeof(Elf_Shdr), 1693c17b0bd2SConrad Meyer ("e_shoff: %zu, hdrsize - shdr: %zu", 169407f825e8SConrad Meyer (size_t)ehdr->e_shoff, hdrsize - sizeof(Elf_Shdr))); 1695c17b0bd2SConrad Meyer 1696c17b0bd2SConrad Meyer shdr = (Elf_Shdr *)((char *)hdr + ehdr->e_shoff); 1697c17b0bd2SConrad Meyer memset(shdr, 0, sizeof(*shdr)); 1698c17b0bd2SConrad Meyer /* 1699c17b0bd2SConrad Meyer * A special first section is used to hold large segment and 1700c17b0bd2SConrad Meyer * section counts. This was proposed by Sun Microsystems in 1701c17b0bd2SConrad Meyer * Solaris and has been adopted by Linux; the standard ELF 1702c17b0bd2SConrad Meyer * tools are already familiar with the technique. 1703c17b0bd2SConrad Meyer * 1704c17b0bd2SConrad Meyer * See table 7-7 of the Solaris "Linker and Libraries Guide" 1705c17b0bd2SConrad Meyer * (or 12-7 depending on the version of the document) for more 1706c17b0bd2SConrad Meyer * details. 1707c17b0bd2SConrad Meyer */ 1708c17b0bd2SConrad Meyer shdr->sh_type = SHT_NULL; 1709c17b0bd2SConrad Meyer shdr->sh_size = ehdr->e_shnum; 1710c17b0bd2SConrad Meyer shdr->sh_link = ehdr->e_shstrndx; 1711c17b0bd2SConrad Meyer shdr->sh_info = numsegs + 1; 1712c17b0bd2SConrad Meyer } 1713bd390213SMikolaj Golub 1714bd390213SMikolaj Golub /* 1715bd390213SMikolaj Golub * Fill in the program header entries. 1716bd390213SMikolaj Golub */ 1717c17b0bd2SConrad Meyer phdr = (Elf_Phdr *)((char *)hdr + ehdr->e_phoff); 1718bd390213SMikolaj Golub 1719bd390213SMikolaj Golub /* The note segement. */ 1720bd390213SMikolaj Golub phdr->p_type = PT_NOTE; 1721bd390213SMikolaj Golub phdr->p_offset = hdrsize; 1722bd390213SMikolaj Golub phdr->p_vaddr = 0; 1723bd390213SMikolaj Golub phdr->p_paddr = 0; 1724bd390213SMikolaj Golub phdr->p_filesz = notesz; 1725bd390213SMikolaj Golub phdr->p_memsz = 0; 1726bd390213SMikolaj Golub phdr->p_flags = PF_R; 17271b8388cdSMikolaj Golub phdr->p_align = ELF_NOTE_ROUNDSIZE; 1728bd390213SMikolaj Golub phdr++; 1729bd390213SMikolaj Golub 1730bd390213SMikolaj Golub /* All the writable segments from the program. */ 1731bd390213SMikolaj Golub phc.phdr = phdr; 1732bd390213SMikolaj Golub phc.offset = round_page(hdrsize + notesz); 17331005d8afSConrad Meyer each_dumpable_segment(td, cb_put_phdr, &phc); 1734bd390213SMikolaj Golub } 1735bd390213SMikolaj Golub 1736bd390213SMikolaj Golub static size_t 1737bd390213SMikolaj Golub register_note(struct note_info_list *list, int type, outfunc_t out, void *arg) 1738bd390213SMikolaj Golub { 1739bd390213SMikolaj Golub struct note_info *ninfo; 1740bd390213SMikolaj Golub size_t size, notesize; 1741bd390213SMikolaj Golub 1742bd390213SMikolaj Golub size = 0; 1743bd390213SMikolaj Golub out(arg, NULL, &size); 1744bd390213SMikolaj Golub ninfo = malloc(sizeof(*ninfo), M_TEMP, M_ZERO | M_WAITOK); 1745bd390213SMikolaj Golub ninfo->type = type; 1746bd390213SMikolaj Golub ninfo->outfunc = out; 1747bd390213SMikolaj Golub ninfo->outarg = arg; 1748bd390213SMikolaj Golub ninfo->outsize = size; 1749bd390213SMikolaj Golub TAILQ_INSERT_TAIL(list, ninfo, link); 1750bd390213SMikolaj Golub 1751bd390213SMikolaj Golub if (type == -1) 1752bd390213SMikolaj Golub return (size); 1753bd390213SMikolaj Golub 1754bd390213SMikolaj Golub notesize = sizeof(Elf_Note) + /* note header */ 1755180e57e5SJohn Baldwin roundup2(sizeof(FREEBSD_ABI_VENDOR), ELF_NOTE_ROUNDSIZE) + 1756180e57e5SJohn Baldwin /* note name */ 1757180e57e5SJohn Baldwin roundup2(size, ELF_NOTE_ROUNDSIZE); /* note description */ 1758180e57e5SJohn Baldwin 1759180e57e5SJohn Baldwin return (notesize); 1760180e57e5SJohn Baldwin } 1761180e57e5SJohn Baldwin 1762180e57e5SJohn Baldwin static size_t 1763180e57e5SJohn Baldwin append_note_data(const void *src, void *dst, size_t len) 1764180e57e5SJohn Baldwin { 1765180e57e5SJohn Baldwin size_t padded_len; 1766180e57e5SJohn Baldwin 1767180e57e5SJohn Baldwin padded_len = roundup2(len, ELF_NOTE_ROUNDSIZE); 1768180e57e5SJohn Baldwin if (dst != NULL) { 1769180e57e5SJohn Baldwin bcopy(src, dst, len); 1770180e57e5SJohn Baldwin bzero((char *)dst + len, padded_len - len); 1771180e57e5SJohn Baldwin } 1772180e57e5SJohn Baldwin return (padded_len); 1773180e57e5SJohn Baldwin } 1774180e57e5SJohn Baldwin 1775180e57e5SJohn Baldwin size_t 1776180e57e5SJohn Baldwin __elfN(populate_note)(int type, void *src, void *dst, size_t size, void **descp) 1777180e57e5SJohn Baldwin { 1778180e57e5SJohn Baldwin Elf_Note *note; 1779180e57e5SJohn Baldwin char *buf; 1780180e57e5SJohn Baldwin size_t notesize; 1781180e57e5SJohn Baldwin 1782180e57e5SJohn Baldwin buf = dst; 1783180e57e5SJohn Baldwin if (buf != NULL) { 1784180e57e5SJohn Baldwin note = (Elf_Note *)buf; 1785180e57e5SJohn Baldwin note->n_namesz = sizeof(FREEBSD_ABI_VENDOR); 1786180e57e5SJohn Baldwin note->n_descsz = size; 1787180e57e5SJohn Baldwin note->n_type = type; 1788180e57e5SJohn Baldwin buf += sizeof(*note); 1789180e57e5SJohn Baldwin buf += append_note_data(FREEBSD_ABI_VENDOR, buf, 1790180e57e5SJohn Baldwin sizeof(FREEBSD_ABI_VENDOR)); 1791180e57e5SJohn Baldwin append_note_data(src, buf, size); 1792180e57e5SJohn Baldwin if (descp != NULL) 1793180e57e5SJohn Baldwin *descp = buf; 1794180e57e5SJohn Baldwin } 1795180e57e5SJohn Baldwin 1796180e57e5SJohn Baldwin notesize = sizeof(Elf_Note) + /* note header */ 1797180e57e5SJohn Baldwin roundup2(sizeof(FREEBSD_ABI_VENDOR), ELF_NOTE_ROUNDSIZE) + 1798180e57e5SJohn Baldwin /* note name */ 17991b8388cdSMikolaj Golub roundup2(size, ELF_NOTE_ROUNDSIZE); /* note description */ 1800bd390213SMikolaj Golub 1801bd390213SMikolaj Golub return (notesize); 1802bd390213SMikolaj Golub } 1803bd390213SMikolaj Golub 1804bd390213SMikolaj Golub static void 1805bd390213SMikolaj Golub __elfN(putnote)(struct note_info *ninfo, struct sbuf *sb) 1806bd390213SMikolaj Golub { 1807bd390213SMikolaj Golub Elf_Note note; 180814bdbaf2SConrad Meyer ssize_t old_len, sect_len; 180914bdbaf2SConrad Meyer size_t new_len, descsz, i; 1810bd390213SMikolaj Golub 1811bd390213SMikolaj Golub if (ninfo->type == -1) { 1812bd390213SMikolaj Golub ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize); 1813bd390213SMikolaj Golub return; 1814bd390213SMikolaj Golub } 1815bd390213SMikolaj Golub 1816180e57e5SJohn Baldwin note.n_namesz = sizeof(FREEBSD_ABI_VENDOR); 1817bd390213SMikolaj Golub note.n_descsz = ninfo->outsize; 1818bd390213SMikolaj Golub note.n_type = ninfo->type; 1819bd390213SMikolaj Golub 1820bd390213SMikolaj Golub sbuf_bcat(sb, ¬e, sizeof(note)); 1821bd390213SMikolaj Golub sbuf_start_section(sb, &old_len); 1822180e57e5SJohn Baldwin sbuf_bcat(sb, FREEBSD_ABI_VENDOR, sizeof(FREEBSD_ABI_VENDOR)); 18231b8388cdSMikolaj Golub sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0); 1824bd390213SMikolaj Golub if (note.n_descsz == 0) 1825bd390213SMikolaj Golub return; 1826bd390213SMikolaj Golub sbuf_start_section(sb, &old_len); 1827bd390213SMikolaj Golub ninfo->outfunc(ninfo->outarg, sb, &ninfo->outsize); 182814bdbaf2SConrad Meyer sect_len = sbuf_end_section(sb, old_len, ELF_NOTE_ROUNDSIZE, 0); 182914bdbaf2SConrad Meyer if (sect_len < 0) 183014bdbaf2SConrad Meyer return; 183114bdbaf2SConrad Meyer 183214bdbaf2SConrad Meyer new_len = (size_t)sect_len; 183314bdbaf2SConrad Meyer descsz = roundup(note.n_descsz, ELF_NOTE_ROUNDSIZE); 183414bdbaf2SConrad Meyer if (new_len < descsz) { 183514bdbaf2SConrad Meyer /* 183614bdbaf2SConrad Meyer * It is expected that individual note emitters will correctly 183714bdbaf2SConrad Meyer * predict their expected output size and fill up to that size 183814bdbaf2SConrad Meyer * themselves, padding in a format-specific way if needed. 183914bdbaf2SConrad Meyer * However, in case they don't, just do it here with zeros. 184014bdbaf2SConrad Meyer */ 184114bdbaf2SConrad Meyer for (i = 0; i < descsz - new_len; i++) 184214bdbaf2SConrad Meyer sbuf_putc(sb, 0); 184314bdbaf2SConrad Meyer } else if (new_len > descsz) { 184414bdbaf2SConrad Meyer /* 184514bdbaf2SConrad Meyer * We can't always truncate sb -- we may have drained some 184614bdbaf2SConrad Meyer * of it already. 184714bdbaf2SConrad Meyer */ 184814bdbaf2SConrad Meyer KASSERT(new_len == descsz, ("%s: Note type %u changed as we " 184914bdbaf2SConrad Meyer "read it (%zu > %zu). Since it is longer than " 185014bdbaf2SConrad Meyer "expected, this coredump's notes are corrupt. THIS " 185114bdbaf2SConrad Meyer "IS A BUG in the note_procstat routine for type %u.\n", 185214bdbaf2SConrad Meyer __func__, (unsigned)note.n_type, new_len, descsz, 185314bdbaf2SConrad Meyer (unsigned)note.n_type)); 185414bdbaf2SConrad Meyer } 1855bd390213SMikolaj Golub } 1856bd390213SMikolaj Golub 1857bd390213SMikolaj Golub /* 1858bd390213SMikolaj Golub * Miscellaneous note out functions. 1859bd390213SMikolaj Golub */ 1860bd390213SMikolaj Golub 1861841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32 1862841c0c7eSNathan Whitehorn #include <compat/freebsd32/freebsd32.h> 1863841c0c7eSNathan Whitehorn 186462919d78SPeter Wemm typedef struct prstatus32 elf_prstatus_t; 186562919d78SPeter Wemm typedef struct prpsinfo32 elf_prpsinfo_t; 186662919d78SPeter Wemm typedef struct fpreg32 elf_prfpregset_t; 186762919d78SPeter Wemm typedef struct fpreg32 elf_fpregset_t; 186862919d78SPeter Wemm typedef struct reg32 elf_gregset_t; 18697f08176eSAttilio Rao typedef struct thrmisc32 elf_thrmisc_t; 1870f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK KERN_PROC_MASK32 1871f1fca82eSMikolaj Golub typedef struct kinfo_proc32 elf_kinfo_proc_t; 1872f1fca82eSMikolaj Golub typedef uint32_t elf_ps_strings_t; 187362919d78SPeter Wemm #else 187462919d78SPeter Wemm typedef prstatus_t elf_prstatus_t; 187562919d78SPeter Wemm typedef prpsinfo_t elf_prpsinfo_t; 187662919d78SPeter Wemm typedef prfpregset_t elf_prfpregset_t; 187762919d78SPeter Wemm typedef prfpregset_t elf_fpregset_t; 187862919d78SPeter Wemm typedef gregset_t elf_gregset_t; 18797f08176eSAttilio Rao typedef thrmisc_t elf_thrmisc_t; 1880f1fca82eSMikolaj Golub #define ELF_KERN_PROC_MASK 0 1881f1fca82eSMikolaj Golub typedef struct kinfo_proc elf_kinfo_proc_t; 1882f1fca82eSMikolaj Golub typedef vm_offset_t elf_ps_strings_t; 188362919d78SPeter Wemm #endif 188462919d78SPeter Wemm 18858c64af4fSJohn Polstra static void 1886bd390213SMikolaj Golub __elfN(note_prpsinfo)(void *arg, struct sbuf *sb, size_t *sizep) 18878c64af4fSJohn Polstra { 1888c77547d2SJohn Baldwin struct sbuf sbarg; 1889c77547d2SJohn Baldwin size_t len; 1890c77547d2SJohn Baldwin char *cp, *end; 1891247aba24SMarcel Moolenaar struct proc *p; 1892bd390213SMikolaj Golub elf_prpsinfo_t *psinfo; 1893c77547d2SJohn Baldwin int error; 18948c64af4fSJohn Polstra 1895bd390213SMikolaj Golub p = (struct proc *)arg; 1896bd390213SMikolaj Golub if (sb != NULL) { 1897bd390213SMikolaj Golub KASSERT(*sizep == sizeof(*psinfo), ("invalid size")); 1898bd390213SMikolaj Golub psinfo = malloc(sizeof(*psinfo), M_TEMP, M_ZERO | M_WAITOK); 18998c9b7b2cSMarcel Moolenaar psinfo->pr_version = PRPSINFO_VERSION; 190062919d78SPeter Wemm psinfo->pr_psinfosz = sizeof(elf_prpsinfo_t); 1901ccd3953eSJohn Baldwin strlcpy(psinfo->pr_fname, p->p_comm, sizeof(psinfo->pr_fname)); 1902c77547d2SJohn Baldwin PROC_LOCK(p); 1903c77547d2SJohn Baldwin if (p->p_args != NULL) { 1904c77547d2SJohn Baldwin len = sizeof(psinfo->pr_psargs) - 1; 1905c77547d2SJohn Baldwin if (len > p->p_args->ar_length) 1906c77547d2SJohn Baldwin len = p->p_args->ar_length; 1907c77547d2SJohn Baldwin memcpy(psinfo->pr_psargs, p->p_args->ar_args, len); 1908c77547d2SJohn Baldwin PROC_UNLOCK(p); 1909c77547d2SJohn Baldwin error = 0; 1910c77547d2SJohn Baldwin } else { 1911c77547d2SJohn Baldwin _PHOLD(p); 1912c77547d2SJohn Baldwin PROC_UNLOCK(p); 1913c77547d2SJohn Baldwin sbuf_new(&sbarg, psinfo->pr_psargs, 1914c77547d2SJohn Baldwin sizeof(psinfo->pr_psargs), SBUF_FIXEDLEN); 1915c77547d2SJohn Baldwin error = proc_getargv(curthread, p, &sbarg); 1916c77547d2SJohn Baldwin PRELE(p); 1917c77547d2SJohn Baldwin if (sbuf_finish(&sbarg) == 0) 1918c77547d2SJohn Baldwin len = sbuf_len(&sbarg) - 1; 1919c77547d2SJohn Baldwin else 1920c77547d2SJohn Baldwin len = sizeof(psinfo->pr_psargs) - 1; 1921c77547d2SJohn Baldwin sbuf_delete(&sbarg); 1922c77547d2SJohn Baldwin } 1923c77547d2SJohn Baldwin if (error || len == 0) 1924ccd3953eSJohn Baldwin strlcpy(psinfo->pr_psargs, p->p_comm, 19258c9b7b2cSMarcel Moolenaar sizeof(psinfo->pr_psargs)); 1926c77547d2SJohn Baldwin else { 1927c77547d2SJohn Baldwin KASSERT(len < sizeof(psinfo->pr_psargs), 1928c77547d2SJohn Baldwin ("len is too long: %zu vs %zu", len, 1929c77547d2SJohn Baldwin sizeof(psinfo->pr_psargs))); 1930c77547d2SJohn Baldwin cp = psinfo->pr_psargs; 1931c77547d2SJohn Baldwin end = cp + len - 1; 1932c77547d2SJohn Baldwin for (;;) { 1933c77547d2SJohn Baldwin cp = memchr(cp, '\0', end - cp); 1934c77547d2SJohn Baldwin if (cp == NULL) 1935c77547d2SJohn Baldwin break; 1936c77547d2SJohn Baldwin *cp = ' '; 1937c77547d2SJohn Baldwin } 1938c77547d2SJohn Baldwin } 1939ccb83afdSJohn Baldwin psinfo->pr_pid = p->p_pid; 1940bd390213SMikolaj Golub sbuf_bcat(sb, psinfo, sizeof(*psinfo)); 1941bd390213SMikolaj Golub free(psinfo, M_TEMP); 1942bd390213SMikolaj Golub } 1943bd390213SMikolaj Golub *sizep = sizeof(*psinfo); 1944bd390213SMikolaj Golub } 1945bd390213SMikolaj Golub 1946bd390213SMikolaj Golub static void 1947bd390213SMikolaj Golub __elfN(note_prstatus)(void *arg, struct sbuf *sb, size_t *sizep) 1948bd390213SMikolaj Golub { 1949bd390213SMikolaj Golub struct thread *td; 1950bd390213SMikolaj Golub elf_prstatus_t *status; 1951bd390213SMikolaj Golub 1952bd390213SMikolaj Golub td = (struct thread *)arg; 1953bd390213SMikolaj Golub if (sb != NULL) { 1954bd390213SMikolaj Golub KASSERT(*sizep == sizeof(*status), ("invalid size")); 1955bd390213SMikolaj Golub status = malloc(sizeof(*status), M_TEMP, M_ZERO | M_WAITOK); 19568c9b7b2cSMarcel Moolenaar status->pr_version = PRSTATUS_VERSION; 195762919d78SPeter Wemm status->pr_statussz = sizeof(elf_prstatus_t); 195862919d78SPeter Wemm status->pr_gregsetsz = sizeof(elf_gregset_t); 195962919d78SPeter Wemm status->pr_fpregsetsz = sizeof(elf_fpregset_t); 19608c9b7b2cSMarcel Moolenaar status->pr_osreldate = osreldate; 1961bd390213SMikolaj Golub status->pr_cursig = td->td_proc->p_sig; 1962bd390213SMikolaj Golub status->pr_pid = td->td_tid; 1963841c0c7eSNathan Whitehorn #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32 1964bd390213SMikolaj Golub fill_regs32(td, &status->pr_reg); 196562919d78SPeter Wemm #else 1966bd390213SMikolaj Golub fill_regs(td, &status->pr_reg); 196762919d78SPeter Wemm #endif 1968bd390213SMikolaj Golub sbuf_bcat(sb, status, sizeof(*status)); 1969bd390213SMikolaj Golub free(status, M_TEMP); 19708c9b7b2cSMarcel Moolenaar } 1971bd390213SMikolaj Golub *sizep = sizeof(*status); 1972bd390213SMikolaj Golub } 1973bd390213SMikolaj Golub 1974bd390213SMikolaj Golub static void 1975bd390213SMikolaj Golub __elfN(note_fpregset)(void *arg, struct sbuf *sb, size_t *sizep) 1976bd390213SMikolaj Golub { 1977bd390213SMikolaj Golub struct thread *td; 1978bd390213SMikolaj Golub elf_prfpregset_t *fpregset; 1979bd390213SMikolaj Golub 1980bd390213SMikolaj Golub td = (struct thread *)arg; 1981bd390213SMikolaj Golub if (sb != NULL) { 1982bd390213SMikolaj Golub KASSERT(*sizep == sizeof(*fpregset), ("invalid size")); 1983bd390213SMikolaj Golub fpregset = malloc(sizeof(*fpregset), M_TEMP, M_ZERO | M_WAITOK); 1984bd390213SMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32 1985bd390213SMikolaj Golub fill_fpregs32(td, fpregset); 1986bd390213SMikolaj Golub #else 1987bd390213SMikolaj Golub fill_fpregs(td, fpregset); 1988bd390213SMikolaj Golub #endif 1989bd390213SMikolaj Golub sbuf_bcat(sb, fpregset, sizeof(*fpregset)); 1990bd390213SMikolaj Golub free(fpregset, M_TEMP); 1991bd390213SMikolaj Golub } 1992bd390213SMikolaj Golub *sizep = sizeof(*fpregset); 1993bd390213SMikolaj Golub } 1994bd390213SMikolaj Golub 1995bd390213SMikolaj Golub static void 1996bd390213SMikolaj Golub __elfN(note_thrmisc)(void *arg, struct sbuf *sb, size_t *sizep) 1997bd390213SMikolaj Golub { 1998bd390213SMikolaj Golub struct thread *td; 1999bd390213SMikolaj Golub elf_thrmisc_t thrmisc; 2000bd390213SMikolaj Golub 2001bd390213SMikolaj Golub td = (struct thread *)arg; 2002bd390213SMikolaj Golub if (sb != NULL) { 2003bd390213SMikolaj Golub KASSERT(*sizep == sizeof(thrmisc), ("invalid size")); 2004bd390213SMikolaj Golub bzero(&thrmisc._pad, sizeof(thrmisc._pad)); 2005bd390213SMikolaj Golub strcpy(thrmisc.pr_tname, td->td_name); 2006bd390213SMikolaj Golub sbuf_bcat(sb, &thrmisc, sizeof(thrmisc)); 2007bd390213SMikolaj Golub } 2008bd390213SMikolaj Golub *sizep = sizeof(thrmisc); 2009bd390213SMikolaj Golub } 2010bd390213SMikolaj Golub 20114da47b2fSMarcel Moolenaar /* 20124da47b2fSMarcel Moolenaar * Allow for MD specific notes, as well as any MD 20134da47b2fSMarcel Moolenaar * specific preparations for writing MI notes. 20144da47b2fSMarcel Moolenaar */ 20158c64af4fSJohn Polstra static void 2016bd390213SMikolaj Golub __elfN(note_threadmd)(void *arg, struct sbuf *sb, size_t *sizep) 20178c64af4fSJohn Polstra { 2018bd390213SMikolaj Golub struct thread *td; 2019bd390213SMikolaj Golub void *buf; 2020bd390213SMikolaj Golub size_t size; 20218c64af4fSJohn Polstra 2022bd390213SMikolaj Golub td = (struct thread *)arg; 2023bd390213SMikolaj Golub size = *sizep; 2024bd390213SMikolaj Golub if (size != 0 && sb != NULL) 2025bd390213SMikolaj Golub buf = malloc(size, M_TEMP, M_ZERO | M_WAITOK); 202683a396ceSChristian Brueffer else 202783a396ceSChristian Brueffer buf = NULL; 2028bd390213SMikolaj Golub size = 0; 2029bd390213SMikolaj Golub __elfN(dump_thread)(td, buf, &size); 203064779280SKonstantin Belousov KASSERT(sb == NULL || *sizep == size, ("invalid size")); 203183a396ceSChristian Brueffer if (size != 0 && sb != NULL) 2032bd390213SMikolaj Golub sbuf_bcat(sb, buf, size); 2033a1761d73SChristian Brueffer free(buf, M_TEMP); 2034bd390213SMikolaj Golub *sizep = size; 20358c64af4fSJohn Polstra } 20368c64af4fSJohn Polstra 2037f1fca82eSMikolaj Golub #ifdef KINFO_PROC_SIZE 2038f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_proc) == KINFO_PROC_SIZE); 2039f1fca82eSMikolaj Golub #endif 2040f1fca82eSMikolaj Golub 2041f1fca82eSMikolaj Golub static void 2042f1fca82eSMikolaj Golub __elfN(note_procstat_proc)(void *arg, struct sbuf *sb, size_t *sizep) 2043f1fca82eSMikolaj Golub { 2044f1fca82eSMikolaj Golub struct proc *p; 2045f1fca82eSMikolaj Golub size_t size; 2046f1fca82eSMikolaj Golub int structsize; 2047f1fca82eSMikolaj Golub 2048f1fca82eSMikolaj Golub p = (struct proc *)arg; 2049f1fca82eSMikolaj Golub size = sizeof(structsize) + p->p_numthreads * 2050f1fca82eSMikolaj Golub sizeof(elf_kinfo_proc_t); 2051f1fca82eSMikolaj Golub 2052f1fca82eSMikolaj Golub if (sb != NULL) { 2053f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2054f1fca82eSMikolaj Golub structsize = sizeof(elf_kinfo_proc_t); 2055f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 20566662ce5aSMateusz Guzik sx_slock(&proctree_lock); 2057f1fca82eSMikolaj Golub PROC_LOCK(p); 2058f1fca82eSMikolaj Golub kern_proc_out(p, sb, ELF_KERN_PROC_MASK); 20596662ce5aSMateusz Guzik sx_sunlock(&proctree_lock); 2060f1fca82eSMikolaj Golub } 2061f1fca82eSMikolaj Golub *sizep = size; 2062f1fca82eSMikolaj Golub } 2063f1fca82eSMikolaj Golub 2064f1fca82eSMikolaj Golub #ifdef KINFO_FILE_SIZE 2065f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_file) == KINFO_FILE_SIZE); 2066f1fca82eSMikolaj Golub #endif 2067f1fca82eSMikolaj Golub 2068f1fca82eSMikolaj Golub static void 2069f1fca82eSMikolaj Golub note_procstat_files(void *arg, struct sbuf *sb, size_t *sizep) 2070f1fca82eSMikolaj Golub { 2071f1fca82eSMikolaj Golub struct proc *p; 207214bdbaf2SConrad Meyer size_t size, sect_sz, i; 207314bdbaf2SConrad Meyer ssize_t start_len, sect_len; 207414bdbaf2SConrad Meyer int structsize, filedesc_flags; 207514bdbaf2SConrad Meyer 2076bcb60d52SConrad Meyer if (coredump_pack_fileinfo) 207714bdbaf2SConrad Meyer filedesc_flags = KERN_FILEDESC_PACK_KINFO; 207814bdbaf2SConrad Meyer else 207914bdbaf2SConrad Meyer filedesc_flags = 0; 2080f1fca82eSMikolaj Golub 2081f1fca82eSMikolaj Golub p = (struct proc *)arg; 208214bdbaf2SConrad Meyer structsize = sizeof(struct kinfo_file); 2083f1fca82eSMikolaj Golub if (sb == NULL) { 2084f1fca82eSMikolaj Golub size = 0; 2085f1fca82eSMikolaj Golub sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN); 2086f1fca82eSMikolaj Golub sbuf_set_drain(sb, sbuf_drain_count, &size); 2087f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2088f1fca82eSMikolaj Golub PROC_LOCK(p); 208914bdbaf2SConrad Meyer kern_proc_filedesc_out(p, sb, -1, filedesc_flags); 2090f1fca82eSMikolaj Golub sbuf_finish(sb); 2091f1fca82eSMikolaj Golub sbuf_delete(sb); 2092f1fca82eSMikolaj Golub *sizep = size; 2093f1fca82eSMikolaj Golub } else { 209414bdbaf2SConrad Meyer sbuf_start_section(sb, &start_len); 209514bdbaf2SConrad Meyer 2096f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2097f1fca82eSMikolaj Golub PROC_LOCK(p); 209814bdbaf2SConrad Meyer kern_proc_filedesc_out(p, sb, *sizep - sizeof(structsize), 209914bdbaf2SConrad Meyer filedesc_flags); 210014bdbaf2SConrad Meyer 210114bdbaf2SConrad Meyer sect_len = sbuf_end_section(sb, start_len, 0, 0); 210214bdbaf2SConrad Meyer if (sect_len < 0) 210314bdbaf2SConrad Meyer return; 210414bdbaf2SConrad Meyer sect_sz = sect_len; 210514bdbaf2SConrad Meyer 210614bdbaf2SConrad Meyer KASSERT(sect_sz <= *sizep, 210714bdbaf2SConrad Meyer ("kern_proc_filedesc_out did not respect maxlen; " 210814bdbaf2SConrad Meyer "requested %zu, got %zu", *sizep - sizeof(structsize), 210914bdbaf2SConrad Meyer sect_sz - sizeof(structsize))); 211014bdbaf2SConrad Meyer 211114bdbaf2SConrad Meyer for (i = 0; i < *sizep - sect_sz && sb->s_error == 0; i++) 211214bdbaf2SConrad Meyer sbuf_putc(sb, 0); 2113f1fca82eSMikolaj Golub } 2114f1fca82eSMikolaj Golub } 2115f1fca82eSMikolaj Golub 2116f1fca82eSMikolaj Golub #ifdef KINFO_VMENTRY_SIZE 2117f1fca82eSMikolaj Golub CTASSERT(sizeof(struct kinfo_vmentry) == KINFO_VMENTRY_SIZE); 2118f1fca82eSMikolaj Golub #endif 2119f1fca82eSMikolaj Golub 2120f1fca82eSMikolaj Golub static void 2121f1fca82eSMikolaj Golub note_procstat_vmmap(void *arg, struct sbuf *sb, size_t *sizep) 2122f1fca82eSMikolaj Golub { 2123f1fca82eSMikolaj Golub struct proc *p; 2124f1fca82eSMikolaj Golub size_t size; 2125e6b95927SConrad Meyer int structsize, vmmap_flags; 2126e6b95927SConrad Meyer 2127e6b95927SConrad Meyer if (coredump_pack_vmmapinfo) 2128e6b95927SConrad Meyer vmmap_flags = KERN_VMMAP_PACK_KINFO; 2129e6b95927SConrad Meyer else 2130e6b95927SConrad Meyer vmmap_flags = 0; 2131f1fca82eSMikolaj Golub 2132f1fca82eSMikolaj Golub p = (struct proc *)arg; 2133e6b95927SConrad Meyer structsize = sizeof(struct kinfo_vmentry); 2134f1fca82eSMikolaj Golub if (sb == NULL) { 2135f1fca82eSMikolaj Golub size = 0; 2136f1fca82eSMikolaj Golub sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN); 2137f1fca82eSMikolaj Golub sbuf_set_drain(sb, sbuf_drain_count, &size); 2138f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2139f1fca82eSMikolaj Golub PROC_LOCK(p); 2140e6b95927SConrad Meyer kern_proc_vmmap_out(p, sb, -1, vmmap_flags); 2141f1fca82eSMikolaj Golub sbuf_finish(sb); 2142f1fca82eSMikolaj Golub sbuf_delete(sb); 2143f1fca82eSMikolaj Golub *sizep = size; 2144f1fca82eSMikolaj Golub } else { 2145f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2146f1fca82eSMikolaj Golub PROC_LOCK(p); 2147e6b95927SConrad Meyer kern_proc_vmmap_out(p, sb, *sizep - sizeof(structsize), 2148e6b95927SConrad Meyer vmmap_flags); 2149f1fca82eSMikolaj Golub } 2150f1fca82eSMikolaj Golub } 2151f1fca82eSMikolaj Golub 2152f1fca82eSMikolaj Golub static void 2153f1fca82eSMikolaj Golub note_procstat_groups(void *arg, struct sbuf *sb, size_t *sizep) 2154f1fca82eSMikolaj Golub { 2155f1fca82eSMikolaj Golub struct proc *p; 2156f1fca82eSMikolaj Golub size_t size; 2157f1fca82eSMikolaj Golub int structsize; 2158f1fca82eSMikolaj Golub 2159f1fca82eSMikolaj Golub p = (struct proc *)arg; 2160f1fca82eSMikolaj Golub size = sizeof(structsize) + p->p_ucred->cr_ngroups * sizeof(gid_t); 2161f1fca82eSMikolaj Golub if (sb != NULL) { 2162f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2163f1fca82eSMikolaj Golub structsize = sizeof(gid_t); 2164f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2165f1fca82eSMikolaj Golub sbuf_bcat(sb, p->p_ucred->cr_groups, p->p_ucred->cr_ngroups * 2166f1fca82eSMikolaj Golub sizeof(gid_t)); 2167f1fca82eSMikolaj Golub } 2168f1fca82eSMikolaj Golub *sizep = size; 2169f1fca82eSMikolaj Golub } 2170f1fca82eSMikolaj Golub 2171f1fca82eSMikolaj Golub static void 2172f1fca82eSMikolaj Golub note_procstat_umask(void *arg, struct sbuf *sb, size_t *sizep) 2173f1fca82eSMikolaj Golub { 2174f1fca82eSMikolaj Golub struct proc *p; 2175f1fca82eSMikolaj Golub size_t size; 2176f1fca82eSMikolaj Golub int structsize; 2177f1fca82eSMikolaj Golub 2178f1fca82eSMikolaj Golub p = (struct proc *)arg; 2179f1fca82eSMikolaj Golub size = sizeof(structsize) + sizeof(p->p_fd->fd_cmask); 2180f1fca82eSMikolaj Golub if (sb != NULL) { 2181f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2182f1fca82eSMikolaj Golub structsize = sizeof(p->p_fd->fd_cmask); 2183f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2184f1fca82eSMikolaj Golub sbuf_bcat(sb, &p->p_fd->fd_cmask, sizeof(p->p_fd->fd_cmask)); 2185f1fca82eSMikolaj Golub } 2186f1fca82eSMikolaj Golub *sizep = size; 2187f1fca82eSMikolaj Golub } 2188f1fca82eSMikolaj Golub 2189f1fca82eSMikolaj Golub static void 2190f1fca82eSMikolaj Golub note_procstat_rlimit(void *arg, struct sbuf *sb, size_t *sizep) 2191f1fca82eSMikolaj Golub { 2192f1fca82eSMikolaj Golub struct proc *p; 2193f1fca82eSMikolaj Golub struct rlimit rlim[RLIM_NLIMITS]; 2194f1fca82eSMikolaj Golub size_t size; 2195f1fca82eSMikolaj Golub int structsize, i; 2196f1fca82eSMikolaj Golub 2197f1fca82eSMikolaj Golub p = (struct proc *)arg; 2198f1fca82eSMikolaj Golub size = sizeof(structsize) + sizeof(rlim); 2199f1fca82eSMikolaj Golub if (sb != NULL) { 2200f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2201f1fca82eSMikolaj Golub structsize = sizeof(rlim); 2202f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2203f1fca82eSMikolaj Golub PROC_LOCK(p); 2204f1fca82eSMikolaj Golub for (i = 0; i < RLIM_NLIMITS; i++) 2205f6f6d240SMateusz Guzik lim_rlimit_proc(p, i, &rlim[i]); 2206f1fca82eSMikolaj Golub PROC_UNLOCK(p); 2207f1fca82eSMikolaj Golub sbuf_bcat(sb, rlim, sizeof(rlim)); 2208f1fca82eSMikolaj Golub } 2209f1fca82eSMikolaj Golub *sizep = size; 2210f1fca82eSMikolaj Golub } 2211f1fca82eSMikolaj Golub 2212f1fca82eSMikolaj Golub static void 2213f1fca82eSMikolaj Golub note_procstat_osrel(void *arg, struct sbuf *sb, size_t *sizep) 2214f1fca82eSMikolaj Golub { 2215f1fca82eSMikolaj Golub struct proc *p; 2216f1fca82eSMikolaj Golub size_t size; 2217f1fca82eSMikolaj Golub int structsize; 2218f1fca82eSMikolaj Golub 2219f1fca82eSMikolaj Golub p = (struct proc *)arg; 2220f1fca82eSMikolaj Golub size = sizeof(structsize) + sizeof(p->p_osrel); 2221f1fca82eSMikolaj Golub if (sb != NULL) { 2222f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2223f1fca82eSMikolaj Golub structsize = sizeof(p->p_osrel); 2224f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2225f1fca82eSMikolaj Golub sbuf_bcat(sb, &p->p_osrel, sizeof(p->p_osrel)); 2226f1fca82eSMikolaj Golub } 2227f1fca82eSMikolaj Golub *sizep = size; 2228f1fca82eSMikolaj Golub } 2229f1fca82eSMikolaj Golub 2230f1fca82eSMikolaj Golub static void 2231f1fca82eSMikolaj Golub __elfN(note_procstat_psstrings)(void *arg, struct sbuf *sb, size_t *sizep) 2232f1fca82eSMikolaj Golub { 2233f1fca82eSMikolaj Golub struct proc *p; 2234f1fca82eSMikolaj Golub elf_ps_strings_t ps_strings; 2235f1fca82eSMikolaj Golub size_t size; 2236f1fca82eSMikolaj Golub int structsize; 2237f1fca82eSMikolaj Golub 2238f1fca82eSMikolaj Golub p = (struct proc *)arg; 2239f1fca82eSMikolaj Golub size = sizeof(structsize) + sizeof(ps_strings); 2240f1fca82eSMikolaj Golub if (sb != NULL) { 2241f1fca82eSMikolaj Golub KASSERT(*sizep == size, ("invalid size")); 2242f1fca82eSMikolaj Golub structsize = sizeof(ps_strings); 2243f1fca82eSMikolaj Golub #if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32 2244f1fca82eSMikolaj Golub ps_strings = PTROUT(p->p_sysent->sv_psstrings); 2245f1fca82eSMikolaj Golub #else 2246f1fca82eSMikolaj Golub ps_strings = p->p_sysent->sv_psstrings; 2247f1fca82eSMikolaj Golub #endif 2248f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2249f1fca82eSMikolaj Golub sbuf_bcat(sb, &ps_strings, sizeof(ps_strings)); 2250f1fca82eSMikolaj Golub } 2251f1fca82eSMikolaj Golub *sizep = size; 2252f1fca82eSMikolaj Golub } 2253f1fca82eSMikolaj Golub 2254f1fca82eSMikolaj Golub static void 2255f1fca82eSMikolaj Golub __elfN(note_procstat_auxv)(void *arg, struct sbuf *sb, size_t *sizep) 2256f1fca82eSMikolaj Golub { 2257f1fca82eSMikolaj Golub struct proc *p; 2258f1fca82eSMikolaj Golub size_t size; 2259f1fca82eSMikolaj Golub int structsize; 2260f1fca82eSMikolaj Golub 2261f1fca82eSMikolaj Golub p = (struct proc *)arg; 2262f1fca82eSMikolaj Golub if (sb == NULL) { 2263f1fca82eSMikolaj Golub size = 0; 2264f1fca82eSMikolaj Golub sb = sbuf_new(NULL, NULL, 128, SBUF_FIXEDLEN); 2265f1fca82eSMikolaj Golub sbuf_set_drain(sb, sbuf_drain_count, &size); 2266f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2267f1fca82eSMikolaj Golub PHOLD(p); 2268f1fca82eSMikolaj Golub proc_getauxv(curthread, p, sb); 2269f1fca82eSMikolaj Golub PRELE(p); 2270f1fca82eSMikolaj Golub sbuf_finish(sb); 2271f1fca82eSMikolaj Golub sbuf_delete(sb); 2272f1fca82eSMikolaj Golub *sizep = size; 2273f1fca82eSMikolaj Golub } else { 2274f1fca82eSMikolaj Golub structsize = sizeof(Elf_Auxinfo); 2275f1fca82eSMikolaj Golub sbuf_bcat(sb, &structsize, sizeof(structsize)); 2276f1fca82eSMikolaj Golub PHOLD(p); 2277f1fca82eSMikolaj Golub proc_getauxv(curthread, p, sb); 2278f1fca82eSMikolaj Golub PRELE(p); 2279f1fca82eSMikolaj Golub } 2280f1fca82eSMikolaj Golub } 2281f1fca82eSMikolaj Golub 228232c01de2SDmitry Chagin static boolean_t 22831a9c7decSKonstantin Belousov __elfN(parse_notes)(struct image_params *imgp, Elf_Brandnote *checknote, 22841a9c7decSKonstantin Belousov int32_t *osrel, const Elf_Phdr *pnote) 228532c01de2SDmitry Chagin { 2286267c52fcSKonstantin Belousov const Elf_Note *note, *note0, *note_end; 228732c01de2SDmitry Chagin const char *note_name; 22886c775eb6SKonstantin Belousov char *buf; 22896c775eb6SKonstantin Belousov int i, error; 22906c775eb6SKonstantin Belousov boolean_t res; 229132c01de2SDmitry Chagin 22926c775eb6SKonstantin Belousov /* We need some limit, might as well use PAGE_SIZE. */ 22936c775eb6SKonstantin Belousov if (pnote == NULL || pnote->p_filesz > PAGE_SIZE) 229432c01de2SDmitry Chagin return (FALSE); 22956c775eb6SKonstantin Belousov ASSERT_VOP_LOCKED(imgp->vp, "parse_notes"); 22966c775eb6SKonstantin Belousov if (pnote->p_offset > PAGE_SIZE || 22976c775eb6SKonstantin Belousov pnote->p_filesz > PAGE_SIZE - pnote->p_offset) { 22986c775eb6SKonstantin Belousov VOP_UNLOCK(imgp->vp, 0); 22996c775eb6SKonstantin Belousov buf = malloc(pnote->p_filesz, M_TEMP, M_WAITOK); 23006c775eb6SKonstantin Belousov vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY); 23016c775eb6SKonstantin Belousov error = vn_rdwr(UIO_READ, imgp->vp, buf, pnote->p_filesz, 23026c775eb6SKonstantin Belousov pnote->p_offset, UIO_SYSSPACE, IO_NODELOCKED, 23036c775eb6SKonstantin Belousov curthread->td_ucred, NOCRED, NULL, curthread); 23046c775eb6SKonstantin Belousov if (error != 0) { 23056c775eb6SKonstantin Belousov uprintf("i/o error PT_NOTE\n"); 23066c775eb6SKonstantin Belousov res = FALSE; 23076c775eb6SKonstantin Belousov goto ret; 23086c775eb6SKonstantin Belousov } 23096c775eb6SKonstantin Belousov note = note0 = (const Elf_Note *)buf; 23106c775eb6SKonstantin Belousov note_end = (const Elf_Note *)(buf + pnote->p_filesz); 23116c775eb6SKonstantin Belousov } else { 23126c775eb6SKonstantin Belousov note = note0 = (const Elf_Note *)(imgp->image_header + 23136c775eb6SKonstantin Belousov pnote->p_offset); 231432c01de2SDmitry Chagin note_end = (const Elf_Note *)(imgp->image_header + 231532c01de2SDmitry Chagin pnote->p_offset + pnote->p_filesz); 23166c775eb6SKonstantin Belousov buf = NULL; 23176c775eb6SKonstantin Belousov } 2318267c52fcSKonstantin Belousov for (i = 0; i < 100 && note >= note0 && note < note_end; i++) { 2319d1ae5c83SKonstantin Belousov if (!aligned(note, Elf32_Addr) || (const char *)note_end - 23206c775eb6SKonstantin Belousov (const char *)note < sizeof(Elf_Note)) { 23216c775eb6SKonstantin Belousov res = FALSE; 23226c775eb6SKonstantin Belousov goto ret; 23236c775eb6SKonstantin Belousov } 232432c01de2SDmitry Chagin if (note->n_namesz != checknote->hdr.n_namesz || 232532c01de2SDmitry Chagin note->n_descsz != checknote->hdr.n_descsz || 232632c01de2SDmitry Chagin note->n_type != checknote->hdr.n_type) 232732c01de2SDmitry Chagin goto nextnote; 232832c01de2SDmitry Chagin note_name = (const char *)(note + 1); 2329d1ae5c83SKonstantin Belousov if (note_name + checknote->hdr.n_namesz >= 2330d1ae5c83SKonstantin Belousov (const char *)note_end || strncmp(checknote->vendor, 2331d1ae5c83SKonstantin Belousov note_name, checknote->hdr.n_namesz) != 0) 233232c01de2SDmitry Chagin goto nextnote; 233332c01de2SDmitry Chagin 233432c01de2SDmitry Chagin /* 233532c01de2SDmitry Chagin * Fetch the osreldate for binary 233632c01de2SDmitry Chagin * from the ELF OSABI-note if necessary. 233732c01de2SDmitry Chagin */ 233889ffc202SBjoern A. Zeeb if ((checknote->flags & BN_TRANSLATE_OSREL) != 0 && 23396c775eb6SKonstantin Belousov checknote->trans_osrel != NULL) { 23406c775eb6SKonstantin Belousov res = checknote->trans_osrel(note, osrel); 23416c775eb6SKonstantin Belousov goto ret; 23426c775eb6SKonstantin Belousov } 23436c775eb6SKonstantin Belousov res = TRUE; 23446c775eb6SKonstantin Belousov goto ret; 234532c01de2SDmitry Chagin nextnote: 234632c01de2SDmitry Chagin note = (const Elf_Note *)((const char *)(note + 1) + 23471b8388cdSMikolaj Golub roundup2(note->n_namesz, ELF_NOTE_ROUNDSIZE) + 23481b8388cdSMikolaj Golub roundup2(note->n_descsz, ELF_NOTE_ROUNDSIZE)); 234932c01de2SDmitry Chagin } 23506c775eb6SKonstantin Belousov res = FALSE; 23516c775eb6SKonstantin Belousov ret: 23526c775eb6SKonstantin Belousov free(buf, M_TEMP); 23536c775eb6SKonstantin Belousov return (res); 235432c01de2SDmitry Chagin } 235532c01de2SDmitry Chagin 235632c01de2SDmitry Chagin /* 23571a9c7decSKonstantin Belousov * Try to find the appropriate ABI-note section for checknote, 23581a9c7decSKonstantin Belousov * fetch the osreldate for binary from the ELF OSABI-note. Only the 23591a9c7decSKonstantin Belousov * first page of the image is searched, the same as for headers. 23601a9c7decSKonstantin Belousov */ 23611a9c7decSKonstantin Belousov static boolean_t 23621a9c7decSKonstantin Belousov __elfN(check_note)(struct image_params *imgp, Elf_Brandnote *checknote, 23631a9c7decSKonstantin Belousov int32_t *osrel) 23641a9c7decSKonstantin Belousov { 23651a9c7decSKonstantin Belousov const Elf_Phdr *phdr; 23661a9c7decSKonstantin Belousov const Elf_Ehdr *hdr; 23671a9c7decSKonstantin Belousov int i; 23681a9c7decSKonstantin Belousov 23691a9c7decSKonstantin Belousov hdr = (const Elf_Ehdr *)imgp->image_header; 23701a9c7decSKonstantin Belousov phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff); 23711a9c7decSKonstantin Belousov 23721a9c7decSKonstantin Belousov for (i = 0; i < hdr->e_phnum; i++) { 23731a9c7decSKonstantin Belousov if (phdr[i].p_type == PT_NOTE && 23741a9c7decSKonstantin Belousov __elfN(parse_notes)(imgp, checknote, osrel, &phdr[i])) 23751a9c7decSKonstantin Belousov return (TRUE); 23761a9c7decSKonstantin Belousov } 23771a9c7decSKonstantin Belousov return (FALSE); 23781a9c7decSKonstantin Belousov 23791a9c7decSKonstantin Belousov } 23801a9c7decSKonstantin Belousov 23811a9c7decSKonstantin Belousov /* 2382e1743d02SSøren Schmidt * Tell kern_execve.c about it, with a little help from the linker. 2383e1743d02SSøren Schmidt */ 2384a360a43dSJake Burkholder static struct execsw __elfN(execsw) = { 2385a360a43dSJake Burkholder __CONCAT(exec_, __elfN(imgact)), 2386a360a43dSJake Burkholder __XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) 2387a360a43dSJake Burkholder }; 2388a360a43dSJake Burkholder EXEC_SET(__CONCAT(elf, __ELF_WORD_SIZE), __elfN(execsw)); 2389e7228204SAlfred Perlstein 2390ed167eaaSKonstantin Belousov static vm_prot_t 2391ed167eaaSKonstantin Belousov __elfN(trans_prot)(Elf_Word flags) 2392ed167eaaSKonstantin Belousov { 2393ed167eaaSKonstantin Belousov vm_prot_t prot; 2394ed167eaaSKonstantin Belousov 2395ed167eaaSKonstantin Belousov prot = 0; 2396ed167eaaSKonstantin Belousov if (flags & PF_X) 2397ed167eaaSKonstantin Belousov prot |= VM_PROT_EXECUTE; 2398ed167eaaSKonstantin Belousov if (flags & PF_W) 2399ed167eaaSKonstantin Belousov prot |= VM_PROT_WRITE; 2400ed167eaaSKonstantin Belousov if (flags & PF_R) 2401ed167eaaSKonstantin Belousov prot |= VM_PROT_READ; 2402676eda08SMarcel Moolenaar #if __ELF_WORD_SIZE == 32 2403e7d939bdSMarcel Moolenaar #if defined(__amd64__) 2404126b36a2SKonstantin Belousov if (i386_read_exec && (flags & PF_R)) 2405676eda08SMarcel Moolenaar prot |= VM_PROT_EXECUTE; 2406676eda08SMarcel Moolenaar #endif 2407676eda08SMarcel Moolenaar #endif 2408ed167eaaSKonstantin Belousov return (prot); 2409ed167eaaSKonstantin Belousov } 2410ed167eaaSKonstantin Belousov 2411ed167eaaSKonstantin Belousov static Elf_Word 2412ed167eaaSKonstantin Belousov __elfN(untrans_prot)(vm_prot_t prot) 2413ed167eaaSKonstantin Belousov { 2414ed167eaaSKonstantin Belousov Elf_Word flags; 2415ed167eaaSKonstantin Belousov 2416ed167eaaSKonstantin Belousov flags = 0; 2417ed167eaaSKonstantin Belousov if (prot & VM_PROT_EXECUTE) 2418ed167eaaSKonstantin Belousov flags |= PF_X; 2419ed167eaaSKonstantin Belousov if (prot & VM_PROT_READ) 2420ed167eaaSKonstantin Belousov flags |= PF_R; 2421ed167eaaSKonstantin Belousov if (prot & VM_PROT_WRITE) 2422ed167eaaSKonstantin Belousov flags |= PF_W; 2423ed167eaaSKonstantin Belousov return (flags); 2424ed167eaaSKonstantin Belousov } 2425