Sync changes from OpenBSD. Most importantly, this adds reverse proxy support.
[dragonfly.git] / libexec / rtld-elf / rtld.c
CommitLineData
984263bc
MD
1/*-
2 * Copyright 1996, 1997, 1998, 1999, 2000 John D. Polstra.
3 * Copyright 2003 Alexander Kabaev <kan@FreeBSD.ORG>.
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25 *
26 * $FreeBSD: src/libexec/rtld-elf/rtld.c,v 1.43.2.15 2003/02/20 20:42:46 kan Exp $
b6a22d96 27 * $DragonFly: src/libexec/rtld-elf/rtld.c,v 1.14 2005/02/24 03:23:01 joerg Exp $
984263bc
MD
28 */
29
30/*
31 * Dynamic linker for ELF.
32 *
33 * John Polstra <jdp@polstra.com>.
34 */
35
36#ifndef __GNUC__
37#error "GCC is needed to compile this file"
38#endif
39
40#include <sys/param.h>
41#include <sys/mman.h>
42#include <sys/stat.h>
8ca15ec8 43#include <sys/resident.h>
984263bc
MD
44
45#include <dlfcn.h>
46#include <err.h>
47#include <errno.h>
48#include <fcntl.h>
49#include <stdarg.h>
50#include <stdio.h>
51#include <stdlib.h>
52#include <string.h>
53#include <unistd.h>
54
55#include "debug.h"
56#include "rtld.h"
57
984263bc 58#define PATH_RTLD "/usr/libexec/ld-elf.so.1"
8ca15ec8 59#define LD_ARY_CACHE 16
984263bc
MD
60
61/* Types. */
62typedef void (*func_ptr_type)();
63typedef void * (*path_enum_proc) (const char *path, size_t len, void *arg);
64
65/*
66 * This structure provides a reentrant way to keep a list of objects and
67 * check which ones have already been processed in some way.
68 */
69typedef struct Struct_DoneList {
70 const Obj_Entry **objs; /* Array of object pointers */
71 unsigned int num_alloc; /* Allocated size of the array */
72 unsigned int num_used; /* Number of array slots used */
73} DoneList;
74
75/*
76 * Function declarations.
77 */
984263bc
MD
78static void die(void);
79static void digest_dynamic(Obj_Entry *);
8ca15ec8 80static const char *_getenv_ld(const char *id);
984263bc
MD
81static Obj_Entry *digest_phdr(const Elf_Phdr *, int, caddr_t, const char *);
82static Obj_Entry *dlcheck(void *);
83static int do_search_info(const Obj_Entry *obj, int, struct dl_serinfo *);
84static bool donelist_check(DoneList *, const Obj_Entry *);
85static void errmsg_restore(char *);
86static char *errmsg_save(void);
87static void *fill_search_info(const char *, size_t, void *);
88static char *find_library(const char *, const Obj_Entry *);
b6a22d96 89static Obj_Entry *find_object(const char *);
984263bc
MD
90static const char *gethints(void);
91static void init_dag(Obj_Entry *);
92static void init_dag1(Obj_Entry *root, Obj_Entry *obj, DoneList *);
93static void init_rtld(caddr_t);
94static void initlist_add_neededs(Needed_Entry *needed, Objlist *list);
95static void initlist_add_objects(Obj_Entry *obj, Obj_Entry **tail,
96 Objlist *list);
97static bool is_exported(const Elf_Sym *);
98static void linkmap_add(Obj_Entry *);
99static void linkmap_delete(Obj_Entry *);
100static int load_needed_objects(Obj_Entry *);
101static int load_preload_objects(void);
102static Obj_Entry *load_object(char *);
103static void lock_check(void);
104static Obj_Entry *obj_from_addr(const void *);
105static void objlist_call_fini(Objlist *);
106static void objlist_call_init(Objlist *);
107static void objlist_clear(Objlist *);
108static Objlist_Entry *objlist_find(Objlist *, const Obj_Entry *);
109static void objlist_init(Objlist *);
110static void objlist_push_head(Objlist *, Obj_Entry *);
111static void objlist_push_tail(Objlist *, Obj_Entry *);
112static void objlist_remove(Objlist *, Obj_Entry *);
113static void objlist_remove_unref(Objlist *);
114static void *path_enumerate(const char *, path_enum_proc, void *);
115static int relocate_objects(Obj_Entry *, bool);
116static int rtld_dirname(const char *, char *);
117static void rtld_exit(void);
118static char *search_library_path(const char *, const char *);
119static const void **get_program_var_addr(const char *name);
120static void set_program_var(const char *, const void *);
121static const Elf_Sym *symlook_default(const char *, unsigned long hash,
122 const Obj_Entry *refobj, const Obj_Entry **defobj_out, bool in_plt);
123static const Elf_Sym *symlook_list(const char *, unsigned long,
124 Objlist *, const Obj_Entry **, bool in_plt, DoneList *);
125static void trace_loaded_objects(Obj_Entry *obj);
126static void unlink_object(Obj_Entry *);
127static void unload_object(Obj_Entry *);
128static void unref_dag(Obj_Entry *);
129
130void r_debug_state(struct r_debug*, struct link_map*);
131
132/*
133 * Data declarations.
134 */
135static char *error_message; /* Message for dlerror(), or NULL */
136struct r_debug r_debug; /* for GDB; */
137static bool trust; /* False for setuid and setgid programs */
8ca15ec8
MD
138static const char *ld_bind_now; /* Environment variable for immediate binding */
139static const char *ld_debug; /* Environment variable for debugging */
140static const char *ld_library_path; /* Environment variable for search path */
984263bc
MD
141static char *ld_preload; /* Environment variable for libraries to
142 load first */
8ca15ec8 143static const char *ld_tracing; /* Called from ldd(1) to print libs */
984263bc
MD
144static Obj_Entry *obj_list; /* Head of linked list of shared objects */
145static Obj_Entry **obj_tail; /* Link field of last object in list */
8ca15ec8 146static Obj_Entry **preload_tail;
984263bc
MD
147static Obj_Entry *obj_main; /* The main program shared object */
148static Obj_Entry obj_rtld; /* The dynamic linker shared object */
149static unsigned int obj_count; /* Number of objects in obj_list */
33a8b578 150static int ld_resident; /* Non-zero if resident */
8ca15ec8
MD
151static const char *ld_ary[LD_ARY_CACHE];
152static int ld_index;
984263bc
MD
153
154static Objlist list_global = /* Objects dlopened with RTLD_GLOBAL */
155 STAILQ_HEAD_INITIALIZER(list_global);
156static Objlist list_main = /* Objects loaded at program startup */
157 STAILQ_HEAD_INITIALIZER(list_main);
158static Objlist list_fini = /* Objects needing fini() calls */
159 STAILQ_HEAD_INITIALIZER(list_fini);
160
161static LockInfo lockinfo;
162
163static Elf_Sym sym_zero; /* For resolving undefined weak refs. */
164
165#define GDB_STATE(s,m) r_debug.r_state = s; r_debug_state(&r_debug,m);
166
167extern Elf_Dyn _DYNAMIC;
168#pragma weak _DYNAMIC
169
170/*
171 * These are the functions the dynamic linker exports to application
172 * programs. They are the only symbols the dynamic linker is willing
173 * to export from itself.
174 */
175static func_ptr_type exports[] = {
176 (func_ptr_type) &_rtld_error,
177 (func_ptr_type) &dlclose,
178 (func_ptr_type) &dlerror,
179 (func_ptr_type) &dlopen,
180 (func_ptr_type) &dlsym,
181 (func_ptr_type) &dladdr,
182 (func_ptr_type) &dllockinit,
183 (func_ptr_type) &dlinfo,
184 NULL
185};
186
187/*
188 * Global declarations normally provided by crt1. The dynamic linker is
189 * not built with crt1, so we have to provide them ourselves.
190 */
191char *__progname;
192char **environ;
193
194/*
195 * Fill in a DoneList with an allocation large enough to hold all of
196 * the currently-loaded objects. Keep this as a macro since it calls
197 * alloca and we want that to occur within the scope of the caller.
198 */
199#define donelist_init(dlp) \
200 ((dlp)->objs = alloca(obj_count * sizeof (dlp)->objs[0]), \
201 assert((dlp)->objs != NULL), \
202 (dlp)->num_alloc = obj_count, \
203 (dlp)->num_used = 0)
204
205static __inline void
206rlock_acquire(void)
207{
208 lockinfo.rlock_acquire(lockinfo.thelock);
209 atomic_incr_int(&lockinfo.rcount);
210 lock_check();
211}
212
213static __inline void
214wlock_acquire(void)
215{
216 lockinfo.wlock_acquire(lockinfo.thelock);
217 atomic_incr_int(&lockinfo.wcount);
218 lock_check();
219}
220
221static __inline void
222rlock_release(void)
223{
224 atomic_decr_int(&lockinfo.rcount);
225 lockinfo.rlock_release(lockinfo.thelock);
226}
227
228static __inline void
229wlock_release(void)
230{
231 atomic_decr_int(&lockinfo.wcount);
232 lockinfo.wlock_release(lockinfo.thelock);
233}
234
235/*
236 * Main entry point for dynamic linking. The first argument is the
237 * stack pointer. The stack is expected to be laid out as described
238 * in the SVR4 ABI specification, Intel 386 Processor Supplement.
239 * Specifically, the stack pointer points to a word containing
240 * ARGC. Following that in the stack is a null-terminated sequence
241 * of pointers to argument strings. Then comes a null-terminated
242 * sequence of pointers to environment strings. Finally, there is a
243 * sequence of "auxiliary vector" entries.
244 *
245 * The second argument points to a place to store the dynamic linker's
246 * exit procedure pointer and the third to a place to store the main
247 * program's object.
248 *
249 * The return value is the main program's entry point.
250 */
251func_ptr_type
252_rtld(Elf_Addr *sp, func_ptr_type *exit_proc, Obj_Entry **objp)
253{
254 Elf_Auxinfo *aux_info[AT_COUNT];
255 int i;
256 int argc;
257 char **argv;
258 char **env;
259 Elf_Auxinfo *aux;
260 Elf_Auxinfo *auxp;
261 const char *argv0;
262 Obj_Entry *obj;
984263bc
MD
263 Objlist initlist;
264
8ca15ec8
MD
265 ld_index = 0; /* don't use old env cache in case we are resident */
266
984263bc
MD
267 /*
268 * On entry, the dynamic linker itself has not been relocated yet.
269 * Be very careful not to reference any global data until after
270 * init_rtld has returned. It is OK to reference file-scope statics
271 * and string constants, and to call static and global functions.
272 */
273
274 /* Find the auxiliary vector on the stack. */
275 argc = *sp++;
276 argv = (char **) sp;
277 sp += argc + 1; /* Skip over arguments and NULL terminator */
278 env = (char **) sp;
984263bc 279
33a8b578
MD
280 /*
281 * If we aren't already resident we have to dig out some more info.
282 * Note that auxinfo does not exist when we are resident.
283 */
284 if (ld_resident == 0) {
285 while (*sp++ != 0) /* Skip over environment, and NULL terminator */
286 ;
287 aux = (Elf_Auxinfo *) sp;
288
289 /* Digest the auxiliary vector. */
290 for (i = 0; i < AT_COUNT; i++)
291 aux_info[i] = NULL;
292 for (auxp = aux; auxp->a_type != AT_NULL; auxp++) {
293 if (auxp->a_type < AT_COUNT)
294 aux_info[auxp->a_type] = auxp;
295 }
296
297 /* Initialize and relocate ourselves. */
298 assert(aux_info[AT_BASE] != NULL);
299 init_rtld((caddr_t) aux_info[AT_BASE]->a_un.a_ptr);
300 }
984263bc
MD
301
302 __progname = obj_rtld.path;
303 argv0 = argv[0] != NULL ? argv[0] : "(null)";
304 environ = env;
305
8ca15ec8 306 trust = (geteuid() == getuid()) && (getegid() == getgid());
984263bc 307
8ca15ec8 308 ld_bind_now = _getenv_ld("LD_BIND_NOW");
984263bc 309 if (trust) {
8ca15ec8
MD
310 ld_debug = _getenv_ld("LD_DEBUG");
311 ld_library_path = _getenv_ld("LD_LIBRARY_PATH");
312 ld_preload = (char *)_getenv_ld("LD_PRELOAD");
984263bc 313 }
8ca15ec8 314 ld_tracing = _getenv_ld("LD_TRACE_LOADED_OBJECTS");
984263bc
MD
315
316 if (ld_debug != NULL && *ld_debug != '\0')
317 debug = 1;
318 dbg("%s is initialized, base address = %p", __progname,
319 (caddr_t) aux_info[AT_BASE]->a_un.a_ptr);
320 dbg("RTLD dynamic = %p", obj_rtld.dynamic);
321 dbg("RTLD pltgot = %p", obj_rtld.pltgot);
322
33a8b578
MD
323 /*
324 * If we are resident we can skip work that we have already done.
325 * Note that the stack is reset and there is no Elf_Auxinfo
326 * when running from a resident image, and the static globals setup
327 * between here and resident_skip will have already been setup.
328 */
8ca15ec8 329 if (ld_resident)
33a8b578 330 goto resident_skip1;
33a8b578 331
984263bc
MD
332 /*
333 * Load the main program, or process its program header if it is
334 * already loaded.
335 */
336 if (aux_info[AT_EXECFD] != NULL) { /* Load the main program. */
337 int fd = aux_info[AT_EXECFD]->a_un.a_val;
338 dbg("loading main program");
339 obj_main = map_object(fd, argv0, NULL);
340 close(fd);
341 if (obj_main == NULL)
342 die();
343 } else { /* Main program already loaded. */
344 const Elf_Phdr *phdr;
345 int phnum;
346 caddr_t entry;
347
348 dbg("processing main program's program header");
349 assert(aux_info[AT_PHDR] != NULL);
350 phdr = (const Elf_Phdr *) aux_info[AT_PHDR]->a_un.a_ptr;
351 assert(aux_info[AT_PHNUM] != NULL);
352 phnum = aux_info[AT_PHNUM]->a_un.a_val;
353 assert(aux_info[AT_PHENT] != NULL);
354 assert(aux_info[AT_PHENT]->a_un.a_val == sizeof(Elf_Phdr));
355 assert(aux_info[AT_ENTRY] != NULL);
356 entry = (caddr_t) aux_info[AT_ENTRY]->a_un.a_ptr;
357 if ((obj_main = digest_phdr(phdr, phnum, entry, argv0)) == NULL)
358 die();
359 }
360
361 obj_main->path = xstrdup(argv0);
362 obj_main->mainprog = true;
363
364 /*
365 * Get the actual dynamic linker pathname from the executable if
366 * possible. (It should always be possible.) That ensures that
367 * gdb will find the right dynamic linker even if a non-standard
368 * one is being used.
369 */
370 if (obj_main->interp != NULL &&
371 strcmp(obj_main->interp, obj_rtld.path) != 0) {
372 free(obj_rtld.path);
373 obj_rtld.path = xstrdup(obj_main->interp);
b7b05c9f 374 __progname = obj_rtld.path;
984263bc
MD
375 }
376
377 digest_dynamic(obj_main);
378
379 linkmap_add(obj_main);
380 linkmap_add(&obj_rtld);
381
382 /* Link the main program into the list of objects. */
383 *obj_tail = obj_main;
384 obj_tail = &obj_main->next;
385 obj_count++;
386 obj_main->refcount++;
387 /* Make sure we don't call the main program's init and fini functions. */
388 obj_main->init = obj_main->fini = NULL;
389
390 /* Initialize a fake symbol for resolving undefined weak references. */
391 sym_zero.st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE);
392 sym_zero.st_shndx = SHN_ABS;
393
394 dbg("loading LD_PRELOAD libraries");
395 if (load_preload_objects() == -1)
396 die();
397 preload_tail = obj_tail;
398
399 dbg("loading needed objects");
400 if (load_needed_objects(obj_main) == -1)
401 die();
402
403 /* Make a list of all objects loaded at startup. */
404 for (obj = obj_list; obj != NULL; obj = obj->next)
405 objlist_push_tail(&list_main, obj);
406
33a8b578
MD
407resident_skip1:
408
984263bc
MD
409 if (ld_tracing) { /* We're done */
410 trace_loaded_objects(obj_main);
411 exit(0);
412 }
413
33a8b578
MD
414 if (ld_resident) /* XXX clean this up! */
415 goto resident_skip2;
416
4a8d9350
JS
417 if (getenv("LD_DUMP_REL_PRE") != NULL) {
418 dump_relocations(obj_main);
419 exit (0);
420 }
421
6192271e
MD
422 if (relocate_objects(obj_main,
423 ld_bind_now != NULL && *ld_bind_now != '\0') == -1)
424 die();
984263bc 425
6192271e
MD
426 dbg("doing copy relocations");
427 if (do_copy_relocations(obj_main) == -1)
428 die();
1c76efe5 429
33a8b578
MD
430resident_skip2:
431
8ca15ec8 432 if (_getenv_ld("LD_RESIDENT_UNREGISTER_NOW")) {
33a8b578
MD
433 if (exec_sys_unregister(-1) < 0) {
434 dbg("exec_sys_unregister failed %d\n", errno);
435 exit(errno);
436 }
437 dbg("exec_sys_unregister success\n");
438 exit(0);
439 }
984263bc 440
4a8d9350
JS
441 if (getenv("LD_DUMP_REL_POST") != NULL) {
442 dump_relocations(obj_main);
443 exit (0);
444 }
445
984263bc
MD
446 dbg("initializing key program variables");
447 set_program_var("__progname", argv[0] != NULL ? basename(argv[0]) : "");
448 set_program_var("environ", env);
449
8ca15ec8
MD
450 if (_getenv_ld("LD_RESIDENT_REGISTER_NOW")) {
451 extern void resident_start(void);
452 ld_resident = 1;
453 if (exec_sys_register(resident_start) < 0) {
454 dbg("exec_sys_register failed %d\n", errno);
455 exit(errno);
456 }
457 dbg("exec_sys_register success\n");
458 exit(0);
459 }
460
984263bc
MD
461 dbg("initializing thread locks");
462 lockdflt_init(&lockinfo);
463 lockinfo.thelock = lockinfo.lock_create(lockinfo.context);
464
465 /* Make a list of init functions to call. */
466 objlist_init(&initlist);
467 initlist_add_objects(obj_list, preload_tail, &initlist);
468
469 r_debug_state(NULL, &obj_main->linkmap); /* say hello to gdb! */
470
471 objlist_call_init(&initlist);
472 wlock_acquire();
473 objlist_clear(&initlist);
474 wlock_release();
475
8ca15ec8
MD
476
477
984263bc
MD
478 dbg("transferring control to program entry point = %p", obj_main->entry);
479
480 /* Return the exit procedure and the program entry point. */
481 *exit_proc = rtld_exit;
482 *objp = obj_main;
483 return (func_ptr_type) obj_main->entry;
484}
485
486Elf_Addr
487_rtld_bind(Obj_Entry *obj, Elf_Word reloff)
488{
489 const Elf_Rel *rel;
490 const Elf_Sym *def;
491 const Obj_Entry *defobj;
492 Elf_Addr *where;
493 Elf_Addr target;
494
495 rlock_acquire();
496 if (obj->pltrel)
497 rel = (const Elf_Rel *) ((caddr_t) obj->pltrel + reloff);
498 else
499 rel = (const Elf_Rel *) ((caddr_t) obj->pltrela + reloff);
500
501 where = (Elf_Addr *) (obj->relocbase + rel->r_offset);
502 def = find_symdef(ELF_R_SYM(rel->r_info), obj, &defobj, true, NULL);
503 if (def == NULL)
504 die();
505
506 target = (Elf_Addr)(defobj->relocbase + def->st_value);
507
508 dbg("\"%s\" in \"%s\" ==> %p in \"%s\"",
509 defobj->strtab + def->st_name, basename(obj->path),
510 (void *)target, basename(defobj->path));
511
512 reloc_jmpslot(where, target);
513 rlock_release();
514 return target;
515}
516
517/*
518 * Error reporting function. Use it like printf. If formats the message
519 * into a buffer, and sets things up so that the next call to dlerror()
520 * will return the message.
521 */
522void
523_rtld_error(const char *fmt, ...)
524{
525 static char buf[512];
526 va_list ap;
527
528 va_start(ap, fmt);
529 vsnprintf(buf, sizeof buf, fmt, ap);
530 error_message = buf;
531 va_end(ap);
532}
533
534/*
535 * Return a dynamically-allocated copy of the current error message, if any.
536 */
537static char *
538errmsg_save(void)
539{
540 return error_message == NULL ? NULL : xstrdup(error_message);
541}
542
543/*
544 * Restore the current error message from a copy which was previously saved
545 * by errmsg_save(). The copy is freed.
546 */
547static void
548errmsg_restore(char *saved_msg)
549{
550 if (saved_msg == NULL)
551 error_message = NULL;
552 else {
553 _rtld_error("%s", saved_msg);
554 free(saved_msg);
555 }
556}
557
1c76efe5 558const char *
984263bc
MD
559basename(const char *name)
560{
561 const char *p = strrchr(name, '/');
562 return p != NULL ? p + 1 : name;
563}
564
565static void
566die(void)
567{
568 const char *msg = dlerror();
569
570 if (msg == NULL)
571 msg = "Fatal error";
572 errx(1, "%s", msg);
573}
574
575/*
576 * Process a shared object's DYNAMIC section, and save the important
577 * information in its Obj_Entry structure.
578 */
579static void
580digest_dynamic(Obj_Entry *obj)
581{
582 const Elf_Dyn *dynp;
583 Needed_Entry **needed_tail = &obj->needed;
584 const Elf_Dyn *dyn_rpath = NULL;
585 int plttype = DT_REL;
586
587 for (dynp = obj->dynamic; dynp->d_tag != DT_NULL; dynp++) {
588 switch (dynp->d_tag) {
589
590 case DT_REL:
591 obj->rel = (const Elf_Rel *) (obj->relocbase + dynp->d_un.d_ptr);
592 break;
593
594 case DT_RELSZ:
595 obj->relsize = dynp->d_un.d_val;
596 break;
597
598 case DT_RELENT:
599 assert(dynp->d_un.d_val == sizeof(Elf_Rel));
600 break;
601
602 case DT_JMPREL:
603 obj->pltrel = (const Elf_Rel *)
604 (obj->relocbase + dynp->d_un.d_ptr);
605 break;
606
607 case DT_PLTRELSZ:
608 obj->pltrelsize = dynp->d_un.d_val;
609 break;
610
611 case DT_RELA:
612 obj->rela = (const Elf_Rela *) (obj->relocbase + dynp->d_un.d_ptr);
613 break;
614
615 case DT_RELASZ:
616 obj->relasize = dynp->d_un.d_val;
617 break;
618
619 case DT_RELAENT:
620 assert(dynp->d_un.d_val == sizeof(Elf_Rela));
621 break;
622
623 case DT_PLTREL:
624 plttype = dynp->d_un.d_val;
625 assert(dynp->d_un.d_val == DT_REL || plttype == DT_RELA);
626 break;
627
628 case DT_SYMTAB:
629 obj->symtab = (const Elf_Sym *)
630 (obj->relocbase + dynp->d_un.d_ptr);
631 break;
632
633 case DT_SYMENT:
634 assert(dynp->d_un.d_val == sizeof(Elf_Sym));
635 break;
636
637 case DT_STRTAB:
638 obj->strtab = (const char *) (obj->relocbase + dynp->d_un.d_ptr);
639 break;
640
641 case DT_STRSZ:
642 obj->strsize = dynp->d_un.d_val;
643 break;
644
645 case DT_HASH:
646 {
647 const Elf_Addr *hashtab = (const Elf_Addr *)
648 (obj->relocbase + dynp->d_un.d_ptr);
649 obj->nbuckets = hashtab[0];
650 obj->nchains = hashtab[1];
651 obj->buckets = hashtab + 2;
652 obj->chains = obj->buckets + obj->nbuckets;
653 }
654 break;
655
656 case DT_NEEDED:
657 if (!obj->rtld) {
658 Needed_Entry *nep = NEW(Needed_Entry);
659 nep->name = dynp->d_un.d_val;
660 nep->obj = NULL;
661 nep->next = NULL;
662
663 *needed_tail = nep;
664 needed_tail = &nep->next;
665 }
666 break;
667
668 case DT_PLTGOT:
669 obj->pltgot = (Elf_Addr *) (obj->relocbase + dynp->d_un.d_ptr);
670 break;
671
672 case DT_TEXTREL:
673 obj->textrel = true;
674 break;
675
676 case DT_SYMBOLIC:
677 obj->symbolic = true;
678 break;
679
680 case DT_RPATH:
167f7029 681 case DT_RUNPATH: /* XXX: process separately */
984263bc
MD
682 /*
683 * We have to wait until later to process this, because we
684 * might not have gotten the address of the string table yet.
685 */
686 dyn_rpath = dynp;
687 break;
688
689 case DT_SONAME:
690 /* Not used by the dynamic linker. */
691 break;
692
693 case DT_INIT:
694 obj->init = (InitFunc) (obj->relocbase + dynp->d_un.d_ptr);
695 break;
696
697 case DT_FINI:
698 obj->fini = (InitFunc) (obj->relocbase + dynp->d_un.d_ptr);
699 break;
700
701 case DT_DEBUG:
702 /* XXX - not implemented yet */
703 dbg("Filling in DT_DEBUG entry");
704 ((Elf_Dyn*)dynp)->d_un.d_ptr = (Elf_Addr) &r_debug;
705 break;
706
167f7029
JS
707 case DT_FLAGS:
708 if (dynp->d_un.d_val & DF_ORIGIN) {
709 obj->origin_path = xmalloc(PATH_MAX);
710 if (rtld_dirname(obj->path, obj->origin_path) == -1)
711 die();
712 }
713 if (dynp->d_un.d_val & DF_SYMBOLIC)
714 obj->symbolic = true;
715 if (dynp->d_un.d_val & DF_TEXTREL)
716 obj->textrel = true;
717 if (dynp->d_un.d_val & DF_BIND_NOW)
718 obj->bind_now = true;
719 if (dynp->d_un.d_val & DF_STATIC_TLS)
720 ;
721 break;
722
984263bc
MD
723 default:
724 dbg("Ignoring d_tag %d = %#x", dynp->d_tag, dynp->d_tag);
725 break;
726 }
727 }
728
729 obj->traced = false;
730
731 if (plttype == DT_RELA) {
732 obj->pltrela = (const Elf_Rela *) obj->pltrel;
733 obj->pltrel = NULL;
734 obj->pltrelasize = obj->pltrelsize;
735 obj->pltrelsize = 0;
736 }
737
738 if (dyn_rpath != NULL)
739 obj->rpath = obj->strtab + dyn_rpath->d_un.d_val;
740}
741
742/*
743 * Process a shared object's program header. This is used only for the
744 * main program, when the kernel has already loaded the main program
745 * into memory before calling the dynamic linker. It creates and
746 * returns an Obj_Entry structure.
747 */
748static Obj_Entry *
749digest_phdr(const Elf_Phdr *phdr, int phnum, caddr_t entry, const char *path)
750{
751 Obj_Entry *obj;
752 const Elf_Phdr *phlimit = phdr + phnum;
753 const Elf_Phdr *ph;
754 int nsegs = 0;
755
756 obj = obj_new();
757 for (ph = phdr; ph < phlimit; ph++) {
758 switch (ph->p_type) {
759
760 case PT_PHDR:
761 if ((const Elf_Phdr *)ph->p_vaddr != phdr) {
762 _rtld_error("%s: invalid PT_PHDR", path);
763 return NULL;
764 }
765 obj->phdr = (const Elf_Phdr *) ph->p_vaddr;
766 obj->phsize = ph->p_memsz;
767 break;
768
769 case PT_INTERP:
770 obj->interp = (const char *) ph->p_vaddr;
771 break;
772
773 case PT_LOAD:
774 if (nsegs == 0) { /* First load segment */
775 obj->vaddrbase = trunc_page(ph->p_vaddr);
776 obj->mapbase = (caddr_t) obj->vaddrbase;
777 obj->relocbase = obj->mapbase - obj->vaddrbase;
778 obj->textsize = round_page(ph->p_vaddr + ph->p_memsz) -
779 obj->vaddrbase;
780 } else { /* Last load segment */
781 obj->mapsize = round_page(ph->p_vaddr + ph->p_memsz) -
782 obj->vaddrbase;
783 }
784 nsegs++;
785 break;
786
787 case PT_DYNAMIC:
788 obj->dynamic = (const Elf_Dyn *) ph->p_vaddr;
789 break;
790 }
791 }
792 if (nsegs < 1) {
793 _rtld_error("%s: too few PT_LOAD segments", path);
794 return NULL;
795 }
796
797 obj->entry = entry;
798 return obj;
799}
800
801static Obj_Entry *
802dlcheck(void *handle)
803{
804 Obj_Entry *obj;
805
806 for (obj = obj_list; obj != NULL; obj = obj->next)
807 if (obj == (Obj_Entry *) handle)
808 break;
809
810 if (obj == NULL || obj->refcount == 0 || obj->dl_refcount == 0) {
811 _rtld_error("Invalid shared object handle %p", handle);
812 return NULL;
813 }
814 return obj;
815}
816
817/*
818 * If the given object is already in the donelist, return true. Otherwise
819 * add the object to the list and return false.
820 */
821static bool
822donelist_check(DoneList *dlp, const Obj_Entry *obj)
823{
824 unsigned int i;
825
826 for (i = 0; i < dlp->num_used; i++)
827 if (dlp->objs[i] == obj)
828 return true;
829 /*
830 * Our donelist allocation should always be sufficient. But if
831 * our threads locking isn't working properly, more shared objects
832 * could have been loaded since we allocated the list. That should
833 * never happen, but we'll handle it properly just in case it does.
834 */
835 if (dlp->num_used < dlp->num_alloc)
836 dlp->objs[dlp->num_used++] = obj;
837 return false;
838}
839
840/*
841 * Hash function for symbol table lookup. Don't even think about changing
842 * this. It is specified by the System V ABI.
843 */
844unsigned long
845elf_hash(const char *name)
846{
847 const unsigned char *p = (const unsigned char *) name;
848 unsigned long h = 0;
849 unsigned long g;
850
851 while (*p != '\0') {
852 h = (h << 4) + *p++;
853 if ((g = h & 0xf0000000) != 0)
854 h ^= g >> 24;
855 h &= ~g;
856 }
857 return h;
858}
859
860/*
861 * Find the library with the given name, and return its full pathname.
862 * The returned string is dynamically allocated. Generates an error
863 * message and returns NULL if the library cannot be found.
864 *
865 * If the second argument is non-NULL, then it refers to an already-
866 * loaded shared object, whose library search path will be searched.
867 *
868 * The search order is:
984263bc 869 * LD_LIBRARY_PATH
4e390e27 870 * rpath in the referencing file
984263bc
MD
871 * ldconfig hints
872 * /usr/lib
873 */
874static char *
875find_library(const char *name, const Obj_Entry *refobj)
876{
877 char *pathname;
878
879 if (strchr(name, '/') != NULL) { /* Hard coded pathname */
880 if (name[0] != '/' && !trust) {
881 _rtld_error("Absolute pathname required for shared object \"%s\"",
882 name);
883 return NULL;
884 }
885 return xstrdup(name);
886 }
887
888 dbg(" Searching for \"%s\"", name);
889
890 if ((pathname = search_library_path(name, ld_library_path)) != NULL ||
891 (refobj != NULL &&
892 (pathname = search_library_path(name, refobj->rpath)) != NULL) ||
893 (pathname = search_library_path(name, gethints())) != NULL ||
894 (pathname = search_library_path(name, STANDARD_LIBRARY_PATH)) != NULL)
895 return pathname;
896
446c0d3a
JS
897 if(refobj != NULL && refobj->path != NULL) {
898 _rtld_error("Shared object \"%s\" not found, required by \"%s\"",
899 name, basename(refobj->path));
900 } else {
901 _rtld_error("Shared object \"%s\" not found", name);
902 }
984263bc
MD
903 return NULL;
904}
905
906/*
907 * Given a symbol number in a referencing object, find the corresponding
908 * definition of the symbol. Returns a pointer to the symbol, or NULL if
909 * no definition was found. Returns a pointer to the Obj_Entry of the
910 * defining object via the reference parameter DEFOBJ_OUT.
911 */
912const Elf_Sym *
913find_symdef(unsigned long symnum, const Obj_Entry *refobj,
914 const Obj_Entry **defobj_out, bool in_plt, SymCache *cache)
915{
916 const Elf_Sym *ref;
917 const Elf_Sym *def;
918 const Obj_Entry *defobj;
919 const char *name;
920 unsigned long hash;
921
922 /*
923 * If we have already found this symbol, get the information from
924 * the cache.
925 */
926 if (symnum >= refobj->nchains)
927 return NULL; /* Bad object */
928 if (cache != NULL && cache[symnum].sym != NULL) {
929 *defobj_out = cache[symnum].obj;
930 return cache[symnum].sym;
931 }
932
933 ref = refobj->symtab + symnum;
934 name = refobj->strtab + ref->st_name;
935 hash = elf_hash(name);
936 defobj = NULL;
937
938 def = symlook_default(name, hash, refobj, &defobj, in_plt);
939
940 /*
941 * If we found no definition and the reference is weak, treat the
942 * symbol as having the value zero.
943 */
944 if (def == NULL && ELF_ST_BIND(ref->st_info) == STB_WEAK) {
945 def = &sym_zero;
946 defobj = obj_main;
947 }
948
949 if (def != NULL) {
950 *defobj_out = defobj;
951 /* Record the information in the cache to avoid subsequent lookups. */
952 if (cache != NULL) {
953 cache[symnum].sym = def;
954 cache[symnum].obj = defobj;
955 }
956 } else
957 _rtld_error("%s: Undefined symbol \"%s\"", refobj->path, name);
958 return def;
959}
960
961/*
962 * Return the search path from the ldconfig hints file, reading it if
963 * necessary. Returns NULL if there are problems with the hints file,
964 * or if the search path there is empty.
965 */
966static const char *
967gethints(void)
968{
969 static char *hints;
970
971 if (hints == NULL) {
972 int fd;
973 struct elfhints_hdr hdr;
974 char *p;
975
976 /* Keep from trying again in case the hints file is bad. */
977 hints = "";
978
979 if ((fd = open(_PATH_ELF_HINTS, O_RDONLY)) == -1)
980 return NULL;
981 if (read(fd, &hdr, sizeof hdr) != sizeof hdr ||
982 hdr.magic != ELFHINTS_MAGIC ||
983 hdr.version != 1) {
984 close(fd);
985 return NULL;
986 }
987 p = xmalloc(hdr.dirlistlen + 1);
988 if (lseek(fd, hdr.strtab + hdr.dirlist, SEEK_SET) == -1 ||
989 read(fd, p, hdr.dirlistlen + 1) != hdr.dirlistlen + 1) {
990 free(p);
991 close(fd);
992 return NULL;
993 }
994 hints = p;
995 close(fd);
996 }
997 return hints[0] != '\0' ? hints : NULL;
998}
999
1000static void
1001init_dag(Obj_Entry *root)
1002{
1003 DoneList donelist;
1004
1005 donelist_init(&donelist);
1006 init_dag1(root, root, &donelist);
1007}
1008
1009static void
1010init_dag1(Obj_Entry *root, Obj_Entry *obj, DoneList *dlp)
1011{
1012 const Needed_Entry *needed;
1013
1014 if (donelist_check(dlp, obj))
1015 return;
1016 objlist_push_tail(&obj->dldags, root);
1017 objlist_push_tail(&root->dagmembers, obj);
1018 for (needed = obj->needed; needed != NULL; needed = needed->next)
1019 if (needed->obj != NULL)
1020 init_dag1(root, needed->obj, dlp);
1021}
1022
1023/*
1024 * Initialize the dynamic linker. The argument is the address at which
1025 * the dynamic linker has been mapped into memory. The primary task of
1026 * this function is to relocate the dynamic linker.
1027 */
1028static void
1029init_rtld(caddr_t mapbase)
1030{
1031 /*
1032 * Conjure up an Obj_Entry structure for the dynamic linker.
1033 *
1034 * The "path" member is supposed to be dynamically-allocated, but we
1035 * aren't yet initialized sufficiently to do that. Below we will
1036 * replace the static version with a dynamically-allocated copy.
1037 */
1038 obj_rtld.path = PATH_RTLD;
1039 obj_rtld.rtld = true;
1040 obj_rtld.mapbase = mapbase;
1041#ifdef PIC
1042 obj_rtld.relocbase = mapbase;
1043#endif
1044 if (&_DYNAMIC != 0) {
1045 obj_rtld.dynamic = rtld_dynamic(&obj_rtld);
1046 digest_dynamic(&obj_rtld);
1047 assert(obj_rtld.needed == NULL);
1048 assert(!obj_rtld.textrel);
1049
1050 /*
1051 * Temporarily put the dynamic linker entry into the object list, so
1052 * that symbols can be found.
1053 */
1054 obj_list = &obj_rtld;
1055 obj_tail = &obj_rtld.next;
1056 obj_count = 1;
1057
1058 relocate_objects(&obj_rtld, true);
1059 }
1060
1061 /* Make the object list empty again. */
1062 obj_list = NULL;
1063 obj_tail = &obj_list;
1064 obj_count = 0;
1065
1066 /* Replace the path with a dynamically allocated copy. */
1067 obj_rtld.path = xstrdup(obj_rtld.path);
1068
1069 r_debug.r_brk = r_debug_state;
1070 r_debug.r_state = RT_CONSISTENT;
1071}
1072
1073/*
1074 * Add the init functions from a needed object list (and its recursive
1075 * needed objects) to "list". This is not used directly; it is a helper
1076 * function for initlist_add_objects(). The write lock must be held
1077 * when this function is called.
1078 */
1079static void
1080initlist_add_neededs(Needed_Entry *needed, Objlist *list)
1081{
1082 /* Recursively process the successor needed objects. */
1083 if (needed->next != NULL)
1084 initlist_add_neededs(needed->next, list);
1085
1086 /* Process the current needed object. */
1087 if (needed->obj != NULL)
1088 initlist_add_objects(needed->obj, &needed->obj->next, list);
1089}
1090
1091/*
1092 * Scan all of the DAGs rooted in the range of objects from "obj" to
1093 * "tail" and add their init functions to "list". This recurses over
1094 * the DAGs and ensure the proper init ordering such that each object's
1095 * needed libraries are initialized before the object itself. At the
1096 * same time, this function adds the objects to the global finalization
1097 * list "list_fini" in the opposite order. The write lock must be
1098 * held when this function is called.
1099 */
1100static void
1101initlist_add_objects(Obj_Entry *obj, Obj_Entry **tail, Objlist *list)
1102{
1103 if (obj->init_done)
1104 return;
1105 obj->init_done = true;
1106
1107 /* Recursively process the successor objects. */
1108 if (&obj->next != tail)
1109 initlist_add_objects(obj->next, tail, list);
1110
1111 /* Recursively process the needed objects. */
1112 if (obj->needed != NULL)
1113 initlist_add_neededs(obj->needed, list);
1114
1115 /* Add the object to the init list. */
1116 if (obj->init != NULL)
1117 objlist_push_tail(list, obj);
1118
1119 /* Add the object to the global fini list in the reverse order. */
1120 if (obj->fini != NULL)
1121 objlist_push_head(&list_fini, obj);
1122}
1123
1124static bool
1125is_exported(const Elf_Sym *def)
1126{
1127 func_ptr_type value;
1128 const func_ptr_type *p;
1129
1130 value = (func_ptr_type)(obj_rtld.relocbase + def->st_value);
1131 for (p = exports; *p != NULL; p++)
1132 if (*p == value)
1133 return true;
1134 return false;
1135}
1136
1137/*
1138 * Given a shared object, traverse its list of needed objects, and load
1139 * each of them. Returns 0 on success. Generates an error message and
1140 * returns -1 on failure.
1141 */
1142static int
1143load_needed_objects(Obj_Entry *first)
1144{
1145 Obj_Entry *obj;
1146
1147 for (obj = first; obj != NULL; obj = obj->next) {
1148 Needed_Entry *needed;
1149
1150 for (needed = obj->needed; needed != NULL; needed = needed->next) {
1151 const char *name = obj->strtab + needed->name;
1152 char *path = find_library(name, obj);
1153
1154 needed->obj = NULL;
1155 if (path == NULL && !ld_tracing)
1156 return -1;
1157
1158 if (path) {
1159 needed->obj = load_object(path);
1160 if (needed->obj == NULL && !ld_tracing)
1161 return -1; /* XXX - cleanup */
1162 }
1163 }
1164 }
1165
1166 return 0;
1167}
1168
1169static int
1170load_preload_objects(void)
1171{
1172 char *p = ld_preload;
1173 static const char delim[] = " \t:;";
1174
1175 if (p == NULL)
1176 return NULL;
1177
1178 p += strspn(p, delim);
1179 while (*p != '\0') {
1180 size_t len = strcspn(p, delim);
1181 char *path;
1182 char savech;
1183
1184 savech = p[len];
1185 p[len] = '\0';
1186 if ((path = find_library(p, NULL)) == NULL)
1187 return -1;
1188 if (load_object(path) == NULL)
1189 return -1; /* XXX - cleanup */
1190 p[len] = savech;
1191 p += len;
1192 p += strspn(p, delim);
1193 }
1194 return 0;
1195}
1196
b6a22d96
JS
1197/*
1198 * Returns a point to the Obj_Entry for the object with the given path.
1199 * Returns NULL if no matching object was found.
1200 */
1201static Obj_Entry *
1202find_object(const char *path)
1203{
1204 Obj_Entry *obj;
1205
1206 for (obj = obj_list->next; obj != NULL; obj = obj->next) {
1207 if (strcmp(obj->path, path) == 0)
1208 return(obj);
1209 }
1210 return(NULL);
1211}
1212
984263bc
MD
1213/*
1214 * Load a shared object into memory, if it is not already loaded. The
1215 * argument must be a string allocated on the heap. This function assumes
1216 * responsibility for freeing it when necessary.
1217 *
1218 * Returns a pointer to the Obj_Entry for the object. Returns NULL
1219 * on failure.
1220 */
1221static Obj_Entry *
1222load_object(char *path)
1223{
1224 Obj_Entry *obj;
1225 int fd = -1;
1226 struct stat sb;
1227
b6a22d96 1228 obj = find_object(path);
984263bc
MD
1229
1230 /*
1231 * If we didn't find a match by pathname, open the file and check
1232 * again by device and inode. This avoids false mismatches caused
1233 * by multiple links or ".." in pathnames.
1234 *
1235 * To avoid a race, we open the file and use fstat() rather than
1236 * using stat().
1237 */
1238 if (obj == NULL) {
1239 if ((fd = open(path, O_RDONLY)) == -1) {
1240 _rtld_error("Cannot open \"%s\"", path);
1241 return NULL;
1242 }
1243 if (fstat(fd, &sb) == -1) {
1244 _rtld_error("Cannot fstat \"%s\"", path);
1245 close(fd);
1246 return NULL;
1247 }
1248 for (obj = obj_list->next; obj != NULL; obj = obj->next) {
1249 if (obj->ino == sb.st_ino && obj->dev == sb.st_dev) {
1250 close(fd);
1251 break;
1252 }
1253 }
1254 }
1255
1256 if (obj == NULL) { /* First use of this object, so we must map it in */
1257 dbg("loading \"%s\"", path);
1258 obj = map_object(fd, path, &sb);
1259 close(fd);
1260 if (obj == NULL) {
1261 free(path);
1262 return NULL;
1263 }
1264
1265 obj->path = path;
1266 digest_dynamic(obj);
1267
1268 *obj_tail = obj;
1269 obj_tail = &obj->next;
1270 obj_count++;
1271 linkmap_add(obj); /* for GDB & dlinfo() */
1272
1273 dbg(" %p .. %p: %s", obj->mapbase,
1274 obj->mapbase + obj->mapsize - 1, obj->path);
1275 if (obj->textrel)
1276 dbg(" WARNING: %s has impure text", obj->path);
1277 } else
1278 free(path);
1279
1280 obj->refcount++;
1281 return obj;
1282}
1283
1284/*
1285 * Check for locking violations and die if one is found.
1286 */
1287static void
1288lock_check(void)
1289{
1290 int rcount, wcount;
1291
1292 rcount = lockinfo.rcount;
1293 wcount = lockinfo.wcount;
1294 assert(rcount >= 0);
1295 assert(wcount >= 0);
1296 if (wcount > 1 || (wcount != 0 && rcount != 0)) {
1297 _rtld_error("Application locking error: %d readers and %d writers"
1298 " in dynamic linker. See DLLOCKINIT(3) in manual pages.",
1299 rcount, wcount);
1300 die();
1301 }
1302}
1303
1304static Obj_Entry *
1305obj_from_addr(const void *addr)
1306{
984263bc
MD
1307 Obj_Entry *obj;
1308
984263bc 1309 for (obj = obj_list; obj != NULL; obj = obj->next) {
984263bc
MD
1310 if (addr < (void *) obj->mapbase)
1311 continue;
c6873e56 1312 if (addr < (void *) (obj->mapbase + obj->mapsize))
984263bc
MD
1313 return obj;
1314 }
1315 return NULL;
1316}
1317
1318/*
1319 * Call the finalization functions for each of the objects in "list"
1320 * which are unreferenced. All of the objects are expected to have
1321 * non-NULL fini functions.
1322 */
1323static void
1324objlist_call_fini(Objlist *list)
1325{
1326 Objlist_Entry *elm;
1327 char *saved_msg;
1328
1329 /*
1330 * Preserve the current error message since a fini function might
1331 * call into the dynamic linker and overwrite it.
1332 */
1333 saved_msg = errmsg_save();
1334 STAILQ_FOREACH(elm, list, link) {
1335 if (elm->obj->refcount == 0) {
1336 dbg("calling fini function for %s", elm->obj->path);
1337 (*elm->obj->fini)();
1338 }
1339 }
1340 errmsg_restore(saved_msg);
1341}
1342
1343/*
1344 * Call the initialization functions for each of the objects in
1345 * "list". All of the objects are expected to have non-NULL init
1346 * functions.
1347 */
1348static void
1349objlist_call_init(Objlist *list)
1350{
1351 Objlist_Entry *elm;
1352 char *saved_msg;
1353
1354 /*
1355 * Preserve the current error message since an init function might
1356 * call into the dynamic linker and overwrite it.
1357 */
1358 saved_msg = errmsg_save();
1359 STAILQ_FOREACH(elm, list, link) {
1360 dbg("calling init function for %s", elm->obj->path);
1361 (*elm->obj->init)();
1362 }
1363 errmsg_restore(saved_msg);
1364}
1365
1366static void
1367objlist_clear(Objlist *list)
1368{
1369 Objlist_Entry *elm;
1370
1371 while (!STAILQ_EMPTY(list)) {
1372 elm = STAILQ_FIRST(list);
1373 STAILQ_REMOVE_HEAD(list, link);
1374 free(elm);
1375 }
1376}
1377
1378static Objlist_Entry *
1379objlist_find(Objlist *list, const Obj_Entry *obj)
1380{
1381 Objlist_Entry *elm;
1382
1383 STAILQ_FOREACH(elm, list, link)
1384 if (elm->obj == obj)
1385 return elm;
1386 return NULL;
1387}
1388
1389static void
1390objlist_init(Objlist *list)
1391{
1392 STAILQ_INIT(list);
1393}
1394
1395static void
1396objlist_push_head(Objlist *list, Obj_Entry *obj)
1397{
1398 Objlist_Entry *elm;
1399
1400 elm = NEW(Objlist_Entry);
1401 elm->obj = obj;
1402 STAILQ_INSERT_HEAD(list, elm, link);
1403}
1404
1405static void
1406objlist_push_tail(Objlist *list, Obj_Entry *obj)
1407{
1408 Objlist_Entry *elm;
1409
1410 elm = NEW(Objlist_Entry);
1411 elm->obj = obj;
1412 STAILQ_INSERT_TAIL(list, elm, link);
1413}
1414
1415static void
1416objlist_remove(Objlist *list, Obj_Entry *obj)
1417{
1418 Objlist_Entry *elm;
1419
1420 if ((elm = objlist_find(list, obj)) != NULL) {
1421 STAILQ_REMOVE(list, elm, Struct_Objlist_Entry, link);
1422 free(elm);
1423 }
1424}
1425
1426/*
1427 * Remove all of the unreferenced objects from "list".
1428 */
1429static void
1430objlist_remove_unref(Objlist *list)
1431{
1432 Objlist newlist;
1433 Objlist_Entry *elm;
1434
1435 STAILQ_INIT(&newlist);
1436 while (!STAILQ_EMPTY(list)) {
1437 elm = STAILQ_FIRST(list);
1438 STAILQ_REMOVE_HEAD(list, link);
1439 if (elm->obj->refcount == 0)
1440 free(elm);
1441 else
1442 STAILQ_INSERT_TAIL(&newlist, elm, link);
1443 }
1444 *list = newlist;
1445}
1446
1447/*
1448 * Relocate newly-loaded shared objects. The argument is a pointer to
1449 * the Obj_Entry for the first such object. All objects from the first
1450 * to the end of the list of objects are relocated. Returns 0 on success,
1451 * or -1 on failure.
1452 */
1453static int
1454relocate_objects(Obj_Entry *first, bool bind_now)
1455{
1456 Obj_Entry *obj;
1457
1458 for (obj = first; obj != NULL; obj = obj->next) {
1459 if (obj != &obj_rtld)
1460 dbg("relocating \"%s\"", obj->path);
1461 if (obj->nbuckets == 0 || obj->nchains == 0 || obj->buckets == NULL ||
1462 obj->symtab == NULL || obj->strtab == NULL) {
1463 _rtld_error("%s: Shared object has no run-time symbol table",
1464 obj->path);
1465 return -1;
1466 }
1467
1468 if (obj->textrel) {
1469 /* There are relocations to the write-protected text segment. */
1470 if (mprotect(obj->mapbase, obj->textsize,
1471 PROT_READ|PROT_WRITE|PROT_EXEC) == -1) {
1472 _rtld_error("%s: Cannot write-enable text segment: %s",
1473 obj->path, strerror(errno));
1474 return -1;
1475 }
1476 }
1477
1478 /* Process the non-PLT relocations. */
1479 if (reloc_non_plt(obj, &obj_rtld))
1480 return -1;
1481
4b89341e
MD
1482 /*
1483 * Reprotect the text segment. Make sure it is included in the
1484 * core dump since we modified it. This unfortunately causes the
1485 * entire text segment to core-out but we don't have much of a
1486 * choice. We could try to only reenable core dumps on pages
1487 * in which relocations occured but that is likely most of the text
1488 * pages anyway, and even that would not work because the rest of
1489 * the text pages would wind up as a read-only OBJT_DEFAULT object
1490 * (created due to our modifications) backed by the original OBJT_VNODE
1491 * object, and the ELF coredump code is currently only able to dump
1492 * vnode records for pure vnode-backed mappings, not vnode backings
1493 * to memory objects.
1494 */
1495 if (obj->textrel) {
1496 madvise(obj->mapbase, obj->textsize, MADV_CORE);
984263bc
MD
1497 if (mprotect(obj->mapbase, obj->textsize,
1498 PROT_READ|PROT_EXEC) == -1) {
1499 _rtld_error("%s: Cannot write-protect text segment: %s",
1500 obj->path, strerror(errno));
1501 return -1;
1502 }
1503 }
1504
1505 /* Process the PLT relocations. */
1506 if (reloc_plt(obj) == -1)
1507 return -1;
1508 /* Relocate the jump slots if we are doing immediate binding. */
167f7029 1509 if (obj->bind_now || bind_now)
984263bc
MD
1510 if (reloc_jmpslots(obj) == -1)
1511 return -1;
1512
1513
1514 /*
1515 * Set up the magic number and version in the Obj_Entry. These
1516 * were checked in the crt1.o from the original ElfKit, so we
1517 * set them for backward compatibility.
1518 */
1519 obj->magic = RTLD_MAGIC;
1520 obj->version = RTLD_VERSION;
1521
1522 /* Set the special PLT or GOT entries. */
1523 init_pltgot(obj);
1524 }
1525
1526 return 0;
1527}
1528
1529/*
1530 * Cleanup procedure. It will be called (by the atexit mechanism) just
1531 * before the process exits.
1532 */
1533static void
1534rtld_exit(void)
1535{
1536 Obj_Entry *obj;
1537
1538 dbg("rtld_exit()");
1539 /* Clear all the reference counts so the fini functions will be called. */
1540 for (obj = obj_list; obj != NULL; obj = obj->next)
1541 obj->refcount = 0;
1542 objlist_call_fini(&list_fini);
1543 /* No need to remove the items from the list, since we are exiting. */
1544}
1545
1546static void *
1547path_enumerate(const char *path, path_enum_proc callback, void *arg)
1548{
1549 if (path == NULL)
1550 return (NULL);
1551
1552 path += strspn(path, ":;");
1553 while (*path != '\0') {
1554 size_t len;
1555 char *res;
1556
1557 len = strcspn(path, ":;");
1558 res = callback(path, len, arg);
1559
1560 if (res != NULL)
1561 return (res);
1562
1563 path += len;
1564 path += strspn(path, ":;");
1565 }
1566
1567 return (NULL);
1568}
1569
1570struct try_library_args {
1571 const char *name;
1572 size_t namelen;
1573 char *buffer;
1574 size_t buflen;
1575};
1576
1577static void *
1578try_library_path(const char *dir, size_t dirlen, void *param)
1579{
1580 struct try_library_args *arg;
1581
1582 arg = param;
1583 if (*dir == '/' || trust) {
1584 char *pathname;
1585
1586 if (dirlen + 1 + arg->namelen + 1 > arg->buflen)
1587 return (NULL);
1588
1589 pathname = arg->buffer;
1590 strncpy(pathname, dir, dirlen);
1591 pathname[dirlen] = '/';
1592 strcpy(pathname + dirlen + 1, arg->name);
1593
1594 dbg(" Trying \"%s\"", pathname);
1595 if (access(pathname, F_OK) == 0) { /* We found it */
1596 pathname = xmalloc(dirlen + 1 + arg->namelen + 1);
1597 strcpy(pathname, arg->buffer);
1598 return (pathname);
1599 }
1600 }
1601 return (NULL);
1602}
1603
1604static char *
1605search_library_path(const char *name, const char *path)
1606{
1607 char *p;
1608 struct try_library_args arg;
1609
1610 if (path == NULL)
1611 return NULL;
1612
1613 arg.name = name;
1614 arg.namelen = strlen(name);
1615 arg.buffer = xmalloc(PATH_MAX);
1616 arg.buflen = PATH_MAX;
1617
1618 p = path_enumerate(path, try_library_path, &arg);
1619
1620 free(arg.buffer);
1621
1622 return (p);
1623}
1624
1625int
1626dlclose(void *handle)
1627{
1628 Obj_Entry *root;
1629
1630 wlock_acquire();
1631 root = dlcheck(handle);
1632 if (root == NULL) {
1633 wlock_release();
1634 return -1;
1635 }
1636
1637 /* Unreference the object and its dependencies. */
1638 root->dl_refcount--;
1639 unref_dag(root);
1640
1641 if (root->refcount == 0) {
1642 /*
1643 * The object is no longer referenced, so we must unload it.
1644 * First, call the fini functions with no locks held.
1645 */
1646 wlock_release();
1647 objlist_call_fini(&list_fini);
1648 wlock_acquire();
1649 objlist_remove_unref(&list_fini);
1650
1651 /* Finish cleaning up the newly-unreferenced objects. */
1652 GDB_STATE(RT_DELETE,&root->linkmap);
1653 unload_object(root);
1654 GDB_STATE(RT_CONSISTENT,NULL);
1655 }
1656 wlock_release();
1657 return 0;
1658}
1659
1660const char *
1661dlerror(void)
1662{
1663 char *msg = error_message;
1664 error_message = NULL;
1665 return msg;
1666}
1667
1668/*
1669 * This function is deprecated and has no effect.
1670 */
1671void
1672dllockinit(void *context,
1673 void *(*lock_create)(void *context),
1674 void (*rlock_acquire)(void *lock),
1675 void (*wlock_acquire)(void *lock),
1676 void (*lock_release)(void *lock),
1677 void (*lock_destroy)(void *lock),
1678 void (*context_destroy)(void *context))
1679{
1680 static void *cur_context;
1681 static void (*cur_context_destroy)(void *);
1682
1683 /* Just destroy the context from the previous call, if necessary. */
1684 if (cur_context_destroy != NULL)
1685 cur_context_destroy(cur_context);
1686 cur_context = context;
1687 cur_context_destroy = context_destroy;
1688}
1689
1690void *
1691dlopen(const char *name, int mode)
1692{
1693 Obj_Entry **old_obj_tail;
1694 Obj_Entry *obj;
1695 Objlist initlist;
1696 int result;
1697
1698 ld_tracing = (mode & RTLD_TRACE) == 0 ? NULL : "1";
1699 if (ld_tracing != NULL)
1700 environ = (char **)*get_program_var_addr("environ");
1701
1702 objlist_init(&initlist);
1703
1704 wlock_acquire();
1705 GDB_STATE(RT_ADD,NULL);
1706
1707 old_obj_tail = obj_tail;
1708 obj = NULL;
1709 if (name == NULL) {
1710 obj = obj_main;
1711 obj->refcount++;
1712 } else {
1713 char *path = find_library(name, obj_main);
1714 if (path != NULL)
1715 obj = load_object(path);
1716 }
1717
1718 if (obj) {
1719 obj->dl_refcount++;
8ca15ec8 1720 if ((mode & RTLD_GLOBAL) && objlist_find(&list_global, obj) == NULL)
984263bc
MD
1721 objlist_push_tail(&list_global, obj);
1722 mode &= RTLD_MODEMASK;
1723 if (*old_obj_tail != NULL) { /* We loaded something new. */
1724 assert(*old_obj_tail == obj);
1725
1726 result = load_needed_objects(obj);
1727 if (result != -1 && ld_tracing)
1728 goto trace;
1729
1730 if (result == -1 ||
1731 (init_dag(obj), relocate_objects(obj, mode == RTLD_NOW)) == -1) {
1732 obj->dl_refcount--;
1733 unref_dag(obj);
1734 if (obj->refcount == 0)
1735 unload_object(obj);
1736 obj = NULL;
1737 } else {
1738 /* Make list of init functions to call. */
1739 initlist_add_objects(obj, &obj->next, &initlist);
1740 }
1741 } else if (ld_tracing)
1742 goto trace;
1743 }
1744
1745 GDB_STATE(RT_CONSISTENT,obj ? &obj->linkmap : NULL);
1746
1747 /* Call the init functions with no locks held. */
1748 wlock_release();
1749 objlist_call_init(&initlist);
1750 wlock_acquire();
1751 objlist_clear(&initlist);
1752 wlock_release();
1753 return obj;
1754trace:
1755 trace_loaded_objects(obj);
1756 wlock_release();
1757 exit(0);
1758}
1759
1760void *
1761dlsym(void *handle, const char *name)
1762{
1763 const Obj_Entry *obj;
1764 unsigned long hash;
1765 const Elf_Sym *def;
1766 const Obj_Entry *defobj;
1767
1768 hash = elf_hash(name);
1769 def = NULL;
1770 defobj = NULL;
1771
1772 rlock_acquire();
1773 if (handle == NULL || handle == RTLD_NEXT ||
1774 handle == RTLD_DEFAULT || handle == RTLD_SELF) {
1775 void *retaddr;
1776
1777 retaddr = __builtin_return_address(0); /* __GNUC__ only */
1778 if ((obj = obj_from_addr(retaddr)) == NULL) {
1779 _rtld_error("Cannot determine caller's shared object");
1780 rlock_release();
1781 return NULL;
1782 }
1783 if (handle == NULL) { /* Just the caller's shared object. */
1784 def = symlook_obj(name, hash, obj, true);
1785 defobj = obj;
1786 } else if (handle == RTLD_NEXT || /* Objects after caller's */
1787 handle == RTLD_SELF) { /* ... caller included */
1788 if (handle == RTLD_NEXT)
1789 obj = obj->next;
1790 for (; obj != NULL; obj = obj->next) {
1791 if ((def = symlook_obj(name, hash, obj, true)) != NULL) {
1792 defobj = obj;
1793 break;
1794 }
1795 }
1796 } else {
1797 assert(handle == RTLD_DEFAULT);
1798 def = symlook_default(name, hash, obj, &defobj, true);
1799 }
1800 } else {
1801 if ((obj = dlcheck(handle)) == NULL) {
1802 rlock_release();
1803 return NULL;
1804 }
1805
1806 if (obj->mainprog) {
1807 DoneList donelist;
1808
1809 /* Search main program and all libraries loaded by it. */
1810 donelist_init(&donelist);
1811 def = symlook_list(name, hash, &list_main, &defobj, true,
1812 &donelist);
1813 } else {
1814 /*
1815 * XXX - This isn't correct. The search should include the whole
1816 * DAG rooted at the given object.
1817 */
1818 def = symlook_obj(name, hash, obj, true);
1819 defobj = obj;
1820 }
1821 }
1822
1823 if (def != NULL) {
1824 rlock_release();
1825 return defobj->relocbase + def->st_value;
1826 }
1827
1828 _rtld_error("Undefined symbol \"%s\"", name);
1829 rlock_release();
1830 return NULL;
1831}
1832
1833int
1834dladdr(const void *addr, Dl_info *info)
1835{
1836 const Obj_Entry *obj;
1837 const Elf_Sym *def;
1838 void *symbol_addr;
1839 unsigned long symoffset;
1840
1841 rlock_acquire();
1842 obj = obj_from_addr(addr);
1843 if (obj == NULL) {
1844 _rtld_error("No shared object contains address");
1845 rlock_release();
1846 return 0;
1847 }
1848 info->dli_fname = obj->path;
1849 info->dli_fbase = obj->mapbase;
1850 info->dli_saddr = (void *)0;
1851 info->dli_sname = NULL;
1852
1853 /*
1854 * Walk the symbol list looking for the symbol whose address is
1855 * closest to the address sent in.
1856 */
1857 for (symoffset = 0; symoffset < obj->nchains; symoffset++) {
1858 def = obj->symtab + symoffset;
1859
1860 /*
1861 * For skip the symbol if st_shndx is either SHN_UNDEF or
1862 * SHN_COMMON.
1863 */
1864 if (def->st_shndx == SHN_UNDEF || def->st_shndx == SHN_COMMON)
1865 continue;
1866
1867 /*
1868 * If the symbol is greater than the specified address, or if it
1869 * is further away from addr than the current nearest symbol,
1870 * then reject it.
1871 */
1872 symbol_addr = obj->relocbase + def->st_value;
1873 if (symbol_addr > addr || symbol_addr < info->dli_saddr)
1874 continue;
1875
1876 /* Update our idea of the nearest symbol. */
1877 info->dli_sname = obj->strtab + def->st_name;
1878 info->dli_saddr = symbol_addr;
1879
1880 /* Exact match? */
1881 if (info->dli_saddr == addr)
1882 break;
1883 }
1884 rlock_release();
1885 return 1;
1886}
1887
1888int
1889dlinfo(void *handle, int request, void *p)
1890{
1891 const Obj_Entry *obj;
1892 int error;
1893
1894 rlock_acquire();
1895
1896 if (handle == NULL || handle == RTLD_SELF) {
1897 void *retaddr;
1898
1899 retaddr = __builtin_return_address(0); /* __GNUC__ only */
1900 if ((obj = obj_from_addr(retaddr)) == NULL)
1901 _rtld_error("Cannot determine caller's shared object");
1902 } else
1903 obj = dlcheck(handle);
1904
1905 if (obj == NULL) {
1906 rlock_release();
1907 return (-1);
1908 }
1909
1910 error = 0;
1911 switch (request) {
1912 case RTLD_DI_LINKMAP:
1913 *((struct link_map const **)p) = &obj->linkmap;
1914 break;
1915 case RTLD_DI_ORIGIN:
1916 error = rtld_dirname(obj->path, p);
1917 break;
1918
1919 case RTLD_DI_SERINFOSIZE:
1920 case RTLD_DI_SERINFO:
1921 error = do_search_info(obj, request, (struct dl_serinfo *)p);
1922 break;
1923
1924 default:
1925 _rtld_error("Invalid request %d passed to dlinfo()", request);
1926 error = -1;
1927 }
1928
1929 rlock_release();
1930
1931 return (error);
1932}
1933
1934struct fill_search_info_args {
1935 int request;
1936 unsigned int flags;
1937 Dl_serinfo *serinfo;
1938 Dl_serpath *serpath;
1939 char *strspace;
1940};
1941
1942static void *
1943fill_search_info(const char *dir, size_t dirlen, void *param)
1944{
1945 struct fill_search_info_args *arg;
1946
1947 arg = param;
1948
1949 if (arg->request == RTLD_DI_SERINFOSIZE) {
1950 arg->serinfo->dls_cnt ++;
1951 arg->serinfo->dls_size += dirlen + 1;
1952 } else {
1953 struct dl_serpath *s_entry;
1954
1955 s_entry = arg->serpath;
1956 s_entry->dls_name = arg->strspace;
1957 s_entry->dls_flags = arg->flags;
1958
1959 strncpy(arg->strspace, dir, dirlen);
1960 arg->strspace[dirlen] = '\0';
1961
1962 arg->strspace += dirlen + 1;
1963 arg->serpath++;
1964 }
1965
1966 return (NULL);
1967}
1968
1969static int
1970do_search_info(const Obj_Entry *obj, int request, struct dl_serinfo *info)
1971{
1972 struct dl_serinfo _info;
1973 struct fill_search_info_args args;
1974
1975 args.request = RTLD_DI_SERINFOSIZE;
1976 args.serinfo = &_info;
1977
1978 _info.dls_size = __offsetof(struct dl_serinfo, dls_serpath);
1979 _info.dls_cnt = 0;
1980
1981 path_enumerate(ld_library_path, fill_search_info, &args);
1982 path_enumerate(obj->rpath, fill_search_info, &args);
1983 path_enumerate(gethints(), fill_search_info, &args);
1984 path_enumerate(STANDARD_LIBRARY_PATH, fill_search_info, &args);
1985
1986
1987 if (request == RTLD_DI_SERINFOSIZE) {
1988 info->dls_size = _info.dls_size;
1989 info->dls_cnt = _info.dls_cnt;
1990 return (0);
1991 }
1992
1993 if (info->dls_cnt != _info.dls_cnt || info->dls_size != _info.dls_size) {
1994 _rtld_error("Uninitialized Dl_serinfo struct passed to dlinfo()");
1995 return (-1);
1996 }
1997
1998 args.request = RTLD_DI_SERINFO;
1999 args.serinfo = info;
2000 args.serpath = &info->dls_serpath[0];
2001 args.strspace = (char *)&info->dls_serpath[_info.dls_cnt];
2002
2003 args.flags = LA_SER_LIBPATH;
2004 if (path_enumerate(ld_library_path, fill_search_info, &args) != NULL)
2005 return (-1);
2006
2007 args.flags = LA_SER_RUNPATH;
2008 if (path_enumerate(obj->rpath, fill_search_info, &args) != NULL)
2009 return (-1);
2010
2011 args.flags = LA_SER_CONFIG;
2012 if (path_enumerate(gethints(), fill_search_info, &args) != NULL)
2013 return (-1);
2014
2015 args.flags = LA_SER_DEFAULT;
2016 if (path_enumerate(STANDARD_LIBRARY_PATH, fill_search_info, &args) != NULL)
2017 return (-1);
2018 return (0);
2019}
2020
2021static int
2022rtld_dirname(const char *path, char *bname)
2023{
2024 const char *endp;
2025
2026 /* Empty or NULL string gets treated as "." */
2027 if (path == NULL || *path == '\0') {
2028 bname[0] = '.';
2029 bname[1] = '\0';
2030 return (0);
2031 }
2032
2033 /* Strip trailing slashes */
2034 endp = path + strlen(path) - 1;
2035 while (endp > path && *endp == '/')
2036 endp--;
2037
2038 /* Find the start of the dir */
2039 while (endp > path && *endp != '/')
2040 endp--;
2041
2042 /* Either the dir is "/" or there are no slashes */
2043 if (endp == path) {
2044 bname[0] = *endp == '/' ? '/' : '.';
2045 bname[1] = '\0';
2046 return (0);
2047 } else {
2048 do {
2049 endp--;
2050 } while (endp > path && *endp == '/');
2051 }
2052
2053 if (endp - path + 2 > PATH_MAX)
2054 {
2055 _rtld_error("Filename is too long: %s", path);
2056 return(-1);
2057 }
2058
2059 strncpy(bname, path, endp - path + 1);
2060 bname[endp - path + 1] = '\0';
2061 return (0);
2062}
2063
2064static void
2065linkmap_add(Obj_Entry *obj)
2066{
2067 struct link_map *l = &obj->linkmap;
2068 struct link_map *prev;
2069
2070 obj->linkmap.l_name = obj->path;
2071 obj->linkmap.l_addr = obj->mapbase;
2072 obj->linkmap.l_ld = obj->dynamic;
2073#ifdef __mips__
2074 /* GDB needs load offset on MIPS to use the symbols */
2075 obj->linkmap.l_offs = obj->relocbase;
2076#endif
2077
2078 if (r_debug.r_map == NULL) {
2079 r_debug.r_map = l;
2080 return;
2081 }
2082
2083 /*
2084 * Scan to the end of the list, but not past the entry for the
2085 * dynamic linker, which we want to keep at the very end.
2086 */
2087 for (prev = r_debug.r_map;
2088 prev->l_next != NULL && prev->l_next != &obj_rtld.linkmap;
2089 prev = prev->l_next)
2090 ;
2091
2092 /* Link in the new entry. */
2093 l->l_prev = prev;
2094 l->l_next = prev->l_next;
2095 if (l->l_next != NULL)
2096 l->l_next->l_prev = l;
2097 prev->l_next = l;
2098}
2099
2100static void
2101linkmap_delete(Obj_Entry *obj)
2102{
2103 struct link_map *l = &obj->linkmap;
2104
2105 if (l->l_prev == NULL) {
2106 if ((r_debug.r_map = l->l_next) != NULL)
2107 l->l_next->l_prev = NULL;
2108 return;
2109 }
2110
2111 if ((l->l_prev->l_next = l->l_next) != NULL)
2112 l->l_next->l_prev = l->l_prev;
2113}
2114
2115/*
2116 * Function for the debugger to set a breakpoint on to gain control.
2117 *
2118 * The two parameters allow the debugger to easily find and determine
2119 * what the runtime loader is doing and to whom it is doing it.
2120 *
2121 * When the loadhook trap is hit (r_debug_state, set at program
2122 * initialization), the arguments can be found on the stack:
2123 *
2124 * +8 struct link_map *m
2125 * +4 struct r_debug *rd
2126 * +0 RetAddr
2127 */
2128void
2129r_debug_state(struct r_debug* rd, struct link_map *m)
2130{
2131}
2132
2133/*
2134 * Get address of the pointer variable in the main program.
2135 */
2136static const void **
2137get_program_var_addr(const char *name)
2138{
2139 const Obj_Entry *obj;
2140 unsigned long hash;
2141
2142 hash = elf_hash(name);
2143 for (obj = obj_main; obj != NULL; obj = obj->next) {
2144 const Elf_Sym *def;
2145
2146 if ((def = symlook_obj(name, hash, obj, false)) != NULL) {
2147 const void **addr;
2148
2149 addr = (const void **)(obj->relocbase + def->st_value);
2150 return addr;
2151 }
2152 }
2153 return NULL;
2154}
2155
2156/*
2157 * Set a pointer variable in the main program to the given value. This
2158 * is used to set key variables such as "environ" before any of the
2159 * init functions are called.
2160 */
2161static void
2162set_program_var(const char *name, const void *value)
2163{
2164 const void **addr;
2165
2166 if ((addr = get_program_var_addr(name)) != NULL) {
2167 dbg("\"%s\": *%p <-- %p", name, addr, value);
2168 *addr = value;
2169 }
2170}
2171
8ca15ec8
MD
2172/*
2173 * This is a special version of getenv which is far more efficient
2174 * at finding LD_ environment vars.
2175 */
2176static
2177const char *
2178_getenv_ld(const char *id)
2179{
2180 const char *envp;
2181 int i, j;
2182 int idlen = strlen(id);
2183
2184 if (ld_index == LD_ARY_CACHE)
2185 return(getenv(id));
2186 if (ld_index == 0) {
2187 for (i = j = 0; (envp = environ[i]) != NULL && j < LD_ARY_CACHE; ++i) {
2188 if (envp[0] == 'L' && envp[1] == 'D' && envp[2] == '_')
2189 ld_ary[j++] = envp;
2190 }
2191 if (j == 0)
2192 ld_ary[j++] = "";
2193 ld_index = j;
2194 }
2195 for (i = ld_index - 1; i >= 0; --i) {
2196 if (strncmp(ld_ary[i], id, idlen) == 0 && ld_ary[i][idlen] == '=')
2197 return(ld_ary[i] + idlen + 1);
2198 }
2199 return(NULL);
2200}
2201
984263bc
MD
2202/*
2203 * Given a symbol name in a referencing object, find the corresponding
2204 * definition of the symbol. Returns a pointer to the symbol, or NULL if
2205 * no definition was found. Returns a pointer to the Obj_Entry of the
2206 * defining object via the reference parameter DEFOBJ_OUT.
2207 */
2208static const Elf_Sym *
2209symlook_default(const char *name, unsigned long hash,
2210 const Obj_Entry *refobj, const Obj_Entry **defobj_out, bool in_plt)
2211{
2212 DoneList donelist;
2213 const Elf_Sym *def;
2214 const Elf_Sym *symp;
2215 const Obj_Entry *obj;
2216 const Obj_Entry *defobj;
2217 const Objlist_Entry *elm;
2218 def = NULL;
2219 defobj = NULL;
2220 donelist_init(&donelist);
2221
2222 /* Look first in the referencing object if linked symbolically. */
2223 if (refobj->symbolic && !donelist_check(&donelist, refobj)) {
2224 symp = symlook_obj(name, hash, refobj, in_plt);
2225 if (symp != NULL) {
2226 def = symp;
2227 defobj = refobj;
2228 }
2229 }
2230
2231 /* Search all objects loaded at program start up. */
2232 if (def == NULL || ELF_ST_BIND(def->st_info) == STB_WEAK) {
2233 symp = symlook_list(name, hash, &list_main, &obj, in_plt, &donelist);
2234 if (symp != NULL &&
2235 (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
2236 def = symp;
2237 defobj = obj;
2238 }
2239 }
2240
2241 /* Search all DAGs whose roots are RTLD_GLOBAL objects. */
2242 STAILQ_FOREACH(elm, &list_global, link) {
2243 if (def != NULL && ELF_ST_BIND(def->st_info) != STB_WEAK)
2244 break;
2245 symp = symlook_list(name, hash, &elm->obj->dagmembers, &obj, in_plt,
2246 &donelist);
2247 if (symp != NULL &&
2248 (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
2249 def = symp;
2250 defobj = obj;
2251 }
2252 }
2253
2254 /* Search all dlopened DAGs containing the referencing object. */
2255 STAILQ_FOREACH(elm, &refobj->dldags, link) {
2256 if (def != NULL && ELF_ST_BIND(def->st_info) != STB_WEAK)
2257 break;
2258 symp = symlook_list(name, hash, &elm->obj->dagmembers, &obj, in_plt,
2259 &donelist);
2260 if (symp != NULL &&
2261 (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
2262 def = symp;
2263 defobj = obj;
2264 }
2265 }
2266
2267 /*
2268 * Search the dynamic linker itself, and possibly resolve the
2269 * symbol from there. This is how the application links to
2270 * dynamic linker services such as dlopen. Only the values listed
2271 * in the "exports" array can be resolved from the dynamic linker.
2272 */
2273 if (def == NULL || ELF_ST_BIND(def->st_info) == STB_WEAK) {
2274 symp = symlook_obj(name, hash, &obj_rtld, in_plt);
2275 if (symp != NULL && is_exported(symp)) {
2276 def = symp;
2277 defobj = &obj_rtld;
2278 }
2279 }
2280
2281 if (def != NULL)
2282 *defobj_out = defobj;
2283 return def;
2284}
2285
2286static const Elf_Sym *
2287symlook_list(const char *name, unsigned long hash, Objlist *objlist,
2288 const Obj_Entry **defobj_out, bool in_plt, DoneList *dlp)
2289{
2290 const Elf_Sym *symp;
2291 const Elf_Sym *def;
2292 const Obj_Entry *defobj;
2293 const Objlist_Entry *elm;
2294
2295 def = NULL;
2296 defobj = NULL;
2297 STAILQ_FOREACH(elm, objlist, link) {
2298 if (donelist_check(dlp, elm->obj))
2299 continue;
2300 if ((symp = symlook_obj(name, hash, elm->obj, in_plt)) != NULL) {
2301 if (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK) {
2302 def = symp;
2303 defobj = elm->obj;
2304 if (ELF_ST_BIND(def->st_info) != STB_WEAK)
2305 break;
2306 }
2307 }
2308 }
2309 if (def != NULL)
2310 *defobj_out = defobj;
2311 return def;
2312}
2313
2314/*
2315 * Search the symbol table of a single shared object for a symbol of
2316 * the given name. Returns a pointer to the symbol, or NULL if no
2317 * definition was found.
2318 *
2319 * The symbol's hash value is passed in for efficiency reasons; that
2320 * eliminates many recomputations of the hash value.
2321 */
2322const Elf_Sym *
2323symlook_obj(const char *name, unsigned long hash, const Obj_Entry *obj,
2324 bool in_plt)
2325{
2326 if (obj->buckets != NULL) {
2327 unsigned long symnum = obj->buckets[hash % obj->nbuckets];
2328
2329 while (symnum != STN_UNDEF) {
2330 const Elf_Sym *symp;
2331 const char *strp;
2332
2333 if (symnum >= obj->nchains)
2334 return NULL; /* Bad object */
2335 symp = obj->symtab + symnum;
2336 strp = obj->strtab + symp->st_name;
2337
2338 if (name[0] == strp[0] && strcmp(name, strp) == 0)
2339 return symp->st_shndx != SHN_UNDEF ||
2340 (!in_plt && symp->st_value != 0 &&
2341 ELF_ST_TYPE(symp->st_info) == STT_FUNC) ? symp : NULL;
2342
2343 symnum = obj->chains[symnum];
2344 }
2345 }
2346 return NULL;
2347}
2348
2349static void
2350trace_loaded_objects(Obj_Entry *obj)
2351{
8ca15ec8 2352 const char *fmt1, *fmt2, *fmt, *main_local;
984263bc
MD
2353 int c;
2354
8ca15ec8 2355 if ((main_local = _getenv_ld("LD_TRACE_LOADED_OBJECTS_PROGNAME")) == NULL)
984263bc
MD
2356 main_local = "";
2357
8ca15ec8 2358 if ((fmt1 = _getenv_ld("LD_TRACE_LOADED_OBJECTS_FMT1")) == NULL)
984263bc
MD
2359 fmt1 = "\t%o => %p (%x)\n";
2360
8ca15ec8 2361 if ((fmt2 = _getenv_ld("LD_TRACE_LOADED_OBJECTS_FMT2")) == NULL)
984263bc
MD
2362 fmt2 = "\t%o (%x)\n";
2363
2364 for (; obj; obj = obj->next) {
2365 Needed_Entry *needed;
2366 char *name, *path;
2367 bool is_lib;
2368
2369 for (needed = obj->needed; needed; needed = needed->next) {
2370 if (needed->obj != NULL) {
2371 if (needed->obj->traced)
2372 continue;
2373 needed->obj->traced = true;
2374 path = needed->obj->path;
2375 } else
2376 path = "not found";
2377
2378 name = (char *)obj->strtab + needed->name;
2379 is_lib = strncmp(name, "lib", 3) == 0; /* XXX - bogus */
2380
2381 fmt = is_lib ? fmt1 : fmt2;
2382 while ((c = *fmt++) != '\0') {
2383 switch (c) {
2384 default:
2385 putchar(c);
2386 continue;
2387 case '\\':
2388 switch (c = *fmt) {
2389 case '\0':
2390 continue;
2391 case 'n':
2392 putchar('\n');
2393 break;
2394 case 't':
2395 putchar('\t');
2396 break;
2397 }
2398 break;
2399 case '%':
2400 switch (c = *fmt) {
2401 case '\0':
2402 continue;
2403 case '%':
2404 default:
2405 putchar(c);
2406 break;
2407 case 'A':
2408 printf("%s", main_local);
2409 break;
2410 case 'a':
2411 printf("%s", obj_main->path);
2412 break;
2413 case 'o':
2414 printf("%s", name);
2415 break;
2416#if 0
2417 case 'm':
2418 printf("%d", sodp->sod_major);
2419 break;
2420 case 'n':
2421 printf("%d", sodp->sod_minor);
2422 break;
2423#endif
2424 case 'p':
2425 printf("%s", path);
2426 break;
2427 case 'x':
2428 printf("%p", needed->obj ? needed->obj->mapbase : 0);
2429 break;
2430 }
2431 break;
2432 }
2433 ++fmt;
2434 }
2435 }
2436 }
2437}
2438
2439/*
2440 * Unload a dlopened object and its dependencies from memory and from
2441 * our data structures. It is assumed that the DAG rooted in the
2442 * object has already been unreferenced, and that the object has a
2443 * reference count of 0.
2444 */
2445static void
2446unload_object(Obj_Entry *root)
2447{
2448 Obj_Entry *obj;
2449 Obj_Entry **linkp;
2450
2451 assert(root->refcount == 0);
2452
2453 /*
2454 * Pass over the DAG removing unreferenced objects from
2455 * appropriate lists.
2456 */
2457 unlink_object(root);
2458
2459 /* Unmap all objects that are no longer referenced. */
2460 linkp = &obj_list->next;
2461 while ((obj = *linkp) != NULL) {
2462 if (obj->refcount == 0) {
2463 dbg("unloading \"%s\"", obj->path);
2464 munmap(obj->mapbase, obj->mapsize);
2465 linkmap_delete(obj);
2466 *linkp = obj->next;
2467 obj_count--;
2468 obj_free(obj);
2469 } else
2470 linkp = &obj->next;
2471 }
2472 obj_tail = linkp;
2473}
2474
2475static void
2476unlink_object(Obj_Entry *root)
2477{
2478 const Needed_Entry *needed;
2479 Objlist_Entry *elm;
2480
2481 if (root->refcount == 0) {
2482 /* Remove the object from the RTLD_GLOBAL list. */
2483 objlist_remove(&list_global, root);
2484
2485 /* Remove the object from all objects' DAG lists. */
2486 STAILQ_FOREACH(elm, &root->dagmembers , link)
2487 objlist_remove(&elm->obj->dldags, root);
2488 }
2489
2490 for (needed = root->needed; needed != NULL; needed = needed->next)
2491 if (needed->obj != NULL)
2492 unlink_object(needed->obj);
2493}
2494
2495static void
2496unref_dag(Obj_Entry *root)
2497{
2498 const Needed_Entry *needed;
2499
2500 if (root->refcount == 0)
2501 return;
2502 root->refcount--;
2503 if (root->refcount == 0)
2504 for (needed = root->needed; needed != NULL; needed = needed->next)
2505 if (needed->obj != NULL)
2506 unref_dag(needed->obj);
2507}