comment non-obvious de bruijn sequence code in int parser
[musl] / src / ldso / dynlink.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <unistd.h>
5 #include <stdint.h>
6 #include <elf.h>
7 #include <sys/mman.h>
8 #include <limits.h>
9 #include <stdint.h>
10 #include <fcntl.h>
11 #include <sys/stat.h>
12 #include <errno.h>
13 #include <limits.h>
14 #include <elf.h>
15 #include <setjmp.h>
16 #include <pthread.h>
17 #include <dlfcn.h>
18
19 #include "reloc.h"
20
21 #if ULONG_MAX == 0xffffffff
22 typedef Elf32_Ehdr Ehdr;
23 typedef Elf32_Phdr Phdr;
24 typedef Elf32_Sym Sym;
25 #define R_TYPE(x) ((x)&255)
26 #define R_SYM(x) ((x)>>8)
27 #else
28 typedef Elf64_Ehdr Ehdr;
29 typedef Elf64_Phdr Phdr;
30 typedef Elf64_Sym Sym;
31 #define R_TYPE(x) ((x)&0xffffffff)
32 #define R_SYM(x) ((x)>>32)
33 #endif
34
35 struct dso
36 {
37         struct dso *next, *prev;
38         int refcnt;
39         size_t *dynv;
40         Sym *syms;
41         uint32_t *hashtab;
42         char *strings;
43         unsigned char *base;
44         unsigned char *map;
45         size_t map_len;
46         dev_t dev;
47         ino_t ino;
48         int global;
49         int relocated;
50         struct dso **deps;
51         char *name;
52         char buf[];
53 };
54
55 static struct dso *head, *tail, *libc;
56 static char *env_path, *sys_path, *r_path;
57 static int rtld_used;
58 static int runtime;
59 static jmp_buf rtld_fail;
60 static pthread_rwlock_t lock;
61
62 #define AUX_CNT 15
63 #define DYN_CNT 34
64
65 static void decode_vec(size_t *v, size_t *a, size_t cnt)
66 {
67         memset(a, 0, cnt*sizeof(size_t));
68         for (; v[0]; v+=2) if (v[0]<cnt) {
69                 a[0] |= 1ULL<<v[0];
70                 a[v[0]] = v[1];
71         }
72 }
73
74 static uint32_t hash(const char *s)
75 {
76         uint_fast32_t h = 0;
77         while (*s) {
78                 h = 16*h + *s++;
79                 h ^= h>>24 & 0xf0;
80         }
81         return h & 0xfffffff;
82 }
83
84 static Sym *lookup(const char *s, uint32_t h, Sym *syms, uint32_t *hashtab, char *strings)
85 {
86         size_t i;
87         for (i=hashtab[2+h%hashtab[0]]; i; i=hashtab[2+hashtab[0]+i]) {
88                 if (!strcmp(s, strings+syms[i].st_name))
89                         return syms+i;
90         }
91         return 0;
92 }
93
94 #define OK_TYPES (1<<STT_NOTYPE | 1<<STT_OBJECT | 1<<STT_FUNC | 1<<STT_COMMON)
95 #define OK_BINDS (1<<STB_GLOBAL | 1<<STB_WEAK)
96
97 static void *find_sym(struct dso *dso, const char *s, int need_def)
98 {
99         uint32_t h = hash(s);
100         void *def = 0;
101         if (h==0x6b366be && !strcmp(s, "dlopen")) rtld_used = 1;
102         if (h==0x6b3afd && !strcmp(s, "dlsym")) rtld_used = 1;
103         for (; dso; dso=dso->next) {
104                 Sym *sym;
105                 if (!dso->global) continue;
106                 sym = lookup(s, h, dso->syms, dso->hashtab, dso->strings);
107                 if (sym && (!need_def || sym->st_shndx) && sym->st_value
108                  && (1<<(sym->st_info&0xf) & OK_TYPES)
109                  && (1<<(sym->st_info>>4) & OK_BINDS)) {
110                         def = dso->base + sym->st_value;
111                         if (sym->st_info>>4 == STB_GLOBAL) break;
112                 }
113         }
114         return def;
115 }
116
117 static void do_relocs(unsigned char *base, size_t *rel, size_t rel_size, size_t stride, Sym *syms, char *strings, struct dso *dso)
118 {
119         Sym *sym;
120         const char *name;
121         size_t sym_val, sym_size;
122         size_t *reloc_addr;
123         void *ctx;
124         int type;
125         int sym_index;
126
127         for (; rel_size; rel+=stride, rel_size-=stride*sizeof(size_t)) {
128                 reloc_addr = (void *)(base + rel[0]);
129                 type = R_TYPE(rel[1]);
130                 sym_index = R_SYM(rel[1]);
131                 if (sym_index) {
132                         sym = syms + sym_index;
133                         name = strings + sym->st_name;
134                         ctx = IS_COPY(type) ? dso->next : dso;
135                         sym_val = (size_t)find_sym(ctx, name, IS_PLT(type));
136                         if (!sym_val && sym->st_info>>4 != STB_WEAK) {
137                                 if (runtime) longjmp(rtld_fail, 1);
138                                 dprintf(2, "%s: symbol not found\n", name);
139                                 _exit(127);
140                         }
141                         sym_size = sym->st_size;
142                 }
143                 do_single_reloc(reloc_addr, type, sym_val, sym_size, base, rel[2]);
144         }
145 }
146
147 /* A huge hack: to make up for the wastefulness of shared libraries
148  * needing at least a page of dirty memory even if they have no global
149  * data, we reclaim the gaps at the beginning and end of writable maps
150  * and "donate" them to the heap by setting up minimal malloc
151  * structures and then freeing them. */
152
153 static void reclaim(unsigned char *base, size_t start, size_t end)
154 {
155         size_t *a, *z;
156         start = start + 6*sizeof(size_t)-1 & -4*sizeof(size_t);
157         end = (end & -4*sizeof(size_t)) - 2*sizeof(size_t);
158         if (start>end || end-start < 4*sizeof(size_t)) return;
159         a = (size_t *)(base + start);
160         z = (size_t *)(base + end);
161         a[-2] = 1;
162         a[-1] = z[0] = end-start + 2*sizeof(size_t) | 1;
163         z[1] = 1;
164         free(a);
165 }
166
167 static void reclaim_gaps(unsigned char *base, Phdr *ph, size_t phent, size_t phcnt)
168 {
169         for (; phcnt--; ph=(void *)((char *)ph+phent)) {
170                 if (ph->p_type!=PT_LOAD) continue;
171                 if ((ph->p_flags&(PF_R|PF_W))!=(PF_R|PF_W)) continue;
172                 reclaim(base, ph->p_vaddr & -PAGE_SIZE, ph->p_vaddr);
173                 reclaim(base, ph->p_vaddr+ph->p_memsz,
174                         ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE);
175         }
176 }
177
178 static void *map_library(int fd, size_t *lenp, unsigned char **basep, size_t *dynp)
179 {
180         Ehdr buf[(896+sizeof(Ehdr))/sizeof(Ehdr)];
181         size_t phsize;
182         size_t addr_min=SIZE_MAX, addr_max=0, map_len;
183         size_t this_min, this_max;
184         off_t off_start;
185         Ehdr *eh;
186         Phdr *ph;
187         unsigned prot;
188         unsigned char *map, *base;
189         size_t dyn;
190         size_t i;
191
192         ssize_t l = read(fd, buf, sizeof buf);
193         if (l<sizeof *eh) return 0;
194         eh = buf;
195         phsize = eh->e_phentsize * eh->e_phnum;
196         if (phsize + sizeof *eh > l) return 0;
197         if (eh->e_phoff + phsize > l) {
198                 l = pread(fd, buf+1, phsize, eh->e_phoff);
199                 if (l != phsize) return 0;
200                 eh->e_phoff = sizeof *eh;
201         }
202         ph = (void *)((char *)buf + eh->e_phoff);
203         for (i=eh->e_phnum; i; i--, ph=(void *)((char *)ph+eh->e_phentsize)) {
204                 if (ph->p_type == PT_DYNAMIC)
205                         dyn = ph->p_vaddr;
206                 if (ph->p_type != PT_LOAD) continue;
207                 if (ph->p_vaddr < addr_min) {
208                         addr_min = ph->p_vaddr;
209                         off_start = ph->p_offset;
210                         prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) |
211                                 ((ph->p_flags&PF_W) ? PROT_WRITE: 0) |
212                                 ((ph->p_flags&PF_X) ? PROT_EXEC : 0));
213                 }
214                 if (ph->p_vaddr+ph->p_memsz > addr_max) {
215                         addr_max = ph->p_vaddr+ph->p_memsz;
216                 }
217         }
218         if (!dyn) return 0;
219         addr_max += PAGE_SIZE-1;
220         addr_max &= -PAGE_SIZE;
221         addr_min &= -PAGE_SIZE;
222         off_start &= -PAGE_SIZE;
223         map_len = addr_max - addr_min + off_start;
224         /* The first time, we map too much, possibly even more than
225          * the length of the file. This is okay because we will not
226          * use the invalid part; we just need to reserve the right
227          * amount of virtual address space to map over later. */
228         map = mmap((void *)addr_min, map_len, prot, MAP_PRIVATE, fd, off_start);
229         if (map==MAP_FAILED) return 0;
230         base = map - addr_min;
231         ph = (void *)((char *)buf + eh->e_phoff);
232         for (i=eh->e_phnum; i; i--, ph=(void *)((char *)ph+eh->e_phentsize)) {
233                 if (ph->p_type != PT_LOAD) continue;
234                 /* Reuse the existing mapping for the lowest-address LOAD */
235                 if ((ph->p_vaddr & -PAGE_SIZE) == addr_min) continue;
236                 this_min = ph->p_vaddr & -PAGE_SIZE;
237                 this_max = ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE;
238                 off_start = ph->p_offset & -PAGE_SIZE;
239                 prot = (((ph->p_flags&PF_R) ? PROT_READ : 0) |
240                         ((ph->p_flags&PF_W) ? PROT_WRITE: 0) |
241                         ((ph->p_flags&PF_X) ? PROT_EXEC : 0));
242                 if (mmap(base+this_min, this_max-this_min, prot, MAP_PRIVATE|MAP_FIXED, fd, off_start) == MAP_FAILED) {
243                         munmap(map, map_len);
244                         return 0;
245                 }
246                 if (ph->p_memsz > ph->p_filesz) {
247                         size_t brk = (size_t)base+ph->p_vaddr+ph->p_filesz;
248                         size_t pgbrk = brk+PAGE_SIZE-1 & -PAGE_SIZE;
249                         memset((void *)brk, 0, pgbrk-brk & PAGE_SIZE-1);
250                         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) {
251                                 munmap(map, map_len);
252                                 return 0;
253                         }
254                 }
255         }
256         for (i=0; ((size_t *)(base+dyn))[i]; i+=2)
257                 if (((size_t *)(base+dyn))[i]==DT_TEXTREL) {
258                         mprotect(map, map_len, PROT_READ|PROT_WRITE|PROT_EXEC);
259                         break;
260                 }
261         if (!runtime) reclaim_gaps(base, (void *)((char *)buf + eh->e_phoff),
262                 eh->e_phentsize, eh->e_phnum);
263         *lenp = map_len;
264         *basep = base;
265         *dynp = dyn;
266         return map;
267 }
268
269 static int path_open(const char *name, const char *search)
270 {
271         char buf[2*NAME_MAX+2];
272         const char *s=search, *z;
273         int l, fd;
274         for (;;) {
275                 while (*s==':') s++;
276                 if (!*s) return -1;
277                 z = strchr(s, ':');
278                 l = z ? z-s : strlen(s);
279                 snprintf(buf, sizeof buf, "%.*s/%s", l, s, name);
280                 if ((fd = open(buf, O_RDONLY))>=0) return fd;
281                 s += l;
282         }
283 }
284
285 static struct dso *load_library(const char *name)
286 {
287         unsigned char *base, *map;
288         size_t dyno, map_len;
289         struct dso *p;
290         size_t dyn[DYN_CNT] = {0};
291         int fd;
292         struct stat st;
293
294         /* Catch and block attempts to reload the implementation itself */
295         if (name[0]=='l' && name[1]=='i' && name[2]=='b') {
296                 static const char *rp, reserved[] =
297                         "c\0pthread\0rt\0m\0dl\0util\0xnet\0";
298                 char *z = strchr(name, '.');
299                 if (z) {
300                         size_t l = z-name;
301                         for (rp=reserved; *rp && memcmp(name+3, rp, l-3); rp+=strlen(rp)+1);
302                         if (*rp) {
303                                 if (!libc->prev) {
304                                         tail->next = libc;
305                                         libc->prev = tail;
306                                         tail = libc->next ? libc->next : libc;
307                                 }
308                                 return libc;
309                         }
310                 }
311         }
312         /* Search for the name to see if it's already loaded */
313         for (p=head->next; p; p=p->next) {
314                 if (!strcmp(p->name, name)) {
315                         p->refcnt++;
316                         return p;
317                 }
318         }
319         if (strchr(name, '/')) {
320                 fd = open(name, O_RDONLY);
321         } else {
322                 if (strlen(name) > NAME_MAX) return 0;
323                 fd = -1;
324                 if (r_path) fd = path_open(name, r_path);
325                 if (fd < 0 && env_path) fd = path_open(name, env_path);
326                 if (fd < 0) {
327                         if (!sys_path) {
328                                 FILE *f = fopen(ETC_LDSO_PATH, "r");
329                                 if (f) {
330                                         if (getline(&sys_path, (size_t[1]){0}, f) > 0)
331                                                 sys_path[strlen(sys_path)-1]=0;
332                                         fclose(f);
333                                 }
334                         }
335                         if (sys_path) fd = path_open(name, sys_path);
336                         else fd = path_open(name, "/lib:/usr/local/lib:/usr/lib");
337                 }
338         }
339         if (fd < 0) return 0;
340         if (fstat(fd, &st) < 0) {
341                 close(fd);
342                 return 0;
343         }
344         for (p=head->next; p; p=p->next) {
345                 if (p->dev == st.st_dev && p->ino == st.st_ino) {
346                         close(fd);
347                         p->refcnt++;
348                         return p;
349                 }
350         }
351         map = map_library(fd, &map_len, &base, &dyno);
352         close(fd);
353         if (!map) return 0;
354         p = calloc(1, sizeof *p + strlen(name) + 1);
355         if (!p) {
356                 munmap(map, map_len);
357                 return 0;
358         }
359
360         p->map = map;
361         p->map_len = map_len;
362         p->base = base;
363         p->dynv = (void *)(base + dyno);
364         decode_vec(p->dynv, dyn, DYN_CNT);
365
366         p->syms = (void *)(base + dyn[DT_SYMTAB]);
367         p->hashtab = (void *)(base + dyn[DT_HASH]);
368         p->strings = (void *)(base + dyn[DT_STRTAB]);
369         p->dev = st.st_dev;
370         p->ino = st.st_ino;
371         p->refcnt = 1;
372         p->name = p->buf;
373         strcpy(p->name, name);
374
375         tail->next = p;
376         p->prev = tail;
377         tail = p;
378
379         return p;
380 }
381
382 static void load_deps(struct dso *p)
383 {
384         size_t i, ndeps=0;
385         struct dso ***deps = &p->deps, **tmp, *dep;
386         for (; p; p=p->next) {
387                 for (i=0; p->dynv[i]; i+=2) {
388                         if (p->dynv[i] != DT_RPATH) continue;
389                         r_path = (void *)(p->strings + p->dynv[i+1]);
390                 }
391                 for (i=0; p->dynv[i]; i+=2) {
392                         if (p->dynv[i] != DT_NEEDED) continue;
393                         dep = load_library(p->strings + p->dynv[i+1]);
394                         if (!dep) {
395                                 if (runtime) longjmp(rtld_fail, 1);
396                                 dprintf(2, "%s: %m (needed by %s)\n",
397                                         p->strings + p->dynv[i+1], p->name);
398                                 _exit(127);
399                         }
400                         if (runtime) {
401                                 tmp = realloc(*deps, sizeof(*tmp)*(ndeps+2));
402                                 if (!tmp) longjmp(rtld_fail, 1);
403                                 tmp[ndeps++] = dep;
404                                 tmp[ndeps] = 0;
405                                 *deps = tmp;
406                         }
407                 }
408                 r_path = 0;
409         }
410 }
411
412 static void make_global(struct dso *p)
413 {
414         for (; p; p=p->next) p->global = 1;
415 }
416
417 static void reloc_all(struct dso *p)
418 {
419         size_t dyn[DYN_CNT] = {0};
420         for (; p; p=p->next) {
421                 if (p->relocated) continue;
422                 decode_vec(p->dynv, dyn, DYN_CNT);
423                 do_relocs(p->base, (void *)(p->base+dyn[DT_JMPREL]), dyn[DT_PLTRELSZ],
424                         2+(dyn[DT_PLTREL]==DT_RELA), p->syms, p->strings, head);
425                 do_relocs(p->base, (void *)(p->base+dyn[DT_REL]), dyn[DT_RELSZ],
426                         2, p->syms, p->strings, head);
427                 do_relocs(p->base, (void *)(p->base+dyn[DT_RELA]), dyn[DT_RELASZ],
428                         3, p->syms, p->strings, head);
429                 p->relocated = 1;
430         }
431 }
432
433 static void free_all(struct dso *p)
434 {
435         struct dso *n;
436         while (p) {
437                 n = p->next;
438                 if (p->map) free(p);
439                 p = n;
440         }
441 }
442
443 void *__dynlink(int argc, char **argv, size_t *got)
444 {
445         size_t *auxv, aux[AUX_CNT] = {0};
446         size_t app_dyn[DYN_CNT] = {0};
447         size_t lib_dyn[DYN_CNT] = {0};
448         size_t vdso_dyn[DYN_CNT] = {0};
449         size_t i;
450         Phdr *phdr;
451         Ehdr *ehdr;
452         static struct dso builtin_dsos[3];
453         struct dso *const app = builtin_dsos+0;
454         struct dso *const lib = builtin_dsos+1;
455         struct dso *const vdso = builtin_dsos+2;
456         size_t vdso_base=0;
457
458         /* Find aux vector just past environ[] */
459         for (i=argc+1; argv[i]; i++)
460                 if (!memcmp(argv[i], "LD_LIBRARY_PATH=", 16))
461                         env_path = argv[i]+16;
462         auxv = (void *)(argv+i+1);
463
464         decode_vec(auxv, aux, AUX_CNT);
465
466         for (i=0; auxv[i]; i+=2) {
467                 if (auxv[i]==AT_SYSINFO_EHDR) {
468                         vdso_base = auxv[i+1];
469                         break;
470                 }
471         }
472
473         /* Only trust user/env if kernel says we're not suid/sgid */
474         if ((aux[0]&0x7800)!=0x7800 || aux[AT_UID]!=aux[AT_EUID]
475           || aux[AT_GID]!=aux[AT_EGID]) {
476                 env_path = 0;
477         }
478
479         /* Relocate ldso's DYNAMIC pointer and load vector */
480         decode_vec((void *)(got[0] += aux[AT_BASE]), lib_dyn, DYN_CNT);
481
482         /* Find the program image's DYNAMIC section and decode it */
483         phdr = (void *)aux[AT_PHDR];
484         for (i=aux[AT_PHNUM]; i--; phdr=(void *)((char *)phdr + aux[AT_PHENT])) {
485                 if (phdr->p_type == PT_DYNAMIC) {
486                         decode_vec((void *)phdr->p_vaddr, app_dyn, DYN_CNT);
487                         break;
488                 }
489         }
490
491         *app = (struct dso){
492                 .base = 0,
493                 .strings = (void *)(app_dyn[DT_STRTAB]),
494                 .hashtab = (void *)(app_dyn[DT_HASH]),
495                 .syms = (void *)(app_dyn[DT_SYMTAB]),
496                 .dynv = (void *)(phdr->p_vaddr),
497                 .name = argv[0],
498                 .global = 1,
499                 .next = lib
500         };
501
502         *lib = (struct dso){
503                 .base = (void *)aux[AT_BASE],
504                 .strings = (void *)(aux[AT_BASE]+lib_dyn[DT_STRTAB]),
505                 .hashtab = (void *)(aux[AT_BASE]+lib_dyn[DT_HASH]),
506                 .syms = (void *)(aux[AT_BASE]+lib_dyn[DT_SYMTAB]),
507                 .dynv = (void *)(got[0]),
508                 .name = "libc.so",
509                 .global = 1,
510                 .relocated = 1
511         };
512
513         if (vdso_base) {
514                 ehdr = (void *)vdso_base;
515                 phdr = (void *)(vdso_base + ehdr->e_phoff);
516                 for (i=ehdr->e_phnum; i; i--, phdr=(void *)((char *)phdr + ehdr->e_phentsize)) {
517                         if (phdr->p_type == PT_DYNAMIC)
518                                 vdso->dynv = (void *)(vdso_base + phdr->p_offset);
519                         if (phdr->p_type == PT_LOAD)
520                                 vdso->base = (void *)(vdso_base - phdr->p_vaddr + phdr->p_offset);
521                 }
522                 decode_vec(vdso->dynv, vdso_dyn, DYN_CNT);
523                 vdso->syms = (void *)(vdso->base + vdso_dyn[DT_SYMTAB]);
524                 vdso->hashtab = (void *)(vdso->base + vdso_dyn[DT_HASH]);
525                 vdso->strings = (void *)(vdso->base + vdso_dyn[DT_STRTAB]);
526                 vdso->name = "linux-gate.so.1";
527                 vdso->global = 1;
528
529                 vdso->prev = lib;
530                 lib->next = vdso;
531         }
532
533         /* Relocate the dynamic linker/libc */
534         do_relocs((void *)aux[AT_BASE], (void *)(aux[AT_BASE]+lib_dyn[DT_REL]),
535                 lib_dyn[DT_RELSZ], 2, lib->syms, lib->strings, app);
536         do_relocs((void *)aux[AT_BASE], (void *)(aux[AT_BASE]+lib_dyn[DT_RELA]),
537                 lib_dyn[DT_RELASZ], 3, lib->syms, lib->strings, app);
538
539         /* At this point the standard library is fully functional */
540
541         reclaim_gaps(app->base, (void *)aux[AT_PHDR], aux[AT_PHENT], aux[AT_PHNUM]);
542         ehdr = (void *)lib->base;
543         reclaim_gaps(lib->base, (void *)(lib->base+ehdr->e_phoff),
544                 ehdr->e_phentsize, ehdr->e_phnum);
545
546         head = tail = app;
547         libc = lib;
548         app->next = 0;
549         load_deps(head);
550
551         make_global(head);
552         reloc_all(head->next);
553         reloc_all(head);
554
555         runtime = 1;
556         if (!rtld_used) {
557                 free_all(head);
558                 free(sys_path);
559                 reclaim((void *)builtin_dsos, 0, sizeof builtin_dsos);
560         }
561
562         errno = 0;
563         return (void *)aux[AT_ENTRY];
564 }
565
566 void *dlopen(const char *file, int mode)
567 {
568         struct dso *volatile p, *orig_tail = tail, *next;
569         size_t i;
570
571         if (!file) return head;
572
573         pthread_rwlock_wrlock(&lock);
574
575         if (setjmp(rtld_fail)) {
576                 /* Clean up anything new that was (partially) loaded */
577                 if (p->deps) for (i=0; p->deps[i]; i++)
578                         if (p->deps[i]->global < 0)
579                                 p->deps[i]->global = 0;
580                 for (p=orig_tail->next; p; p=next) {
581                         next = p->next;
582                         munmap(p->map, p->map_len);
583                         free(p->deps);
584                         free(p);
585                 }
586                 tail = orig_tail;
587                 tail->next = 0;
588                 pthread_rwlock_unlock(&lock);
589                 return 0;
590         }
591
592         p = load_library(file);
593         if (!p) goto end;
594
595         /* First load handling */
596         if (!p->deps) {
597                 load_deps(p);
598                 if (p->deps) for (i=0; p->deps[i]; i++)
599                         if (!p->deps[i]->global)
600                                 p->deps[i]->global = -1;
601                 if (!p->global) p->global = -1;
602                 reloc_all(p);
603                 if (p->deps) for (i=0; p->deps[i]; i++)
604                         if (p->deps[i]->global < 0)
605                                 p->deps[i]->global = 0;
606                 if (p->global < 0) p->global = 0;
607         }
608
609         if (mode & RTLD_GLOBAL) {
610                 if (p->deps) for (i=0; p->deps[i]; i++)
611                         p->deps[i]->global = 1;
612                 p->global = 1;
613         }
614
615 end:
616         pthread_rwlock_unlock(&lock);
617         return p;
618 }
619
620 static void *do_dlsym(struct dso *p, const char *s)
621 {
622         size_t i;
623         uint32_t h;
624         Sym *sym;
625         if (p == head || p == RTLD_DEFAULT)
626                 return find_sym(head, s, 0);
627         h = hash(s);
628         sym = lookup(s, h, p->syms, p->hashtab, p->strings);
629         if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
630                 return p->base + sym->st_value;
631         if (p->deps) for (i=0; p->deps[i]; i++) {
632                 sym = lookup(s, h, p->deps[i]->syms,
633                         p->deps[i]->hashtab, p->deps[i]->strings);
634                 if (sym && sym->st_value && (1<<(sym->st_info&0xf) & OK_TYPES))
635                         return p->deps[i]->base + sym->st_value;
636         }
637         return 0;
638 }
639
640 void *dlsym(void *p, const char *s)
641 {
642         void *res;
643         pthread_rwlock_rdlock(&lock);
644         res = do_dlsym(p, s);
645         pthread_rwlock_unlock(&lock);
646         return res;
647 }
648
649 char *dlerror()
650 {
651         return "unknown error";
652 }
653
654 int dlclose(void *p)
655 {
656         return 0;
657 }