1996-03-10 08:42:54 +00:00
|
|
|
|
/*-
|
2001-02-24 22:20:11 +00:00
|
|
|
|
* Copyright (c) 2000 David O'Brien
|
1996-03-10 08:42:54 +00:00
|
|
|
|
* Copyright (c) 1995-1996 S<EFBFBD>ren Schmidt
|
1996-03-10 22:37:34 +00:00
|
|
|
|
* Copyright (c) 1996 Peter Wemm
|
1996-03-10 08:42:54 +00:00
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
|
* modification, are permitted provided that the following conditions
|
|
|
|
|
* are met:
|
|
|
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer
|
|
|
|
|
* in this position and unchanged.
|
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
|
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
|
|
|
* documentation and/or other materials provided with the distribution.
|
|
|
|
|
* 3. The name of the author may not be used to endorse or promote products
|
2002-06-02 20:05:59 +00:00
|
|
|
|
* derived from this software without specific prior written permission
|
1996-03-10 08:42:54 +00:00
|
|
|
|
*
|
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
|
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
|
|
|
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
|
|
|
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
|
|
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
|
|
|
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
|
|
|
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
*/
|
|
|
|
|
|
2003-06-11 00:56:59 +00:00
|
|
|
|
#include <sys/cdefs.h>
|
|
|
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
|
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#include "opt_compat.h"
|
2010-03-02 06:58:58 +00:00
|
|
|
|
#include "opt_core.h"
|
2005-06-30 07:49:22 +00:00
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <sys/param.h>
|
|
|
|
|
#include <sys/exec.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/fcntl.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <sys/imgact.h>
|
|
|
|
|
#include <sys/imgact_elf.h>
|
|
|
|
|
#include <sys/kernel.h>
|
2001-03-28 09:17:56 +00:00
|
|
|
|
#include <sys/lock.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <sys/malloc.h>
|
2005-09-15 15:03:48 +00:00
|
|
|
|
#include <sys/mount.h>
|
2000-10-20 07:58:15 +00:00
|
|
|
|
#include <sys/mutex.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/mman.h>
|
1996-05-01 02:43:13 +00:00
|
|
|
|
#include <sys/namei.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/pioctl.h>
|
1996-05-01 02:43:13 +00:00
|
|
|
|
#include <sys/proc.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/procfs.h>
|
2011-04-05 20:23:59 +00:00
|
|
|
|
#include <sys/racct.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/resourcevar.h>
|
2005-12-16 18:34:14 +00:00
|
|
|
|
#include <sys/sf_buf.h>
|
2010-08-17 08:55:45 +00:00
|
|
|
|
#include <sys/smp.h>
|
2000-09-10 13:54:52 +00:00
|
|
|
|
#include <sys/systm.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <sys/signalvar.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/stat.h>
|
2001-03-28 11:52:56 +00:00
|
|
|
|
#include <sys/sx.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/syscall.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <sys/sysctl.h>
|
1998-09-14 22:46:08 +00:00
|
|
|
|
#include <sys/sysent.h>
|
1996-05-01 02:43:13 +00:00
|
|
|
|
#include <sys/vnode.h>
|
2010-03-02 06:58:58 +00:00
|
|
|
|
#include <sys/syslog.h>
|
|
|
|
|
#include <sys/eventhandler.h>
|
|
|
|
|
|
|
|
|
|
#include <net/zlib.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
#include <vm/vm.h>
|
|
|
|
|
#include <vm/vm_kern.h>
|
|
|
|
|
#include <vm/vm_param.h>
|
|
|
|
|
#include <vm/pmap.h>
|
|
|
|
|
#include <vm/vm_map.h>
|
1998-09-16 02:04:05 +00:00
|
|
|
|
#include <vm/vm_object.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <vm/vm_extern.h>
|
|
|
|
|
|
1998-10-18 15:55:12 +00:00
|
|
|
|
#include <machine/elf.h>
|
1996-03-10 08:42:54 +00:00
|
|
|
|
#include <machine/md_var.h>
|
|
|
|
|
|
2000-04-18 02:39:26 +00:00
|
|
|
|
#define OLD_EI_BRAND 8
|
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
static int __elfN(check_header)(const Elf_Ehdr *hdr);
|
2009-03-13 16:40:51 +00:00
|
|
|
|
static Elf_Brandinfo *__elfN(get_brandinfo)(struct image_params *imgp,
|
|
|
|
|
const char *interp, int32_t *osrel);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
static int __elfN(load_file)(struct proc *p, const char *file, u_long *addr,
|
|
|
|
|
u_long *entry, size_t pagesize);
|
2005-12-21 18:58:40 +00:00
|
|
|
|
static int __elfN(load_section)(struct vmspace *vmspace, vm_object_t object,
|
1998-09-14 22:46:08 +00:00
|
|
|
|
vm_offset_t offset, caddr_t vmaddr, size_t memsz, size_t filsz,
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_prot_t prot, size_t pagesize);
|
|
|
|
|
static int __CONCAT(exec_, __elfN(imgact))(struct image_params *imgp);
|
Fix handling of .note.ABI-tag section for GNU systems [1].
Handle GNU/Linux according to LSB Core Specification 4.0,
Chapter 11. Object Format, 11.8. ABI note tag.
Also check the first word of desc, not only name, according to
glibc abi-tags specification to distinguish between Linux and
kFreeBSD.
Add explicit handling for Debian GNU/kFreeBSD, which runs
on our kernels as well [2].
In {amd64,i386}/trap.c, when checking osrel of the current process,
also check the ABI to not change the signal behaviour for Linux
binary processes, now that we save an osrel version for all three
from the lists above in struct proc [2].
These changes make it possible to run FreeBSD, Debian GNU/kFreeBSD
and Linux binaries on the same machine again for at least i386 and
amd64, and no longer break kFreeBSD which was detected as GNU(/Linux).
PR: kern/135468
Submitted by: dchagin [1] (initial patch)
Suggested by: kib [2]
Tested by: Petr Salinger (Petr.Salinger seznam.cz) for kFreeBSD
Reviewed by: kib
MFC after: 3 days
2009-08-24 16:19:47 +00:00
|
|
|
|
static boolean_t __elfN(freebsd_trans_osrel)(const Elf_Note *note,
|
|
|
|
|
int32_t *osrel);
|
|
|
|
|
static boolean_t kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel);
|
2009-03-13 16:40:51 +00:00
|
|
|
|
static boolean_t __elfN(check_note)(struct image_params *imgp,
|
|
|
|
|
Elf_Brandnote *checknote, int32_t *osrel);
|
2011-01-08 16:02:14 +00:00
|
|
|
|
static vm_prot_t __elfN(trans_prot)(Elf_Word);
|
|
|
|
|
static Elf_Word __elfN(untrans_prot)(vm_prot_t);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2003-01-04 22:07:48 +00:00
|
|
|
|
SYSCTL_NODE(_kern, OID_AUTO, __CONCAT(elf, __ELF_WORD_SIZE), CTLFLAG_RW, 0,
|
|
|
|
|
"");
|
|
|
|
|
|
2010-03-02 06:58:58 +00:00
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
static int compress_core(gzFile, char *, char *, unsigned int,
|
|
|
|
|
struct thread * td);
|
|
|
|
|
#define CORE_BUF_SIZE (16 * 1024)
|
|
|
|
|
#endif
|
|
|
|
|
|
2003-01-05 03:48:14 +00:00
|
|
|
|
int __elfN(fallback_brand) = -1;
|
|
|
|
|
SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
|
|
|
|
|
fallback_brand, CTLFLAG_RW, &__elfN(fallback_brand), 0,
|
2003-01-04 22:07:48 +00:00
|
|
|
|
__XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) " brand of last resort");
|
|
|
|
|
TUNABLE_INT("kern.elf" __XSTRING(__ELF_WORD_SIZE) ".fallback_brand",
|
2003-01-05 03:48:14 +00:00
|
|
|
|
&__elfN(fallback_brand));
|
2003-01-04 22:07:48 +00:00
|
|
|
|
|
2002-12-21 01:15:39 +00:00
|
|
|
|
static int elf_legacy_coredump = 0;
|
2003-01-04 22:07:48 +00:00
|
|
|
|
SYSCTL_INT(_debug, OID_AUTO, __elfN(legacy_coredump), CTLFLAG_RW,
|
2002-12-16 19:24:43 +00:00
|
|
|
|
&elf_legacy_coredump, 0, "");
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2011-01-08 16:30:59 +00:00
|
|
|
|
static int __elfN(nxstack) = 0;
|
|
|
|
|
SYSCTL_INT(__CONCAT(_kern_elf, __ELF_WORD_SIZE), OID_AUTO,
|
|
|
|
|
nxstack, CTLFLAG_RW, &__elfN(nxstack), 0,
|
|
|
|
|
__XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE)) ": enable non-executable stack");
|
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
static Elf_Brandinfo *elf_brand_list[MAX_BRANDS];
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2007-12-04 12:21:27 +00:00
|
|
|
|
#define trunc_page_ps(va, ps) ((va) & ~(ps - 1))
|
|
|
|
|
#define round_page_ps(va, ps) (((va) + (ps - 1)) & ~(ps - 1))
|
|
|
|
|
#define aligned(a, t) (trunc_page_ps((u_long)(a), sizeof(t)) == (u_long)(a))
|
|
|
|
|
|
2009-03-13 16:40:51 +00:00
|
|
|
|
static const char FREEBSD_ABI_VENDOR[] = "FreeBSD";
|
|
|
|
|
|
|
|
|
|
Elf_Brandnote __elfN(freebsd_brandnote) = {
|
|
|
|
|
.hdr.n_namesz = sizeof(FREEBSD_ABI_VENDOR),
|
|
|
|
|
.hdr.n_descsz = sizeof(int32_t),
|
|
|
|
|
.hdr.n_type = 1,
|
|
|
|
|
.vendor = FREEBSD_ABI_VENDOR,
|
Fix handling of .note.ABI-tag section for GNU systems [1].
Handle GNU/Linux according to LSB Core Specification 4.0,
Chapter 11. Object Format, 11.8. ABI note tag.
Also check the first word of desc, not only name, according to
glibc abi-tags specification to distinguish between Linux and
kFreeBSD.
Add explicit handling for Debian GNU/kFreeBSD, which runs
on our kernels as well [2].
In {amd64,i386}/trap.c, when checking osrel of the current process,
also check the ABI to not change the signal behaviour for Linux
binary processes, now that we save an osrel version for all three
from the lists above in struct proc [2].
These changes make it possible to run FreeBSD, Debian GNU/kFreeBSD
and Linux binaries on the same machine again for at least i386 and
amd64, and no longer break kFreeBSD which was detected as GNU(/Linux).
PR: kern/135468
Submitted by: dchagin [1] (initial patch)
Suggested by: kib [2]
Tested by: Petr Salinger (Petr.Salinger seznam.cz) for kFreeBSD
Reviewed by: kib
MFC after: 3 days
2009-08-24 16:19:47 +00:00
|
|
|
|
.flags = BN_TRANSLATE_OSREL,
|
|
|
|
|
.trans_osrel = __elfN(freebsd_trans_osrel)
|
2009-03-13 16:40:51 +00:00
|
|
|
|
};
|
|
|
|
|
|
Fix handling of .note.ABI-tag section for GNU systems [1].
Handle GNU/Linux according to LSB Core Specification 4.0,
Chapter 11. Object Format, 11.8. ABI note tag.
Also check the first word of desc, not only name, according to
glibc abi-tags specification to distinguish between Linux and
kFreeBSD.
Add explicit handling for Debian GNU/kFreeBSD, which runs
on our kernels as well [2].
In {amd64,i386}/trap.c, when checking osrel of the current process,
also check the ABI to not change the signal behaviour for Linux
binary processes, now that we save an osrel version for all three
from the lists above in struct proc [2].
These changes make it possible to run FreeBSD, Debian GNU/kFreeBSD
and Linux binaries on the same machine again for at least i386 and
amd64, and no longer break kFreeBSD which was detected as GNU(/Linux).
PR: kern/135468
Submitted by: dchagin [1] (initial patch)
Suggested by: kib [2]
Tested by: Petr Salinger (Petr.Salinger seznam.cz) for kFreeBSD
Reviewed by: kib
MFC after: 3 days
2009-08-24 16:19:47 +00:00
|
|
|
|
static boolean_t
|
|
|
|
|
__elfN(freebsd_trans_osrel)(const Elf_Note *note, int32_t *osrel)
|
|
|
|
|
{
|
|
|
|
|
uintptr_t p;
|
|
|
|
|
|
|
|
|
|
p = (uintptr_t)(note + 1);
|
|
|
|
|
p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
|
|
|
|
|
*osrel = *(const int32_t *)(p);
|
|
|
|
|
|
|
|
|
|
return (TRUE);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char GNU_ABI_VENDOR[] = "GNU";
|
|
|
|
|
static int GNU_KFREEBSD_ABI_DESC = 3;
|
|
|
|
|
|
|
|
|
|
Elf_Brandnote __elfN(kfreebsd_brandnote) = {
|
|
|
|
|
.hdr.n_namesz = sizeof(GNU_ABI_VENDOR),
|
|
|
|
|
.hdr.n_descsz = 16, /* XXX at least 16 */
|
|
|
|
|
.hdr.n_type = 1,
|
|
|
|
|
.vendor = GNU_ABI_VENDOR,
|
|
|
|
|
.flags = BN_TRANSLATE_OSREL,
|
|
|
|
|
.trans_osrel = kfreebsd_trans_osrel
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static boolean_t
|
|
|
|
|
kfreebsd_trans_osrel(const Elf_Note *note, int32_t *osrel)
|
|
|
|
|
{
|
|
|
|
|
const Elf32_Word *desc;
|
|
|
|
|
uintptr_t p;
|
|
|
|
|
|
|
|
|
|
p = (uintptr_t)(note + 1);
|
|
|
|
|
p += roundup2(note->n_namesz, sizeof(Elf32_Addr));
|
|
|
|
|
|
|
|
|
|
desc = (const Elf32_Word *)p;
|
|
|
|
|
if (desc[0] != GNU_KFREEBSD_ABI_DESC)
|
|
|
|
|
return (FALSE);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Debian GNU/kFreeBSD embed the earliest compatible kernel version
|
|
|
|
|
* (__FreeBSD_version: <major><two digit minor>Rxx) in the LSB way.
|
|
|
|
|
*/
|
|
|
|
|
*osrel = desc[1] * 100000 + desc[2] * 1000 + desc[3];
|
|
|
|
|
|
|
|
|
|
return (TRUE);
|
|
|
|
|
}
|
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(insert_brand_entry)(Elf_Brandinfo *entry)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2002-08-24 22:55:16 +00:00
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
1996-10-16 17:51:08 +00:00
|
|
|
|
if (elf_brand_list[i] == NULL) {
|
|
|
|
|
elf_brand_list[i] = entry;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2009-10-03 10:50:00 +00:00
|
|
|
|
if (i == MAX_BRANDS) {
|
|
|
|
|
printf("WARNING: %s: could not insert brandinfo entry: %p\n",
|
|
|
|
|
__func__, entry);
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (-1);
|
2009-10-03 10:50:00 +00:00
|
|
|
|
}
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (0);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(remove_brand_entry)(Elf_Brandinfo *entry)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
2002-08-24 22:55:16 +00:00
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
1996-10-16 17:51:08 +00:00
|
|
|
|
if (elf_brand_list[i] == entry) {
|
|
|
|
|
elf_brand_list[i] = NULL;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
1996-10-16 17:51:08 +00:00
|
|
|
|
if (i == MAX_BRANDS)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (-1);
|
|
|
|
|
return (0);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-02-04 12:42:39 +00:00
|
|
|
|
int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(brand_inuse)(Elf_Brandinfo *entry)
|
1999-02-04 12:42:39 +00:00
|
|
|
|
{
|
|
|
|
|
struct proc *p;
|
2000-11-22 07:42:04 +00:00
|
|
|
|
int rval = FALSE;
|
1999-02-04 12:42:39 +00:00
|
|
|
|
|
2001-03-28 11:52:56 +00:00
|
|
|
|
sx_slock(&allproc_lock);
|
2007-01-17 14:58:53 +00:00
|
|
|
|
FOREACH_PROC_IN_SYSTEM(p) {
|
2000-11-22 07:42:04 +00:00
|
|
|
|
if (p->p_sysent == entry->sysvec) {
|
|
|
|
|
rval = TRUE;
|
|
|
|
|
break;
|
|
|
|
|
}
|
1999-02-04 12:42:39 +00:00
|
|
|
|
}
|
2001-03-28 11:52:56 +00:00
|
|
|
|
sx_sunlock(&allproc_lock);
|
1999-02-04 12:42:39 +00:00
|
|
|
|
|
2000-11-22 07:42:04 +00:00
|
|
|
|
return (rval);
|
1999-02-04 12:42:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
2002-09-02 04:50:57 +00:00
|
|
|
|
static Elf_Brandinfo *
|
2009-03-13 16:40:51 +00:00
|
|
|
|
__elfN(get_brandinfo)(struct image_params *imgp, const char *interp,
|
|
|
|
|
int32_t *osrel)
|
2002-09-02 04:50:57 +00:00
|
|
|
|
{
|
2009-03-13 16:40:51 +00:00
|
|
|
|
const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
Elf_Brandinfo *bi;
|
2009-03-13 16:40:51 +00:00
|
|
|
|
boolean_t ret;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/*
|
2009-03-13 16:40:51 +00:00
|
|
|
|
* We support four types of branding -- (1) the ELF EI_OSABI field
|
2002-09-02 04:50:57 +00:00
|
|
|
|
* that SCO added to the ELF spec, (2) FreeBSD 3.x's traditional string
|
2009-03-13 16:40:51 +00:00
|
|
|
|
* branding w/in the ELF header, (3) path of the `interp_path'
|
|
|
|
|
* field, and (4) the ".note.ABI-tag" ELF section.
|
2002-09-02 04:50:57 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2009-03-13 16:40:51 +00:00
|
|
|
|
/* Look for an ".note.ABI-tag" ELF section */
|
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
|
|
|
|
bi = elf_brand_list[i];
|
2009-08-30 14:38:17 +00:00
|
|
|
|
if (bi == NULL)
|
|
|
|
|
continue;
|
|
|
|
|
if (hdr->e_machine == bi->machine && (bi->flags &
|
|
|
|
|
(BI_BRAND_NOTE|BI_BRAND_NOTE_MANDATORY)) != 0) {
|
2009-03-13 16:40:51 +00:00
|
|
|
|
ret = __elfN(check_note)(imgp, bi->brand_note, osrel);
|
|
|
|
|
if (ret)
|
|
|
|
|
return (bi);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-09-02 04:50:57 +00:00
|
|
|
|
/* If the executable has a brand, search for it in the brand list. */
|
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
|
|
|
|
bi = elf_brand_list[i];
|
2009-08-30 14:38:17 +00:00
|
|
|
|
if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
|
|
|
|
|
continue;
|
|
|
|
|
if (hdr->e_machine == bi->machine &&
|
2002-09-02 04:50:57 +00:00
|
|
|
|
(hdr->e_ident[EI_OSABI] == bi->brand ||
|
|
|
|
|
strncmp((const char *)&hdr->e_ident[OLD_EI_BRAND],
|
|
|
|
|
bi->compat_3_brand, strlen(bi->compat_3_brand)) == 0))
|
|
|
|
|
return (bi);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Lacking a known brand, search for a recognized interpreter. */
|
|
|
|
|
if (interp != NULL) {
|
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
|
|
|
|
bi = elf_brand_list[i];
|
2009-08-30 14:38:17 +00:00
|
|
|
|
if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
|
|
|
|
|
continue;
|
|
|
|
|
if (hdr->e_machine == bi->machine &&
|
2002-09-02 04:50:57 +00:00
|
|
|
|
strcmp(interp, bi->interp_path) == 0)
|
|
|
|
|
return (bi);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Lacking a recognized interpreter, try the default brand */
|
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
|
|
|
|
bi = elf_brand_list[i];
|
2009-08-30 14:38:17 +00:00
|
|
|
|
if (bi == NULL || bi->flags & BI_BRAND_NOTE_MANDATORY)
|
|
|
|
|
continue;
|
|
|
|
|
if (hdr->e_machine == bi->machine &&
|
2003-01-05 03:48:14 +00:00
|
|
|
|
__elfN(fallback_brand) == bi->brand)
|
2002-09-02 04:50:57 +00:00
|
|
|
|
return (bi);
|
|
|
|
|
}
|
|
|
|
|
return (NULL);
|
|
|
|
|
}
|
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
static int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(check_header)(const Elf_Ehdr *hdr)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
2002-09-08 02:17:44 +00:00
|
|
|
|
Elf_Brandinfo *bi;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
1998-10-18 15:55:12 +00:00
|
|
|
|
if (!IS_ELF(*hdr) ||
|
|
|
|
|
hdr->e_ident[EI_CLASS] != ELF_TARG_CLASS ||
|
|
|
|
|
hdr->e_ident[EI_DATA] != ELF_TARG_DATA ||
|
2004-03-18 16:33:05 +00:00
|
|
|
|
hdr->e_ident[EI_VERSION] != EV_CURRENT ||
|
|
|
|
|
hdr->e_phentsize != sizeof(Elf_Phdr) ||
|
|
|
|
|
hdr->e_version != ELF_TARG_VER)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (ENOEXEC);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
/*
|
|
|
|
|
* Make sure we have at least one brand for this machine.
|
|
|
|
|
*/
|
|
|
|
|
|
2002-08-24 22:55:16 +00:00
|
|
|
|
for (i = 0; i < MAX_BRANDS; i++) {
|
2002-09-08 02:17:44 +00:00
|
|
|
|
bi = elf_brand_list[i];
|
|
|
|
|
if (bi != NULL && bi->machine == hdr->e_machine)
|
2002-07-20 02:56:12 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (i == MAX_BRANDS)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (ENOEXEC);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (0);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(map_partial)(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
vm_offset_t start, vm_offset_t end, vm_prot_t prot)
|
2002-07-20 02:56:12 +00:00
|
|
|
|
{
|
2005-12-16 18:34:14 +00:00
|
|
|
|
struct sf_buf *sf;
|
|
|
|
|
int error;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_offset_t off;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Create the page if it doesn't exist yet. Ignore errors.
|
|
|
|
|
*/
|
|
|
|
|
vm_map_lock(map);
|
2005-12-20 23:42:18 +00:00
|
|
|
|
vm_map_insert(map, NULL, 0, trunc_page(start), round_page(end),
|
|
|
|
|
VM_PROT_ALL, VM_PROT_ALL, 0);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_map_unlock(map);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Find the page from the underlying object.
|
|
|
|
|
*/
|
|
|
|
|
if (object) {
|
2005-12-16 18:34:14 +00:00
|
|
|
|
sf = vm_imgact_map_page(object, offset);
|
|
|
|
|
if (sf == NULL)
|
|
|
|
|
return (KERN_FAILURE);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
off = offset - trunc_page(offset);
|
2005-12-16 18:34:14 +00:00
|
|
|
|
error = copyout((caddr_t)sf_buf_kva(sf) + off, (caddr_t)start,
|
2002-08-25 20:48:45 +00:00
|
|
|
|
end - start);
|
2005-12-16 18:34:14 +00:00
|
|
|
|
vm_imgact_unmap_page(sf);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (error) {
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (KERN_FAILURE);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (KERN_SUCCESS);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
__elfN(map_insert)(vm_map_t map, vm_object_t object, vm_ooffset_t offset,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
vm_offset_t start, vm_offset_t end, vm_prot_t prot, int cow)
|
2002-07-20 02:56:12 +00:00
|
|
|
|
{
|
2005-12-16 18:34:14 +00:00
|
|
|
|
struct sf_buf *sf;
|
|
|
|
|
vm_offset_t off;
|
2003-05-31 19:55:05 +00:00
|
|
|
|
vm_size_t sz;
|
|
|
|
|
int error, rv;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
|
|
|
|
|
if (start != trunc_page(start)) {
|
2002-08-25 22:36:52 +00:00
|
|
|
|
rv = __elfN(map_partial)(map, object, offset, start,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
round_page(start), prot);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (rv)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (rv);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
offset += round_page(start) - start;
|
|
|
|
|
start = round_page(start);
|
|
|
|
|
}
|
|
|
|
|
if (end != round_page(end)) {
|
2002-08-25 22:36:52 +00:00
|
|
|
|
rv = __elfN(map_partial)(map, object, offset +
|
2005-12-20 23:42:18 +00:00
|
|
|
|
trunc_page(end) - start, trunc_page(end), end, prot);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (rv)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (rv);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
end = trunc_page(end);
|
|
|
|
|
}
|
|
|
|
|
if (end > start) {
|
|
|
|
|
if (offset & PAGE_MASK) {
|
|
|
|
|
/*
|
|
|
|
|
* The mapping is not page aligned. This means we have
|
|
|
|
|
* to copy the data. Sigh.
|
|
|
|
|
*/
|
2005-12-16 19:14:25 +00:00
|
|
|
|
rv = vm_map_find(map, NULL, 0, &start, end - start,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
FALSE, prot | VM_PROT_WRITE, VM_PROT_ALL, 0);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (rv)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (rv);
|
2005-12-16 18:34:14 +00:00
|
|
|
|
if (object == NULL)
|
|
|
|
|
return (KERN_SUCCESS);
|
|
|
|
|
for (; start < end; start += sz) {
|
|
|
|
|
sf = vm_imgact_map_page(object, offset);
|
|
|
|
|
if (sf == NULL)
|
|
|
|
|
return (KERN_FAILURE);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
off = offset - trunc_page(offset);
|
|
|
|
|
sz = end - start;
|
2005-12-16 18:34:14 +00:00
|
|
|
|
if (sz > PAGE_SIZE - off)
|
|
|
|
|
sz = PAGE_SIZE - off;
|
|
|
|
|
error = copyout((caddr_t)sf_buf_kva(sf) + off,
|
2002-08-25 22:36:52 +00:00
|
|
|
|
(caddr_t)start, sz);
|
2005-12-16 18:34:14 +00:00
|
|
|
|
vm_imgact_unmap_page(sf);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (error) {
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (KERN_FAILURE);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
2005-12-16 18:34:14 +00:00
|
|
|
|
offset += sz;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
rv = KERN_SUCCESS;
|
|
|
|
|
} else {
|
2006-01-21 20:11:49 +00:00
|
|
|
|
vm_object_reference(object);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_map_lock(map);
|
2002-08-24 22:55:16 +00:00
|
|
|
|
rv = vm_map_insert(map, object, offset, start, end,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
prot, VM_PROT_ALL, cow);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_map_unlock(map);
|
2006-01-21 20:11:49 +00:00
|
|
|
|
if (rv != KERN_SUCCESS)
|
|
|
|
|
vm_object_deallocate(object);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (rv);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
} else {
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (KERN_SUCCESS);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
2005-12-21 18:58:40 +00:00
|
|
|
|
__elfN(load_section)(struct vmspace *vmspace,
|
|
|
|
|
vm_object_t object, vm_offset_t offset,
|
2002-07-20 02:56:12 +00:00
|
|
|
|
caddr_t vmaddr, size_t memsz, size_t filsz, vm_prot_t prot,
|
|
|
|
|
size_t pagesize)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
2005-12-16 18:34:14 +00:00
|
|
|
|
struct sf_buf *sf;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
size_t map_len;
|
|
|
|
|
vm_offset_t map_addr;
|
2002-12-16 19:24:43 +00:00
|
|
|
|
int error, rv, cow;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
size_t copy_len;
|
1998-10-18 15:55:12 +00:00
|
|
|
|
vm_offset_t file_addr;
|
|
|
|
|
|
2000-07-23 06:49:46 +00:00
|
|
|
|
/*
|
|
|
|
|
* It's necessary to fail if the filsz + offset taken from the
|
|
|
|
|
* header is greater than the actual file pager object's size.
|
|
|
|
|
* If we were to allow this, then the vm_map_find() below would
|
|
|
|
|
* walk right off the end of the file object and into the ether.
|
|
|
|
|
*
|
|
|
|
|
* While I'm here, might as well check for something else that
|
|
|
|
|
* is invalid: filsz cannot be greater than memsz.
|
|
|
|
|
*/
|
|
|
|
|
if ((off_t)filsz + offset > object->un_pager.vnp.vnp_size ||
|
|
|
|
|
filsz > memsz) {
|
|
|
|
|
uprintf("elf_load_section: truncated ELF file\n");
|
|
|
|
|
return (ENOEXEC);
|
|
|
|
|
}
|
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
map_addr = trunc_page_ps((vm_offset_t)vmaddr, pagesize);
|
|
|
|
|
file_addr = trunc_page_ps(offset, pagesize);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1998-10-18 15:55:12 +00:00
|
|
|
|
/*
|
|
|
|
|
* We have two choices. We can either clear the data in the last page
|
|
|
|
|
* of an oversized mapping, or we can start the anon mapping a page
|
|
|
|
|
* early and copy the initialized data into that first page. We
|
|
|
|
|
* choose the second..
|
|
|
|
|
*/
|
1996-03-10 08:42:54 +00:00
|
|
|
|
if (memsz > filsz)
|
2002-08-24 22:55:16 +00:00
|
|
|
|
map_len = trunc_page_ps(offset + filsz, pagesize) - file_addr;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
else
|
2002-08-24 22:55:16 +00:00
|
|
|
|
map_len = round_page_ps(offset + filsz, pagesize) - file_addr;
|
1998-10-18 15:55:12 +00:00
|
|
|
|
|
|
|
|
|
if (map_len != 0) {
|
2002-12-16 19:24:43 +00:00
|
|
|
|
/* cow flags: don't dump readonly sections in core */
|
|
|
|
|
cow = MAP_COPY_ON_WRITE | MAP_PREFAULT |
|
|
|
|
|
(prot & VM_PROT_WRITE ? 0 : MAP_DISABLE_COREDUMP);
|
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
rv = __elfN(map_insert)(&vmspace->vm_map,
|
1998-10-18 15:55:12 +00:00
|
|
|
|
object,
|
|
|
|
|
file_addr, /* file offset */
|
|
|
|
|
map_addr, /* virtual start */
|
|
|
|
|
map_addr + map_len,/* virtual end */
|
|
|
|
|
prot,
|
2002-12-16 19:24:43 +00:00
|
|
|
|
cow);
|
2006-01-21 20:11:49 +00:00
|
|
|
|
if (rv != KERN_SUCCESS)
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (EINVAL);
|
1998-10-18 15:55:12 +00:00
|
|
|
|
|
|
|
|
|
/* we can stop now if we've covered it all */
|
2001-05-19 01:28:09 +00:00
|
|
|
|
if (memsz == filsz) {
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (0);
|
2001-05-19 01:28:09 +00:00
|
|
|
|
}
|
1998-10-18 15:55:12 +00:00
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
1998-10-18 15:55:12 +00:00
|
|
|
|
* We have to get the remaining bit of the file into the first part
|
|
|
|
|
* of the oversized map segment. This is normally because the .data
|
|
|
|
|
* segment in the file is extended to provide bss. It's a neat idea
|
|
|
|
|
* to try and save a page, but it's a pain in the behind to implement.
|
1996-03-10 08:42:54 +00:00
|
|
|
|
*/
|
2002-07-20 02:56:12 +00:00
|
|
|
|
copy_len = (offset + filsz) - trunc_page_ps(offset + filsz, pagesize);
|
|
|
|
|
map_addr = trunc_page_ps((vm_offset_t)vmaddr + filsz, pagesize);
|
2002-08-25 20:48:45 +00:00
|
|
|
|
map_len = round_page_ps((vm_offset_t)vmaddr + memsz, pagesize) -
|
|
|
|
|
map_addr;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1998-10-18 15:55:12 +00:00
|
|
|
|
/* This had damn well better be true! */
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if (map_len != 0) {
|
2002-08-25 22:36:52 +00:00
|
|
|
|
rv = __elfN(map_insert)(&vmspace->vm_map, NULL, 0, map_addr,
|
2005-12-20 23:42:18 +00:00
|
|
|
|
map_addr + map_len, VM_PROT_ALL, 0);
|
2001-05-19 01:28:09 +00:00
|
|
|
|
if (rv != KERN_SUCCESS) {
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (EINVAL);
|
2001-12-16 17:21:16 +00:00
|
|
|
|
}
|
1996-03-10 22:37:34 +00:00
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1998-10-18 15:55:12 +00:00
|
|
|
|
if (copy_len != 0) {
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_offset_t off;
|
2005-12-16 18:34:14 +00:00
|
|
|
|
|
|
|
|
|
sf = vm_imgact_map_page(object, offset + filsz);
|
|
|
|
|
if (sf == NULL)
|
|
|
|
|
return (EIO);
|
1998-10-18 15:55:12 +00:00
|
|
|
|
|
|
|
|
|
/* send the page fragment to user space */
|
2002-08-25 22:36:52 +00:00
|
|
|
|
off = trunc_page_ps(offset + filsz, pagesize) -
|
|
|
|
|
trunc_page(offset + filsz);
|
2005-12-16 18:34:14 +00:00
|
|
|
|
error = copyout((caddr_t)sf_buf_kva(sf) + off,
|
|
|
|
|
(caddr_t)map_addr, copy_len);
|
|
|
|
|
vm_imgact_unmap_page(sf);
|
2001-05-19 01:28:09 +00:00
|
|
|
|
if (error) {
|
1998-10-18 15:55:12 +00:00
|
|
|
|
return (error);
|
2001-05-19 01:28:09 +00:00
|
|
|
|
}
|
1998-10-18 15:55:12 +00:00
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2002-07-20 02:56:12 +00:00
|
|
|
|
* set it to the specified protection.
|
|
|
|
|
* XXX had better undo the damage from pasting over the cracks here!
|
1996-03-10 08:42:54 +00:00
|
|
|
|
*/
|
2002-07-20 02:56:12 +00:00
|
|
|
|
vm_map_protect(&vmspace->vm_map, trunc_page(map_addr),
|
|
|
|
|
round_page(map_addr + map_len), prot, FALSE);
|
1996-03-10 22:37:34 +00:00
|
|
|
|
|
2005-12-20 23:42:18 +00:00
|
|
|
|
return (0);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
1999-02-20 23:52:34 +00:00
|
|
|
|
/*
|
|
|
|
|
* Load the file "file" into memory. It may be either a shared object
|
|
|
|
|
* or an executable.
|
|
|
|
|
*
|
|
|
|
|
* The "addr" reference parameter is in/out. On entry, it specifies
|
|
|
|
|
* the address where a shared object should be loaded. If the file is
|
|
|
|
|
* an executable, this value is ignored. On exit, "addr" specifies
|
|
|
|
|
* where the file was actually loaded.
|
|
|
|
|
*
|
|
|
|
|
* The "entry" reference parameter is out only. On exit, it specifies
|
|
|
|
|
* the entry point for the loaded file.
|
|
|
|
|
*/
|
1996-03-10 08:42:54 +00:00
|
|
|
|
static int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(load_file)(struct proc *p, const char *file, u_long *addr,
|
|
|
|
|
u_long *entry, size_t pagesize)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
2001-08-16 16:14:26 +00:00
|
|
|
|
struct {
|
|
|
|
|
struct nameidata nd;
|
|
|
|
|
struct vattr attr;
|
|
|
|
|
struct image_params image_params;
|
|
|
|
|
} *tempdata;
|
1999-01-27 21:50:00 +00:00
|
|
|
|
const Elf_Ehdr *hdr = NULL;
|
|
|
|
|
const Elf_Phdr *phdr = NULL;
|
2001-08-16 16:14:26 +00:00
|
|
|
|
struct nameidata *nd;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
struct vmspace *vmspace = p->p_vmspace;
|
2001-08-16 16:14:26 +00:00
|
|
|
|
struct vattr *attr;
|
|
|
|
|
struct image_params *imgp;
|
1998-10-18 15:55:12 +00:00
|
|
|
|
vm_prot_t prot;
|
1999-02-20 23:52:34 +00:00
|
|
|
|
u_long rbase;
|
|
|
|
|
u_long base_addr = 0;
|
2005-09-15 15:03:48 +00:00
|
|
|
|
int vfslocked, error, i, numsegs;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2003-02-19 05:47:46 +00:00
|
|
|
|
tempdata = malloc(sizeof(*tempdata), M_TEMP, M_WAITOK);
|
2001-08-16 16:14:26 +00:00
|
|
|
|
nd = &tempdata->nd;
|
|
|
|
|
attr = &tempdata->attr;
|
|
|
|
|
imgp = &tempdata->image_params;
|
|
|
|
|
|
1998-03-02 05:47:58 +00:00
|
|
|
|
/*
|
|
|
|
|
* Initialize part of the common data
|
|
|
|
|
*/
|
|
|
|
|
imgp->proc = p;
|
2001-08-16 16:14:26 +00:00
|
|
|
|
imgp->attr = attr;
|
1998-03-02 05:47:58 +00:00
|
|
|
|
imgp->firstpage = NULL;
|
2004-04-23 03:01:40 +00:00
|
|
|
|
imgp->image_header = NULL;
|
2002-07-06 07:00:01 +00:00
|
|
|
|
imgp->object = NULL;
|
2002-11-08 20:49:50 +00:00
|
|
|
|
imgp->execlabel = NULL;
|
1998-03-02 05:47:58 +00:00
|
|
|
|
|
2005-09-15 15:03:48 +00:00
|
|
|
|
NDINIT(nd, LOOKUP, MPSAFE|LOCKLEAF|FOLLOW, UIO_SYSSPACE, file,
|
|
|
|
|
curthread);
|
|
|
|
|
vfslocked = 0;
|
2001-08-16 16:14:26 +00:00
|
|
|
|
if ((error = namei(nd)) != 0) {
|
|
|
|
|
nd->ni_vp = NULL;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
goto fail;
|
|
|
|
|
}
|
2005-09-15 15:03:48 +00:00
|
|
|
|
vfslocked = NDHASGIANT(nd);
|
2001-08-16 16:14:26 +00:00
|
|
|
|
NDFREE(nd, NDF_ONLY_PNBUF);
|
|
|
|
|
imgp->vp = nd->ni_vp;
|
1998-03-02 05:47:58 +00:00
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
/*
|
|
|
|
|
* Check permissions, modes, uid, etc on the file, and "open" it.
|
|
|
|
|
*/
|
1998-03-02 05:47:58 +00:00
|
|
|
|
error = exec_check_permissions(imgp);
|
2005-12-21 18:58:40 +00:00
|
|
|
|
if (error)
|
1998-03-02 05:47:58 +00:00
|
|
|
|
goto fail;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1998-03-02 05:47:58 +00:00
|
|
|
|
error = exec_map_first_page(imgp);
|
2005-12-21 18:58:40 +00:00
|
|
|
|
if (error)
|
|
|
|
|
goto fail;
|
|
|
|
|
|
2000-07-23 06:49:46 +00:00
|
|
|
|
/*
|
|
|
|
|
* Also make certain that the interpreter stays the same, so set
|
2002-08-04 10:29:36 +00:00
|
|
|
|
* its VV_TEXT flag, too.
|
2000-07-23 06:49:46 +00:00
|
|
|
|
*/
|
2005-12-21 18:58:40 +00:00
|
|
|
|
nd->ni_vp->v_vflag |= VV_TEXT;
|
2002-08-04 10:29:36 +00:00
|
|
|
|
|
2005-01-25 00:40:01 +00:00
|
|
|
|
imgp->object = nd->ni_vp->v_object;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
|
hdr = (const Elf_Ehdr *)imgp->image_header;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
if ((error = __elfN(check_header)(hdr)) != 0)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
goto fail;
|
1999-02-20 23:52:34 +00:00
|
|
|
|
if (hdr->e_type == ET_DYN)
|
|
|
|
|
rbase = *addr;
|
|
|
|
|
else if (hdr->e_type == ET_EXEC)
|
|
|
|
|
rbase = 0;
|
|
|
|
|
else {
|
|
|
|
|
error = ENOEXEC;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2004-03-18 16:33:05 +00:00
|
|
|
|
/* Only support headers that fit within first page for now */
|
|
|
|
|
/* (multiplication of two Elf_Half fields will not overflow) */
|
1998-10-18 15:55:12 +00:00
|
|
|
|
if ((hdr->e_phoff > PAGE_SIZE) ||
|
2004-03-18 16:33:05 +00:00
|
|
|
|
(hdr->e_phentsize * hdr->e_phnum) > PAGE_SIZE - hdr->e_phoff) {
|
1998-03-02 05:47:58 +00:00
|
|
|
|
error = ENOEXEC;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
|
|
|
|
|
1999-01-27 21:50:00 +00:00
|
|
|
|
phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
|
2007-12-04 12:21:27 +00:00
|
|
|
|
if (!aligned(phdr, Elf_Addr)) {
|
|
|
|
|
error = ENOEXEC;
|
|
|
|
|
goto fail;
|
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1999-02-20 23:52:34 +00:00
|
|
|
|
for (i = 0, numsegs = 0; i < hdr->e_phnum; i++) {
|
2009-10-10 15:28:52 +00:00
|
|
|
|
if (phdr[i].p_type == PT_LOAD && phdr[i].p_memsz != 0) {
|
|
|
|
|
/* Loadable segment */
|
2011-01-08 16:02:14 +00:00
|
|
|
|
prot = __elfN(trans_prot)(phdr[i].p_flags);
|
2005-12-21 18:58:40 +00:00
|
|
|
|
if ((error = __elfN(load_section)(vmspace,
|
|
|
|
|
imgp->object, phdr[i].p_offset,
|
2002-08-25 22:36:52 +00:00
|
|
|
|
(caddr_t)(uintptr_t)phdr[i].p_vaddr + rbase,
|
|
|
|
|
phdr[i].p_memsz, phdr[i].p_filesz, prot,
|
|
|
|
|
pagesize)) != 0)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
goto fail;
|
|
|
|
|
/*
|
1999-02-20 23:52:34 +00:00
|
|
|
|
* Establish the base address if this is the
|
|
|
|
|
* first segment.
|
1996-03-10 08:42:54 +00:00
|
|
|
|
*/
|
1999-02-20 23:52:34 +00:00
|
|
|
|
if (numsegs == 0)
|
2002-08-25 20:48:45 +00:00
|
|
|
|
base_addr = trunc_page(phdr[i].p_vaddr +
|
|
|
|
|
rbase);
|
1999-02-20 23:52:34 +00:00
|
|
|
|
numsegs++;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
1999-02-20 23:52:34 +00:00
|
|
|
|
*addr = base_addr;
|
2002-08-24 22:55:16 +00:00
|
|
|
|
*entry = (unsigned long)hdr->e_entry + rbase;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
fail:
|
1998-03-02 05:47:58 +00:00
|
|
|
|
if (imgp->firstpage)
|
|
|
|
|
exec_unmap_first_page(imgp);
|
2002-07-06 07:00:01 +00:00
|
|
|
|
|
2001-08-16 16:14:26 +00:00
|
|
|
|
if (nd->ni_vp)
|
2005-12-21 18:58:40 +00:00
|
|
|
|
vput(nd->ni_vp);
|
2001-08-16 16:14:26 +00:00
|
|
|
|
|
2005-09-15 15:03:48 +00:00
|
|
|
|
VFS_UNLOCK_GIANT(vfslocked);
|
2001-08-16 16:14:26 +00:00
|
|
|
|
free(tempdata, M_TEMP);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (error);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
1998-02-09 06:11:36 +00:00
|
|
|
|
static int
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__CONCAT(exec_, __elfN(imgact))(struct image_params *imgp)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
2002-08-24 22:55:16 +00:00
|
|
|
|
const Elf_Ehdr *hdr = (const Elf_Ehdr *)imgp->image_header;
|
2009-03-13 16:40:51 +00:00
|
|
|
|
const Elf_Phdr *phdr;
|
2006-01-21 20:11:49 +00:00
|
|
|
|
Elf_Auxargs *elf_auxargs;
|
1997-04-13 01:48:35 +00:00
|
|
|
|
struct vmspace *vmspace;
|
1998-10-18 15:55:12 +00:00
|
|
|
|
vm_prot_t prot;
|
2002-09-04 04:42:12 +00:00
|
|
|
|
u_long text_size = 0, data_size = 0, total_size = 0;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
u_long text_addr = 0, data_addr = 0;
|
2002-08-30 18:09:46 +00:00
|
|
|
|
u_long seg_size, seg_addr;
|
2009-10-18 12:57:48 +00:00
|
|
|
|
u_long addr, baddr, et_dyn_addr, entry = 0, proghdr = 0;
|
2009-03-13 16:40:51 +00:00
|
|
|
|
int32_t osrel = 0;
|
2009-10-18 12:57:48 +00:00
|
|
|
|
int error = 0, i, n;
|
2008-01-05 08:35:56 +00:00
|
|
|
|
const char *interp = NULL, *newinterp = NULL;
|
1998-10-11 19:22:07 +00:00
|
|
|
|
Elf_Brandinfo *brand_info;
|
2001-08-16 16:14:26 +00:00
|
|
|
|
char *path;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
struct sysentvec *sv;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Do we have a valid ELF header ?
|
2005-12-26 21:23:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Only allow ET_EXEC & ET_DYN here, reject ET_DYN later
|
|
|
|
|
* if particular brand doesn't support it.
|
1996-03-10 08:42:54 +00:00
|
|
|
|
*/
|
2005-12-26 21:23:57 +00:00
|
|
|
|
if (__elfN(check_header)(hdr) != 0 ||
|
|
|
|
|
(hdr->e_type != ET_EXEC && hdr->e_type != ET_DYN))
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (-1);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* From here on down, we return an errno, not -1, as we've
|
|
|
|
|
* detected an ELF file.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if ((hdr->e_phoff > PAGE_SIZE) ||
|
1998-10-18 15:55:12 +00:00
|
|
|
|
(hdr->e_phoff + hdr->e_phentsize * hdr->e_phnum) > PAGE_SIZE) {
|
1998-03-02 05:47:58 +00:00
|
|
|
|
/* Only support headers in first page for now */
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (ENOEXEC);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
2002-08-24 22:55:16 +00:00
|
|
|
|
phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
|
2007-12-04 12:21:27 +00:00
|
|
|
|
if (!aligned(phdr, Elf_Addr))
|
|
|
|
|
return (ENOEXEC);
|
2009-10-18 12:57:48 +00:00
|
|
|
|
n = 0;
|
|
|
|
|
baddr = 0;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
for (i = 0; i < hdr->e_phnum; i++) {
|
2011-01-08 16:30:59 +00:00
|
|
|
|
switch (phdr[i].p_type) {
|
|
|
|
|
case PT_LOAD:
|
2009-10-18 12:57:48 +00:00
|
|
|
|
if (n == 0)
|
|
|
|
|
baddr = phdr[i].p_vaddr;
|
|
|
|
|
n++;
|
2011-01-08 16:30:59 +00:00
|
|
|
|
break;
|
|
|
|
|
case PT_INTERP:
|
2006-01-21 20:11:49 +00:00
|
|
|
|
/* Path to interpreter */
|
2002-09-02 04:50:57 +00:00
|
|
|
|
if (phdr[i].p_filesz > MAXPATHLEN ||
|
2005-12-24 04:57:50 +00:00
|
|
|
|
phdr[i].p_offset + phdr[i].p_filesz > PAGE_SIZE)
|
|
|
|
|
return (ENOEXEC);
|
2002-09-02 04:50:57 +00:00
|
|
|
|
interp = imgp->image_header + phdr[i].p_offset;
|
2011-01-08 16:30:59 +00:00
|
|
|
|
break;
|
|
|
|
|
case PT_GNU_STACK:
|
|
|
|
|
if (__elfN(nxstack))
|
|
|
|
|
imgp->stack_prot =
|
|
|
|
|
__elfN(trans_prot)(phdr[i].p_flags);
|
|
|
|
|
break;
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-13 16:40:51 +00:00
|
|
|
|
brand_info = __elfN(get_brandinfo)(imgp, interp, &osrel);
|
2002-09-02 04:50:57 +00:00
|
|
|
|
if (brand_info == NULL) {
|
|
|
|
|
uprintf("ELF binary type \"%u\" not known.\n",
|
|
|
|
|
hdr->e_ident[EI_OSABI]);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
return (ENOEXEC);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
2009-10-10 15:33:01 +00:00
|
|
|
|
if (hdr->e_type == ET_DYN) {
|
|
|
|
|
if ((brand_info->flags & BI_CAN_EXEC_DYN) == 0)
|
|
|
|
|
return (ENOEXEC);
|
2009-10-18 12:57:48 +00:00
|
|
|
|
/*
|
|
|
|
|
* Honour the base load address from the dso if it is
|
|
|
|
|
* non-zero for some reason.
|
|
|
|
|
*/
|
|
|
|
|
if (baddr == 0)
|
|
|
|
|
et_dyn_addr = ET_DYN_LOAD_ADDR;
|
|
|
|
|
else
|
|
|
|
|
et_dyn_addr = 0;
|
2009-10-10 15:33:01 +00:00
|
|
|
|
} else
|
|
|
|
|
et_dyn_addr = 0;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
sv = brand_info->sysvec;
|
2003-12-23 02:42:39 +00:00
|
|
|
|
if (interp != NULL && brand_info->interp_newpath != NULL)
|
2008-01-05 08:35:56 +00:00
|
|
|
|
newinterp = brand_info->interp_newpath;
|
2002-09-02 04:50:57 +00:00
|
|
|
|
|
2005-12-24 04:57:50 +00:00
|
|
|
|
/*
|
|
|
|
|
* Avoid a possible deadlock if the current address space is destroyed
|
|
|
|
|
* and that address space maps the locked vnode. In the common case,
|
|
|
|
|
* the locked vnode's v_usecount is decremented but remains greater
|
|
|
|
|
* than zero. Consequently, the vnode lock is not needed by vrele().
|
|
|
|
|
* However, in cases where the vnode lock is external, such as nullfs,
|
|
|
|
|
* v_usecount may become zero.
|
|
|
|
|
*/
|
2008-01-13 14:44:15 +00:00
|
|
|
|
VOP_UNLOCK(imgp->vp, 0);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
|
2007-11-05 11:36:16 +00:00
|
|
|
|
error = exec_new_vmspace(imgp, sv);
|
2007-05-14 22:40:04 +00:00
|
|
|
|
imgp->proc->p_sysent = sv;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2008-01-10 01:10:58 +00:00
|
|
|
|
vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
|
2007-11-05 11:36:16 +00:00
|
|
|
|
if (error)
|
|
|
|
|
return (error);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
|
1997-04-13 01:48:35 +00:00
|
|
|
|
vmspace = imgp->proc->p_vmspace;
|
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
for (i = 0; i < hdr->e_phnum; i++) {
|
2002-08-24 22:55:16 +00:00
|
|
|
|
switch (phdr[i].p_type) {
|
1996-03-10 08:42:54 +00:00
|
|
|
|
case PT_LOAD: /* Loadable segment */
|
2009-10-10 15:28:52 +00:00
|
|
|
|
if (phdr[i].p_memsz == 0)
|
|
|
|
|
break;
|
2011-01-08 16:02:14 +00:00
|
|
|
|
prot = __elfN(trans_prot)(phdr[i].p_flags);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
#if defined(__ia64__) && __ELF_WORD_SIZE == 32 && defined(IA32_ME_HARDER)
|
|
|
|
|
/*
|
|
|
|
|
* Some x86 binaries assume read == executable,
|
|
|
|
|
* notably the M3 runtime and therefore cvsup
|
|
|
|
|
*/
|
|
|
|
|
if (prot & VM_PROT_READ)
|
|
|
|
|
prot |= VM_PROT_EXECUTE;
|
|
|
|
|
#endif
|
|
|
|
|
|
2005-12-21 18:58:40 +00:00
|
|
|
|
if ((error = __elfN(load_section)(vmspace,
|
|
|
|
|
imgp->object, phdr[i].p_offset,
|
2009-10-10 15:33:01 +00:00
|
|
|
|
(caddr_t)(uintptr_t)phdr[i].p_vaddr + et_dyn_addr,
|
2002-08-25 22:36:52 +00:00
|
|
|
|
phdr[i].p_memsz, phdr[i].p_filesz, prot,
|
2002-09-02 04:50:57 +00:00
|
|
|
|
sv->sv_pagesize)) != 0)
|
2005-12-24 04:57:50 +00:00
|
|
|
|
return (error);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2004-08-08 09:48:10 +00:00
|
|
|
|
/*
|
|
|
|
|
* If this segment contains the program headers,
|
|
|
|
|
* remember their virtual address for the AT_PHDR
|
|
|
|
|
* aux entry. Static binaries don't usually include
|
|
|
|
|
* a PT_PHDR entry.
|
|
|
|
|
*/
|
|
|
|
|
if (phdr[i].p_offset == 0 &&
|
|
|
|
|
hdr->e_phoff + hdr->e_phnum * hdr->e_phentsize
|
|
|
|
|
<= phdr[i].p_filesz)
|
2009-10-10 15:33:01 +00:00
|
|
|
|
proghdr = phdr[i].p_vaddr + hdr->e_phoff +
|
|
|
|
|
et_dyn_addr;
|
2004-08-08 09:48:10 +00:00
|
|
|
|
|
2009-10-10 15:33:01 +00:00
|
|
|
|
seg_addr = trunc_page(phdr[i].p_vaddr + et_dyn_addr);
|
2002-08-30 18:09:46 +00:00
|
|
|
|
seg_size = round_page(phdr[i].p_memsz +
|
2009-10-10 15:33:01 +00:00
|
|
|
|
phdr[i].p_vaddr + et_dyn_addr - seg_addr);
|
2002-08-30 18:09:46 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2010-03-25 14:21:22 +00:00
|
|
|
|
* Make the largest executable segment the official
|
|
|
|
|
* text segment and all others data.
|
2002-09-04 04:42:12 +00:00
|
|
|
|
*
|
|
|
|
|
* Note that obreak() assumes that data_addr +
|
|
|
|
|
* data_size == end of data load area, and the ELF
|
|
|
|
|
* file format expects segments to be sorted by
|
|
|
|
|
* address. If multiple data segments exist, the
|
|
|
|
|
* last one will be used.
|
2002-08-30 18:09:46 +00:00
|
|
|
|
*/
|
2010-03-25 14:21:22 +00:00
|
|
|
|
|
|
|
|
|
if (phdr[i].p_flags & PF_X && text_size < seg_size) {
|
2002-09-03 21:18:17 +00:00
|
|
|
|
text_size = seg_size;
|
|
|
|
|
text_addr = seg_addr;
|
|
|
|
|
} else {
|
2002-09-04 04:42:12 +00:00
|
|
|
|
data_size = seg_size;
|
|
|
|
|
data_addr = seg_addr;
|
2002-08-30 18:09:46 +00:00
|
|
|
|
}
|
2002-09-04 04:42:12 +00:00
|
|
|
|
total_size += seg_size;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
break;
|
|
|
|
|
case PT_PHDR: /* Program header table info */
|
2009-10-10 15:33:01 +00:00
|
|
|
|
proghdr = phdr[i].p_vaddr + et_dyn_addr;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
break;
|
|
|
|
|
default:
|
1998-10-18 15:55:12 +00:00
|
|
|
|
break;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
2002-10-23 01:57:39 +00:00
|
|
|
|
|
|
|
|
|
if (data_addr == 0 && data_size == 0) {
|
|
|
|
|
data_addr = text_addr;
|
|
|
|
|
data_size = text_size;
|
|
|
|
|
}
|
|
|
|
|
|
2010-03-25 14:21:22 +00:00
|
|
|
|
entry = (u_long)hdr->e_entry + et_dyn_addr;
|
|
|
|
|
|
2002-10-23 01:57:39 +00:00
|
|
|
|
/*
|
|
|
|
|
* Check limits. It should be safe to check the
|
|
|
|
|
* limits after loading the segments since we do
|
|
|
|
|
* not actually fault in all the segments pages.
|
|
|
|
|
*/
|
2004-02-04 21:52:57 +00:00
|
|
|
|
PROC_LOCK(imgp->proc);
|
|
|
|
|
if (data_size > lim_cur(imgp->proc, RLIMIT_DATA) ||
|
2002-10-23 01:57:39 +00:00
|
|
|
|
text_size > maxtsiz ||
|
2011-04-05 20:23:59 +00:00
|
|
|
|
total_size > lim_cur(imgp->proc, RLIMIT_VMEM) ||
|
|
|
|
|
racct_set(imgp->proc, RACCT_DATA, data_size) != 0 ||
|
|
|
|
|
racct_set(imgp->proc, RACCT_VMEM, total_size) != 0) {
|
2004-02-04 21:52:57 +00:00
|
|
|
|
PROC_UNLOCK(imgp->proc);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
return (ENOMEM);
|
2002-10-23 01:57:39 +00:00
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
|
|
|
|
vmspace->vm_tsize = text_size >> PAGE_SHIFT;
|
1998-07-15 05:00:26 +00:00
|
|
|
|
vmspace->vm_taddr = (caddr_t)(uintptr_t)text_addr;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
vmspace->vm_dsize = data_size >> PAGE_SHIFT;
|
1998-07-15 05:00:26 +00:00
|
|
|
|
vmspace->vm_daddr = (caddr_t)(uintptr_t)data_addr;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2003-09-25 01:10:26 +00:00
|
|
|
|
/*
|
|
|
|
|
* We load the dynamic linker where a userland call
|
|
|
|
|
* to mmap(0, ...) would put it. The rationale behind this
|
|
|
|
|
* calculation is that it leaves room for the heap to grow to
|
|
|
|
|
* its maximum allowed size.
|
|
|
|
|
*/
|
|
|
|
|
addr = round_page((vm_offset_t)imgp->proc->p_vmspace->vm_daddr +
|
2004-02-04 21:52:57 +00:00
|
|
|
|
lim_max(imgp->proc, RLIMIT_DATA));
|
|
|
|
|
PROC_UNLOCK(imgp->proc);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1996-10-16 17:51:08 +00:00
|
|
|
|
imgp->entry_addr = entry;
|
|
|
|
|
|
2003-12-23 02:42:39 +00:00
|
|
|
|
if (interp != NULL) {
|
2008-01-05 08:35:56 +00:00
|
|
|
|
int have_interp = FALSE;
|
2008-01-13 14:44:15 +00:00
|
|
|
|
VOP_UNLOCK(imgp->vp, 0);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
if (brand_info->emul_path != NULL &&
|
|
|
|
|
brand_info->emul_path[0] != '\0') {
|
|
|
|
|
path = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
|
|
|
|
|
snprintf(path, MAXPATHLEN, "%s%s",
|
|
|
|
|
brand_info->emul_path, interp);
|
|
|
|
|
error = __elfN(load_file)(imgp->proc, path, &addr,
|
|
|
|
|
&imgp->entry_addr, sv->sv_pagesize);
|
|
|
|
|
free(path, M_TEMP);
|
|
|
|
|
if (error == 0)
|
2008-01-05 08:35:56 +00:00
|
|
|
|
have_interp = TRUE;
|
2005-12-24 04:57:50 +00:00
|
|
|
|
}
|
2008-01-05 08:35:56 +00:00
|
|
|
|
if (!have_interp && newinterp != NULL) {
|
|
|
|
|
error = __elfN(load_file)(imgp->proc, newinterp, &addr,
|
|
|
|
|
&imgp->entry_addr, sv->sv_pagesize);
|
2008-10-08 11:11:36 +00:00
|
|
|
|
if (error == 0)
|
|
|
|
|
have_interp = TRUE;
|
2008-01-05 08:35:56 +00:00
|
|
|
|
}
|
|
|
|
|
if (!have_interp) {
|
2005-12-24 04:57:50 +00:00
|
|
|
|
error = __elfN(load_file)(imgp->proc, interp, &addr,
|
|
|
|
|
&imgp->entry_addr, sv->sv_pagesize);
|
|
|
|
|
}
|
2008-01-10 01:10:58 +00:00
|
|
|
|
vn_lock(imgp->vp, LK_EXCLUSIVE | LK_RETRY);
|
2003-12-23 02:42:39 +00:00
|
|
|
|
if (error != 0) {
|
|
|
|
|
uprintf("ELF interpreter %s not found\n", interp);
|
2005-12-24 04:57:50 +00:00
|
|
|
|
return (error);
|
2003-12-23 02:42:39 +00:00
|
|
|
|
}
|
2009-01-25 12:07:43 +00:00
|
|
|
|
} else
|
2009-10-18 12:57:48 +00:00
|
|
|
|
addr = et_dyn_addr;
|
1996-10-16 17:51:08 +00:00
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
/*
|
|
|
|
|
* Construct auxargs table (used by the fixup routine)
|
|
|
|
|
*/
|
2003-02-19 05:47:46 +00:00
|
|
|
|
elf_auxargs = malloc(sizeof(Elf_Auxargs), M_TEMP, M_WAITOK);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
elf_auxargs->execfd = -1;
|
|
|
|
|
elf_auxargs->phdr = proghdr;
|
|
|
|
|
elf_auxargs->phent = hdr->e_phentsize;
|
|
|
|
|
elf_auxargs->phnum = hdr->e_phnum;
|
|
|
|
|
elf_auxargs->pagesz = PAGE_SIZE;
|
|
|
|
|
elf_auxargs->base = addr;
|
|
|
|
|
elf_auxargs->flags = 0;
|
|
|
|
|
elf_auxargs->entry = entry;
|
|
|
|
|
|
|
|
|
|
imgp->auxargs = elf_auxargs;
|
|
|
|
|
imgp->interpreted = 0;
|
2010-03-25 14:31:26 +00:00
|
|
|
|
imgp->reloc_base = addr;
|
2009-03-13 16:40:51 +00:00
|
|
|
|
imgp->proc->p_osrel = osrel;
|
2007-12-04 12:28:07 +00:00
|
|
|
|
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (error);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
}
|
|
|
|
|
|
2003-01-04 22:07:48 +00:00
|
|
|
|
#define suword __CONCAT(suword, __ELF_WORD_SIZE)
|
2002-07-20 02:56:12 +00:00
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
__elfN(freebsd_fixup)(register_t **stack_base, struct image_params *imgp)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
{
|
1998-06-07 17:13:14 +00:00
|
|
|
|
Elf_Auxargs *args = (Elf_Auxargs *)imgp->auxargs;
|
2003-01-04 22:07:48 +00:00
|
|
|
|
Elf_Addr *base;
|
|
|
|
|
Elf_Addr *pos;
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2003-01-04 22:07:48 +00:00
|
|
|
|
base = (Elf_Addr *)*stack_base;
|
2005-01-29 23:12:00 +00:00
|
|
|
|
pos = base + (imgp->args->argc + imgp->args->envc + 2);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
2008-12-17 16:25:20 +00:00
|
|
|
|
if (args->execfd != -1)
|
1996-03-10 08:42:54 +00:00
|
|
|
|
AUXARGS_ENTRY(pos, AT_EXECFD, args->execfd);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PHDR, args->phdr);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PHENT, args->phent);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PHNUM, args->phnum);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PAGESZ, args->pagesz);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_FLAGS, args->flags);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_ENTRY, args->entry);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_BASE, args->base);
|
2009-03-17 12:53:28 +00:00
|
|
|
|
if (imgp->execpathp != 0)
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_EXECPATH, imgp->execpathp);
|
2010-08-17 08:55:45 +00:00
|
|
|
|
AUXARGS_ENTRY(pos, AT_OSRELDATE, osreldate);
|
|
|
|
|
if (imgp->canary != 0) {
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_CANARY, imgp->canary);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_CANARYLEN, imgp->canarylen);
|
|
|
|
|
}
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_NCPUS, mp_ncpus);
|
|
|
|
|
if (imgp->pagesizes != 0) {
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PAGESIZES, imgp->pagesizes);
|
|
|
|
|
AUXARGS_ENTRY(pos, AT_PAGESIZESLEN, imgp->pagesizeslen);
|
|
|
|
|
}
|
2011-01-08 18:41:19 +00:00
|
|
|
|
AUXARGS_ENTRY(pos, AT_STACKPROT, imgp->sysent->sv_shared_page_obj
|
|
|
|
|
!= NULL && imgp->stack_prot != 0 ? imgp->stack_prot :
|
|
|
|
|
imgp->sysent->sv_stackprot);
|
1996-03-10 08:42:54 +00:00
|
|
|
|
AUXARGS_ENTRY(pos, AT_NULL, 0);
|
|
|
|
|
|
|
|
|
|
free(imgp->auxargs, M_TEMP);
|
|
|
|
|
imgp->auxargs = NULL;
|
|
|
|
|
|
2002-07-20 02:56:12 +00:00
|
|
|
|
base--;
|
2005-01-29 23:12:00 +00:00
|
|
|
|
suword(base, (long)imgp->args->argc);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
*stack_base = (register_t *)base;
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (0);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
}
|
1996-03-10 08:42:54 +00:00
|
|
|
|
|
1998-09-14 22:46:08 +00:00
|
|
|
|
/*
|
|
|
|
|
* Code for generating ELF core dumps.
|
|
|
|
|
*/
|
|
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
|
typedef void (*segment_callback)(vm_map_entry_t, void *);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
|
|
|
|
/* Closure for cb_put_phdr(). */
|
|
|
|
|
struct phdr_closure {
|
|
|
|
|
Elf_Phdr *phdr; /* Program header to fill in */
|
|
|
|
|
Elf_Off offset; /* Offset of segment in core file */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
/* Closure for cb_size_segment(). */
|
|
|
|
|
struct sseg_closure {
|
|
|
|
|
int count; /* Count of writable segments. */
|
|
|
|
|
size_t size; /* Total size of all writable segments. */
|
|
|
|
|
};
|
|
|
|
|
|
2002-03-19 21:25:46 +00:00
|
|
|
|
static void cb_put_phdr(vm_map_entry_t, void *);
|
|
|
|
|
static void cb_size_segment(vm_map_entry_t, void *);
|
2004-06-26 18:58:22 +00:00
|
|
|
|
static void each_writable_segment(struct thread *, segment_callback, void *);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
static int __elfN(corehdr)(struct thread *, struct vnode *, struct ucred *,
|
2010-03-02 06:58:58 +00:00
|
|
|
|
int, void *, size_t, gzFile);
|
2004-06-26 18:58:22 +00:00
|
|
|
|
static void __elfN(puthdr)(struct thread *, void *, size_t *, int);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
static void __elfN(putnote)(void *, size_t *, const char *, int,
|
2002-03-19 21:25:46 +00:00
|
|
|
|
const void *, size_t);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
|
2010-03-02 06:58:58 +00:00
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
extern int compress_user_cores;
|
|
|
|
|
extern int compress_user_cores_gzlevel;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
core_output(struct vnode *vp, void *base, size_t len, off_t offset,
|
|
|
|
|
struct ucred *active_cred, struct ucred *file_cred,
|
|
|
|
|
struct thread *td, char *core_buf, gzFile gzfile) {
|
|
|
|
|
|
|
|
|
|
int error;
|
|
|
|
|
if (gzfile) {
|
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
error = compress_core(gzfile, base, core_buf, len, td);
|
|
|
|
|
#else
|
|
|
|
|
panic("shouldn't be here");
|
|
|
|
|
#endif
|
|
|
|
|
} else {
|
|
|
|
|
error = vn_rdwr_inchunks(UIO_WRITE, vp, base, len, offset,
|
|
|
|
|
UIO_USERSPACE, IO_UNIT | IO_DIRECT, active_cred, file_cred,
|
|
|
|
|
NULL, td);
|
|
|
|
|
}
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
|
1998-09-14 22:46:08 +00:00
|
|
|
|
int
|
2010-03-02 06:58:58 +00:00
|
|
|
|
__elfN(coredump)(struct thread *td, struct vnode *vp, off_t limit, int flags)
|
1999-09-01 00:29:56 +00:00
|
|
|
|
{
|
2004-06-26 18:58:22 +00:00
|
|
|
|
struct ucred *cred = td->td_ucred;
|
1999-09-01 00:29:56 +00:00
|
|
|
|
int error = 0;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
struct sseg_closure seginfo;
|
|
|
|
|
void *hdr;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
size_t hdrsize;
|
|
|
|
|
|
2010-03-02 06:58:58 +00:00
|
|
|
|
gzFile gzfile = Z_NULL;
|
|
|
|
|
char *core_buf = NULL;
|
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
char gzopen_flags[8];
|
|
|
|
|
char *p;
|
|
|
|
|
int doing_compress = flags & IMGACT_CORE_COMPRESS;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
hdr = NULL;
|
|
|
|
|
|
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
if (doing_compress) {
|
|
|
|
|
p = gzopen_flags;
|
|
|
|
|
*p++ = 'w';
|
|
|
|
|
if (compress_user_cores_gzlevel >= 0 &&
|
|
|
|
|
compress_user_cores_gzlevel <= 9)
|
|
|
|
|
*p++ = '0' + compress_user_cores_gzlevel;
|
|
|
|
|
*p = 0;
|
|
|
|
|
gzfile = gz_open("", gzopen_flags, vp);
|
|
|
|
|
if (gzfile == Z_NULL) {
|
|
|
|
|
error = EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
core_buf = malloc(CORE_BUF_SIZE, M_TEMP, M_WAITOK | M_ZERO);
|
|
|
|
|
if (!core_buf) {
|
|
|
|
|
error = ENOMEM;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
1998-09-16 02:04:05 +00:00
|
|
|
|
/* Size the program segments. */
|
|
|
|
|
seginfo.count = 0;
|
|
|
|
|
seginfo.size = 0;
|
2004-06-26 18:58:22 +00:00
|
|
|
|
each_writable_segment(td, cb_size_segment, &seginfo);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Calculate the size of the core file header area by making
|
|
|
|
|
* a dry run of generating it. Nothing is written, but the
|
|
|
|
|
* size is calculated.
|
|
|
|
|
*/
|
|
|
|
|
hdrsize = 0;
|
2004-06-26 18:58:22 +00:00
|
|
|
|
__elfN(puthdr)(td, (void *)NULL, &hdrsize, seginfo.count);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
2011-04-05 20:23:59 +00:00
|
|
|
|
PROC_LOCK(td->td_proc);
|
|
|
|
|
error = racct_add(td->td_proc, RACCT_CORE, hdrsize + seginfo.size);
|
|
|
|
|
PROC_UNLOCK(td->td_proc);
|
|
|
|
|
if (error != 0) {
|
|
|
|
|
error = EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
2010-04-30 03:13:24 +00:00
|
|
|
|
if (hdrsize + seginfo.size >= limit) {
|
|
|
|
|
error = EFAULT;
|
|
|
|
|
goto done;
|
|
|
|
|
}
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate memory for building the header, fill it up,
|
|
|
|
|
* and write it out.
|
|
|
|
|
*/
|
2003-02-19 05:47:46 +00:00
|
|
|
|
hdr = malloc(hdrsize, M_TEMP, M_WAITOK);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
if (hdr == NULL) {
|
2010-04-30 03:13:24 +00:00
|
|
|
|
error = EINVAL;
|
|
|
|
|
goto done;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
}
|
2010-03-02 06:58:58 +00:00
|
|
|
|
error = __elfN(corehdr)(td, vp, cred, seginfo.count, hdr, hdrsize,
|
|
|
|
|
gzfile);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
|
|
|
|
/* Write the contents of all of the writable segments. */
|
|
|
|
|
if (error == 0) {
|
|
|
|
|
Elf_Phdr *php;
|
2004-06-05 02:00:12 +00:00
|
|
|
|
off_t offset;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
php = (Elf_Phdr *)((char *)hdr + sizeof(Elf_Ehdr)) + 1;
|
|
|
|
|
offset = hdrsize;
|
2002-08-24 22:55:16 +00:00
|
|
|
|
for (i = 0; i < seginfo.count; i++) {
|
2010-03-02 06:58:58 +00:00
|
|
|
|
error = core_output(vp, (caddr_t)(uintptr_t)php->p_vaddr,
|
|
|
|
|
php->p_filesz, offset, cred, NOCRED, curthread, core_buf, gzfile);
|
2004-06-05 02:00:12 +00:00
|
|
|
|
if (error != 0)
|
|
|
|
|
break;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
offset += php->p_filesz;
|
|
|
|
|
php++;
|
|
|
|
|
}
|
|
|
|
|
}
|
2010-03-02 06:58:58 +00:00
|
|
|
|
if (error) {
|
|
|
|
|
log(LOG_WARNING,
|
|
|
|
|
"Failed to write core file for process %s (error %d)\n",
|
|
|
|
|
curproc->p_comm, error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
done:
|
2010-04-30 03:13:24 +00:00
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
2010-03-02 06:58:58 +00:00
|
|
|
|
if (core_buf)
|
|
|
|
|
free(core_buf, M_TEMP);
|
|
|
|
|
if (gzfile)
|
|
|
|
|
gzclose(gzfile);
|
2010-03-04 21:53:45 +00:00
|
|
|
|
#endif
|
2010-03-02 06:58:58 +00:00
|
|
|
|
|
1998-09-16 02:04:05 +00:00
|
|
|
|
free(hdr, M_TEMP);
|
2002-07-20 02:56:12 +00:00
|
|
|
|
|
2002-08-24 22:01:40 +00:00
|
|
|
|
return (error);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
}
|
|
|
|
|
|
1998-09-16 02:04:05 +00:00
|
|
|
|
/*
|
|
|
|
|
* A callback for each_writable_segment() to write out the segment's
|
|
|
|
|
* program header entry.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
cb_put_phdr(entry, closure)
|
|
|
|
|
vm_map_entry_t entry;
|
|
|
|
|
void *closure;
|
|
|
|
|
{
|
|
|
|
|
struct phdr_closure *phc = (struct phdr_closure *)closure;
|
|
|
|
|
Elf_Phdr *phdr = phc->phdr;
|
|
|
|
|
|
|
|
|
|
phc->offset = round_page(phc->offset);
|
|
|
|
|
|
|
|
|
|
phdr->p_type = PT_LOAD;
|
|
|
|
|
phdr->p_offset = phc->offset;
|
|
|
|
|
phdr->p_vaddr = entry->start;
|
|
|
|
|
phdr->p_paddr = 0;
|
|
|
|
|
phdr->p_filesz = phdr->p_memsz = entry->end - entry->start;
|
|
|
|
|
phdr->p_align = PAGE_SIZE;
|
2011-01-08 16:02:14 +00:00
|
|
|
|
phdr->p_flags = __elfN(untrans_prot)(entry->protection);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
|
|
|
|
phc->offset += phdr->p_filesz;
|
|
|
|
|
phc->phdr++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* A callback for each_writable_segment() to gather information about
|
|
|
|
|
* the number of segments and their total size.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
cb_size_segment(entry, closure)
|
|
|
|
|
vm_map_entry_t entry;
|
|
|
|
|
void *closure;
|
|
|
|
|
{
|
|
|
|
|
struct sseg_closure *ssc = (struct sseg_closure *)closure;
|
|
|
|
|
|
|
|
|
|
ssc->count++;
|
|
|
|
|
ssc->size += entry->end - entry->start;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* For each writable segment in the process's memory map, call the given
|
|
|
|
|
* function with a pointer to the map entry and some arbitrary
|
|
|
|
|
* caller-supplied data.
|
|
|
|
|
*/
|
|
|
|
|
static void
|
2004-06-26 18:58:22 +00:00
|
|
|
|
each_writable_segment(td, func, closure)
|
|
|
|
|
struct thread *td;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
segment_callback func;
|
|
|
|
|
void *closure;
|
|
|
|
|
{
|
2004-06-26 18:58:22 +00:00
|
|
|
|
struct proc *p = td->td_proc;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
vm_map_t map = &p->p_vmspace->vm_map;
|
|
|
|
|
vm_map_entry_t entry;
|
2006-11-19 23:38:59 +00:00
|
|
|
|
vm_object_t backing_object, object;
|
|
|
|
|
boolean_t ignore_entry;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
2006-11-19 23:38:59 +00:00
|
|
|
|
vm_map_lock_read(map);
|
2002-08-24 22:55:16 +00:00
|
|
|
|
for (entry = map->header.next; entry != &map->header;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
entry = entry->next) {
|
2002-12-16 19:24:43 +00:00
|
|
|
|
/*
|
|
|
|
|
* Don't dump inaccessible mappings, deal with legacy
|
|
|
|
|
* coredump mode.
|
|
|
|
|
*
|
|
|
|
|
* Note that read-only segments related to the elf binary
|
|
|
|
|
* are marked MAP_ENTRY_NOCOREDUMP now so we no longer
|
|
|
|
|
* need to arbitrarily ignore such segments.
|
|
|
|
|
*/
|
|
|
|
|
if (elf_legacy_coredump) {
|
|
|
|
|
if ((entry->protection & VM_PROT_RW) != VM_PROT_RW)
|
|
|
|
|
continue;
|
|
|
|
|
} else {
|
|
|
|
|
if ((entry->protection & VM_PROT_ALL) == 0)
|
|
|
|
|
continue;
|
|
|
|
|
}
|
1998-09-16 02:04:05 +00:00
|
|
|
|
|
2000-02-28 04:10:35 +00:00
|
|
|
|
/*
|
2002-12-16 19:24:43 +00:00
|
|
|
|
* Dont include memory segment in the coredump if
|
|
|
|
|
* MAP_NOCORE is set in mmap(2) or MADV_NOCORE in
|
|
|
|
|
* madvise(2). Do not dump submaps (i.e. parts of the
|
|
|
|
|
* kernel map).
|
|
|
|
|
*/
|
|
|
|
|
if (entry->eflags & (MAP_ENTRY_NOCOREDUMP|MAP_ENTRY_IS_SUB_MAP))
|
2000-02-28 04:10:35 +00:00
|
|
|
|
continue;
|
|
|
|
|
|
2006-11-19 23:38:59 +00:00
|
|
|
|
if ((object = entry->object.vm_object) == NULL)
|
1998-09-16 02:04:05 +00:00
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* Ignore memory-mapped devices and such things. */
|
2006-11-19 23:38:59 +00:00
|
|
|
|
VM_OBJECT_LOCK(object);
|
|
|
|
|
while ((backing_object = object->backing_object) != NULL) {
|
|
|
|
|
VM_OBJECT_LOCK(backing_object);
|
|
|
|
|
VM_OBJECT_UNLOCK(object);
|
|
|
|
|
object = backing_object;
|
|
|
|
|
}
|
|
|
|
|
ignore_entry = object->type != OBJT_DEFAULT &&
|
|
|
|
|
object->type != OBJT_SWAP && object->type != OBJT_VNODE;
|
|
|
|
|
VM_OBJECT_UNLOCK(object);
|
|
|
|
|
if (ignore_entry)
|
1998-09-16 02:04:05 +00:00
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
(*func)(entry, closure);
|
|
|
|
|
}
|
2006-11-19 23:38:59 +00:00
|
|
|
|
vm_map_unlock_read(map);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Write the core file header to the file, including padding up to
|
|
|
|
|
* the page boundary.
|
|
|
|
|
*/
|
1998-09-14 22:46:08 +00:00
|
|
|
|
static int
|
2010-03-02 06:58:58 +00:00
|
|
|
|
__elfN(corehdr)(td, vp, cred, numsegs, hdr, hdrsize, gzfile)
|
2001-09-12 08:38:13 +00:00
|
|
|
|
struct thread *td;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
struct vnode *vp;
|
|
|
|
|
struct ucred *cred;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
int numsegs;
|
|
|
|
|
size_t hdrsize;
|
|
|
|
|
void *hdr;
|
2010-03-02 06:58:58 +00:00
|
|
|
|
gzFile gzfile;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
{
|
|
|
|
|
size_t off;
|
|
|
|
|
|
|
|
|
|
/* Fill in the header. */
|
1998-09-16 02:04:05 +00:00
|
|
|
|
bzero(hdr, hdrsize);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
off = 0;
|
2004-06-26 18:58:22 +00:00
|
|
|
|
__elfN(puthdr)(td, hdr, &off, numsegs);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
|
2010-03-02 06:58:58 +00:00
|
|
|
|
if (!gzfile) {
|
|
|
|
|
/* Write it to the core file. */
|
|
|
|
|
return (vn_rdwr_inchunks(UIO_WRITE, vp, hdr, hdrsize, (off_t)0,
|
|
|
|
|
UIO_SYSSPACE, IO_UNIT | IO_DIRECT, cred, NOCRED, NULL,
|
|
|
|
|
td));
|
|
|
|
|
} else {
|
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
if (gzwrite(gzfile, hdr, hdrsize) != hdrsize) {
|
|
|
|
|
log(LOG_WARNING,
|
|
|
|
|
"Failed to compress core file header for process"
|
|
|
|
|
" %s.\n", curproc->p_comm);
|
|
|
|
|
return (EFAULT);
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
return (0);
|
|
|
|
|
}
|
|
|
|
|
#else
|
|
|
|
|
panic("shouldn't be here");
|
|
|
|
|
#endif
|
|
|
|
|
}
|
1998-09-15 22:23:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2010-03-11 14:49:06 +00:00
|
|
|
|
#if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
|
|
|
|
|
#include <compat/freebsd32/freebsd32.h>
|
|
|
|
|
|
2005-06-30 07:49:22 +00:00
|
|
|
|
typedef struct prstatus32 elf_prstatus_t;
|
|
|
|
|
typedef struct prpsinfo32 elf_prpsinfo_t;
|
|
|
|
|
typedef struct fpreg32 elf_prfpregset_t;
|
|
|
|
|
typedef struct fpreg32 elf_fpregset_t;
|
|
|
|
|
typedef struct reg32 elf_gregset_t;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
typedef struct thrmisc32 elf_thrmisc_t;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#else
|
|
|
|
|
typedef prstatus_t elf_prstatus_t;
|
|
|
|
|
typedef prpsinfo_t elf_prpsinfo_t;
|
|
|
|
|
typedef prfpregset_t elf_prfpregset_t;
|
|
|
|
|
typedef prfpregset_t elf_fpregset_t;
|
|
|
|
|
typedef gregset_t elf_gregset_t;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
typedef thrmisc_t elf_thrmisc_t;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
1998-09-14 22:46:08 +00:00
|
|
|
|
static void
|
2004-06-26 18:58:22 +00:00
|
|
|
|
__elfN(puthdr)(struct thread *td, void *dst, size_t *off, int numsegs)
|
1998-09-14 22:46:08 +00:00
|
|
|
|
{
|
2004-04-03 20:25:41 +00:00
|
|
|
|
struct {
|
2005-06-30 07:49:22 +00:00
|
|
|
|
elf_prstatus_t status;
|
|
|
|
|
elf_prfpregset_t fpregset;
|
|
|
|
|
elf_prpsinfo_t psinfo;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
elf_thrmisc_t thrmisc;
|
2004-04-03 20:25:41 +00:00
|
|
|
|
} *tempdata;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
elf_prstatus_t *status;
|
|
|
|
|
elf_prfpregset_t *fpregset;
|
|
|
|
|
elf_prpsinfo_t *psinfo;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
elf_thrmisc_t *thrmisc;
|
2004-06-26 18:58:22 +00:00
|
|
|
|
struct proc *p;
|
|
|
|
|
struct thread *thr;
|
2004-04-03 20:25:41 +00:00
|
|
|
|
size_t ehoff, noteoff, notesz, phoff;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
|
2004-06-26 18:58:22 +00:00
|
|
|
|
p = td->td_proc;
|
|
|
|
|
|
1998-09-14 22:46:08 +00:00
|
|
|
|
ehoff = *off;
|
|
|
|
|
*off += sizeof(Elf_Ehdr);
|
|
|
|
|
|
|
|
|
|
phoff = *off;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
*off += (numsegs + 1) * sizeof(Elf_Phdr);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
|
|
|
|
|
noteoff = *off;
|
2004-04-03 20:25:41 +00:00
|
|
|
|
/*
|
|
|
|
|
* Don't allocate space for the notes if we're just calculating
|
|
|
|
|
* the size of the header. We also don't collect the data.
|
|
|
|
|
*/
|
|
|
|
|
if (dst != NULL) {
|
|
|
|
|
tempdata = malloc(sizeof(*tempdata), M_TEMP, M_ZERO|M_WAITOK);
|
|
|
|
|
status = &tempdata->status;
|
|
|
|
|
fpregset = &tempdata->fpregset;
|
|
|
|
|
psinfo = &tempdata->psinfo;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
thrmisc = &tempdata->thrmisc;
|
2004-04-03 20:25:41 +00:00
|
|
|
|
} else {
|
|
|
|
|
tempdata = NULL;
|
|
|
|
|
status = NULL;
|
|
|
|
|
fpregset = NULL;
|
|
|
|
|
psinfo = NULL;
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
thrmisc = NULL;
|
2004-04-03 20:25:41 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dst != NULL) {
|
|
|
|
|
psinfo->pr_version = PRPSINFO_VERSION;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
psinfo->pr_psinfosz = sizeof(elf_prpsinfo_t);
|
2008-05-15 03:07:34 +00:00
|
|
|
|
strlcpy(psinfo->pr_fname, p->p_comm, sizeof(psinfo->pr_fname));
|
2004-04-03 20:25:41 +00:00
|
|
|
|
/*
|
|
|
|
|
* XXX - We don't fill in the command line arguments properly
|
|
|
|
|
* yet.
|
|
|
|
|
*/
|
2008-05-15 03:07:34 +00:00
|
|
|
|
strlcpy(psinfo->pr_psargs, p->p_comm,
|
2004-04-03 20:25:41 +00:00
|
|
|
|
sizeof(psinfo->pr_psargs));
|
|
|
|
|
}
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(putnote)(dst, off, "FreeBSD", NT_PRPSINFO, psinfo,
|
1998-09-14 22:46:08 +00:00
|
|
|
|
sizeof *psinfo);
|
2004-04-03 20:25:41 +00:00
|
|
|
|
|
|
|
|
|
/*
|
2004-07-18 20:28:07 +00:00
|
|
|
|
* To have the debugger select the right thread (LWP) as the initial
|
|
|
|
|
* thread, we dump the state of the thread passed to us in td first.
|
|
|
|
|
* This is the thread that causes the core dump and thus likely to
|
|
|
|
|
* be the right thread one wants to have selected in the debugger.
|
2004-04-03 20:25:41 +00:00
|
|
|
|
*/
|
2004-06-26 18:58:22 +00:00
|
|
|
|
thr = td;
|
|
|
|
|
while (thr != NULL) {
|
2004-04-03 20:25:41 +00:00
|
|
|
|
if (dst != NULL) {
|
|
|
|
|
status->pr_version = PRSTATUS_VERSION;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
status->pr_statussz = sizeof(elf_prstatus_t);
|
|
|
|
|
status->pr_gregsetsz = sizeof(elf_gregset_t);
|
|
|
|
|
status->pr_fpregsetsz = sizeof(elf_fpregset_t);
|
2004-04-03 20:25:41 +00:00
|
|
|
|
status->pr_osreldate = osreldate;
|
|
|
|
|
status->pr_cursig = p->p_sig;
|
2004-07-18 20:28:07 +00:00
|
|
|
|
status->pr_pid = thr->td_tid;
|
2010-03-11 14:49:06 +00:00
|
|
|
|
#if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
|
2005-06-30 07:49:22 +00:00
|
|
|
|
fill_regs32(thr, &status->pr_reg);
|
|
|
|
|
fill_fpregs32(thr, fpregset);
|
|
|
|
|
#else
|
2004-04-03 20:25:41 +00:00
|
|
|
|
fill_regs(thr, &status->pr_reg);
|
|
|
|
|
fill_fpregs(thr, fpregset);
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#endif
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
memset(&thrmisc->_pad, 0, sizeof (thrmisc->_pad));
|
|
|
|
|
strcpy(thrmisc->pr_tname, thr->td_name);
|
2004-04-03 20:25:41 +00:00
|
|
|
|
}
|
|
|
|
|
__elfN(putnote)(dst, off, "FreeBSD", NT_PRSTATUS, status,
|
|
|
|
|
sizeof *status);
|
|
|
|
|
__elfN(putnote)(dst, off, "FreeBSD", NT_FPREGSET, fpregset,
|
|
|
|
|
sizeof *fpregset);
|
Add the ability for GDB to printout the thread name along with other
thread specific informations.
In order to do that, and in order to avoid KBI breakage with existing
infrastructure the following semantic is implemented:
- For live programs, a new member to the PT_LWPINFO is added (pl_tdname)
- For cores, a new ELF note is added (NT_THRMISC) that can be used for
storing thread specific, miscellaneous, informations. Right now it is
just popluated with a thread name.
GDB, then, retrieves the correct informations from the corefile via the
BFD interface, as it groks the ELF notes and create appropriate
pseudo-sections.
Sponsored by: Sandvine Incorporated
Tested by: gianni
Discussed with: dim, kan, kib
MFC after: 2 weeks
2010-11-22 14:42:13 +00:00
|
|
|
|
__elfN(putnote)(dst, off, "FreeBSD", NT_THRMISC, thrmisc,
|
|
|
|
|
sizeof *thrmisc);
|
2004-08-11 02:35:06 +00:00
|
|
|
|
/*
|
|
|
|
|
* Allow for MD specific notes, as well as any MD
|
|
|
|
|
* specific preparations for writing MI notes.
|
|
|
|
|
*/
|
|
|
|
|
__elfN(dump_thread)(thr, dst, off);
|
2004-06-26 18:58:22 +00:00
|
|
|
|
|
|
|
|
|
thr = (thr == td) ? TAILQ_FIRST(&p->p_threads) :
|
2004-04-03 20:25:41 +00:00
|
|
|
|
TAILQ_NEXT(thr, td_plist);
|
2004-06-26 18:58:22 +00:00
|
|
|
|
if (thr == td)
|
2004-04-03 20:25:41 +00:00
|
|
|
|
thr = TAILQ_NEXT(thr, td_plist);
|
2004-06-26 18:58:22 +00:00
|
|
|
|
}
|
2004-04-03 20:25:41 +00:00
|
|
|
|
|
1998-09-14 22:46:08 +00:00
|
|
|
|
notesz = *off - noteoff;
|
|
|
|
|
|
2004-04-03 20:25:41 +00:00
|
|
|
|
if (dst != NULL)
|
|
|
|
|
free(tempdata, M_TEMP);
|
|
|
|
|
|
1998-09-16 02:04:05 +00:00
|
|
|
|
/* Align up to a page boundary for the program segments. */
|
1998-09-14 22:46:08 +00:00
|
|
|
|
*off = round_page(*off);
|
|
|
|
|
|
|
|
|
|
if (dst != NULL) {
|
|
|
|
|
Elf_Ehdr *ehdr;
|
|
|
|
|
Elf_Phdr *phdr;
|
1998-09-16 02:04:05 +00:00
|
|
|
|
struct phdr_closure phc;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Fill in the ELF header.
|
|
|
|
|
*/
|
|
|
|
|
ehdr = (Elf_Ehdr *)((char *)dst + ehoff);
|
|
|
|
|
ehdr->e_ident[EI_MAG0] = ELFMAG0;
|
|
|
|
|
ehdr->e_ident[EI_MAG1] = ELFMAG1;
|
|
|
|
|
ehdr->e_ident[EI_MAG2] = ELFMAG2;
|
|
|
|
|
ehdr->e_ident[EI_MAG3] = ELFMAG3;
|
|
|
|
|
ehdr->e_ident[EI_CLASS] = ELF_CLASS;
|
|
|
|
|
ehdr->e_ident[EI_DATA] = ELF_DATA;
|
|
|
|
|
ehdr->e_ident[EI_VERSION] = EV_CURRENT;
|
2000-04-18 02:39:26 +00:00
|
|
|
|
ehdr->e_ident[EI_OSABI] = ELFOSABI_FREEBSD;
|
|
|
|
|
ehdr->e_ident[EI_ABIVERSION] = 0;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
ehdr->e_ident[EI_PAD] = 0;
|
|
|
|
|
ehdr->e_type = ET_CORE;
|
2010-03-11 14:49:06 +00:00
|
|
|
|
#if defined(COMPAT_FREEBSD32) && __ELF_WORD_SIZE == 32
|
|
|
|
|
ehdr->e_machine = ELF_ARCH32;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#else
|
1998-09-14 22:46:08 +00:00
|
|
|
|
ehdr->e_machine = ELF_ARCH;
|
2005-06-30 07:49:22 +00:00
|
|
|
|
#endif
|
1998-09-14 22:46:08 +00:00
|
|
|
|
ehdr->e_version = EV_CURRENT;
|
|
|
|
|
ehdr->e_entry = 0;
|
|
|
|
|
ehdr->e_phoff = phoff;
|
|
|
|
|
ehdr->e_flags = 0;
|
|
|
|
|
ehdr->e_ehsize = sizeof(Elf_Ehdr);
|
|
|
|
|
ehdr->e_phentsize = sizeof(Elf_Phdr);
|
1998-09-16 02:04:05 +00:00
|
|
|
|
ehdr->e_phnum = numsegs + 1;
|
1998-09-14 22:46:08 +00:00
|
|
|
|
ehdr->e_shentsize = sizeof(Elf_Shdr);
|
|
|
|
|
ehdr->e_shnum = 0;
|
|
|
|
|
ehdr->e_shstrndx = SHN_UNDEF;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Fill in the program header entries.
|
|
|
|
|
*/
|
|
|
|
|
phdr = (Elf_Phdr *)((char *)dst + phoff);
|
|
|
|
|
|
|
|
|
|
/* The note segement. */
|
|
|
|
|
phdr->p_type = PT_NOTE;
|
|
|
|
|
phdr->p_offset = noteoff;
|
|
|
|
|
phdr->p_vaddr = 0;
|
|
|
|
|
phdr->p_paddr = 0;
|
|
|
|
|
phdr->p_filesz = notesz;
|
|
|
|
|
phdr->p_memsz = 0;
|
|
|
|
|
phdr->p_flags = 0;
|
|
|
|
|
phdr->p_align = 0;
|
|
|
|
|
phdr++;
|
|
|
|
|
|
1998-09-16 02:04:05 +00:00
|
|
|
|
/* All the writable segments from the program. */
|
|
|
|
|
phc.phdr = phdr;
|
|
|
|
|
phc.offset = *off;
|
2004-06-26 18:58:22 +00:00
|
|
|
|
each_writable_segment(td, cb_put_phdr, &phc);
|
1998-09-14 22:46:08 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2002-07-20 02:56:12 +00:00
|
|
|
|
__elfN(putnote)(void *dst, size_t *off, const char *name, int type,
|
1998-09-14 22:46:08 +00:00
|
|
|
|
const void *desc, size_t descsz)
|
|
|
|
|
{
|
|
|
|
|
Elf_Note note;
|
|
|
|
|
|
|
|
|
|
note.n_namesz = strlen(name) + 1;
|
|
|
|
|
note.n_descsz = descsz;
|
|
|
|
|
note.n_type = type;
|
|
|
|
|
if (dst != NULL)
|
|
|
|
|
bcopy(¬e, (char *)dst + *off, sizeof note);
|
|
|
|
|
*off += sizeof note;
|
|
|
|
|
if (dst != NULL)
|
|
|
|
|
bcopy(name, (char *)dst + *off, note.n_namesz);
|
|
|
|
|
*off += roundup2(note.n_namesz, sizeof(Elf_Size));
|
|
|
|
|
if (dst != NULL)
|
|
|
|
|
bcopy(desc, (char *)dst + *off, note.n_descsz);
|
|
|
|
|
*off += roundup2(note.n_descsz, sizeof(Elf_Size));
|
|
|
|
|
}
|
|
|
|
|
|
2009-03-13 16:40:51 +00:00
|
|
|
|
/*
|
|
|
|
|
* Try to find the appropriate ABI-note section for checknote,
|
|
|
|
|
* fetch the osreldate for binary from the ELF OSABI-note. Only the
|
|
|
|
|
* first page of the image is searched, the same as for headers.
|
|
|
|
|
*/
|
|
|
|
|
static boolean_t
|
|
|
|
|
__elfN(check_note)(struct image_params *imgp, Elf_Brandnote *checknote,
|
|
|
|
|
int32_t *osrel)
|
|
|
|
|
{
|
2009-03-22 13:42:41 +00:00
|
|
|
|
const Elf_Note *note, *note0, *note_end;
|
2009-03-17 09:50:40 +00:00
|
|
|
|
const Elf_Phdr *phdr, *pnote;
|
|
|
|
|
const Elf_Ehdr *hdr;
|
2009-03-13 16:40:51 +00:00
|
|
|
|
const char *note_name;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
pnote = NULL;
|
2009-03-17 09:50:40 +00:00
|
|
|
|
hdr = (const Elf_Ehdr *)imgp->image_header;
|
|
|
|
|
phdr = (const Elf_Phdr *)(imgp->image_header + hdr->e_phoff);
|
2009-03-13 16:40:51 +00:00
|
|
|
|
|
|
|
|
|
for (i = 0; i < hdr->e_phnum; i++) {
|
|
|
|
|
if (phdr[i].p_type == PT_NOTE) {
|
|
|
|
|
pnote = &phdr[i];
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (pnote == NULL || pnote->p_offset >= PAGE_SIZE ||
|
|
|
|
|
pnote->p_offset + pnote->p_filesz >= PAGE_SIZE)
|
|
|
|
|
return (FALSE);
|
|
|
|
|
|
2009-03-22 13:42:41 +00:00
|
|
|
|
note = note0 = (const Elf_Note *)(imgp->image_header + pnote->p_offset);
|
2009-03-13 16:40:51 +00:00
|
|
|
|
note_end = (const Elf_Note *)(imgp->image_header +
|
|
|
|
|
pnote->p_offset + pnote->p_filesz);
|
2009-03-22 13:42:41 +00:00
|
|
|
|
for (i = 0; i < 100 && note >= note0 && note < note_end; i++) {
|
|
|
|
|
if (!aligned(note, Elf32_Addr))
|
|
|
|
|
return (FALSE);
|
2009-03-13 16:40:51 +00:00
|
|
|
|
if (note->n_namesz != checknote->hdr.n_namesz ||
|
|
|
|
|
note->n_descsz != checknote->hdr.n_descsz ||
|
|
|
|
|
note->n_type != checknote->hdr.n_type)
|
|
|
|
|
goto nextnote;
|
|
|
|
|
note_name = (const char *)(note + 1);
|
|
|
|
|
if (strncmp(checknote->vendor, note_name,
|
|
|
|
|
checknote->hdr.n_namesz) != 0)
|
|
|
|
|
goto nextnote;
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Fetch the osreldate for binary
|
|
|
|
|
* from the ELF OSABI-note if necessary.
|
|
|
|
|
*/
|
Fix handling of .note.ABI-tag section for GNU systems [1].
Handle GNU/Linux according to LSB Core Specification 4.0,
Chapter 11. Object Format, 11.8. ABI note tag.
Also check the first word of desc, not only name, according to
glibc abi-tags specification to distinguish between Linux and
kFreeBSD.
Add explicit handling for Debian GNU/kFreeBSD, which runs
on our kernels as well [2].
In {amd64,i386}/trap.c, when checking osrel of the current process,
also check the ABI to not change the signal behaviour for Linux
binary processes, now that we save an osrel version for all three
from the lists above in struct proc [2].
These changes make it possible to run FreeBSD, Debian GNU/kFreeBSD
and Linux binaries on the same machine again for at least i386 and
amd64, and no longer break kFreeBSD which was detected as GNU(/Linux).
PR: kern/135468
Submitted by: dchagin [1] (initial patch)
Suggested by: kib [2]
Tested by: Petr Salinger (Petr.Salinger seznam.cz) for kFreeBSD
Reviewed by: kib
MFC after: 3 days
2009-08-24 16:19:47 +00:00
|
|
|
|
if ((checknote->flags & BN_TRANSLATE_OSREL) != 0 &&
|
|
|
|
|
checknote->trans_osrel != NULL)
|
|
|
|
|
return (checknote->trans_osrel(note, osrel));
|
2009-03-13 16:40:51 +00:00
|
|
|
|
return (TRUE);
|
|
|
|
|
|
|
|
|
|
nextnote:
|
|
|
|
|
note = (const Elf_Note *)((const char *)(note + 1) +
|
|
|
|
|
roundup2(note->n_namesz, sizeof(Elf32_Addr)) +
|
|
|
|
|
roundup2(note->n_descsz, sizeof(Elf32_Addr)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return (FALSE);
|
|
|
|
|
}
|
|
|
|
|
|
1996-03-10 08:42:54 +00:00
|
|
|
|
/*
|
|
|
|
|
* Tell kern_execve.c about it, with a little help from the linker.
|
|
|
|
|
*/
|
2003-01-04 22:07:48 +00:00
|
|
|
|
static struct execsw __elfN(execsw) = {
|
|
|
|
|
__CONCAT(exec_, __elfN(imgact)),
|
|
|
|
|
__XSTRING(__CONCAT(ELF, __ELF_WORD_SIZE))
|
|
|
|
|
};
|
|
|
|
|
EXEC_SET(__CONCAT(elf, __ELF_WORD_SIZE), __elfN(execsw));
|
2010-03-02 06:58:58 +00:00
|
|
|
|
|
|
|
|
|
#ifdef COMPRESS_USER_CORES
|
|
|
|
|
/*
|
|
|
|
|
* Compress and write out a core segment for a user process.
|
|
|
|
|
*
|
|
|
|
|
* 'inbuf' is the starting address of a VM segment in the process' address
|
|
|
|
|
* space that is to be compressed and written out to the core file. 'dest_buf'
|
|
|
|
|
* is a buffer in the kernel's address space. The segment is copied from
|
|
|
|
|
* 'inbuf' to 'dest_buf' first before being processed by the compression
|
|
|
|
|
* routine gzwrite(). This copying is necessary because the content of the VM
|
|
|
|
|
* segment may change between the compression pass and the crc-computation pass
|
|
|
|
|
* in gzwrite(). This is because realtime threads may preempt the UNIX kernel.
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
compress_core (gzFile file, char *inbuf, char *dest_buf, unsigned int len,
|
|
|
|
|
struct thread *td)
|
|
|
|
|
{
|
|
|
|
|
int len_compressed;
|
|
|
|
|
int error = 0;
|
|
|
|
|
unsigned int chunk_len;
|
|
|
|
|
|
|
|
|
|
while (len) {
|
|
|
|
|
chunk_len = (len > CORE_BUF_SIZE) ? CORE_BUF_SIZE : len;
|
|
|
|
|
copyin(inbuf, dest_buf, chunk_len);
|
|
|
|
|
len_compressed = gzwrite(file, dest_buf, chunk_len);
|
|
|
|
|
|
|
|
|
|
EVENTHANDLER_INVOKE(app_coredump_progress, td, len_compressed);
|
|
|
|
|
|
|
|
|
|
if ((unsigned int)len_compressed != chunk_len) {
|
|
|
|
|
log(LOG_WARNING,
|
|
|
|
|
"compress_core: length mismatch (0x%x returned, "
|
|
|
|
|
"0x%x expected)\n", len_compressed, chunk_len);
|
|
|
|
|
EVENTHANDLER_INVOKE(app_coredump_error, td,
|
|
|
|
|
"compress_core: length mismatch %x -> %x",
|
|
|
|
|
chunk_len, len_compressed);
|
|
|
|
|
error = EFAULT;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
inbuf += chunk_len;
|
|
|
|
|
len -= chunk_len;
|
2011-02-02 16:35:10 +00:00
|
|
|
|
maybe_yield();
|
2010-03-02 06:58:58 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return (error);
|
|
|
|
|
}
|
|
|
|
|
#endif /* COMPRESS_USER_CORES */
|
2011-01-08 16:02:14 +00:00
|
|
|
|
|
|
|
|
|
static vm_prot_t
|
|
|
|
|
__elfN(trans_prot)(Elf_Word flags)
|
|
|
|
|
{
|
|
|
|
|
vm_prot_t prot;
|
|
|
|
|
|
|
|
|
|
prot = 0;
|
|
|
|
|
if (flags & PF_X)
|
|
|
|
|
prot |= VM_PROT_EXECUTE;
|
|
|
|
|
if (flags & PF_W)
|
|
|
|
|
prot |= VM_PROT_WRITE;
|
|
|
|
|
if (flags & PF_R)
|
|
|
|
|
prot |= VM_PROT_READ;
|
|
|
|
|
return (prot);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static Elf_Word
|
|
|
|
|
__elfN(untrans_prot)(vm_prot_t prot)
|
|
|
|
|
{
|
|
|
|
|
Elf_Word flags;
|
|
|
|
|
|
|
|
|
|
flags = 0;
|
|
|
|
|
if (prot & VM_PROT_EXECUTE)
|
|
|
|
|
flags |= PF_X;
|
|
|
|
|
if (prot & VM_PROT_READ)
|
|
|
|
|
flags |= PF_R;
|
|
|
|
|
if (prot & VM_PROT_WRITE)
|
|
|
|
|
flags |= PF_W;
|
|
|
|
|
return (flags);
|
|
|
|
|
}
|