#include <errno.h>
#include <limits.h>
#include <elf.h>
+#include <link.h>
#include <setjmp.h>
#include <pthread.h>
#include <ctype.h>
#include <dlfcn.h>
#include "pthread_impl.h"
#include "libc.h"
-#undef libc
static int errflag;
static char errbuf[128];
size_t *dynv;
struct dso *next, *prev;
+ Phdr *phdr;
+ int phnum;
int refcnt;
Sym *syms;
uint32_t *hashtab;
void __init_ssp(size_t *);
void *__install_initial_tls(void *);
-static struct dso *head, *tail, *libc, *fini_head;
+static struct dso *head, *tail, *ldso, *fini_head;
static char *env_path, *sys_path, *r_path;
+static unsigned long long gencnt;
static int ssp_used;
static int runtime;
static int ldd_mode;
static int ldso_fail;
+static int noload;
static jmp_buf rtld_fail;
static pthread_rwlock_t lock;
static struct debug debug;
-static size_t *auxv;
-static size_t tls_cnt, tls_offset, tls_start, tls_align = 4*sizeof(size_t);
+static size_t tls_cnt, tls_offset, tls_align = 4*sizeof(size_t);
static pthread_mutex_t init_fini_lock = { ._m_type = PTHREAD_MUTEX_RECURSIVE };
struct debug *_dl_debug_addr = &debug;
-#define AUX_CNT 24
+#define AUX_CNT 38
#define DYN_CNT 34
static void decode_vec(size_t *v, size_t *a, size_t cnt)
eh->e_phoff = sizeof *eh;
}
ph = (void *)((char *)buf + eh->e_phoff);
+ dso->phdr = ph;
+ dso->phnum = eh->e_phnum;
for (i=eh->e_phnum; i; i--, ph=(void *)((char *)ph+eh->e_phentsize)) {
if (ph->p_type == PT_DYNAMIC)
dyn = ph->p_vaddr;
{
char buf[2*NAME_MAX+2];
const char *pathname;
- unsigned char *base, *map;
- size_t dyno, map_len;
+ unsigned char *map;
+ size_t map_len;
struct dso *p, temp_dso = {0};
int fd;
struct stat st;
size_t l = z-name;
for (rp=reserved; *rp && memcmp(name+3, rp, l-3); rp+=strlen(rp)+1);
if (*rp) {
- if (!libc->prev) {
- tail->next = libc;
- libc->prev = tail;
- tail = libc->next ? libc->next : libc;
+ if (!ldso->prev) {
+ tail->next = ldso;
+ ldso->prev = tail;
+ tail = ldso->next ? ldso->next : ldso;
}
- return libc;
+ return ldso;
}
}
}
if (!sys_path) {
FILE *f = fopen(ETC_LDSO_PATH, "rbe");
if (f) {
- if (getline(&sys_path, (size_t[1]){0}, f) > 0)
- sys_path[strlen(sys_path)-1]=0;
+ if (getline(&sys_path, (size_t[1]){0}, f) > 0) {
+ size_t l = strlen(sys_path);
+ if (l && sys_path[l-1]=='\n')
+ sys_path[l-1] = 0;
+ }
fclose(f);
}
}
- if (sys_path) fd = path_open(name, sys_path, buf, sizeof buf);
- else fd = path_open(name, "/lib:/usr/local/lib:/usr/lib", buf, sizeof buf);
+ if (!sys_path) sys_path = "/lib:/usr/local/lib:/usr/lib";
+ fd = path_open(name, sys_path, buf, sizeof buf);
}
pathname = buf;
}
return p;
}
}
- map = map_library(fd, &temp_dso);
+ map = noload ? 0 : map_library(fd, &temp_dso);
close(fd);
if (!map) return 0;
if (runtime && temp_dso.tls_image) {
size_t per_th = temp_dso.tls_size + temp_dso.tls_align
+ sizeof(void *) * (tls_cnt+3);
- n_th = __libc.threads_minus_1 + 1;
+ n_th = libc.threads_minus_1 + 1;
if (n_th > SSIZE_MAX / per_th) alloc_size = SIZE_MAX;
else alloc_size += n_th * per_th;
}
/* Add a shortname only if name arg was not an explicit pathname. */
if (pathname != name) p->shortname = strrchr(p->name, '/')+1;
if (p->tls_image) {
- if (!__pthread_self_init()) {
+ if (runtime && !__pthread_self_init()) {
free(p);
munmap(map, map_len);
return 0;
}
p->tls_id = ++tls_cnt;
tls_align = MAXP2(tls_align, p->tls_align);
+#ifdef TLS_ABOVE_TP
+ p->tls_offset = tls_offset + ( (tls_align-1) &
+ -(tls_offset + (uintptr_t)p->tls_image) );
+ tls_offset += p->tls_size;
+#else
tls_offset += p->tls_size + p->tls_align - 1;
tls_offset -= (tls_offset + (uintptr_t)p->tls_image)
& (p->tls_align-1);
p->tls_offset = tls_offset;
+#endif
p->new_dtv = (void *)(-sizeof(size_t) &
(uintptr_t)(p->name+strlen(p->name)+sizeof(size_t)));
p->new_tls = (void *)(p->new_dtv + n_th*(tls_cnt+1));
p->prev = tail;
tail = p;
- if (ldd_mode) dprintf(1, "\t%s => %s (%p)\n", name, pathname, base);
+ if (ldd_mode) dprintf(1, "\t%s => %s (%p)\n", name, pathname, p->base);
return p;
}
}
}
-static void free_all(struct dso *p)
-{
- struct dso *n;
- while (p) {
- n = p->next;
- if (p->map && p!=libc && p!=head) free(p);
- p = n;
- }
-}
-
static size_t find_dyn(Phdr *ph, size_t cnt, size_t stride)
{
for (; cnt--; ph = (void *)((char *)ph + stride))
static void do_init_fini(struct dso *p)
{
size_t dyn[DYN_CNT] = {0};
- int need_locking = __libc.threads_minus_1;
+ int need_locking = libc.threads_minus_1;
/* Allow recursive calls that arise when a library calls
* dlopen from one of its constructors, but block any
* other threads until all ctors have finished. */
void **dtv = (void *)mem;
dtv[0] = (void *)tls_cnt;
- mem += __libc.tls_size - sizeof(struct pthread);
+#ifdef TLS_ABOVE_TP
+ mem += sizeof(void *) * (tls_cnt+1);
+ mem += -((uintptr_t)mem + sizeof(struct pthread)) & (tls_align-1);
+ td = (pthread_t)mem;
+ mem += sizeof(struct pthread);
+
+ for (p=head; p; p=p->next) {
+ if (!p->tls_id) continue;
+ dtv[p->tls_id] = mem + p->tls_offset;
+ memcpy(dtv[p->tls_id], p->tls_image, p->tls_len);
+ }
+#else
+ mem += libc.tls_size - sizeof(struct pthread);
mem -= (uintptr_t)mem & (tls_align-1);
- mem -= tls_start;
td = (pthread_t)mem;
for (p=head; p; p=p->next) {
dtv[p->tls_id] = mem - p->tls_offset;
memcpy(dtv[p->tls_id], p->tls_image, p->tls_len);
}
+#endif
td->dtv = dtv;
return td;
}
/* Block signals to make accessing new TLS async-signal-safe */
sigset_t set;
- sigfillset(&set);
- pthread_sigmask(SIG_BLOCK, &set, &set);
+ pthread_sigmask(SIG_BLOCK, SIGALL_SET, &set);
if (self->dtv && v[0]<=(size_t)self->dtv[0] && self->dtv[v[0]]) {
pthread_sigmask(SIG_SETMASK, &set, 0);
return (char *)self->dtv[v[0]]+v[1];
static void update_tls_size()
{
- size_t below_tp = (1+tls_cnt) * sizeof(void *) + tls_offset;
- size_t above_tp = sizeof(struct pthread) + tls_start + tls_align;
- __libc.tls_size = ALIGN(below_tp + above_tp, tls_align);
+ libc.tls_size = ALIGN(
+ (1+tls_cnt) * sizeof(void *) +
+ tls_offset +
+ sizeof(struct pthread) +
+ tls_align * 2,
+ tls_align);
}
void *__dynlink(int argc, char **argv)
struct dso *const vdso = builtin_dsos+2;
char *env_preload=0;
size_t vdso_base;
+ size_t *auxv;
/* Find aux vector just past environ[] */
for (i=argc+1; argv[i]; i++)
lib->name = lib->shortname = "libc.so";
lib->global = 1;
ehdr = (void *)lib->base;
- find_map_range((void *)(aux[AT_BASE]+ehdr->e_phoff),
- ehdr->e_phnum, ehdr->e_phentsize, lib);
- lib->dynv = (void *)(lib->base + find_dyn(
- (void *)(aux[AT_BASE]+ehdr->e_phoff),
- ehdr->e_phnum, ehdr->e_phentsize));
+ lib->phnum = ehdr->e_phnum;
+ lib->phdr = (void *)(aux[AT_BASE]+ehdr->e_phoff);
+ find_map_range(lib->phdr, ehdr->e_phnum, ehdr->e_phentsize, lib);
+ lib->dynv = (void *)(lib->base + find_dyn(lib->phdr,
+ ehdr->e_phnum, ehdr->e_phentsize));
decode_dyn(lib);
if (aux[AT_PHDR]) {
size_t interp_off = 0;
size_t tls_image = 0;
/* Find load address of the main program, via AT_PHDR vs PT_PHDR. */
- phdr = (void *)aux[AT_PHDR];
+ app->phdr = phdr = (void *)aux[AT_PHDR];
+ app->phnum = aux[AT_PHNUM];
for (i=aux[AT_PHNUM]; i; i--, phdr=(void *)((char *)phdr + aux[AT_PHENT])) {
if (phdr->p_type == PT_PHDR)
app->base = (void *)(aux[AT_PHDR] - phdr->p_vaddr);
} else {
int fd;
char *ldname = argv[0];
- size_t dyno, l = strlen(ldname);
+ size_t l = strlen(ldname);
if (l >= 3 && !strcmp(ldname+l-3, "ldd")) ldd_mode = 1;
*argv++ = (void *)-1;
if (argv[0] && !strcmp(argv[0], "--")) *argv++ = (void *)-1;
close(fd);
lib->name = ldname;
app->name = argv[0];
+ app->phnum = ehdr->e_phnum;
+ app->phdr = (void *)(app->base + ehdr->e_phoff);
aux[AT_ENTRY] = ehdr->e_entry;
}
if (app->tls_size) {
app->tls_id = tls_cnt = 1;
- tls_offset = app->tls_offset = app->tls_size;
- tls_start = -((uintptr_t)app->tls_image + app->tls_size)
- & (app->tls_align-1);
+#ifdef TLS_ABOVE_TP
+ app->tls_offset = 0;
+ tls_offset = app->tls_size
+ + ( -((uintptr_t)app->tls_image + app->tls_size)
+ & (app->tls_align-1) );
+#else
+ tls_offset = app->tls_offset = app->tls_size
+ + ( -((uintptr_t)app->tls_image + app->tls_size)
+ & (app->tls_align-1) );
+#endif
tls_align = MAXP2(tls_align, app->tls_align);
}
app->global = 1;
/* Attach to vdso, if provided by the kernel */
if (search_vec(auxv, &vdso_base, AT_SYSINFO_EHDR)) {
ehdr = (void *)vdso_base;
- phdr = (void *)(vdso_base + ehdr->e_phoff);
+ vdso->phdr = phdr = (void *)(vdso_base + ehdr->e_phoff);
+ vdso->phnum = ehdr->e_phnum;
for (i=ehdr->e_phnum; i; i--, phdr=(void *)((char *)phdr + ehdr->e_phentsize)) {
if (phdr->p_type == PT_DYNAMIC)
vdso->dynv = (void *)(vdso_base + phdr->p_offset);
if (phdr->p_type == PT_LOAD)
vdso->base = (void *)(vdso_base - phdr->p_vaddr + phdr->p_offset);
}
- vdso->name = vdso->shortname = "linux-gate.so.1";
+ vdso->name = "";
+ vdso->shortname = "linux-gate.so.1";
vdso->global = 1;
decode_dyn(vdso);
vdso->prev = lib;
* restore the initial chain in preparation for loading third
* party libraries (preload/needed). */
head = tail = app;
- libc = lib;
+ ldso = lib;
app->next = lib;
reloc_all(lib);
app->next = 0;
update_tls_size();
if (tls_cnt) {
- struct dso *p;
- void *mem = mmap(0, __libc.tls_size, PROT_READ|PROT_WRITE,
+ void *mem = mmap(0, libc.tls_size, PROT_READ|PROT_WRITE,
MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
if (mem==MAP_FAILED ||
!__install_initial_tls(__copy_tls(mem))) {
dprintf(2, "%s: Error getting %zu bytes thread-local storage: %m\n",
- argv[0], __libc.tls_size);
+ argv[0], libc.tls_size);
_exit(127);
}
}
debug.state = 0;
_dl_debug_state();
- if (ssp_used) __init_ssp(auxv);
-
- atexit(do_fini);
- do_init_fini(tail);
+ if (ssp_used) __init_ssp((void *)aux[AT_RANDOM]);
errno = 0;
return (void *)aux[AT_ENTRY];
}
+void __init_ldso_ctors(void)
+{
+ atexit(do_fini);
+ do_init_fini(tail);
+}
+
void *dlopen(const char *file, int mode)
{
struct dso *volatile p, *orig_tail, *next;
orig_tls_offset = tls_offset;
orig_tls_align = tls_align;
orig_tail = tail;
+ noload = mode & RTLD_NOLOAD;
if (setjmp(rtld_fail)) {
/* Clean up anything new that was (partially) loaded */
} else p = load_library(file);
if (!p) {
- snprintf(errbuf, sizeof errbuf,
- "Error loading shared library %s: %m", file);
+ snprintf(errbuf, sizeof errbuf, noload ?
+ "Library %s is not already loaded" :
+ "Error loading shared library %s: %m",
+ file);
errflag = 1;
goto end;
}
update_tls_size();
- if (ssp_used) __init_ssp(auxv);
+ if (ssp_used) __init_ssp(libc.auxv);
_dl_debug_state();
orig_tail = tail;
end:
__release_ptc();
+ if (p) gencnt++;
pthread_rwlock_unlock(&lock);
if (p) do_init_fini(orig_tail);
pthread_setcancelstate(cs, 0);
return p;
}
+static int invalid_dso_handle(void *h)
+{
+ struct dso *p;
+ for (p=head; p; p=p->next) if (h==p) return 0;
+ snprintf(errbuf, sizeof errbuf, "Invalid library handle %p", (void *)h);
+ errflag = 1;
+ return 1;
+}
+
static void *do_dlsym(struct dso *p, const char *s, void *ra)
{
size_t i;
uint32_t h = 0, gh = 0;
Sym *sym;
if (p == head || p == RTLD_DEFAULT || p == RTLD_NEXT) {
- if (p == RTLD_NEXT) {
+ if (p == RTLD_DEFAULT) {
+ p = head;
+ } else if (p == RTLD_NEXT) {
for (p=head; p && (unsigned char *)ra-p->map>p->map_len; p=p->next);
if (!p) p=head;
+ p = p->next;
}
- struct symdef def = find_sym(p->next, s, 0);
+ struct symdef def = find_sym(p, s, 0);
if (!def.sym) goto failed;
+ if ((def.sym->st_info&0xf) == STT_TLS)
+ return __tls_get_addr((size_t []){def.dso->tls_id, def.sym->st_value});
return def.dso->base + def.sym->st_value;
}
+ if (p != RTLD_DEFAULT && p != RTLD_NEXT && invalid_dso_handle(p))
+ return 0;
if (p->ghashtab) {
gh = gnu_hash(s);
sym = gnu_lookup(s, gh, p);
h = sysv_hash(s);
sym = sysv_lookup(s, h, p);
}
+ if (sym && (sym->st_info&0xf) == STT_TLS)
+ return __tls_get_addr((size_t []){p->tls_id, sym->st_value});
if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
return p->base + sym->st_value;
if (p->deps) for (i=0; p->deps[i]; i++) {
if (!h) h = sysv_hash(s);
sym = sysv_lookup(s, h, p->deps[i]);
}
+ if (sym && (sym->st_info&0xf) == STT_TLS)
+ return __tls_get_addr((size_t []){p->deps[i]->tls_id, sym->st_value});
if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
return p->deps[i]->base + sym->st_value;
}
}
for (; nsym; nsym--, sym++) {
- if (sym->st_shndx && sym->st_value
+ if (sym->st_value
&& (1<<(sym->st_info&0xf) & OK_TYPES)
&& (1<<(sym->st_info>>4) & OK_BINDS)) {
void *symaddr = p->base + sym->st_value;
pthread_rwlock_unlock(&lock);
return res;
}
+
+int dl_iterate_phdr(int(*callback)(struct dl_phdr_info *info, size_t size, void *data), void *data)
+{
+ struct dso *current;
+ struct dl_phdr_info info;
+ int ret = 0;
+ for(current = head; current;) {
+ info.dlpi_addr = (uintptr_t)current->base;
+ info.dlpi_name = current->name;
+ info.dlpi_phdr = current->phdr;
+ info.dlpi_phnum = current->phnum;
+ info.dlpi_adds = gencnt;
+ info.dlpi_subs = 0;
+ info.dlpi_tls_modid = current->tls_id;
+ info.dlpi_tls_data = current->tls_image;
+
+ ret = (callback)(&info, sizeof (info), data);
+
+ if (ret != 0) break;
+
+ pthread_rwlock_rdlock(&lock);
+ current = current->next;
+ pthread_rwlock_unlock(&lock);
+ }
+ return ret;
+}
#else
+static int invalid_dso_handle(void *h)
+{
+ snprintf(errbuf, sizeof errbuf, "Invalid library handle %p", (void *)h);
+ errflag = 1;
+ return 1;
+}
void *dlopen(const char *file, int mode)
{
return 0;
int dlclose(void *p)
{
- return 0;
+ return invalid_dso_handle(p);
}
projects / musl / blobdiff