1 /* $NetBSD: rtld.c,v 1.105 2004/05/17 13:16:02 skrll Exp $ */ 2 3 /* 4 * Copyright 1996 John D. Polstra. 5 * Copyright 1996 Matt Thomas <matt@3am-software.com> 6 * Copyright 2002 Charles M. Hannum <root@ihack.net> 7 * All rights reserved. 8 * 9 * Redistribution and use in source and binary forms, with or without 10 * modification, are permitted provided that the following conditions 11 * are met: 12 * 1. Redistributions of source code must retain the above copyright 13 * notice, this list of conditions and the following disclaimer. 14 * 2. Redistributions in binary form must reproduce the above copyright 15 * notice, this list of conditions and the following disclaimer in the 16 * documentation and/or other materials provided with the distribution. 17 * 3. All advertising materials mentioning features or use of this software 18 * must display the following acknowledgement: 19 * This product includes software developed by John Polstra. 20 * 4. The name of the author may not be used to endorse or promote products 21 * derived from this software without specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 24 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 25 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 26 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 27 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 28 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 29 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 30 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 31 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 32 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 33 */ 34 35 /* 36 * Dynamic linker for ELF. 37 * 38 * John Polstra <jdp@polstra.com>. 39 */ 40 41 #include <err.h> 42 #include <errno.h> 43 #include <fcntl.h> 44 #include <stdarg.h> 45 #include <stdio.h> 46 #include <stdlib.h> 47 #include <string.h> 48 #include <unistd.h> 49 #include <sys/param.h> 50 #include <sys/mman.h> 51 #include <dirent.h> 52 53 #include <ctype.h> 54 55 #include <dlfcn.h> 56 #include "debug.h" 57 #include "rtld.h" 58 59 #if !defined(lint) 60 #include "sysident.h" 61 #endif 62 63 /* 64 * Function declarations. 65 */ 66 static void _rtld_init(caddr_t, caddr_t); 67 static void _rtld_exit(void); 68 69 Elf_Addr _rtld(Elf_Addr *, Elf_Addr); 70 71 72 /* 73 * Data declarations. 74 */ 75 static char *error_message; /* Message for dlopen(), or NULL */ 76 77 struct r_debug _rtld_debug; /* for GDB; */ 78 bool _rtld_trust; /* False for setuid and setgid programs */ 79 Obj_Entry *_rtld_objlist; /* Head of linked list of shared objects */ 80 Obj_Entry **_rtld_objtail; /* Link field of last object in list */ 81 Obj_Entry *_rtld_objmain; /* The main program shared object */ 82 Obj_Entry _rtld_objself; /* The dynamic linker shared object */ 83 char *_rtld_path = _PATH_RTLD; 84 Elf_Sym _rtld_sym_zero; /* For resolving undefined weak refs. */ 85 int _rtld_pagesz; /* Page size, as provided by kernel */ 86 87 Search_Path *_rtld_default_paths; 88 Search_Path *_rtld_paths; 89 90 Library_Xform *_rtld_xforms; 91 92 /* 93 * Global declarations normally provided by crt0. 94 */ 95 char *__progname; 96 char **environ; 97 98 extern Elf_Addr _GLOBAL_OFFSET_TABLE_[]; 99 extern Elf_Dyn _DYNAMIC; 100 101 static void _rtld_call_fini_functions(Obj_Entry *); 102 static void _rtld_call_init_functions(Obj_Entry *); 103 static Obj_Entry *_rtld_dlcheck(void *); 104 static void _rtld_init_dag(Obj_Entry *); 105 static void _rtld_init_dag1(Obj_Entry *, Obj_Entry *); 106 static void _rtld_objlist_remove(Objlist *, Obj_Entry *); 107 static void _rtld_unload_object(Obj_Entry *, bool); 108 static void _rtld_unref_dag(Obj_Entry *); 109 static Obj_Entry *_rtld_obj_from_addr(const void *); 110 111 static void 112 _rtld_call_fini_functions(Obj_Entry *first) 113 { 114 Obj_Entry *obj; 115 116 for (obj = first; obj != NULL; obj = obj->next) 117 if (obj->fini != NULL) 118 (*obj->fini)(); 119 } 120 121 static void 122 _rtld_call_init_functions(Obj_Entry *first) 123 { 124 125 if (first != NULL) { 126 _rtld_call_init_functions(first->next); 127 if (first->init != NULL) 128 (*first->init)(); 129 } 130 } 131 132 /* 133 * Initialize the dynamic linker. The argument is the address at which 134 * the dynamic linker has been mapped into memory. The primary task of 135 * this function is to create an Obj_Entry for the dynamic linker and 136 * to resolve the PLT relocation for platforms that need it (those that 137 * define __HAVE_FUNCTION_DESCRIPTORS 138 */ 139 static void 140 _rtld_init(caddr_t mapbase, caddr_t relocbase) 141 { 142 143 /* Conjure up an Obj_Entry structure for the dynamic linker. */ 144 _rtld_objself.path = _rtld_path; 145 _rtld_objself.pathlen = strlen(_rtld_path); 146 _rtld_objself.rtld = true; 147 _rtld_objself.mapbase = mapbase; 148 _rtld_objself.relocbase = relocbase; 149 _rtld_objself.dynamic = (Elf_Dyn *) &_DYNAMIC; 150 151 _rtld_digest_dynamic(&_rtld_objself); 152 assert(!_rtld_objself.needed); 153 #if !defined(__hppa__) 154 assert(!_rtld_objself.pltrel && !_rtld_objself.pltrela); 155 #else 156 _rtld_relocate_plt_objects(&_rtld_objself); 157 #endif 158 #if !defined(__mips__) && !defined(__hppa__) 159 assert(!_rtld_objself.pltgot); 160 #endif 161 #if !defined(__arm__) && !defined(__mips__) && !defined(__sh__) 162 /* ARM, MIPS and SH{3,5} have a bogus DT_TEXTREL. */ 163 assert(!_rtld_objself.textrel); 164 #endif 165 166 _rtld_add_paths(&_rtld_default_paths, RTLD_DEFAULT_LIBRARY_PATH); 167 168 /* 169 * Set up the _rtld_objlist pointer, so that rtld symbols can be found. 170 */ 171 _rtld_objlist = &_rtld_objself; 172 173 /* Make the object list empty again. */ 174 _rtld_objlist = NULL; 175 _rtld_objtail = &_rtld_objlist; 176 177 _rtld_debug.r_brk = _rtld_debug_state; 178 _rtld_debug.r_state = RT_CONSISTENT; 179 } 180 181 /* 182 * Cleanup procedure. It will be called (by the atexit() mechanism) just 183 * before the process exits. 184 */ 185 static void 186 _rtld_exit(void) 187 { 188 189 dbg(("rtld_exit()")); 190 191 _rtld_call_fini_functions(_rtld_objlist->next); 192 } 193 194 /* 195 * Main entry point for dynamic linking. The argument is the stack 196 * pointer. The stack is expected to be laid out as described in the 197 * SVR4 ABI specification, Intel 386 Processor Supplement. Specifically, 198 * the stack pointer points to a word containing ARGC. Following that 199 * in the stack is a null-terminated sequence of pointers to argument 200 * strings. Then comes a null-terminated sequence of pointers to 201 * environment strings. Finally, there is a sequence of "auxiliary 202 * vector" entries. 203 * 204 * This function returns the entry point for the main program, the dynamic 205 * linker's exit procedure in sp[0], and a pointer to the main object in 206 * sp[1]. 207 */ 208 Elf_Addr 209 _rtld(Elf_Addr *sp, Elf_Addr relocbase) 210 { 211 const AuxInfo *pAUX_base, *pAUX_entry, *pAUX_execfd, *pAUX_phdr, 212 *pAUX_phent, *pAUX_phnum, *pAUX_euid, *pAUX_egid, 213 *pAUX_ruid, *pAUX_rgid; 214 const AuxInfo *pAUX_pagesz; 215 char **env; 216 const AuxInfo *aux; 217 const AuxInfo *auxp; 218 Elf_Addr *const osp = sp; 219 bool bind_now = 0; 220 const char *ld_bind_now; 221 const char **argv; 222 long argc; 223 const char **real___progname; 224 const Obj_Entry **real___mainprog_obj; 225 char ***real_environ; 226 #if defined(RTLD_DEBUG) 227 int i = 0; 228 #endif 229 230 /* 231 * On entry, the dynamic linker itself has not been relocated yet. 232 * Be very careful not to reference any global data until after 233 * _rtld_init has returned. It is OK to reference file-scope statics 234 * and string constants, and to call static and global functions. 235 */ 236 /* Find the auxiliary vector on the stack. */ 237 /* first Elf_Word reserved to address of exit routine */ 238 #if defined(RTLD_DEBUG) 239 debug = 1; 240 dbg(("sp = %p, argc = %ld, argv = %p <%s> relocbase %p", sp, 241 (long)sp[2], &sp[3], (char *) sp[3], (void *)relocbase)); 242 dbg(("got is at %p, dynamic is at %p", _GLOBAL_OFFSET_TABLE_, 243 &_DYNAMIC)); 244 dbg(("_ctype_ is %p", _ctype_)); 245 #endif 246 247 sp += 2; /* skip over return argument space */ 248 argv = (const char **) &sp[1]; 249 argc = *(long *)sp; 250 sp += 2 + argc; /* Skip over argc, arguments, and NULL 251 * terminator */ 252 env = (char **) sp; 253 while (*sp++ != 0) { /* Skip over environment, and NULL terminator */ 254 #if defined(RTLD_DEBUG) 255 dbg(("env[%d] = %p %s", i++, (void *)sp[-1], (char *)sp[-1])); 256 #endif 257 } 258 aux = (const AuxInfo *) sp; 259 260 pAUX_base = pAUX_entry = pAUX_execfd = NULL; 261 pAUX_phdr = pAUX_phent = pAUX_phnum = NULL; 262 pAUX_euid = pAUX_ruid = pAUX_egid = pAUX_rgid = NULL; 263 pAUX_pagesz = NULL; 264 265 /* Digest the auxiliary vector. */ 266 for (auxp = aux; auxp->a_type != AT_NULL; ++auxp) { 267 switch (auxp->a_type) { 268 case AT_BASE: 269 pAUX_base = auxp; 270 break; 271 case AT_ENTRY: 272 pAUX_entry = auxp; 273 break; 274 case AT_EXECFD: 275 pAUX_execfd = auxp; 276 break; 277 case AT_PHDR: 278 pAUX_phdr = auxp; 279 break; 280 case AT_PHENT: 281 pAUX_phent = auxp; 282 break; 283 case AT_PHNUM: 284 pAUX_phnum = auxp; 285 break; 286 #ifdef AT_EUID 287 case AT_EUID: 288 pAUX_euid = auxp; 289 break; 290 case AT_RUID: 291 pAUX_ruid = auxp; 292 break; 293 case AT_EGID: 294 pAUX_egid = auxp; 295 break; 296 case AT_RGID: 297 pAUX_rgid = auxp; 298 break; 299 #endif 300 case AT_PAGESZ: 301 pAUX_pagesz = auxp; 302 break; 303 } 304 } 305 306 /* Initialize and relocate ourselves. */ 307 if (pAUX_base == NULL) { 308 _rtld_error("Bad pAUX_base"); 309 _rtld_die(); 310 } 311 assert(pAUX_pagesz != NULL); 312 _rtld_pagesz = (int)pAUX_pagesz->a_v; 313 _rtld_init((caddr_t)pAUX_base->a_v, (caddr_t)relocbase); 314 315 __progname = _rtld_objself.path; 316 environ = env; 317 318 _rtld_trust = ((pAUX_euid ? (uid_t)pAUX_euid->a_v : geteuid()) == 319 (pAUX_ruid ? (uid_t)pAUX_ruid->a_v : getuid())) && 320 ((pAUX_egid ? (gid_t)pAUX_egid->a_v : getegid()) == 321 (pAUX_rgid ? (gid_t)pAUX_rgid->a_v : getgid())); 322 323 ld_bind_now = getenv("LD_BIND_NOW"); 324 if (ld_bind_now != NULL && *ld_bind_now != '\0') 325 bind_now = true; 326 if (_rtld_trust) { 327 #ifdef DEBUG 328 const char *ld_debug = getenv("LD_DEBUG"); 329 #ifdef RTLD_DEBUG 330 debug = 0; 331 #endif 332 if (ld_debug != NULL && *ld_debug != '\0') 333 debug = 1; 334 #endif 335 _rtld_add_paths(&_rtld_paths, getenv("LD_LIBRARY_PATH")); 336 } 337 _rtld_process_hints(&_rtld_paths, &_rtld_xforms, _PATH_LD_HINTS); 338 dbg(("dynamic linker is initialized, mapbase=%p, relocbase=%p", 339 _rtld_objself.mapbase, _rtld_objself.relocbase)); 340 341 /* 342 * Load the main program, or process its program header if it is 343 * already loaded. 344 */ 345 if (pAUX_execfd != NULL) { /* Load the main program. */ 346 int fd = pAUX_execfd->a_v; 347 dbg(("loading main program")); 348 _rtld_objmain = _rtld_map_object(xstrdup(argv[0] ? argv[0] : 349 "main program"), fd, NULL); 350 close(fd); 351 if (_rtld_objmain == NULL) 352 _rtld_die(); 353 } else { /* Main program already loaded. */ 354 const Elf_Phdr *phdr; 355 int phnum; 356 caddr_t entry; 357 358 dbg(("processing main program's program header")); 359 assert(pAUX_phdr != NULL); 360 phdr = (const Elf_Phdr *) pAUX_phdr->a_v; 361 assert(pAUX_phnum != NULL); 362 phnum = pAUX_phnum->a_v; 363 assert(pAUX_phent != NULL); 364 assert(pAUX_phent->a_v == sizeof(Elf_Phdr)); 365 assert(pAUX_entry != NULL); 366 entry = (caddr_t) pAUX_entry->a_v; 367 _rtld_objmain = _rtld_digest_phdr(phdr, phnum, entry); 368 _rtld_objmain->path = xstrdup(argv[0] ? argv[0] : 369 "main program"); 370 _rtld_objmain->pathlen = strlen(_rtld_objmain->path); 371 } 372 373 _rtld_objmain->mainprog = true; 374 375 /* 376 * Get the actual dynamic linker pathname from the executable if 377 * possible. (It should always be possible.) That ensures that 378 * gdb will find the right dynamic linker even if a non-standard 379 * one is being used. 380 */ 381 if (_rtld_objmain->interp != NULL && 382 strcmp(_rtld_objmain->interp, _rtld_objself.path) != 0) 383 _rtld_objself.path = xstrdup(_rtld_objmain->interp); 384 dbg(("actual dynamic linker is %s", _rtld_objself.path)); 385 386 _rtld_digest_dynamic(_rtld_objmain); 387 388 /* Link the main program into the list of objects. */ 389 *_rtld_objtail = _rtld_objmain; 390 _rtld_objtail = &_rtld_objmain->next; 391 392 _rtld_linkmap_add(_rtld_objmain); 393 _rtld_linkmap_add(&_rtld_objself); 394 395 ++_rtld_objmain->refcount; 396 _rtld_objmain->mainref = 1; 397 _rtld_objlist_add(&_rtld_list_main, _rtld_objmain); 398 399 /* Initialize a fake symbol for resolving undefined weak references. */ 400 _rtld_sym_zero.st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE); 401 _rtld_sym_zero.st_shndx = SHN_ABS; 402 403 /* 404 * Pre-load user-specified objects after the main program but before 405 * any shared object dependencies. 406 */ 407 dbg(("preloading objects")); 408 if (_rtld_trust && _rtld_preload(getenv("LD_PRELOAD")) == -1) 409 _rtld_die(); 410 411 dbg(("loading needed objects")); 412 if (_rtld_load_needed_objects(_rtld_objmain, RTLD_MAIN) == -1) 413 _rtld_die(); 414 415 dbg(("relocating objects")); 416 if (_rtld_relocate_objects(_rtld_objmain, bind_now) == -1) 417 _rtld_die(); 418 419 dbg(("doing copy relocations")); 420 if (_rtld_do_copy_relocations(_rtld_objmain) == -1) 421 _rtld_die(); 422 423 /* 424 * Set the __progname, environ and, __mainprog_obj before 425 * calling anything that might use them. 426 */ 427 real___progname = _rtld_objmain_sym("__progname"); 428 if (real___progname) { 429 if (argv[0] != NULL) { 430 if ((*real___progname = strrchr(argv[0], '/')) == NULL) 431 (*real___progname) = argv[0]; 432 else 433 (*real___progname)++; 434 } else { 435 (*real___progname) = NULL; 436 } 437 } 438 real_environ = _rtld_objmain_sym("environ"); 439 if (real_environ) 440 *real_environ = environ; 441 /* 442 * Set __mainprog_obj for old binaries. 443 */ 444 real___mainprog_obj = _rtld_objmain_sym("__mainprog_obj"); 445 if (real___mainprog_obj) 446 *real___mainprog_obj = _rtld_objmain; 447 448 dbg(("calling _init functions")); 449 _rtld_call_init_functions(_rtld_objmain->next); 450 451 dbg(("control at program entry point = %p, obj = %p, exit = %p", 452 _rtld_objmain->entry, _rtld_objmain, _rtld_exit)); 453 454 /* 455 * Return with the entry point and the exit procedure in at the top 456 * of stack. 457 */ 458 459 _rtld_debug_state(); /* say hello to gdb! */ 460 461 ((void **) osp)[0] = _rtld_exit; 462 ((void **) osp)[1] = _rtld_objmain; 463 return (Elf_Addr) _rtld_objmain->entry; 464 } 465 466 void 467 _rtld_die(void) 468 { 469 const char *msg = dlerror(); 470 471 if (msg == NULL) 472 msg = "Fatal error"; 473 xerrx(1, "%s", msg); 474 } 475 476 static Obj_Entry * 477 _rtld_dlcheck(void *handle) 478 { 479 Obj_Entry *obj; 480 481 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) 482 if (obj == (Obj_Entry *) handle) 483 break; 484 485 if (obj == NULL || obj->dl_refcount == 0) { 486 xwarnx("Invalid shared object handle %p", handle); 487 return NULL; 488 } 489 return obj; 490 } 491 492 static void 493 _rtld_init_dag(Obj_Entry *root) 494 { 495 496 _rtld_init_dag1(root, root); 497 } 498 499 static void 500 _rtld_init_dag1(Obj_Entry *root, Obj_Entry *obj) 501 { 502 const Needed_Entry *needed; 503 504 if (!obj->mainref) { 505 if (_rtld_objlist_find(&obj->dldags, root)) 506 return; 507 rdbg(("add %p (%s) to %p (%s) DAG", obj, obj->path, root, 508 root->path)); 509 _rtld_objlist_add(&obj->dldags, root); 510 _rtld_objlist_add(&root->dagmembers, obj); 511 } 512 for (needed = obj->needed; needed != NULL; needed = needed->next) 513 if (needed->obj != NULL) 514 _rtld_init_dag1(root, needed->obj); 515 } 516 517 /* 518 * Note, this is called only for objects loaded by dlopen(). 519 */ 520 static void 521 _rtld_unload_object(Obj_Entry *root, bool do_fini_funcs) 522 { 523 524 _rtld_unref_dag(root); 525 if (root->refcount == 0) { /* We are finished with some objects. */ 526 Obj_Entry *obj; 527 Obj_Entry **linkp; 528 Objlist_Entry *elm; 529 530 /* Finalize objects that are about to be unmapped. */ 531 if (do_fini_funcs) 532 for (obj = _rtld_objlist->next; obj != NULL; obj = obj->next) 533 if (obj->refcount == 0 && obj->fini != NULL) 534 (*obj->fini)(); 535 536 /* Remove the DAG from all objects' DAG lists. */ 537 SIMPLEQ_FOREACH(elm, &root->dagmembers, link) 538 _rtld_objlist_remove(&elm->obj->dldags, root); 539 540 /* Remove the DAG from the RTLD_GLOBAL list. */ 541 if (root->globalref) { 542 root->globalref = 0; 543 _rtld_objlist_remove(&_rtld_list_global, root); 544 } 545 546 /* Unmap all objects that are no longer referenced. */ 547 linkp = &_rtld_objlist->next; 548 while ((obj = *linkp) != NULL) { 549 if (obj->refcount == 0) { 550 #ifdef RTLD_DEBUG 551 dbg(("unloading \"%s\"", obj->path)); 552 #endif 553 munmap(obj->mapbase, obj->mapsize); 554 _rtld_objlist_remove(&_rtld_list_global, obj); 555 _rtld_linkmap_delete(obj); 556 *linkp = obj->next; 557 _rtld_obj_free(obj); 558 } else 559 linkp = &obj->next; 560 } 561 _rtld_objtail = linkp; 562 } 563 } 564 565 static void 566 _rtld_unref_dag(Obj_Entry *root) 567 { 568 569 assert(root); 570 assert(root->refcount != 0); 571 --root->refcount; 572 if (root->refcount == 0) { 573 const Needed_Entry *needed; 574 575 for (needed = root->needed; needed != NULL; 576 needed = needed->next) { 577 if (needed->obj != NULL) 578 _rtld_unref_dag(needed->obj); 579 } 580 } 581 } 582 583 int 584 dlclose(void *handle) 585 { 586 Obj_Entry *root = _rtld_dlcheck(handle); 587 588 if (root == NULL) 589 return -1; 590 591 _rtld_debug.r_state = RT_DELETE; 592 _rtld_debug_state(); 593 594 --root->dl_refcount; 595 _rtld_unload_object(root, true); 596 597 _rtld_debug.r_state = RT_CONSISTENT; 598 _rtld_debug_state(); 599 600 return 0; 601 } 602 603 char * 604 dlerror(void) 605 { 606 char *msg = error_message; 607 608 error_message = NULL; 609 return msg; 610 } 611 612 void * 613 dlopen(const char *name, int mode) 614 { 615 Obj_Entry **old_obj_tail = _rtld_objtail; 616 Obj_Entry *obj = NULL; 617 618 _rtld_debug.r_state = RT_ADD; 619 _rtld_debug_state(); 620 621 if (name == NULL) { 622 obj = _rtld_objmain; 623 obj->refcount++; 624 } else 625 obj = _rtld_load_library(name, _rtld_objmain, mode); 626 627 if (obj != NULL) { 628 ++obj->dl_refcount; 629 if (*old_obj_tail != NULL) { /* We loaded something new. */ 630 assert(*old_obj_tail == obj); 631 632 if (_rtld_load_needed_objects(obj, mode) == -1 || 633 (_rtld_init_dag(obj), 634 _rtld_relocate_objects(obj, 635 ((mode & 3) == RTLD_NOW))) == -1) { 636 _rtld_unload_object(obj, false); 637 obj->dl_refcount--; 638 obj = NULL; 639 } else 640 _rtld_call_init_functions(obj); 641 } 642 } 643 _rtld_debug.r_state = RT_CONSISTENT; 644 _rtld_debug_state(); 645 646 return obj; 647 } 648 649 /* 650 * Find a symbol in the main program. 651 */ 652 void * 653 _rtld_objmain_sym(const char *name) 654 { 655 unsigned long hash; 656 const Elf_Sym *def; 657 const Obj_Entry *obj; 658 659 hash = _rtld_elf_hash(name); 660 obj = _rtld_objmain; 661 662 def = _rtld_symlook_list(name, hash, &_rtld_list_main, &obj, false); 663 664 if (def != NULL) 665 return obj->relocbase + def->st_value; 666 return(NULL); 667 } 668 669 void * 670 dlsym(void *handle, const char *name) 671 { 672 const Obj_Entry *obj; 673 unsigned long hash; 674 const Elf_Sym *def; 675 const Obj_Entry *defobj; 676 void *retaddr; 677 678 hash = _rtld_elf_hash(name); 679 def = NULL; 680 defobj = NULL; 681 682 switch ((intptr_t)handle) { 683 case (intptr_t)NULL: 684 case (intptr_t)RTLD_NEXT: 685 case (intptr_t)RTLD_DEFAULT: 686 case (intptr_t)RTLD_SELF: 687 retaddr = __builtin_return_address(0); /* __GNUC__ only */ 688 if ((obj = _rtld_obj_from_addr(retaddr)) == NULL) { 689 _rtld_error("Cannot determine caller's shared object"); 690 return NULL; 691 } 692 693 switch ((intptr_t)handle) { 694 case (intptr_t)NULL: /* Just the caller's shared object. */ 695 def = _rtld_symlook_obj(name, hash, obj, false); 696 defobj = obj; 697 break; 698 699 case (intptr_t)RTLD_NEXT: /* Objects after callers */ 700 obj = obj->next; 701 /*FALLTHROUGH*/ 702 703 case (intptr_t)RTLD_SELF: /* Caller included */ 704 for (; obj; obj = obj->next) { 705 if ((def = _rtld_symlook_obj(name, hash, obj, 706 false)) != NULL) { 707 defobj = obj; 708 break; 709 } 710 } 711 break; 712 713 case (intptr_t)RTLD_DEFAULT: 714 def = _rtld_symlook_default(name, hash, obj, &defobj, 715 false); 716 break; 717 718 default: 719 abort(); 720 } 721 break; 722 723 default: 724 if ((obj = _rtld_dlcheck(handle)) == NULL) 725 return NULL; 726 727 if (obj->mainprog) { 728 /* Search main program and all libraries loaded by it */ 729 def = _rtld_symlook_list(name, hash, &_rtld_list_main, 730 &defobj, false); 731 } else { 732 /* 733 * XXX - This isn't correct. The search should include 734 * the whole DAG rooted at the given object. 735 */ 736 def = _rtld_symlook_obj(name, hash, obj, false); 737 defobj = obj; 738 } 739 break; 740 } 741 742 if (def != NULL) { 743 #ifdef __HAVE_FUNCTION_DESCRIPTORS 744 if (ELF_ST_TYPE(def->st_info) == STT_FUNC) 745 return (void *)_rtld_function_descriptor_alloc(defobj, 746 def, 0); 747 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 748 return defobj->relocbase + def->st_value; 749 } 750 751 _rtld_error("Undefined symbol \"%s\"", name); 752 return NULL; 753 } 754 755 int 756 dladdr(const void *addr, Dl_info *info) 757 { 758 const Obj_Entry *obj; 759 const Elf_Sym *def, *best_def; 760 void *symbol_addr; 761 unsigned long symoffset; 762 763 #ifdef __HAVE_FUNCTION_DESCRIPTORS 764 addr = _rtld_function_descriptor_function(addr); 765 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 766 767 obj = _rtld_obj_from_addr(addr); 768 if (obj == NULL) { 769 _rtld_error("No shared object contains address"); 770 return 0; 771 } 772 info->dli_fname = obj->path; 773 info->dli_fbase = obj->mapbase; 774 info->dli_saddr = (void *)0; 775 info->dli_sname = NULL; 776 777 /* 778 * Walk the symbol list looking for the symbol whose address is 779 * closest to the address sent in. 780 */ 781 best_def = NULL; 782 for (symoffset = 0; symoffset < obj->nchains; symoffset++) { 783 def = obj->symtab + symoffset; 784 785 /* 786 * For skip the symbol if st_shndx is either SHN_UNDEF or 787 * SHN_COMMON. 788 */ 789 if (def->st_shndx == SHN_UNDEF || def->st_shndx == SHN_COMMON) 790 continue; 791 792 /* 793 * If the symbol is greater than the specified address, or if it 794 * is further away from addr than the current nearest symbol, 795 * then reject it. 796 */ 797 symbol_addr = obj->relocbase + def->st_value; 798 if (symbol_addr > addr || symbol_addr < info->dli_saddr) 799 continue; 800 801 /* Update our idea of the nearest symbol. */ 802 info->dli_sname = obj->strtab + def->st_name; 803 info->dli_saddr = symbol_addr; 804 best_def = def; 805 806 /* Exact match? */ 807 if (info->dli_saddr == addr) 808 break; 809 } 810 811 #ifdef __HAVE_FUNCTION_DESCRIPTORS 812 if (best_def != NULL && ELF_ST_TYPE(best_def->st_info) == STT_FUNC) 813 info->dli_saddr = (void *)_rtld_function_descriptor_alloc(obj, 814 best_def, 0); 815 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 816 817 return 1; 818 } 819 820 /* 821 * Error reporting function. Use it like printf. If formats the message 822 * into a buffer, and sets things up so that the next call to dlerror() 823 * will return the message. 824 */ 825 void 826 _rtld_error(const char *fmt,...) 827 { 828 static char buf[512]; 829 va_list ap; 830 831 va_start(ap, fmt); 832 xvsnprintf(buf, sizeof buf, fmt, ap); 833 error_message = buf; 834 va_end(ap); 835 } 836 837 void 838 _rtld_debug_state(void) 839 { 840 841 /* do nothing */ 842 } 843 844 void 845 _rtld_linkmap_add(Obj_Entry *obj) 846 { 847 struct link_map *l = &obj->linkmap; 848 struct link_map *prev; 849 850 obj->linkmap.l_name = obj->path; 851 obj->linkmap.l_addr = obj->relocbase; 852 obj->linkmap.l_ld = obj->dynamic; 853 #ifdef __mips__ 854 /* XXX This field is not standard and will be removed eventually. */ 855 obj->linkmap.l_offs = obj->relocbase; 856 #endif 857 858 if (_rtld_debug.r_map == NULL) { 859 _rtld_debug.r_map = l; 860 return; 861 } 862 for (prev = _rtld_debug.r_map; prev->l_next != NULL; prev = prev->l_next); 863 l->l_prev = prev; 864 prev->l_next = l; 865 l->l_next = NULL; 866 } 867 868 void 869 _rtld_linkmap_delete(Obj_Entry *obj) 870 { 871 struct link_map *l = &obj->linkmap; 872 873 if (l->l_prev == NULL) { 874 if ((_rtld_debug.r_map = l->l_next) != NULL) 875 l->l_next->l_prev = NULL; 876 return; 877 } 878 if ((l->l_prev->l_next = l->l_next) != NULL) 879 l->l_next->l_prev = l->l_prev; 880 } 881 882 static Obj_Entry * 883 _rtld_obj_from_addr(const void *addr) 884 { 885 Obj_Entry *obj; 886 887 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) { 888 if (addr < (void *) obj->mapbase) 889 continue; 890 if (addr < (void *) (obj->mapbase + obj->mapsize)) 891 return obj; 892 } 893 return NULL; 894 } 895 896 static void 897 _rtld_objlist_remove(Objlist *list, Obj_Entry *obj) 898 { 899 Objlist_Entry *elm; 900 901 if ((elm = _rtld_objlist_find(list, obj)) != NULL) { 902 SIMPLEQ_REMOVE(list, elm, Struct_Objlist_Entry, link); 903 free(elm); 904 } 905 } 906