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