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