X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=src%2Fldso%2Fdynlink.c;h=cab30089e5d1cc0ceeb58f50d1f81805f1ad11b7;hb=bd275378d35b3535bc8b8321780b00e486c36d96;hp=a08300de3efbc56d66d5108bc99b65a75ebc98d4;hpb=9a4ad02214a859e93d2c980e4535378a6a74e3a6;p=musl diff --git a/src/ldso/dynlink.c b/src/ldso/dynlink.c index a08300de..cab30089 100644 --- a/src/ldso/dynlink.c +++ b/src/ldso/dynlink.c @@ -19,26 +19,12 @@ #include #include "pthread_impl.h" #include "libc.h" +#include "dynlink.h" -static int errflag; -static char errbuf[128]; +static void error(const char *, ...); #ifdef SHARED -#if ULONG_MAX == 0xffffffff -typedef Elf32_Ehdr Ehdr; -typedef Elf32_Phdr Phdr; -typedef Elf32_Sym Sym; -#define R_TYPE(x) ((x)&255) -#define R_SYM(x) ((x)>>8) -#else -typedef Elf64_Ehdr Ehdr; -typedef Elf64_Phdr Phdr; -typedef Elf64_Sym Sym; -#define R_TYPE(x) ((x)&0xffffffff) -#define R_SYM(x) ((x)>>32) -#endif - #define MAXP2(a,b) (-(-(a)&-(b))) #define ALIGN(x,y) ((x)+(y)-1 & -(y)) @@ -56,7 +42,11 @@ struct td_index { }; struct dso { +#if DL_FDPIC + struct fdpic_loadmap *loadmap; +#else unsigned char *base; +#endif char *name; size_t *dynv; struct dso *next, *prev; @@ -85,10 +75,20 @@ struct dso { size_t relro_start, relro_end; void **new_dtv; unsigned char *new_tls; - int new_dtv_idx, new_tls_idx; + volatile int new_dtv_idx, new_tls_idx; struct td_index *td_index; struct dso *fini_next; char *shortname; +#if DL_FDPIC + unsigned char *base; +#else + struct fdpic_loadmap *loadmap; +#endif + struct funcdesc { + void *addr; + size_t *got; + } *funcdescs; + size_t *got; char buf[]; }; @@ -97,32 +97,23 @@ struct symdef { struct dso *dso; }; -enum { - REL_ERR, - REL_SYMBOLIC, - REL_GOT, - REL_PLT, - REL_RELATIVE, - REL_OFFSET, - REL_OFFSET32, - REL_COPY, - REL_SYM_OR_REL, - REL_TLS, /* everything past here is TLS */ - REL_DTPMOD, - REL_DTPOFF, - REL_TPOFF, - REL_TPOFF_NEG, - REL_TLSDESC, -}; - -#include "reloc.h" - int __init_tp(void *); void __init_libc(char **, char *); const char *__libc_get_version(void); -static struct dso *head, *tail, *ldso, *fini_head; +static struct builtin_tls { + char c; + struct pthread pt; + void *space[16]; +} builtin_tls[1]; +#define MIN_TLS_ALIGN offsetof(struct builtin_tls, pt) + +#define ADDEND_LIMIT 4096 +static size_t *saved_addends, *apply_addends_to; + +static struct dso ldso; +static struct dso *head, *tail, *fini_head; static char *env_path, *sys_path; static unsigned long long gencnt; static int runtime; @@ -132,21 +123,43 @@ static int noload; static jmp_buf *rtld_fail; static pthread_rwlock_t lock; static struct debug debug; -static size_t tls_cnt, tls_offset, tls_align = 4*sizeof(size_t); +static size_t tls_cnt, tls_offset, tls_align = MIN_TLS_ALIGN; static size_t static_tls_cnt; static pthread_mutex_t init_fini_lock = { ._m_type = PTHREAD_MUTEX_RECURSIVE }; -static long long builtin_tls[(sizeof(struct pthread) + 64)/sizeof(long long)]; +static struct fdpic_loadmap *app_loadmap; +static struct fdpic_dummy_loadmap app_dummy_loadmap; struct debug *_dl_debug_addr = &debug; -#define AUX_CNT 38 -#define DYN_CNT 34 +static int dl_strcmp(const char *l, const char *r) +{ + for (; *l==*r && *l; l++, r++); + return *(unsigned char *)l - *(unsigned char *)r; +} +#define strcmp(l,r) dl_strcmp(l,r) + +/* Compute load address for a virtual address in a given dso. */ +#if DL_FDPIC +static void *laddr(const struct dso *p, size_t v) +{ + size_t j=0; + if (!p->loadmap) return p->base + v; + for (j=0; v-p->loadmap->segs[j].p_vaddr >= p->loadmap->segs[j].p_memsz; j++); + return (void *)(v - p->loadmap->segs[j].p_vaddr + p->loadmap->segs[j].addr); +} +#define fpaddr(p, v) ((void (*)())&(struct funcdesc){ \ + laddr(p, v), (p)->got }) +#else +#define laddr(p, v) (void *)((p)->base + (v)) +#define fpaddr(p, v) ((void (*)())laddr(p, v)) +#endif static void decode_vec(size_t *v, size_t *a, size_t cnt) { - memset(a, 0, cnt*sizeof(size_t)); - for (; v[0]; v+=2) if (v[0]syms; - char *strings = dso->strings; - uint32_t *hashtab = dso->ghashtab; uint32_t nbuckets = hashtab[0]; uint32_t *buckets = hashtab + 4 + hashtab[2]*(sizeof(size_t)/4); - uint32_t h2; - uint32_t *hashval; uint32_t i = buckets[h1 % nbuckets]; if (!i) return 0; - hashval = buckets + nbuckets + (i - hashtab[1]); + uint32_t *hashval = buckets + nbuckets + (i - hashtab[1]); for (h1 |= 1; ; i++) { - h2 = *hashval++; - if ((!dso->versym || dso->versym[i] >= 0) - && (h1 == (h2|1)) && !strcmp(s, strings + syms[i].st_name)) - return syms+i; + uint32_t h2 = *hashval++; + if ((h1 == (h2|1)) && (!dso->versym || dso->versym[i] >= 0) + && !strcmp(s, dso->strings + dso->syms[i].st_name)) + return dso->syms+i; if (h2 & 1) break; } return 0; } +static Sym *gnu_lookup_filtered(uint32_t h1, uint32_t *hashtab, struct dso *dso, const char *s, uint32_t fofs, size_t fmask) +{ + const size_t *bloomwords = (const void *)(hashtab+4); + size_t f = bloomwords[fofs & (hashtab[2]-1)]; + if (!(f & fmask)) return 0; + + f >>= (h1 >> hashtab[3]) % (8 * sizeof f); + if (!(f & 1)) return 0; + + return gnu_lookup(h1, hashtab, dso, s); +} + #define OK_TYPES (1<next) { Sym *sym; if (!dso->global) continue; - if (dso->ghashtab) { - if (!gh) gh = gnu_hash(s); - sym = gnu_lookup(s, gh, dso); + if ((ght = dso->ghashtab)) { + if (!ghm) { + gh = gnu_hash(s); + int maskbits = 8 * sizeof ghm; + gho = gh / maskbits; + ghm = 1ul << gh % maskbits; + } + sym = gnu_lookup_filtered(gh, ght, dso, s, gho, ghm); } else { if (!h) h = sysv_hash(s); sym = sysv_lookup(s, h, dso); } if (!sym) continue; if (!sym->st_shndx) - if (need_def || (sym->st_info&0xf) == STT_TLS) + if (need_def || (sym->st_info&0xf) == STT_TLS + || ARCH_SYM_REJECT_UND(sym)) continue; if (!sym->st_value) if ((sym->st_info&0xf) != STT_TLS) @@ -265,8 +285,7 @@ static struct symdef find_sym(struct dso *dso, const char *s, int need_def) return def; } -#define NO_INLINE_ADDEND (1<name, astype); - continue; - } + if (skip_relative && IS_RELATIVE(rel[1], dso->syms)) continue; + type = R_TYPE(rel[1]); + if (type == REL_NONE) continue; sym_index = R_SYM(rel[1]); - reloc_addr = (void *)(base + rel[0]); + reloc_addr = laddr(dso, rel[0]); if (sym_index) { sym = syms + sym_index; name = strings + sym->st_name; ctx = type==REL_COPY ? head->next : head; - def = find_sym(ctx, name, type==REL_PLT); + def = (sym->st_info&0xf) == STT_SECTION + ? (struct symdef){ .dso = dso, .sym = sym } + : find_sym(ctx, name, type==REL_PLT); if (!def.sym && (sym->st_shndx != SHN_UNDEF || sym->st_info>>4 != STB_WEAK)) { error("Error relocating %s: %s: symbol not found", dso->name, name); + if (runtime) longjmp(*rtld_fail, 1); continue; } } else { @@ -313,14 +338,27 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri def.dso = dso; } - addend = stride>2 ? rel[2] - : (1< 2) { + addend = rel[2]; + } else if (type==REL_GOT || type==REL_PLT|| type==REL_COPY) { + addend = 0; + } else if (reuse_addends) { + /* Save original addend in stage 2 where the dso + * chain consists of just ldso; otherwise read back + * saved addend since the inline one was clobbered. */ + if (head==&ldso) + saved_addends[save_slot] = *reloc_addr; + addend = saved_addends[save_slot++]; + } else { + addend = *reloc_addr; + } - sym_val = def.sym ? (size_t)def.dso->base+def.sym->st_value : 0; + sym_val = def.sym ? (size_t)laddr(def.dso, def.sym->st_value) : 0; tls_val = def.sym ? def.sym->st_value : 0; switch(type) { + case REL_NONE: + break; case REL_OFFSET: addend -= (size_t)reloc_addr; case REL_SYMBOLIC: @@ -342,11 +380,20 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri *(uint32_t *)reloc_addr = sym_val + addend - (size_t)reloc_addr; break; + case REL_FUNCDESC: + *reloc_addr = def.sym ? (size_t)(def.dso->funcdescs + + (def.sym - def.dso->syms)) : 0; + break; + case REL_FUNCDESC_VAL: + if ((sym->st_info&0xf) == STT_SECTION) *reloc_addr += sym_val; + else *reloc_addr = sym_val; + reloc_addr[1] = def.sym ? (size_t)def.dso->got : 0; + break; case REL_DTPMOD: *reloc_addr = def.dso->tls_id; break; case REL_DTPOFF: - *reloc_addr = tls_val + addend; + *reloc_addr = tls_val + addend - DTP_OFFSET; break; #ifdef TLS_ABOVE_TP case REL_TPOFF: @@ -364,9 +411,12 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri if (stride<3) addend = reloc_addr[1]; if (runtime && def.dso->tls_id >= static_tls_cnt) { struct td_index *new = malloc(sizeof *new); - if (!new) error( + if (!new) { + error( "Error relocating %s: cannot allocate TLSDESC for %s", dso->name, sym ? name : "(local)" ); + longjmp(*rtld_fail, 1); + } new->next = dso->td_index; dso->td_index = new; new->args[0] = def.dso->tls_id; @@ -384,6 +434,11 @@ static void do_relocs(struct dso *dso, size_t *rel, size_t rel_size, size_t stri #endif } break; + default: + error("Error relocating %s: unsupported relocation type %d", + dso->name, type); + if (runtime) longjmp(*rtld_fail, 1); + continue; } } } @@ -402,8 +457,8 @@ static void reclaim(struct dso *dso, size_t start, size_t end) start = start + 6*sizeof(size_t)-1 & -4*sizeof(size_t); end = (end & -4*sizeof(size_t)) - 2*sizeof(size_t); if (start>end || end-start < 4*sizeof(size_t)) return; - a = (size_t *)(dso->base + start); - z = (size_t *)(dso->base + end); + a = laddr(dso, start); + z = laddr(dso, end); a[-2] = 1; a[-1] = z[0] = end-start + 2*sizeof(size_t) | 1; z[1] = 1; @@ -415,6 +470,7 @@ static void reclaim_gaps(struct dso *dso) Phdr *ph = dso->phdr; size_t phcnt = dso->phnum; + if (DL_FDPIC) return; // FIXME for (; phcnt--; ph=(void *)((char *)ph+dso->phentsize)) { if (ph->p_type!=PT_LOAD) continue; if ((ph->p_flags&(PF_R|PF_W))!=(PF_R|PF_W)) continue; @@ -424,6 +480,44 @@ static void reclaim_gaps(struct dso *dso) } } +static void *mmap_fixed(void *p, size_t n, int prot, int flags, int fd, off_t off) +{ + char *q = mmap(p, n, prot, flags, fd, off); + if (q != MAP_FAILED || errno != EINVAL) return q; + /* Fallbacks for MAP_FIXED failure on NOMMU kernels. */ + if (flags & MAP_ANONYMOUS) { + memset(p, 0, n); + return p; + } + ssize_t r; + if (lseek(fd, off, SEEK_SET) < 0) return MAP_FAILED; + for (q=p; n; q+=r, off+=r, n-=r) { + r = read(fd, q, n); + if (r < 0 && errno != EINTR) return MAP_FAILED; + if (!r) { + memset(q, 0, n); + break; + } + } + return p; +} + +static void unmap_library(struct dso *dso) +{ + if (dso->loadmap) { + size_t i; + for (i=0; iloadmap->nsegs; i++) { + if (!dso->loadmap->segs[i].p_memsz) + continue; + munmap((void *)dso->loadmap->segs[i].addr, + dso->loadmap->segs[i].p_memsz); + } + free(dso->loadmap); + } else if (dso->map && dso->map_len) { + munmap(dso->map, dso->map_len); + } +} + static void *map_library(int fd, struct dso *dso) { Ehdr buf[(896+sizeof(Ehdr))/sizeof(Ehdr)]; @@ -431,6 +525,7 @@ static void *map_library(int fd, struct dso *dso) size_t phsize; size_t addr_min=SIZE_MAX, addr_max=0, map_len; size_t this_min, this_max; + size_t nsegs = 0; off_t off_start; Ehdr *eh; Phdr *ph, *ph0; @@ -474,6 +569,7 @@ static void *map_library(int fd, struct dso *dso) dso->relro_end = (ph->p_vaddr + ph->p_memsz) & -PAGE_SIZE; } if (ph->p_type != PT_LOAD) continue; + nsegs++; if (ph->p_vaddr < addr_min) { addr_min = ph->p_vaddr; off_start = ph->p_offset; @@ -486,6 +582,33 @@ static void *map_library(int fd, struct dso *dso) } } if (!dyn) goto noexec; + if (DL_FDPIC && !(eh->e_flags & FDPIC_CONSTDISP_FLAG)) { + dso->loadmap = calloc(1, sizeof *dso->loadmap + + nsegs * sizeof *dso->loadmap->segs); + if (!dso->loadmap) goto error; + dso->loadmap->nsegs = nsegs; + for (ph=ph0, i=0; ie_phentsize)) { + if (ph->p_type != PT_LOAD) continue; + prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) | + ((ph->p_flags&PF_W) ? PROT_WRITE: 0) | + ((ph->p_flags&PF_X) ? PROT_EXEC : 0)); + map = mmap(0, ph->p_memsz + (ph->p_vaddr & PAGE_SIZE-1), + prot, (prot&PROT_WRITE) ? MAP_PRIVATE : MAP_SHARED, + fd, ph->p_offset & -PAGE_SIZE); + if (map == MAP_FAILED) { + unmap_library(dso); + goto error; + } + dso->loadmap->segs[i].addr = (size_t)map + + (ph->p_vaddr & PAGE_SIZE-1); + dso->loadmap->segs[i].p_vaddr = ph->p_vaddr; + dso->loadmap->segs[i].p_memsz = ph->p_memsz; + i++; + } + map = (void *)dso->loadmap->segs[0].addr; + map_len = 0; + goto done_mapping; + } addr_max += PAGE_SIZE-1; addr_max &= -PAGE_SIZE; addr_min &= -PAGE_SIZE; @@ -497,6 +620,8 @@ static void *map_library(int fd, struct dso *dso) * amount of virtual address space to map over later. */ map = mmap((void *)addr_min, map_len, prot, MAP_PRIVATE, fd, off_start); if (map==MAP_FAILED) goto error; + dso->map = map; + dso->map_len = map_len; /* If the loaded file is not relocatable and the requested address is * not available, then the load operation must fail. */ if (eh->e_type != ET_DYN && addr_min && map!=(void *)addr_min) { @@ -525,34 +650,34 @@ static void *map_library(int fd, struct dso *dso) prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) | ((ph->p_flags&PF_W) ? PROT_WRITE: 0) | ((ph->p_flags&PF_X) ? PROT_EXEC : 0)); - if (mmap(base+this_min, this_max-this_min, prot, MAP_PRIVATE|MAP_FIXED, fd, off_start) == MAP_FAILED) + if (mmap_fixed(base+this_min, this_max-this_min, prot, MAP_PRIVATE|MAP_FIXED, fd, off_start) == MAP_FAILED) goto error; if (ph->p_memsz > ph->p_filesz) { size_t brk = (size_t)base+ph->p_vaddr+ph->p_filesz; size_t pgbrk = brk+PAGE_SIZE-1 & -PAGE_SIZE; memset((void *)brk, 0, pgbrk-brk & PAGE_SIZE-1); - if (pgbrk-(size_t)base < this_max && mmap((void *)pgbrk, (size_t)base+this_max-pgbrk, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED) + if (pgbrk-(size_t)base < this_max && mmap_fixed((void *)pgbrk, (size_t)base+this_max-pgbrk, prot, MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS, -1, 0) == MAP_FAILED) goto error; } } for (i=0; ((size_t *)(base+dyn))[i]; i+=2) if (((size_t *)(base+dyn))[i]==DT_TEXTREL) { - if (mprotect(map, map_len, PROT_READ|PROT_WRITE|PROT_EXEC) < 0) + if (mprotect(map, map_len, PROT_READ|PROT_WRITE|PROT_EXEC) + && errno != ENOSYS) goto error; break; } - dso->map = map; - dso->map_len = map_len; +done_mapping: dso->base = base; - dso->dynv = (void *)(base+dyn); - if (dso->tls_size) dso->tls_image = (void *)(base+tls_image); + dso->dynv = laddr(dso, dyn); + if (dso->tls_size) dso->tls_image = laddr(dso, tls_image); if (!runtime) reclaim_gaps(dso); free(allocated_buf); return map; noexec: errno = ENOEXEC; error: - if (map!=MAP_FAILED) munmap(map, map_len); + if (map!=MAP_FAILED) unmap_library(dso); free(allocated_buf); return 0; } @@ -565,9 +690,20 @@ static int path_open(const char *name, const char *s, char *buf, size_t buf_size s += strspn(s, ":\n"); l = strcspn(s, ":\n"); if (l-1 >= INT_MAX) return -1; - if (snprintf(buf, buf_size, "%.*s/%s", (int)l, s, name) >= buf_size) - continue; - if ((fd = open(buf, O_RDONLY|O_CLOEXEC))>=0) return fd; + if (snprintf(buf, buf_size, "%.*s/%s", (int)l, s, name) < buf_size) { + if ((fd = open(buf, O_RDONLY|O_CLOEXEC))>=0) return fd; + switch (errno) { + case ENOENT: + case ENOTDIR: + case EACCES: + case ENAMETOOLONG: + break; + default: + /* Any negative value but -1 will inhibit + * futher path search. */ + return -2; + } + } s += l; } } @@ -577,8 +713,7 @@ static int fixup_rpath(struct dso *p, char *buf, size_t buf_size) size_t n, l; const char *s, *t, *origin; char *d; - if (p->rpath) return 0; - if (!p->rpath_orig) return -1; + if (p->rpath || !p->rpath_orig) return 0; if (!strchr(p->rpath_orig, '$')) { p->rpath = p->rpath_orig; return 0; @@ -587,11 +722,11 @@ static int fixup_rpath(struct dso *p, char *buf, size_t buf_size) s = p->rpath_orig; while ((t=strchr(s, '$'))) { if (strncmp(t, "$ORIGIN", 7) && strncmp(t, "${ORIGIN}", 9)) - return -1; + return 0; s = t+1; n++; } - if (n > SSIZE_MAX/PATH_MAX) return -1; + if (n > SSIZE_MAX/PATH_MAX) return 0; if (p->kernel_mapped) { /* $ORIGIN searches cannot be performed for the main program @@ -601,10 +736,18 @@ static int fixup_rpath(struct dso *p, char *buf, size_t buf_size) * since the library's pathname came from a trusted source * (either system paths or a call to dlopen). */ if (libc.secure) - return -1; + return 0; l = readlink("/proc/self/exe", buf, buf_size); - if (l >= buf_size) + if (l == -1) switch (errno) { + case ENOENT: + case ENOTDIR: + case EACCES: + break; + default: return -1; + } + if (l >= buf_size) + return 0; buf[l] = 0; origin = buf; } else { @@ -632,18 +775,81 @@ static int fixup_rpath(struct dso *p, char *buf, size_t buf_size) static void decode_dyn(struct dso *p) { - size_t dyn[DYN_CNT] = {0}; + size_t dyn[DYN_CNT]; decode_vec(p->dynv, dyn, DYN_CNT); - p->syms = (void *)(p->base + dyn[DT_SYMTAB]); - p->strings = (void *)(p->base + dyn[DT_STRTAB]); + p->syms = laddr(p, dyn[DT_SYMTAB]); + p->strings = laddr(p, dyn[DT_STRTAB]); if (dyn[0]&(1<hashtab = (void *)(p->base + dyn[DT_HASH]); + p->hashtab = laddr(p, dyn[DT_HASH]); if (dyn[0]&(1<rpath_orig = (void *)(p->strings + dyn[DT_RPATH]); + p->rpath_orig = p->strings + dyn[DT_RPATH]; + if (dyn[0]&(1<rpath_orig = p->strings + dyn[DT_RUNPATH]; + if (dyn[0]&(1<got = laddr(p, dyn[DT_PLTGOT]); if (search_vec(p->dynv, dyn, DT_GNU_HASH)) - p->ghashtab = (void *)(p->base + *dyn); + p->ghashtab = laddr(p, *dyn); if (search_vec(p->dynv, dyn, DT_VERSYM)) - p->versym = (void *)(p->base + *dyn); + p->versym = laddr(p, *dyn); +} + +static size_t count_syms(struct dso *p) +{ + if (p->hashtab) return p->hashtab[1]; + + size_t nsym, i; + uint32_t *buckets = p->ghashtab + 4 + (p->ghashtab[2]*sizeof(size_t)/4); + uint32_t *hashval; + for (i = nsym = 0; i < p->ghashtab[0]; i++) { + if (buckets[i] > nsym) + nsym = buckets[i]; + } + if (nsym) { + hashval = buckets + p->ghashtab[0] + (nsym - p->ghashtab[1]); + do nsym++; + while (!(*hashval++ & 1)); + } + return nsym; +} + +static void *dl_mmap(size_t n) +{ + void *p; + int prot = PROT_READ|PROT_WRITE, flags = MAP_ANONYMOUS|MAP_PRIVATE; +#ifdef SYS_mmap2 + p = (void *)__syscall(SYS_mmap2, 0, n, prot, flags, -1, 0); +#else + p = (void *)__syscall(SYS_mmap, 0, n, prot, flags, -1, 0); +#endif + return p == MAP_FAILED ? 0 : p; +} + +static void makefuncdescs(struct dso *p) +{ + static int self_done; + size_t nsym = count_syms(p); + size_t i, size = nsym * sizeof(*p->funcdescs); + + if (!self_done) { + p->funcdescs = dl_mmap(size); + self_done = 1; + } else { + p->funcdescs = malloc(size); + } + if (!p->funcdescs) { + if (!runtime) a_crash(); + error("Error allocating function descriptors for %s", p->name); + longjmp(*rtld_fail, 1); + } + for (i=0; isyms[i].st_info&0xf)==STT_FUNC && p->syms[i].st_shndx) { + p->funcdescs[i].addr = laddr(p, p->syms[i].st_value); + p->funcdescs[i].got = p->got; + } else { + p->funcdescs[i].addr = 0; + p->funcdescs[i].got = 0; + } + } } static struct dso *load_library(const char *name, struct dso *needed_by) @@ -658,6 +864,11 @@ static struct dso *load_library(const char *name, struct dso *needed_by) int n_th = 0; int is_self = 0; + if (!*name) { + errno = EINVAL; + return 0; + } + /* Catch and block attempts to reload the implementation itself */ if (name[0]=='l' && name[1]=='i' && name[2]=='b') { static const char *rp, reserved[] = @@ -675,22 +886,22 @@ static struct dso *load_library(const char *name, struct dso *needed_by) if (!(reported & mask)) { reported |= mask; dprintf(1, "\t%s => %s (%p)\n", - name, ldso->name, - ldso->base); + name, ldso.name, + ldso.base); } } is_self = 1; } } } - if (!strcmp(name, ldso->name)) is_self = 1; + if (!strcmp(name, ldso.name)) is_self = 1; if (is_self) { - if (!ldso->prev) { - tail->next = ldso; - ldso->prev = tail; - tail = ldso->next ? ldso->next : ldso; + if (!ldso.prev) { + tail->next = &ldso; + ldso.prev = tail; + tail = ldso.next ? ldso.next : &ldso; } - return ldso; + return &ldso; } if (strchr(name, '/')) { pathname = name; @@ -706,20 +917,23 @@ static struct dso *load_library(const char *name, struct dso *needed_by) if (strlen(name) > NAME_MAX) return 0; fd = -1; if (env_path) fd = path_open(name, env_path, buf, sizeof buf); - for (p=needed_by; fd < 0 && p; p=p->needed_by) - if (!fixup_rpath(p, buf, sizeof buf)) + for (p=needed_by; fd == -1 && p; p=p->needed_by) { + if (fixup_rpath(p, buf, sizeof buf) < 0) + fd = -2; /* Inhibit further search. */ + if (p->rpath) fd = path_open(name, p->rpath, buf, sizeof buf); - if (fd < 0) { + } + if (fd == -1) { if (!sys_path) { char *prefix = 0; size_t prefix_len; - if (ldso->name[0]=='/') { + if (ldso.name[0]=='/') { char *s, *t, *z; - for (s=t=z=ldso->name; *s; s++) + for (s=t=z=ldso.name; *s; s++) if (*s=='/') z=t, t=s; - prefix_len = z-ldso->name; + prefix_len = z-ldso.name; if (prefix_len < PATH_MAX) - prefix = ldso->name; + prefix = ldso.name; } if (!prefix) { prefix = ""; @@ -782,7 +996,7 @@ static struct dso *load_library(const char *name, struct dso *needed_by) } p = calloc(1, alloc_size); if (!p) { - munmap(map, temp_dso.map_len); + unmap_library(&temp_dso); return 0; } memcpy(p, &temp_dso, sizeof temp_dso); @@ -796,12 +1010,6 @@ static struct dso *load_library(const char *name, struct dso *needed_by) /* 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 (runtime && !libc.has_thread_pointer) { - munmap(map, p->map_len); - free(p); - errno = ENOSYS; - return 0; - } p->tls_id = ++tls_cnt; tls_align = MAXP2(tls_align, p->tls_align); #ifdef TLS_ABOVE_TP @@ -823,6 +1031,8 @@ static struct dso *load_library(const char *name, struct dso *needed_by) p->prev = tail; tail = p; + if (DL_FDPIC) makefuncdescs(p); + if (ldd_mode) dprintf(1, "\t%s => %s (%p)\n", name, pathname, p->base); return p; @@ -839,6 +1049,7 @@ static void load_deps(struct dso *p) if (!dep) { error("Error loading shared library %s: %m (needed by %s)", p->strings + p->dynv[i+1], p->name); + if (runtime) longjmp(*rtld_fail, 1); continue; } if (runtime) { @@ -857,8 +1068,8 @@ static void load_preload(char *s) int tmp; char *z; for (z=s; *z; s=z) { - for ( ; *s && isspace(*s); s++); - for (z=s; *z && !isspace(*z); z++); + for ( ; *s && (isspace(*s) || *s==':'); s++); + for (z=s; *z && !isspace(*z) && *z!=':'; z++); tmp = *z; *z = 0; load_library(s, 0); @@ -871,24 +1082,45 @@ static void make_global(struct dso *p) for (; p; p=p->next) p->global = 1; } +static void do_mips_relocs(struct dso *p, size_t *got) +{ + size_t i, j, rel[2]; + unsigned char *base = p->base; + i=0; search_vec(p->dynv, &i, DT_MIPS_LOCAL_GOTNO); + if (p==&ldso) { + got += i; + } else { + while (i--) *got++ += (size_t)base; + } + j=0; search_vec(p->dynv, &j, DT_MIPS_GOTSYM); + i=0; search_vec(p->dynv, &i, DT_MIPS_SYMTABNO); + Sym *sym = p->syms + j; + rel[0] = (unsigned char *)got - base; + for (i-=j; i; i--, sym++, rel[0]+=sizeof(size_t)) { + rel[1] = sym-p->syms << 8 | R_MIPS_JUMP_SLOT; + do_relocs(p, rel, sizeof rel, 2); + } +} + static void reloc_all(struct dso *p) { - size_t dyn[DYN_CNT] = {0}; + size_t dyn[DYN_CNT]; for (; p; p=p->next) { if (p->relocated) continue; decode_vec(p->dynv, dyn, DYN_CNT); -#ifdef NEED_ARCH_RELOCS - do_arch_relocs(p, head); -#endif - do_relocs(p, (void *)(p->base+dyn[DT_JMPREL]), dyn[DT_PLTRELSZ], + if (NEED_MIPS_GOT_RELOCS) + do_mips_relocs(p, laddr(p, dyn[DT_PLTGOT])); + do_relocs(p, laddr(p, dyn[DT_JMPREL]), dyn[DT_PLTRELSZ], 2+(dyn[DT_PLTREL]==DT_RELA)); - do_relocs(p, (void *)(p->base+dyn[DT_REL]), dyn[DT_RELSZ], 2); - do_relocs(p, (void *)(p->base+dyn[DT_RELA]), dyn[DT_RELASZ], 3); + do_relocs(p, laddr(p, dyn[DT_REL]), dyn[DT_RELSZ], 2); + do_relocs(p, laddr(p, dyn[DT_RELA]), dyn[DT_RELASZ], 3); - if (p->relro_start != p->relro_end && - mprotect(p->base+p->relro_start, p->relro_end-p->relro_start, PROT_READ) < 0) { + if (head != &ldso && p->relro_start != p->relro_end && + mprotect(laddr(p, p->relro_start), p->relro_end-p->relro_start, PROT_READ) + && errno != ENOSYS) { error("Error relocating %s: RELRO protection failed: %m", p->name); + if (runtime) longjmp(*rtld_fail, 1); } p->relocated = 1; @@ -901,7 +1133,7 @@ static void kernel_mapped_dso(struct dso *p) Phdr *ph = p->phdr; for (cnt = p->phnum; cnt--; ph = (void *)((char *)ph + p->phentsize)) { if (ph->p_type == PT_DYNAMIC) { - p->dynv = (void *)(p->base + ph->p_vaddr); + p->dynv = laddr(p, ph->p_vaddr); } else if (ph->p_type == PT_GNU_RELRO) { p->relro_start = ph->p_vaddr & -PAGE_SIZE; p->relro_end = (ph->p_vaddr + ph->p_memsz) & -PAGE_SIZE; @@ -922,25 +1154,25 @@ static void kernel_mapped_dso(struct dso *p) static void do_fini() { struct dso *p; - size_t dyn[DYN_CNT] = {0}; + size_t dyn[DYN_CNT]; for (p=fini_head; p; p=p->fini_next) { if (!p->constructed) continue; decode_vec(p->dynv, dyn, DYN_CNT); if (dyn[0] & (1<base + dyn[DT_FINI_ARRAY])+n; + size_t *fn = (size_t *)laddr(p, dyn[DT_FINI_ARRAY])+n; while (n--) ((void (*)(void))*--fn)(); } #ifndef NO_LEGACY_INITFINI if ((dyn[0] & (1<base + dyn[DT_FINI]))(); + fpaddr(p, dyn[DT_FINI])(); #endif } } static void do_init_fini(struct dso *p) { - size_t dyn[DYN_CNT] = {0}; + size_t dyn[DYN_CNT]; 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 @@ -956,11 +1188,11 @@ static void do_init_fini(struct dso *p) } #ifndef NO_LEGACY_INITFINI if ((dyn[0] & (1<base + dyn[DT_INIT]))(); + fpaddr(p, dyn[DT_INIT])(); #endif if (dyn[0] & (1<base + dyn[DT_INIT_ARRAY]); + size_t *fn = laddr(p, dyn[DT_INIT_ARRAY]); while (n--) ((void (*)(void))*fn++)(); } if (!need_locking && libc.threads_minus_1) { @@ -971,10 +1203,17 @@ static void do_init_fini(struct dso *p) if (need_locking) pthread_mutex_unlock(&init_fini_lock); } -void _dl_debug_state(void) +void __libc_start_init(void) +{ + do_init_fini(tail); +} + +static void dl_debug_state(void) { } +weak_alias(dl_debug_state, _dl_debug_state); + void __reset_tls() { pthread_t self = __pthread_self(); @@ -992,17 +1231,11 @@ void *__copy_tls(unsigned char *mem) { pthread_t td; struct dso *p; - - void **dtv = (void *)mem; - dtv[0] = (void *)tls_cnt; - if (!tls_cnt) { - td = (void *)(dtv+1); - td->dtv = dtv; - return td; - } + void **dtv; #ifdef TLS_ABOVE_TP - mem += sizeof(void *) * (tls_cnt+1); + dtv = (void **)(mem + libc.tls_size) - (tls_cnt + 1); + mem += -((uintptr_t)mem + sizeof(struct pthread)) & (tls_align-1); td = (pthread_t)mem; mem += sizeof(struct pthread); @@ -1013,6 +1246,8 @@ void *__copy_tls(unsigned char *mem) memcpy(dtv[p->tls_id], p->tls_image, p->tls_len); } #else + dtv = (void **)mem; + mem += libc.tls_size - sizeof(struct pthread); mem -= (uintptr_t)mem & (tls_align-1); td = (pthread_t)mem; @@ -1023,10 +1258,12 @@ void *__copy_tls(unsigned char *mem) memcpy(dtv[p->tls_id], p->tls_image, p->tls_len); } #endif - td->dtv = dtv; + dtv[0] = (void *)tls_cnt; + td->dtv = td->dtv_copy = dtv; return td; } +__attribute__((__visibility__("hidden"))) void *__tls_get_new(size_t *v) { pthread_t self = __pthread_self(); @@ -1036,7 +1273,7 @@ void *__tls_get_new(size_t *v) __block_all_sigs(&set); if (v[0]<=(size_t)self->dtv[0]) { __restore_sigs(&set); - return (char *)self->dtv[v[0]]+v[1]; + return (char *)self->dtv[v[0]]+v[1]+DTP_OFFSET; } /* This is safe without any locks held because, if the caller @@ -1053,7 +1290,7 @@ void *__tls_get_new(size_t *v) memcpy(newdtv, self->dtv, ((size_t)self->dtv[0]+1) * sizeof(void *)); newdtv[0] = (void *)v[0]; - self->dtv = newdtv; + self->dtv = self->dtv_copy = newdtv; } /* Get new TLS memory from all new DSOs up to the requested one */ @@ -1069,7 +1306,7 @@ void *__tls_get_new(size_t *v) if (p->tls_id == v[0]) break; } __restore_sigs(&set); - return mem + v[1]; + return mem + v[1] + DTP_OFFSET; } static void update_tls_size() @@ -1082,95 +1319,154 @@ static void update_tls_size() tls_align); } -void *__dynlink(int argc, char **argv) +/* Stage 1 of the dynamic linker is defined in dlstart.c. It calls the + * following stage 2 and stage 3 functions via primitive symbolic lookup + * since it does not have access to their addresses to begin with. */ + +/* Stage 2 of the dynamic linker is called after relative relocations + * have been processed. It can make function calls to static functions + * and access string literals and static data, but cannot use extern + * symbols. Its job is to perform symbolic relocations on the dynamic + * linker itself, but some of the relocations performed may need to be + * replaced later due to copy relocations in the main program. */ + +void __dls2(unsigned char *base, size_t *sp) { - size_t aux[AUX_CNT] = {0}; + if (DL_FDPIC) { + void *p1 = (void *)sp[-2]; + void *p2 = (void *)sp[-1]; + if (!p1) { + size_t *auxv, aux[AUX_CNT]; + for (auxv=sp+1+*sp+1; *auxv; auxv++); auxv++; + decode_vec(auxv, aux, AUX_CNT); + if (aux[AT_BASE]) ldso.base = (void *)aux[AT_BASE]; + else ldso.base = (void *)(aux[AT_PHDR] & -4096); + } + app_loadmap = p2 ? p1 : 0; + ldso.loadmap = p2 ? p2 : p1; + ldso.base = laddr(&ldso, 0); + } else { + ldso.base = base; + } + Ehdr *ehdr = (void *)ldso.base; + ldso.name = ldso.shortname = "libc.so"; + ldso.global = 1; + ldso.phnum = ehdr->e_phnum; + ldso.phdr = laddr(&ldso, ehdr->e_phoff); + ldso.phentsize = ehdr->e_phentsize; + kernel_mapped_dso(&ldso); + decode_dyn(&ldso); + + if (DL_FDPIC) makefuncdescs(&ldso); + + /* Prepare storage for to save clobbered REL addends so they + * can be reused in stage 3. There should be very few. If + * something goes wrong and there are a huge number, abort + * instead of risking stack overflow. */ + size_t dyn[DYN_CNT]; + decode_vec(ldso.dynv, dyn, DYN_CNT); + size_t *rel = laddr(&ldso, dyn[DT_REL]); + size_t rel_size = dyn[DT_RELSZ]; + size_t symbolic_rel_cnt = 0; + apply_addends_to = rel; + for (; rel_size; rel+=2, rel_size-=2*sizeof(size_t)) + if (!IS_RELATIVE(rel[1], ldso.syms)) symbolic_rel_cnt++; + if (symbolic_rel_cnt >= ADDEND_LIMIT) a_crash(); + size_t addends[symbolic_rel_cnt+1]; + saved_addends = addends; + + head = &ldso; + reloc_all(&ldso); + + ldso.relocated = 0; + + /* Call dynamic linker stage-3, __dls3, looking it up + * symbolically as a barrier against moving the address + * load across the above relocation processing. */ + struct symdef dls3_def = find_sym(&ldso, "__dls3", 0); + if (DL_FDPIC) ((stage3_func)&ldso.funcdescs[dls3_def.sym-ldso.syms])(sp); + else ((stage3_func)laddr(&ldso, dls3_def.sym->st_value))(sp); +} + +/* Stage 3 of the dynamic linker is called with the dynamic linker/libc + * fully functional. Its job is to load (if not already loaded) and + * process dependencies and relocations for the main application and + * transfer control to its entry point. */ + +_Noreturn void __dls3(size_t *sp) +{ + static struct dso app, vdso; + size_t aux[AUX_CNT], *auxv; size_t i; - Phdr *phdr; - Ehdr *ehdr; - static struct dso builtin_dsos[3]; - struct dso *const app = builtin_dsos+0; - struct dso *const lib = builtin_dsos+1; - struct dso *const vdso = builtin_dsos+2; char *env_preload=0; size_t vdso_base; - size_t *auxv; + int argc = *sp; + char **argv = (void *)(sp+1); + char **argv_orig = argv; char **envp = argv+argc+1; - void *initial_tls; - - /* Find aux vector just past environ[] */ - for (i=argc+1; argv[i]; i++) - if (!memcmp(argv[i], "LD_LIBRARY_PATH=", 16)) - env_path = argv[i]+16; - else if (!memcmp(argv[i], "LD_PRELOAD=", 11)) - env_preload = argv[i]+11; - auxv = (void *)(argv+i+1); + /* Find aux vector just past environ[] and use it to initialize + * global data that may be needed before we can make syscalls. */ + __environ = envp; + for (i=argc+1; argv[i]; i++); + libc.auxv = auxv = (void *)(argv+i+1); decode_vec(auxv, aux, AUX_CNT); + __hwcap = aux[AT_HWCAP]; + libc.page_size = aux[AT_PAGESZ]; + libc.secure = ((aux[0]&0x7800)!=0x7800 || aux[AT_UID]!=aux[AT_EUID] + || aux[AT_GID]!=aux[AT_EGID] || aux[AT_SECURE]); + + /* Setup early thread pointer in builtin_tls for ldso/libc itself to + * use during dynamic linking. If possible it will also serve as the + * thread pointer at runtime. */ + libc.tls_size = sizeof builtin_tls; + if (__init_tp(__copy_tls((void *)builtin_tls)) < 0) { + a_crash(); + } /* Only trust user/env if kernel says we're not suid/sgid */ - if ((aux[0]&0x7800)!=0x7800 || aux[AT_UID]!=aux[AT_EUID] - || aux[AT_GID]!=aux[AT_EGID] || aux[AT_SECURE]) { - env_path = 0; - env_preload = 0; - libc.secure = 1; + if (!libc.secure) { + env_path = getenv("LD_LIBRARY_PATH"); + env_preload = getenv("LD_PRELOAD"); } - libc.page_size = aux[AT_PAGESZ]; - /* If the dynamic linker was invoked as a program itself, AT_BASE - * will not be set. In that case, we assume the base address is - * the start of the page containing the PHDRs; I don't know any - * better approach... */ - if (!aux[AT_BASE]) { - aux[AT_BASE] = aux[AT_PHDR] & -PAGE_SIZE; - aux[AT_PHDR] = aux[AT_PHENT] = aux[AT_PHNUM] = 0; - } - - /* The dynamic linker load address is passed by the kernel - * in the AUX vector, so this is easy. */ - lib->base = (void *)aux[AT_BASE]; - lib->name = lib->shortname = "libc.so"; - lib->global = 1; - ehdr = (void *)lib->base; - lib->phnum = ehdr->e_phnum; - lib->phdr = (void *)(aux[AT_BASE]+ehdr->e_phoff); - lib->phentsize = ehdr->e_phentsize; - kernel_mapped_dso(lib); - decode_dyn(lib); - - if (aux[AT_PHDR]) { + /* If the main program was already loaded by the kernel, + * AT_PHDR will point to some location other than the dynamic + * linker's program headers. */ + if (aux[AT_PHDR] != (size_t)ldso.phdr) { size_t interp_off = 0; size_t tls_image = 0; /* Find load address of the main program, via AT_PHDR vs PT_PHDR. */ - app->phdr = phdr = (void *)aux[AT_PHDR]; - app->phnum = aux[AT_PHNUM]; - app->phentsize = aux[AT_PHENT]; + Phdr *phdr = app.phdr = (void *)aux[AT_PHDR]; + app.phnum = aux[AT_PHNUM]; + app.phentsize = aux[AT_PHENT]; 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); + app.base = (void *)(aux[AT_PHDR] - phdr->p_vaddr); else if (phdr->p_type == PT_INTERP) interp_off = (size_t)phdr->p_vaddr; else if (phdr->p_type == PT_TLS) { tls_image = phdr->p_vaddr; - app->tls_len = phdr->p_filesz; - app->tls_size = phdr->p_memsz; - app->tls_align = phdr->p_align; + app.tls_len = phdr->p_filesz; + app.tls_size = phdr->p_memsz; + app.tls_align = phdr->p_align; } } - if (app->tls_size) app->tls_image = (char *)app->base + tls_image; - if (interp_off) lib->name = (char *)app->base + interp_off; + if (DL_FDPIC) app.loadmap = app_loadmap; + if (app.tls_size) app.tls_image = laddr(&app, tls_image); + if (interp_off) ldso.name = laddr(&app, interp_off); if ((aux[0] & (1UL<name = (char *)aux[AT_EXECFN]; + app.name = (char *)aux[AT_EXECFN]; else - app->name = argv[0]; - kernel_mapped_dso(app); + app.name = argv[0]; + kernel_mapped_dso(&app); } else { int fd; char *ldname = argv[0]; size_t l = strlen(ldname); if (l >= 3 && !strcmp(ldname+l-3, "ldd")) ldd_mode = 1; - *argv++ = (void *)-1; + argv++; while (argv[0] && argv[0][0]=='-' && argv[0][1]=='-') { char *opt = argv[0]+2; *argv++ = (void *)-1; @@ -1189,8 +1485,8 @@ void *__dynlink(int argc, char **argv) } else { argv[0] = 0; } - argv[-1] = (void *)-1; } + argv[-1] = (void *)(argc - (argv-argv_orig)); if (!argv[0]) { dprintf(2, "musl libc\n" "Version %s\n" @@ -1206,111 +1502,120 @@ void *__dynlink(int argc, char **argv) _exit(1); } runtime = 1; - ehdr = (void *)map_library(fd, app); + Ehdr *ehdr = (void *)map_library(fd, &app); if (!ehdr) { dprintf(2, "%s: %s: Not a valid dynamic program\n", ldname, argv[0]); _exit(1); } runtime = 0; close(fd); - lib->name = ldname; - app->name = argv[0]; - aux[AT_ENTRY] = (size_t)app->base + ehdr->e_entry; + ldso.name = ldname; + app.name = argv[0]; + aux[AT_ENTRY] = (size_t)laddr(&app, ehdr->e_entry); /* Find the name that would have been used for the dynamic * linker had ldd not taken its place. */ if (ldd_mode) { - for (i=0; iphnum; i++) { - if (app->phdr[i].p_type == PT_INTERP) - lib->name = (void *)(app->base - + app->phdr[i].p_vaddr); + for (i=0; iname, lib->base); + dprintf(1, "\t%s (%p)\n", ldso.name, ldso.base); } } - if (app->tls_size) { - app->tls_id = tls_cnt = 1; + if (app.tls_size) { + app.tls_id = tls_cnt = 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) ); + 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) ); + 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); + tls_align = MAXP2(tls_align, app.tls_align); + } + app.global = 1; + decode_dyn(&app); + if (DL_FDPIC) { + makefuncdescs(&app); + if (!app.loadmap) { + app.loadmap = (void *)&app_dummy_loadmap; + app.loadmap->nsegs = 1; + app.loadmap->segs[0].addr = (size_t)app.map; + app.loadmap->segs[0].p_vaddr = (size_t)app.map + - (size_t)app.base; + app.loadmap->segs[0].p_memsz = app.map_len; + } + argv[-3] = (void *)app.loadmap; } - app->global = 1; - decode_dyn(app); /* Attach to vdso, if provided by the kernel */ if (search_vec(auxv, &vdso_base, AT_SYSINFO_EHDR)) { - ehdr = (void *)vdso_base; - vdso->phdr = phdr = (void *)(vdso_base + ehdr->e_phoff); - vdso->phnum = ehdr->e_phnum; - vdso->phentsize = ehdr->e_phentsize; + Ehdr *ehdr = (void *)vdso_base; + Phdr *phdr = vdso.phdr = (void *)(vdso_base + ehdr->e_phoff); + vdso.phnum = ehdr->e_phnum; + vdso.phentsize = ehdr->e_phentsize; 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); + 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.base = (void *)(vdso_base - phdr->p_vaddr + phdr->p_offset); } - vdso->name = ""; - vdso->shortname = "linux-gate.so.1"; - vdso->global = 1; - decode_dyn(vdso); - vdso->prev = lib; - lib->next = vdso; - } - - /* Initial dso chain consists only of the app. We temporarily - * append the dynamic linker/libc so we can relocate it, then - * restore the initial chain in preparation for loading third - * party libraries (preload/needed). */ - head = tail = app; - ldso = lib; - app->next = lib; - reloc_all(lib); - app->next = 0; - - /* PAST THIS POINT, ALL LIBC INTERFACES ARE FULLY USABLE. */ + vdso.name = ""; + vdso.shortname = "linux-gate.so.1"; + vdso.global = 1; + vdso.relocated = 1; + decode_dyn(&vdso); + vdso.prev = &ldso; + ldso.next = &vdso; + } + + /* Initial dso chain consists only of the app. */ + head = tail = &app; /* Donate unused parts of app and library mapping to malloc */ - reclaim_gaps(app); - reclaim_gaps(lib); + reclaim_gaps(&app); + reclaim_gaps(&ldso); /* Load preload/needed libraries, add their symbols to the global - * namespace, and perform all remaining relocations. The main - * program must be relocated LAST since it may contain copy - * relocations which depend on libraries' relocations. */ + * namespace, and perform all remaining relocations. */ if (env_preload) load_preload(env_preload); - load_deps(app); - make_global(app); + load_deps(&app); + make_global(&app); #ifndef DYNAMIC_IS_RO - for (i=0; app->dynv[i]; i+=2) - if (app->dynv[i]==DT_DEBUG) - app->dynv[i+1] = (size_t)&debug; + for (i=0; app.dynv[i]; i+=2) + if (app.dynv[i]==DT_DEBUG) + app.dynv[i+1] = (size_t)&debug; #endif - reloc_all(app->next); - reloc_all(app); + /* The main program must be relocated LAST since it may contin + * copy relocations which depend on libraries' relocations. */ + reloc_all(app.next); + reloc_all(&app); update_tls_size(); - if (libc.tls_size > sizeof builtin_tls) { - initial_tls = calloc(libc.tls_size, 1); + if (libc.tls_size > sizeof builtin_tls || tls_align > MIN_TLS_ALIGN) { + void *initial_tls = calloc(libc.tls_size, 1); if (!initial_tls) { dprintf(2, "%s: Error getting %zu bytes thread-local storage: %m\n", argv[0], libc.tls_size); _exit(127); } + if (__init_tp(__copy_tls(initial_tls)) < 0) { + a_crash(); + } } else { - initial_tls = builtin_tls; - } - if (__init_tp(__copy_tls(initial_tls)) < 0 && tls_cnt) { - dprintf(2, "%s: Thread-local storage not supported by kernel.\n", argv[0]); - _exit(127); + size_t tmp_tls_size = libc.tls_size; + pthread_t self = __pthread_self(); + /* Temporarily set the tls size to the full size of + * builtin_tls so that __copy_tls will use the same layout + * as it did for before. Then check, just to be safe. */ + libc.tls_size = sizeof builtin_tls; + if (__copy_tls((void*)builtin_tls) != self) a_crash(); + libc.tls_size = tmp_tls_size; } static_tls_cnt = tls_cnt; @@ -1319,23 +1624,22 @@ void *__dynlink(int argc, char **argv) /* Switch to runtime mode: any further failures in the dynamic * linker are a reportable failure rather than a fatal startup - * error. If the dynamic loader (dlopen) will not be used, free - * all memory used by the dynamic linker. */ + * error. */ runtime = 1; debug.ver = 1; - debug.bp = _dl_debug_state; + debug.bp = dl_debug_state; debug.head = head; - debug.base = lib->base; + debug.base = ldso.base; debug.state = 0; _dl_debug_state(); __init_libc(envp, argv[0]); atexit(do_fini); errno = 0; - do_init_fini(tail); - return (void *)aux[AT_ENTRY]; + CRTJMP((void *)aux[AT_ENTRY], argv-1); + for(;;); } void *dlopen(const char *file, int mode) @@ -1367,13 +1671,16 @@ void *dlopen(const char *file, int mode) p->deps[i]->global = 0; for (p=orig_tail->next; p; p=next) { next = p->next; - munmap(p->map, p->map_len); while (p->td_index) { void *tmp = p->td_index->next; free(p->td_index); p->td_index = tmp; } + free(p->funcdescs); + if (p->rpath != p->rpath_orig) + free(p->rpath); free(p->deps); + unmap_library(p); free(p); } tls_cnt = orig_tls_cnt; @@ -1382,16 +1689,14 @@ void *dlopen(const char *file, int mode) tail = orig_tail; tail->next = 0; p = 0; - errflag = 1; goto end; } else p = load_library(file, head); if (!p) { - snprintf(errbuf, sizeof errbuf, noload ? + error(noload ? "Library %s is not already loaded" : "Error loading shared library %s: %m", file); - errflag = 1; goto end; } @@ -1431,23 +1736,44 @@ 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; + error("Invalid library handle %p", (void *)h); return 1; } +static void *addr2dso(size_t a) +{ + struct dso *p; + for (p=head; p; p=p->next) { + if (DL_FDPIC && p->loadmap) { + size_t i; + for (i=0; iloadmap->nsegs; i++) { + if (a-p->loadmap->segs[i].p_vaddr + < p->loadmap->segs[i].p_memsz) + return p; + } + i = count_syms(p); + if (a-(size_t)p->funcdescs < i*sizeof(*p->funcdescs)) + return p; + } else { + if (a-(size_t)p->map < p->map_len) + return p; + } + } + return 0; +} + void *__tls_get_addr(size_t *); static void *do_dlsym(struct dso *p, const char *s, void *ra) { size_t i; - uint32_t h = 0, gh = 0; + uint32_t h = 0, gh = 0, *ght; Sym *sym; if (p == head || p == RTLD_DEFAULT || 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); + p = addr2dso((size_t)ra); if (!p) p=head; p = p->next; } @@ -1455,37 +1781,42 @@ static void *do_dlsym(struct dso *p, const char *s, void *ra) 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 (DL_FDPIC && (def.sym->st_info&0xf) == STT_FUNC) + return def.dso->funcdescs + (def.sym - def.dso->syms); + return laddr(def.dso, def.sym->st_value); } - if (p != RTLD_DEFAULT && p != RTLD_NEXT && invalid_dso_handle(p)) + if (invalid_dso_handle(p)) return 0; - if (p->ghashtab) { + if ((ght = p->ghashtab)) { gh = gnu_hash(s); - sym = gnu_lookup(s, gh, p); + sym = gnu_lookup(gh, ght, p, s); } else { 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 (DL_FDPIC && sym && sym->st_shndx && (sym->st_info&0xf) == STT_FUNC) + return p->funcdescs + (sym - p->syms); if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES)) - return p->base + sym->st_value; + return laddr(p, sym->st_value); if (p->deps) for (i=0; p->deps[i]; i++) { - if (p->deps[i]->ghashtab) { + if ((ght = p->deps[i]->ghashtab)) { if (!gh) gh = gnu_hash(s); - sym = gnu_lookup(s, gh, p->deps[i]); + sym = gnu_lookup(gh, ght, p->deps[i], s); } else { 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 (DL_FDPIC && sym && sym->st_shndx && (sym->st_info&0xf) == STT_FUNC) + return p->deps[i]->funcdescs + (sym - p->deps[i]->syms); if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES)) - return p->deps[i]->base + sym->st_value; + return laddr(p->deps[i], sym->st_value); } failed: - errflag = 1; - snprintf(errbuf, sizeof errbuf, "Symbol not found: %s", s); + error("Symbol not found: %s", s); return 0; } @@ -1495,42 +1826,24 @@ int __dladdr(const void *addr, Dl_info *info) Sym *sym; uint32_t nsym; char *strings; - size_t i; void *best = 0; char *bestname; pthread_rwlock_rdlock(&lock); - for (p=head; p && (unsigned char *)addr-p->map>p->map_len; p=p->next); + p = addr2dso((size_t)addr); pthread_rwlock_unlock(&lock); if (!p) return 0; sym = p->syms; strings = p->strings; - if (p->hashtab) { - nsym = p->hashtab[1]; - } else { - uint32_t *buckets; - uint32_t *hashval; - buckets = p->ghashtab + 4 + (p->ghashtab[2]*sizeof(size_t)/4); - sym += p->ghashtab[1]; - for (i = nsym = 0; i < p->ghashtab[0]; i++) { - if (buckets[i] > nsym) - nsym = buckets[i]; - } - if (nsym) { - nsym -= p->ghashtab[1]; - hashval = buckets + p->ghashtab[0] + nsym; - do nsym++; - while (!(*hashval++ & 1)); - } - } + nsym = count_syms(p); for (; nsym; nsym--, sym++) { 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; + void *symaddr = laddr(p, sym->st_value); if (symaddr > addr || symaddr < best) continue; best = symaddr; @@ -1550,6 +1863,7 @@ int __dladdr(const void *addr, Dl_info *info) return 1; } +__attribute__((__visibility__("hidden"))) void *__dlsym(void *restrict p, const char *restrict s, void *restrict ra) { void *res; @@ -1587,16 +1901,17 @@ int dl_iterate_phdr(int(*callback)(struct dl_phdr_info *info, size_t size, void #else static int invalid_dso_handle(void *h) { - snprintf(errbuf, sizeof errbuf, "Invalid library handle %p", (void *)h); - errflag = 1; + error("Invalid library handle %p", (void *)h); return 1; } void *dlopen(const char *file, int mode) { + error("Dynamic loading not supported"); return 0; } void *__dlsym(void *restrict p, const char *restrict s, void *restrict ra) { + error("Symbol not found: %s", s); return 0; } int __dladdr (const void *addr, Dl_info *info) @@ -1609,8 +1924,7 @@ int __dlinfo(void *dso, int req, void *res) { if (invalid_dso_handle(dso)) return -1; if (req != RTLD_DI_LINKMAP) { - snprintf(errbuf, sizeof errbuf, "Unsupported request %d", req); - errflag = 1; + error("Unsupported request %d", req); return -1; } *(struct link_map **)res = dso; @@ -1619,12 +1933,54 @@ int __dlinfo(void *dso, int req, void *res) char *dlerror() { - if (!errflag) return 0; - errflag = 0; - return errbuf; + pthread_t self = __pthread_self(); + if (!self->dlerror_flag) return 0; + self->dlerror_flag = 0; + char *s = self->dlerror_buf; + if (s == (void *)-1) + return "Dynamic linker failed to allocate memory for error message"; + else + return s; } int dlclose(void *p) { return invalid_dso_handle(p); } + +void __dl_thread_cleanup(void) +{ + pthread_t self = __pthread_self(); + if (self->dlerror_buf != (void *)-1) + free(self->dlerror_buf); +} + +static void error(const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); +#ifdef SHARED + if (!runtime) { + vdprintf(2, fmt, ap); + dprintf(2, "\n"); + ldso_fail = 1; + va_end(ap); + return; + } +#endif + pthread_t self = __pthread_self(); + if (self->dlerror_buf != (void *)-1) + free(self->dlerror_buf); + size_t len = vsnprintf(0, 0, fmt, ap); + va_end(ap); + char *buf = malloc(len+1); + if (buf) { + va_start(ap, fmt); + vsnprintf(buf, len+1, fmt, ap); + va_end(ap); + } else { + buf = (void *)-1; + } + self->dlerror_buf = buf; + self->dlerror_flag = 1; +}