[fusl] Update fusl

fusl/ldso/dynlink.c

 #define _GNU_SOURCE
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <stddef.h>
 #include <string.h>
 #include <unistd.h>
 #include <stdint.h>
 #include <elf.h>
 #include <sys/mman.h>
 #include <limits.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <errno.h>
 #include <link.h>
 #include <setjmp.h>
 #include <pthread.h>
 #include <ctype.h>
 #include <dlfcn.h>
 #include "pthread_impl.h"
 #include "libc.h"
 #include "dynlink.h"
 
 static void error(const char *, ...);
 
-#ifdef SHARED
-
 #define MAXP2(a,b) (-(-(a)&-(b)))
 #define ALIGN(x,y) ((x)+(y)-1 & -(y))
 
 struct debug {
         int ver;
         void *head;
         void (*bp)(void);
         int state;
         void *base;
 };
@@ skipping 1091 matching lines @@
         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;
+                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];
         for (; p; p=p->next) {
                 if (p->relocated) continue;
                 decode_vec(p->dynv, dyn, DYN_CNT);
@@ skipping 177 matching lines @@
  * replaced later due to copy relocations in the main program. */
 
 __attribute__((__visibility__("hidden")))
 void __dls2(unsigned char *base, size_t *sp)
 {
         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++;
+                        for (auxv=sp+1+*sp+1; *auxv; auxv++)
+                                ; // Pass
+                        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;
         }
@@ skipping 166 matching lines @@
                  * linker had ldd not taken its place. */
                 if (ldd_mode) {
                         for (i=0; i<app.phnum; i++) {
                                 if (app.phdr[i].p_type == PT_INTERP)
                                         ldso.name = laddr(&app, app.phdr[i].p_vaddr);
                         }
                         dprintf(1, "\t%s (%p)\n", ldso.name, ldso.base);
                 }
         }
         if (app.tls.size) {
-                libc.tls_head = &app.tls;
+                libc.tls_head = tls_tail = &app.tls;
                 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) );
 #else
                 tls_offset = app.tls.offset = app.tls.size
                         + ( -((uintptr_t)app.tls.image + app.tls.size)
                         & (app.tls.align-1) );
@@ skipping 42 matching lines @@
         /* Donate unused parts of app and library mapping to malloc */
         reclaim_gaps(&app);
         reclaim_gaps(&ldso);
 
         /* Load preload/needed libraries, add their symbols to the global
          * namespace, and perform all remaining relocations. */
         if (env_preload) load_preload(env_preload);
         load_deps(&app);
         make_global(&app);
 
-#ifndef DYNAMIC_IS_RO
-        for (i=0; app.dynv[i]; i+=2)
-                if (app.dynv[i]==DT_DEBUG)
+        for (i=0; app.dynv[i]; i+=2) {
+                if (!DT_DEBUG_INDIRECT && app.dynv[i]==DT_DEBUG)
                         app.dynv[i+1] = (size_t)&debug;
-#endif
+                if (DT_DEBUG_INDIRECT && app.dynv[i]==DT_DEBUG_INDIRECT) {
+                        size_t *ptr = (size_t *) app.dynv[i+1];
+                        *ptr = (size_t)&debug;
+                }
+        }
 
         /* 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 || tls_align > MIN_TLS_ALIGN) {
                 void *initial_tls = calloc(libc.tls_size, 1);
                 if (!initial_tls) {
@@ skipping 124 matching lines @@
         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)
+__attribute__((__visibility__("hidden")))
+int __dl_invalid_handle(void *h)
 {
         struct dso *p;
         for (p=head; p; p=p->next) if (h==p) return 0;
         error("Invalid library handle %p", (void *)h);
         return 1;
 }
 
 static void *addr2dso(size_t a)
 {
         struct dso *p;
@@ skipping 34 matching lines @@
                         p = p->next;
                 }
                 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});
                 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 (invalid_dso_handle(p))
+        if (__dl_invalid_handle(p))
                 return 0;
         if ((ght = p->ghashtab)) {
                 gh = gnu_hash(s);
                 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});
@@ skipping 14 matching lines @@
                 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 laddr(p->deps[i], sym->st_value);
         }
 failed:
         error("Symbol not found: %s", s);
         return 0;
 }
 
-int __dladdr(const void *addr, Dl_info *info)
+int dladdr(const void *addr, Dl_info *info)
 {
         struct dso *p;
         Sym *sym, *bestsym;
         uint32_t nsym;
         char *strings;
         void *best = 0;
 
         pthread_rwlock_rdlock(&lock);
         p = addr2dso((size_t)addr);
         pthread_rwlock_unlock(&lock);
@@ skipping 68 matching lines @@
                 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)
-{
-        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)
-{
-        return 0;
-}
-#endif
 
-int __dlinfo(void *dso, int req, void *res)
-{
-        if (invalid_dso_handle(dso)) return -1;
-        if (req != RTLD_DI_LINKMAP) {
-                error("Unsupported request %d", req);
-                return -1;
-        }
-        *(struct link_map **)res = dso;
-        return 0;
-}
-
-char *dlerror()
-{
-        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);
-}
+__attribute__((__visibility__("hidden")))
+void __dl_vseterr(const char *, va_list);
 
 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);
+        __dl_vseterr(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;
 }