X-Git-Url: http://nsz.repo.hu/git/?p=musl;a=blobdiff_plain;f=src%2Fldso%2Fdynlink.c;h=b51ae77fecb4ab825b6a45f8af9cad7e01a7afff;hp=fc06685f5995b4b6f57b2fe3c508d28f6ba113c1;hb=58aa5f45ed3282751ae118c107ff008d4df765dc;hpb=191ebcac31ceb27664790a70a36ff4602e12d9d0 diff --git a/src/ldso/dynlink.c b/src/ldso/dynlink.c index fc06685f..b51ae77f 100644 --- a/src/ldso/dynlink.c +++ b/src/ldso/dynlink.c @@ -14,8 +14,14 @@ #include #include #include +#include #include +static int errflag; +static char errbuf[128]; + +#ifdef __PIC__ + #include "reloc.h" #if ULONG_MAX == 0xffffffff @@ -32,34 +38,49 @@ typedef Elf64_Sym Sym; #define R_SYM(x) ((x)>>32) #endif -struct dso -{ +struct debug { + int ver; + void *head; + void (*bp)(void); + int state; + void *base; +}; + +struct dso { + unsigned char *base; + char *name; + size_t *dynv; struct dso *next, *prev; + int refcnt; - size_t *dynv; Sym *syms; uint32_t *hashtab; char *strings; - unsigned char *base; unsigned char *map; size_t map_len; dev_t dev; ino_t ino; - int global; - int relocated; + char global; + char relocated; + char constructed; struct dso **deps; - char *name; char buf[]; }; +void __init_ssp(size_t *); + static struct dso *head, *tail, *libc; static char *env_path, *sys_path, *r_path; static int rtld_used; +static int ssp_used; static int runtime; static jmp_buf rtld_fail; static pthread_rwlock_t lock; +static struct debug debug; + +struct debug *_dl_debug_addr = &debug; -#define AUX_CNT 15 +#define AUX_CNT 24 #define DYN_CNT 34 static void decode_vec(size_t *v, size_t *a, size_t cnt) @@ -71,8 +92,9 @@ static void decode_vec(size_t *v, size_t *a, size_t cnt) } } -static uint32_t hash(const char *s) +static uint32_t hash(const char *s0) { + const unsigned char *s = (void *)s0; uint_fast32_t h = 0; while (*s) { h = 16*h + *s++; @@ -92,21 +114,28 @@ static Sym *lookup(const char *s, uint32_t h, Sym *syms, uint32_t *hashtab, char } #define OK_TYPES (1<next) { Sym *sym; if (!dso->global) continue; sym = lookup(s, h, dso->syms, dso->hashtab, dso->strings); if (sym && (!need_def || sym->st_shndx) && sym->st_value - && (1<<(sym->st_info&0xf) & OK_TYPES)) - return dso->base + sym->st_value; + && (1<<(sym->st_info&0xf) & OK_TYPES) + && (1<<(sym->st_info>>4) & OK_BINDS)) { + if (def && sym->st_info>>4 == STB_WEAK) continue; + def = dso->base + sym->st_value; + if (sym->st_info>>4 == STB_GLOBAL) break; + } } - return 0; + return def; } static void do_relocs(unsigned char *base, size_t *rel, size_t rel_size, size_t stride, Sym *syms, char *strings, struct dso *dso) @@ -129,8 +158,11 @@ static void do_relocs(unsigned char *base, size_t *rel, size_t rel_size, size_t ctx = IS_COPY(type) ? dso->next : dso; sym_val = (size_t)find_sym(ctx, name, IS_PLT(type)); if (!sym_val && sym->st_info>>4 != STB_WEAK) { + snprintf(errbuf, sizeof errbuf, + "Error relocating %s: %s: symbol not found", + dso->name, name); if (runtime) longjmp(rtld_fail, 1); - dprintf(2, "%s: symbol not found\n", name); + dprintf(2, "%s\n", errbuf); _exit(127); } sym_size = sym->st_size; @@ -277,12 +309,20 @@ static int path_open(const char *name, const char *search) } } +static void decode_dyn(struct dso *p) +{ + size_t dyn[DYN_CNT] = {0}; + decode_vec(p->dynv, dyn, DYN_CNT); + p->syms = (void *)(p->base + dyn[DT_SYMTAB]); + p->hashtab = (void *)(p->base + dyn[DT_HASH]); + p->strings = (void *)(p->base + dyn[DT_STRTAB]); +} + static struct dso *load_library(const char *name) { unsigned char *base, *map; size_t dyno, map_len; struct dso *p; - size_t dyn[DYN_CNT] = {0}; int fd; struct stat st; @@ -298,7 +338,7 @@ static struct dso *load_library(const char *name) if (!libc->prev) { tail->next = libc; libc->prev = tail; - tail = libc; + tail = libc->next ? libc->next : libc; } return libc; } @@ -356,11 +396,8 @@ static struct dso *load_library(const char *name) p->map_len = map_len; p->base = base; p->dynv = (void *)(base + dyno); - decode_vec(p->dynv, dyn, DYN_CNT); + decode_dyn(p); - p->syms = (void *)(base + dyn[DT_SYMTAB]); - p->hashtab = (void *)(base + dyn[DT_HASH]); - p->strings = (void *)(base + dyn[DT_STRTAB]); p->dev = st.st_dev; p->ino = st.st_ino; p->refcnt = 1; @@ -387,9 +424,11 @@ static void load_deps(struct dso *p) if (p->dynv[i] != DT_NEEDED) continue; dep = load_library(p->strings + p->dynv[i+1]); if (!dep) { - if (runtime) longjmp(rtld_fail, 1); - dprintf(2, "%s: %m (needed by %s)\n", + snprintf(errbuf, sizeof errbuf, + "Error loading shared library %s: %m (needed by %s)", p->strings + p->dynv[i+1], p->name); + if (runtime) longjmp(rtld_fail, 1); + dprintf(2, "%s\n", errbuf); _exit(127); } if (runtime) { @@ -404,6 +443,20 @@ static void load_deps(struct dso *p) } } +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++); + tmp = *z; + *z = 0; + load_library(s); + *z = tmp; + } +} + static void make_global(struct dso *p) { for (; p; p=p->next) p->global = 1; @@ -435,99 +488,158 @@ static void free_all(struct dso *p) } } -void *__dynlink(int argc, char **argv, size_t *got) +static size_t find_dyn(Phdr *ph, size_t cnt, size_t stride) +{ + for (; cnt--; ph = (void *)((char *)ph + stride)) + if (ph->p_type == PT_DYNAMIC) + return ph->p_vaddr; + return 0; +} + +static void do_init_fini(struct dso *p) +{ + size_t dyn[DYN_CNT] = {0}; + for (; p; p=p->prev) { + if (p->constructed) return; + decode_vec(p->dynv, dyn, DYN_CNT); + if (dyn[0] & (1<base + dyn[DT_FINI])); + if (dyn[0] & (1<base + dyn[DT_INIT]))(); + p->constructed = 1; + } +} + +void _dl_debug_state(void) +{ +} + +void *__dynlink(int argc, char **argv) { size_t *auxv, aux[AUX_CNT] = {0}; - size_t app_dyn[DYN_CNT] = {0}; - size_t lib_dyn[DYN_CNT] = {0}; size_t i; Phdr *phdr; Ehdr *ehdr; - struct dso lib, app; + 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; /* 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); decode_vec(auxv, aux, AUX_CNT); /* 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_GID]!=aux[AT_EGID] || aux[AT_SECURE]) { env_path = 0; + env_preload = 0; } - /* Relocate ldso's DYNAMIC pointer and load vector */ - decode_vec((void *)(got[0] += aux[AT_BASE]), lib_dyn, DYN_CNT); - - /* Find the program image's DYNAMIC section and decode it */ + /* 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 = "libc.so"; + lib->global = 1; + ehdr = (void *)lib->base; + lib->dynv = (void *)(lib->base + find_dyn( + (void *)(aux[AT_BASE]+ehdr->e_phoff), + ehdr->e_phnum, ehdr->e_phentsize)); + decode_dyn(lib); + + /* Find load address of the main program, via AT_PHDR vs PT_PHDR. */ + app->base = 0; phdr = (void *)aux[AT_PHDR]; - for (i=aux[AT_PHNUM]; i--; phdr=(void *)((char *)phdr + aux[AT_PHENT])) { - if (phdr->p_type == PT_DYNAMIC) { - decode_vec((void *)phdr->p_vaddr, app_dyn, DYN_CNT); - break; + 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->name = argv[0]; + app->global = 1; + app->constructed = 1; + app->dynv = (void *)(app->base + find_dyn( + (void *)aux[AT_PHDR], aux[AT_PHNUM], aux[AT_PHENT])); + decode_dyn(app); + + /* Attach to vdso, if provided by the kernel */ + for (i=0; auxv[i]; i+=2) { + size_t vdso_base = auxv[i+1]; + if (auxv[i] != AT_SYSINFO_EHDR) continue; + ehdr = (void *)vdso_base; + phdr = (void *)(vdso_base + ehdr->e_phoff); + 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 = "linux-gate.so.1"; + vdso->global = 1; + decode_dyn(vdso); + vdso->prev = lib; + lib->next = vdso; + break; } - app = (struct dso){ - .base = 0, - .strings = (void *)(app_dyn[DT_STRTAB]), - .hashtab = (void *)(app_dyn[DT_HASH]), - .syms = (void *)(app_dyn[DT_SYMTAB]), - .dynv = (void *)(phdr->p_vaddr), - .name = argv[0], - .global = 1, - .next = &lib - }; - - lib = (struct dso){ - .base = (void *)aux[AT_BASE], - .strings = (void *)(aux[AT_BASE]+lib_dyn[DT_STRTAB]), - .hashtab = (void *)(aux[AT_BASE]+lib_dyn[DT_HASH]), - .syms = (void *)(aux[AT_BASE]+lib_dyn[DT_SYMTAB]), - .dynv = (void *)(got[0]), - .name = "libc.so", - .global = 1, - .relocated = 1 - }; - - /* Relocate the dynamic linker/libc */ - do_relocs((void *)aux[AT_BASE], (void *)(aux[AT_BASE]+lib_dyn[DT_REL]), - lib_dyn[DT_RELSZ], 2, lib.syms, lib.strings, &app); - do_relocs((void *)aux[AT_BASE], (void *)(aux[AT_BASE]+lib_dyn[DT_RELA]), - lib_dyn[DT_RELASZ], 3, lib.syms, lib.strings, &app); - - /* At this point the standard library is fully functional */ - - reclaim_gaps(app.base, (void *)aux[AT_PHDR], aux[AT_PHENT], aux[AT_PHNUM]); - ehdr = (void *)lib.base; - reclaim_gaps(lib.base, (void *)(lib.base+ehdr->e_phoff), + /* 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; + libc = lib; + app->next = lib; + reloc_all(lib); + app->next = 0; + + /* PAST THIS POINT, ALL LIBC INTERFACES ARE FULLY USABLE. */ + + /* Donate unused parts of app and library mapping to malloc */ + reclaim_gaps(app->base, (void *)aux[AT_PHDR], aux[AT_PHENT], aux[AT_PHNUM]); + ehdr = (void *)lib->base; + reclaim_gaps(lib->base, (void *)(lib->base+ehdr->e_phoff), ehdr->e_phentsize, ehdr->e_phnum); - head = tail = &app; - libc = &lib; - app.next = 0; - load_deps(head); - - make_global(head); - reloc_all(head->next); - reloc_all(head); - - if (rtld_used) { - runtime = 1; - head->next->prev = malloc(sizeof *head); - *head->next->prev = *head; - head = head->next->prev; - libc->prev->next = malloc(sizeof *libc); - *libc->prev->next = *libc; - libc = libc->prev->next; - if (libc->next) libc->next->prev = libc; - if (tail == &lib) tail = libc; - } else { + /* 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. */ + if (env_preload) load_preload(env_preload); + load_deps(app); + make_global(app); + reloc_all(app->next); + reloc_all(app); + + /* 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. */ + runtime = 1; + + for (i=0; app->dynv[i]; i+=2) + if (app->dynv[i]==DT_DEBUG) + app->dynv[i+1] = (size_t)&debug; + debug.ver = 1; + debug.bp = _dl_debug_state; + debug.head = head; + debug.base = lib->base; + debug.state = 0; + _dl_debug_state(); + + if (ssp_used) __init_ssp(auxv); + + do_init_fini(tail); + + if (!rtld_used) { free_all(head); free(sys_path); + reclaim((void *)builtin_dsos, 0, sizeof builtin_dsos); } errno = 0; @@ -536,11 +648,13 @@ void *__dynlink(int argc, char **argv, size_t *got) void *dlopen(const char *file, int mode) { - struct dso *p, *orig_tail = tail, *next; + struct dso *volatile p, *orig_tail = tail, *next; size_t i; + int cs; if (!file) return head; + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &cs); pthread_rwlock_wrlock(&lock); if (setjmp(rtld_fail)) { @@ -556,12 +670,17 @@ void *dlopen(const char *file, int mode) } tail = orig_tail; tail->next = 0; - pthread_rwlock_unlock(&lock); - return 0; - } + p = 0; + errflag = 1; + goto end; + } else p = load_library(file); - p = load_library(file); - if (!p) goto end; + if (!p) { + snprintf(errbuf, sizeof errbuf, + "Error loading shared library %s: %m", file); + errflag = 1; + goto end; + } /* First load handling */ if (!p->deps) { @@ -583,18 +702,30 @@ void *dlopen(const char *file, int mode) p->global = 1; } + _dl_debug_state(); + + do_init_fini(tail); end: pthread_rwlock_unlock(&lock); + pthread_setcancelstate(cs, 0); return p; } -static void *do_dlsym(struct dso *p, const char *s) +static void *do_dlsym(struct dso *p, const char *s, void *ra) { size_t i; uint32_t h; Sym *sym; - if (p == head || p == RTLD_DEFAULT) - return find_sym(head, s, 0); + 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; + } + if (p == head || p == RTLD_DEFAULT) { + void *res = find_sym(head, s, 0); + if (!res) errflag = 1; + return res; + } h = hash(s); sym = lookup(s, h, p->syms, p->hashtab, p->strings); if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES)) @@ -605,21 +736,35 @@ static void *do_dlsym(struct dso *p, const char *s) if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES)) return p->deps[i]->base + sym->st_value; } + errflag = 1; + snprintf(errbuf, sizeof errbuf, "Symbol not found: %s", s); return 0; } -void *dlsym(void *p, const char *s) +void *__dlsym(void *p, const char *s, void *ra) { void *res; pthread_rwlock_rdlock(&lock); - res = do_dlsym(p, s); + res = do_dlsym(p, s, ra); pthread_rwlock_unlock(&lock); return res; } +#else +void *dlopen(const char *file, int mode) +{ + return 0; +} +void *__dlsym(void *p, const char *s, void *ra) +{ + return 0; +} +#endif char *dlerror() { - return "unknown error"; + if (!errflag) return 0; + errflag = 0; + return errbuf; } int dlclose(void *p)