517 lines
14 KiB
C
517 lines
14 KiB
C
/* $NetBSD: rumpuser_dl.c,v 1.34 2022/04/19 20:32:17 rillig Exp $ */
|
|
|
|
/*
|
|
* Copyright (c) 2009 Antti Kantee. 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.
|
|
* 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.
|
|
*
|
|
* 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 OR CONTRIBUTORS 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.
|
|
*/
|
|
|
|
/*
|
|
* Load all module link sets and feed symbol table to the kernel.
|
|
* Called during rump bootstrap.
|
|
*/
|
|
|
|
/*
|
|
* Solaris libelf.h doesn't support _FILE_OFFSET_BITS=64. Luckily,
|
|
* for this module it doesn't matter.
|
|
*/
|
|
#if defined(__sun__)
|
|
#define RUMPUSER_NO_FILE_OFFSET_BITS
|
|
#endif
|
|
#include "rumpuser_port.h"
|
|
|
|
#if !defined(lint)
|
|
__RCSID("$NetBSD: rumpuser_dl.c,v 1.34 2022/04/19 20:32:17 rillig Exp $");
|
|
#endif /* !lint */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/time.h>
|
|
#include <sys/evcnt.h>
|
|
|
|
#include <assert.h>
|
|
|
|
#include <dlfcn.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdint.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
|
|
#include <rump/rumpuser.h>
|
|
|
|
#if defined(__ELF__) && defined(HAVE_DLINFO)
|
|
#include <elf.h>
|
|
#include <link.h>
|
|
|
|
static size_t symtabsize = 0, strtabsize = 0;
|
|
static size_t symtaboff = 0, strtaboff = 0;
|
|
static uint8_t *symtab = NULL;
|
|
static char *strtab = NULL;
|
|
static unsigned char eident;
|
|
|
|
/* nb5 compat */
|
|
#ifndef Elf_Symindx
|
|
#define Elf_Symindx uint32_t
|
|
#endif
|
|
|
|
static void *
|
|
reservespace(void *store, size_t *storesize,
|
|
size_t storeoff, size_t required)
|
|
{
|
|
size_t chunk, newsize;
|
|
|
|
assert(storeoff <= *storesize);
|
|
chunk = *storesize - storeoff;
|
|
|
|
if (chunk >= required)
|
|
return store;
|
|
|
|
newsize = *storesize + ((size_t)required - chunk);
|
|
store = realloc(store, newsize);
|
|
if (store == NULL) {
|
|
return NULL;
|
|
}
|
|
*((uint8_t *)store + storeoff) = '\0';
|
|
*storesize = newsize;
|
|
|
|
return store;
|
|
}
|
|
|
|
/*
|
|
* Macros to make handling elf32/64 in the code a little saner.
|
|
*/
|
|
|
|
#define DYNn_GETMEMBER(base, n, thevar, result) \
|
|
do { \
|
|
if (eident == ELFCLASS32) { \
|
|
const Elf32_Dyn *dyn = base; \
|
|
/*LINTED*/ \
|
|
result = dyn[n].thevar; \
|
|
} else { \
|
|
const Elf64_Dyn *dyn = base; \
|
|
/*LINTED*/ \
|
|
result = dyn[n].thevar; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SYMn_GETMEMBER(base, n, thevar, result) \
|
|
do { \
|
|
if (eident == ELFCLASS32) { \
|
|
const Elf32_Sym *sym = base; \
|
|
/*LINTED*/ \
|
|
result = sym[n].thevar; \
|
|
} else { \
|
|
const Elf64_Sym *sym = base; \
|
|
/*LINTED*/ \
|
|
result = sym[n].thevar; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SYMn_SETMEMBER(base, n, thevar, value) \
|
|
do { \
|
|
if (eident == ELFCLASS32) { \
|
|
Elf32_Sym *sym = base; \
|
|
/*LINTED*/ \
|
|
sym[n].thevar = value; \
|
|
} else { \
|
|
Elf64_Sym *sym = base; \
|
|
/*LINTED*/ \
|
|
sym[n].thevar = value; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SYM_GETSIZE() ((eident==ELFCLASS32)?sizeof(Elf32_Sym):sizeof(Elf64_Sym))
|
|
|
|
/*
|
|
* On NetBSD, the dynamic section pointer values seem to be relative to
|
|
* the address the dso is mapped at. On glibc, they seem to contain
|
|
* the absolute address. I couldn't find anything definite from a quick
|
|
* read of the standard and therefore I will not go and figure beyond ifdef.
|
|
* On Solaris and DragonFly / FreeBSD, the main object works differently
|
|
* ... uuuuh.
|
|
*/
|
|
#if defined(__GLIBC__) && !defined(__mips__)
|
|
#define adjptr(_map_, _ptr_) ((void *)(_ptr_))
|
|
#elif defined(__sun__) || defined(__DragonFly__) || defined(__FreeBSD__)
|
|
#define adjptr(_map_, _ptr_) \
|
|
(ismainobj ? (void *)(_ptr_) : (void *)(_map_->l_addr + (_ptr_)))
|
|
#else
|
|
/* NetBSD and some others, e.g. Linux + musl */
|
|
#define adjptr(_map_, _ptr_) ((void *)(_map_->l_addr + (_ptr_)))
|
|
#endif
|
|
|
|
static int
|
|
getsymbols(struct link_map *map, int ismainobj)
|
|
{
|
|
char *str_base;
|
|
void *syms_base = NULL; /* XXXgcc */
|
|
size_t curstrsize;
|
|
const void *ed_base;
|
|
uint64_t ed_tag;
|
|
size_t cursymcount;
|
|
unsigned i;
|
|
|
|
if (map->l_addr) {
|
|
if (memcmp((void *)map->l_addr, ELFMAG, SELFMAG) != 0)
|
|
return ENOEXEC;
|
|
eident = *(unsigned char *)(map->l_addr + EI_CLASS);
|
|
if (eident != ELFCLASS32 && eident != ELFCLASS64)
|
|
return ENOEXEC;
|
|
}
|
|
|
|
/*
|
|
* ok, we probably have only the main object. instead of going
|
|
* to disk and reading the ehdr, just try to guess the size.
|
|
*/
|
|
if (eident == 0) {
|
|
if (/*CONSTCOND*/sizeof(void *) == 4)
|
|
eident = ELFCLASS32;
|
|
else
|
|
eident = ELFCLASS64;
|
|
}
|
|
|
|
/*
|
|
* Find symtab and strtab and their sizes.
|
|
*/
|
|
str_base = NULL;
|
|
curstrsize = 0;
|
|
cursymcount = 0;
|
|
ed_base = map->l_ld;
|
|
DYNn_GETMEMBER(ed_base, 0, d_tag, ed_tag);
|
|
for (i = 0; ed_tag != DT_NULL;) {
|
|
uintptr_t edptr;
|
|
size_t edval;
|
|
Elf_Symindx *hashtab;
|
|
|
|
switch (ed_tag) {
|
|
case DT_SYMTAB:
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_ptr, edptr);
|
|
syms_base = adjptr(map, edptr);
|
|
break;
|
|
case DT_STRTAB:
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_ptr, edptr);
|
|
str_base = adjptr(map, edptr);
|
|
break;
|
|
case DT_STRSZ:
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_val, edval);
|
|
curstrsize = edval;
|
|
break;
|
|
case DT_HASH:
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_ptr, edptr);
|
|
hashtab = (Elf_Symindx *)adjptr(map, edptr);
|
|
cursymcount = hashtab[1];
|
|
break;
|
|
#ifdef DT_GNU_HASH
|
|
/*
|
|
* DT_GNU_HASH is a bit more complicated than DT_HASH
|
|
* in this regard since apparently there is no field
|
|
* telling us the total symbol count. Instead, we look
|
|
* for the last valid hash bucket and add its chain length
|
|
* to the bucket's base index.
|
|
*/
|
|
case DT_GNU_HASH: {
|
|
Elf32_Word nbuck, symndx, maskwords, maxchain = 0;
|
|
Elf32_Word *gnuhash, *buckets, *ptr;
|
|
int bi;
|
|
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_ptr, edptr);
|
|
gnuhash = (Elf32_Word *)adjptr(map, edptr);
|
|
|
|
nbuck = gnuhash[0];
|
|
symndx = gnuhash[1];
|
|
maskwords = gnuhash[2];
|
|
|
|
/*
|
|
* First, find the last valid bucket and grab its index
|
|
*/
|
|
if (eident == ELFCLASS64)
|
|
maskwords *= 2; /* sizeof(*buckets) == 4 */
|
|
buckets = gnuhash + 4 + maskwords;
|
|
for (bi = nbuck-1; bi >= 0; bi--) {
|
|
if (buckets[bi] != 0) {
|
|
maxchain = buckets[bi];
|
|
break;
|
|
}
|
|
}
|
|
if (maxchain == 0 || maxchain < symndx)
|
|
break;
|
|
|
|
/*
|
|
* Then, traverse the last chain and count symbols.
|
|
*/
|
|
|
|
cursymcount = maxchain;
|
|
ptr = buckets + nbuck + (maxchain - symndx);
|
|
do {
|
|
cursymcount++;
|
|
} while ((*ptr++ & 1) == 0);
|
|
}
|
|
break;
|
|
#endif
|
|
case DT_SYMENT:
|
|
DYNn_GETMEMBER(ed_base, i, d_un.d_val, edval);
|
|
assert(edval == SYM_GETSIZE());
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
i++;
|
|
DYNn_GETMEMBER(ed_base, i, d_tag, ed_tag);
|
|
}
|
|
|
|
if (str_base == NULL || syms_base == NULL ||
|
|
curstrsize == 0 || cursymcount == 0) {
|
|
fprintf(stderr, "could not find strtab, symtab or their sizes "
|
|
"in %s\n", map->l_name);
|
|
return ENOEXEC;
|
|
}
|
|
|
|
/*
|
|
* Make sure we have enough space for the contents of the symbol
|
|
* and string tables we are currently processing. The total used
|
|
* space will be smaller due to undefined symbols we are not
|
|
* interested in.
|
|
*/
|
|
symtab = reservespace(symtab, &symtabsize,
|
|
symtaboff, cursymcount * SYM_GETSIZE());
|
|
strtab = reservespace(strtab, &strtabsize, strtaboff, curstrsize);
|
|
if (symtab == NULL || strtab == NULL) {
|
|
fprintf(stderr, "failed to reserve memory");
|
|
return ENOMEM;
|
|
}
|
|
|
|
/* iterate over all symbols in current symtab */
|
|
for (i = 0; i < cursymcount; i++) {
|
|
const char *cursymname;
|
|
int shndx, name;
|
|
uintptr_t value;
|
|
void *csym;
|
|
|
|
SYMn_GETMEMBER(syms_base, i, st_shndx, shndx);
|
|
SYMn_GETMEMBER(syms_base, i, st_value, value);
|
|
if (shndx == SHN_UNDEF || value == 0)
|
|
continue;
|
|
|
|
/* get symbol name */
|
|
SYMn_GETMEMBER(syms_base, i, st_name, name);
|
|
cursymname = name + str_base;
|
|
|
|
/*
|
|
* Only accept symbols which are decidedly in
|
|
* the rump kernel namespace.
|
|
* XXX: quirks, but they wouldn't matter here
|
|
*/
|
|
if (strncmp(cursymname, "rump", 4) != 0 &&
|
|
strncmp(cursymname, "RUMP", 4) != 0 &&
|
|
strncmp(cursymname, "__", 2) != 0) {
|
|
continue;
|
|
}
|
|
|
|
memcpy(symtab + symtaboff,
|
|
(const uint8_t *)syms_base + i*SYM_GETSIZE(),SYM_GETSIZE());
|
|
|
|
/*
|
|
* set name to point at new strtab, offset symbol value
|
|
* with lib base address.
|
|
*/
|
|
csym = symtab + symtaboff;
|
|
SYMn_SETMEMBER(csym, 0, st_name, strtaboff);
|
|
SYMn_GETMEMBER(csym, 0, st_value, value);
|
|
SYMn_SETMEMBER(csym, 0, st_value,(intptr_t)(value+map->l_addr));
|
|
symtaboff += SYM_GETSIZE();
|
|
|
|
strcpy(strtab + strtaboff, cursymname);
|
|
strtaboff += strlen(cursymname)+1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
process_object(void *handle,
|
|
rump_modinit_fn domodinit, rump_compload_fn docompload,
|
|
rump_evcntattach_fn doevcntattach)
|
|
{
|
|
const struct modinfo *const *mi_start, *const *mi_end;
|
|
struct rump_component *const *rc, *const *rc_end;
|
|
|
|
struct sysctllog;
|
|
typedef void sysctl_setup_func(struct sysctllog **);
|
|
sysctl_setup_func *const *sfp, *const *sfp_end;
|
|
|
|
struct evcnt *const *evp, *const *evp_end;
|
|
|
|
mi_start = dlsym(handle, "__start_link_set_modules");
|
|
mi_end = dlsym(handle, "__stop_link_set_modules");
|
|
if (mi_start && mi_end)
|
|
domodinit(mi_start, (size_t)(mi_end-mi_start));
|
|
|
|
rc = dlsym(handle, "__start_link_set_rump_components");
|
|
rc_end = dlsym(handle, "__stop_link_set_rump_components");
|
|
if (rc && rc_end) {
|
|
for (; rc < rc_end; rc++)
|
|
docompload(*rc);
|
|
assert(rc == rc_end);
|
|
}
|
|
|
|
/* handle link_set_sysctl_funcs */
|
|
sfp = dlsym(handle, "__start_link_set_sysctl_funcs");
|
|
sfp_end = dlsym(handle, "__stop_link_set_sysctl_funcs");
|
|
if (sfp && sfp_end) {
|
|
for (; sfp < sfp_end; sfp++)
|
|
(**sfp)(NULL);
|
|
assert(sfp == sfp_end);
|
|
}
|
|
|
|
/* handle link_set_evcnts */
|
|
evp = dlsym(handle, "__start_link_set_evcnts");
|
|
evp_end = dlsym(handle, "__stop_link_set_evcnts");
|
|
if (evp && evp_end) {
|
|
for (; evp < evp_end; evp++)
|
|
doevcntattach(*evp);
|
|
assert(evp == evp_end);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Get the linkmap from the dynlinker. Try to load kernel modules
|
|
* from all objects in the linkmap.
|
|
*/
|
|
void
|
|
rumpuser_dl_bootstrap(rump_modinit_fn domodinit,
|
|
rump_symload_fn symload, rump_compload_fn compload,
|
|
rump_evcntattach_fn doevcntattach)
|
|
{
|
|
struct link_map *map, *origmap, *mainmap;
|
|
void *mainhandle;
|
|
int error;
|
|
|
|
mainhandle = dlopen(NULL, RTLD_NOW);
|
|
/* Will be null if statically linked so just return */
|
|
if (mainhandle == NULL)
|
|
return;
|
|
if (dlinfo(mainhandle, RTLD_DI_LINKMAP, &mainmap) == -1) {
|
|
fprintf(stderr, "warning: rumpuser module bootstrap "
|
|
"failed: %s\n", dlerror());
|
|
return;
|
|
}
|
|
origmap = mainmap;
|
|
|
|
/*
|
|
* Use a heuristic to determine if we are static linked.
|
|
* A dynamically linked binary should always have at least
|
|
* two objects: itself and ld.so.
|
|
*
|
|
* In a statically linked binary with glibc the linkmap
|
|
* contains some "info" that leads to a segfault. Since we
|
|
* can't really do anything useful in here without ld.so, just
|
|
* simply bail and let the symbol references in librump do the
|
|
* right things.
|
|
*/
|
|
if (origmap->l_next == NULL && origmap->l_prev == NULL) {
|
|
dlclose(mainhandle);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Process last->first because that's the most probable
|
|
* order for dependencies
|
|
*/
|
|
for (; origmap->l_next; origmap = origmap->l_next)
|
|
continue;
|
|
|
|
/*
|
|
* Build symbol table to hand to the rump kernel. Do this by
|
|
* iterating over all rump libraries and collecting symbol
|
|
* addresses and relocation info.
|
|
*/
|
|
error = 0;
|
|
for (map = origmap; map && !error; map = map->l_prev) {
|
|
if (strstr(map->l_name, "librump") != NULL || map == mainmap)
|
|
error = getsymbols(map, map == mainmap);
|
|
}
|
|
|
|
if (error == 0) {
|
|
void *trimmedsym, *trimmedstr;
|
|
|
|
/*
|
|
* Allocate optimum-sized memory for storing tables
|
|
* and feed to kernel. If memory allocation fails,
|
|
* just give the ones with extra context (although
|
|
* I'm pretty sure we'll die moments later due to
|
|
* memory running out).
|
|
*/
|
|
if ((trimmedsym = malloc(symtaboff)) != NULL) {
|
|
memcpy(trimmedsym, symtab, symtaboff);
|
|
} else {
|
|
trimmedsym = symtab;
|
|
symtab = NULL;
|
|
}
|
|
if ((trimmedstr = malloc(strtaboff)) != NULL) {
|
|
memcpy(trimmedstr, strtab, strtaboff);
|
|
} else {
|
|
trimmedstr = strtab;
|
|
strtab = NULL;
|
|
}
|
|
symload(trimmedsym, symtaboff, trimmedstr, strtaboff);
|
|
}
|
|
free(symtab);
|
|
free(strtab);
|
|
|
|
/*
|
|
* Next, load modules and components.
|
|
*
|
|
* Simply loop through all objects, ones unrelated to rump kernels
|
|
* will not contain link_set_rump_components (well, not including
|
|
* "sabotage", but that needs to be solved at another level anyway).
|
|
*/
|
|
for (map = origmap; map; map = map->l_prev) {
|
|
void *handle;
|
|
|
|
if (map == mainmap) {
|
|
handle = mainhandle;
|
|
} else {
|
|
handle = dlopen(map->l_name, RTLD_LAZY);
|
|
if (handle == NULL)
|
|
continue;
|
|
}
|
|
process_object(handle, domodinit, compload, doevcntattach);
|
|
if (map != mainmap)
|
|
dlclose(handle);
|
|
}
|
|
}
|
|
#else
|
|
/*
|
|
* no dynamic linking supported
|
|
*/
|
|
void
|
|
rumpuser_dl_bootstrap(rump_modinit_fn domodinit,
|
|
rump_symload_fn symload, rump_compload_fn compload,
|
|
rump_evcntattach_fn doevcntattach)
|
|
{
|
|
|
|
return;
|
|
}
|
|
#endif
|