1 /* $NetBSD: rtld.c,v 1.171 2013/11/20 07:18:23 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 <sys/cdefs.h> 42 #ifndef lint 43 __RCSID("$NetBSD: rtld.c,v 1.171 2013/11/20 07:18:23 skrll Exp $"); 44 #endif /* not lint */ 45 46 #include <sys/param.h> 47 #include <sys/atomic.h> 48 #include <sys/mman.h> 49 #include <err.h> 50 #include <errno.h> 51 #include <fcntl.h> 52 #if !defined(__minix) 53 #include <lwp.h> 54 #endif /* !defined(__minix) */ 55 #include <stdarg.h> 56 #include <stdio.h> 57 #include <stdlib.h> 58 #include <string.h> 59 #include <unistd.h> 60 #include <dirent.h> 61 62 #include <ctype.h> 63 64 #include <dlfcn.h> 65 #include "debug.h" 66 #include "rtld.h" 67 68 #if !defined(lint) 69 #include "sysident.h" 70 #endif 71 72 /* 73 * Function declarations. 74 */ 75 static void _rtld_init(caddr_t, caddr_t, const char *); 76 static void _rtld_exit(void); 77 78 Elf_Addr _rtld(Elf_Addr *, Elf_Addr); 79 80 81 /* 82 * Data declarations. 83 */ 84 static char *error_message; /* Message for dlopen(), or NULL */ 85 86 struct r_debug _rtld_debug; /* for GDB; */ 87 bool _rtld_trust; /* False for setuid and setgid programs */ 88 Obj_Entry *_rtld_objlist; /* Head of linked list of shared objects */ 89 Obj_Entry **_rtld_objtail; /* Link field of last object in list */ 90 Obj_Entry *_rtld_objmain; /* The main program shared object */ 91 Obj_Entry _rtld_objself; /* The dynamic linker shared object */ 92 u_int _rtld_objcount; /* Number of objects in _rtld_objlist */ 93 u_int _rtld_objloads; /* Number of objects loaded in _rtld_objlist */ 94 u_int _rtld_objgen; /* Generation count for _rtld_objlist */ 95 const char _rtld_path[] = _PATH_RTLD; 96 97 /* Initialize a fake symbol for resolving undefined weak references. */ 98 Elf_Sym _rtld_sym_zero = { 99 .st_info = ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE), 100 .st_shndx = SHN_ABS, 101 }; 102 size_t _rtld_pagesz; /* Page size, as provided by kernel */ 103 104 Search_Path *_rtld_default_paths; 105 Search_Path *_rtld_paths; 106 107 Library_Xform *_rtld_xforms; 108 static void *auxinfo; 109 110 /* 111 * Global declarations normally provided by crt0. 112 */ 113 char *__progname; 114 char **environ; 115 116 #if !defined(__minix) 117 static volatile bool _rtld_mutex_may_recurse; 118 #endif /* !defined(__minix) */ 119 120 #if defined(RTLD_DEBUG) 121 #ifndef __sh__ 122 extern Elf_Addr _GLOBAL_OFFSET_TABLE_[]; 123 #else /* 32-bit SuperH */ 124 register Elf_Addr *_GLOBAL_OFFSET_TABLE_ asm("r12"); 125 #endif 126 #endif /* RTLD_DEBUG */ 127 extern Elf_Dyn _DYNAMIC; 128 129 static void _rtld_call_fini_functions(sigset_t *, int); 130 static void _rtld_call_init_functions(sigset_t *); 131 static void _rtld_initlist_visit(Objlist *, Obj_Entry *, int); 132 static void _rtld_initlist_tsort(Objlist *, int); 133 static Obj_Entry *_rtld_dlcheck(void *); 134 static void _rtld_init_dag(Obj_Entry *); 135 static void _rtld_init_dag1(Obj_Entry *, Obj_Entry *); 136 static void _rtld_objlist_remove(Objlist *, Obj_Entry *); 137 static void _rtld_objlist_clear(Objlist *); 138 static void _rtld_unload_object(sigset_t *, Obj_Entry *, bool); 139 static void _rtld_unref_dag(Obj_Entry *); 140 static Obj_Entry *_rtld_obj_from_addr(const void *); 141 142 static inline void 143 _rtld_call_initfini_function(fptr_t func, sigset_t *mask) 144 { 145 _rtld_exclusive_exit(mask); 146 (*func)(); 147 _rtld_exclusive_enter(mask); 148 } 149 150 static void 151 _rtld_call_fini_function(Obj_Entry *obj, sigset_t *mask, u_int cur_objgen) 152 { 153 if (obj->fini_arraysz == 0 && (obj->fini == NULL || obj->fini_called)) { 154 return; 155 } 156 if (obj->fini != NULL && !obj->fini_called) { 157 dbg (("calling fini function %s at %p%s", obj->path, 158 (void *)obj->fini, 159 obj->z_initfirst ? " (DF_1_INITFIRST)" : "")); 160 obj->fini_called = 1; 161 _rtld_call_initfini_function(obj->fini, mask); 162 } 163 #ifdef HAVE_INITFINI_ARRAY 164 /* 165 * Now process the fini_array if it exists. Simply go from 166 * start to end. We need to make restartable so just advance 167 * the array pointer and decrement the size each time through 168 * the loop. 169 */ 170 while (obj->fini_arraysz > 0 && _rtld_objgen == cur_objgen) { 171 fptr_t fini = *obj->fini_array++; 172 obj->fini_arraysz--; 173 dbg (("calling fini array function %s at %p%s", obj->path, 174 (void *)fini, 175 obj->z_initfirst ? " (DF_1_INITFIRST)" : "")); 176 _rtld_call_initfini_function(fini, mask); 177 } 178 #endif /* HAVE_INITFINI_ARRAY */ 179 } 180 181 static void 182 _rtld_call_fini_functions(sigset_t *mask, int force) 183 { 184 Objlist_Entry *elm; 185 Objlist finilist; 186 u_int cur_objgen; 187 188 dbg(("_rtld_call_fini_functions(%d)", force)); 189 190 restart: 191 cur_objgen = ++_rtld_objgen; 192 SIMPLEQ_INIT(&finilist); 193 _rtld_initlist_tsort(&finilist, 1); 194 195 /* First pass: objects _not_ marked with DF_1_INITFIRST. */ 196 SIMPLEQ_FOREACH(elm, &finilist, link) { 197 Obj_Entry * const obj = elm->obj; 198 if (!obj->z_initfirst) { 199 if (obj->refcount > 0 && !force) { 200 continue; 201 } 202 /* 203 * XXX This can race against a concurrent dlclose(). 204 * XXX In that case, the object could be unmapped before 205 * XXX the fini() call or the fini_array has completed. 206 */ 207 _rtld_call_fini_function(obj, mask, cur_objgen); 208 if (_rtld_objgen != cur_objgen) { 209 dbg(("restarting fini iteration")); 210 _rtld_objlist_clear(&finilist); 211 goto restart; 212 } 213 } 214 } 215 216 /* Second pass: objects marked with DF_1_INITFIRST. */ 217 SIMPLEQ_FOREACH(elm, &finilist, link) { 218 Obj_Entry * const obj = elm->obj; 219 if (obj->refcount > 0 && !force) { 220 continue; 221 } 222 /* XXX See above for the race condition here */ 223 _rtld_call_fini_function(obj, mask, cur_objgen); 224 if (_rtld_objgen != cur_objgen) { 225 dbg(("restarting fini iteration")); 226 _rtld_objlist_clear(&finilist); 227 goto restart; 228 } 229 } 230 231 _rtld_objlist_clear(&finilist); 232 } 233 234 static void 235 _rtld_call_init_function(Obj_Entry *obj, sigset_t *mask, u_int cur_objgen) 236 { 237 if (obj->init_arraysz == 0 && (obj->init_called || obj->init == NULL)) { 238 return; 239 } 240 if (!obj->init_called && obj->init != NULL) { 241 dbg (("calling init function %s at %p%s", 242 obj->path, (void *)obj->init, 243 obj->z_initfirst ? " (DF_1_INITFIRST)" : "")); 244 obj->init_called = 1; 245 _rtld_call_initfini_function(obj->init, mask); 246 } 247 248 #ifdef HAVE_INITFINI_ARRAY 249 /* 250 * Now process the init_array if it exists. Simply go from 251 * start to end. We need to make restartable so just advance 252 * the array pointer and decrement the size each time through 253 * the loop. 254 */ 255 while (obj->init_arraysz > 0 && _rtld_objgen == cur_objgen) { 256 fptr_t init = *obj->init_array++; 257 obj->init_arraysz--; 258 dbg (("calling init_array function %s at %p%s", 259 obj->path, (void *)init, 260 obj->z_initfirst ? " (DF_1_INITFIRST)" : "")); 261 _rtld_call_initfini_function(init, mask); 262 } 263 #endif /* HAVE_INITFINI_ARRAY */ 264 } 265 266 static void 267 _rtld_call_init_functions(sigset_t *mask) 268 { 269 Objlist_Entry *elm; 270 Objlist initlist; 271 u_int cur_objgen; 272 273 dbg(("_rtld_call_init_functions()")); 274 275 restart: 276 cur_objgen = ++_rtld_objgen; 277 SIMPLEQ_INIT(&initlist); 278 _rtld_initlist_tsort(&initlist, 0); 279 280 /* First pass: objects marked with DF_1_INITFIRST. */ 281 SIMPLEQ_FOREACH(elm, &initlist, link) { 282 Obj_Entry * const obj = elm->obj; 283 if (obj->z_initfirst) { 284 _rtld_call_init_function(obj, mask, cur_objgen); 285 if (_rtld_objgen != cur_objgen) { 286 dbg(("restarting init iteration")); 287 _rtld_objlist_clear(&initlist); 288 goto restart; 289 } 290 } 291 } 292 293 /* Second pass: all other objects. */ 294 SIMPLEQ_FOREACH(elm, &initlist, link) { 295 _rtld_call_init_function(elm->obj, mask, cur_objgen); 296 if (_rtld_objgen != cur_objgen) { 297 dbg(("restarting init iteration")); 298 _rtld_objlist_clear(&initlist); 299 goto restart; 300 } 301 } 302 303 _rtld_objlist_clear(&initlist); 304 } 305 306 /* 307 * Initialize the dynamic linker. The argument is the address at which 308 * the dynamic linker has been mapped into memory. The primary task of 309 * this function is to create an Obj_Entry for the dynamic linker and 310 * to resolve the PLT relocation for platforms that need it (those that 311 * define __HAVE_FUNCTION_DESCRIPTORS 312 */ 313 static void 314 _rtld_init(caddr_t mapbase, caddr_t relocbase, const char *execname) 315 { 316 317 /* Conjure up an Obj_Entry structure for the dynamic linker. */ 318 _rtld_objself.path = __UNCONST(_rtld_path); 319 _rtld_objself.pathlen = sizeof(_rtld_path)-1; 320 _rtld_objself.rtld = true; 321 _rtld_objself.mapbase = mapbase; 322 _rtld_objself.relocbase = relocbase; 323 _rtld_objself.dynamic = (Elf_Dyn *) &_DYNAMIC; 324 _rtld_objself.strtab = "_rtld_sym_zero"; 325 326 /* 327 * Set value to -relocbase so that 328 * 329 * _rtld_objself.relocbase + _rtld_sym_zero.st_value == 0 330 * 331 * This allows unresolved references to weak symbols to be computed 332 * to a value of 0. 333 */ 334 _rtld_sym_zero.st_value = -(uintptr_t)relocbase; 335 336 _rtld_digest_dynamic(_rtld_path, &_rtld_objself); 337 assert(!_rtld_objself.needed); 338 #if !defined(__hppa__) 339 assert(!_rtld_objself.pltrel && !_rtld_objself.pltrela); 340 #else 341 _rtld_relocate_plt_objects(&_rtld_objself); 342 #endif 343 #if !defined(__mips__) && !defined(__hppa__) 344 assert(!_rtld_objself.pltgot); 345 #endif 346 #if !defined(__arm__) && !defined(__mips__) && !defined(__sh__) 347 /* ARM, MIPS and SH{3,5} have a bogus DT_TEXTREL. */ 348 assert(!_rtld_objself.textrel); 349 #endif 350 351 _rtld_add_paths(execname, &_rtld_default_paths, 352 RTLD_DEFAULT_LIBRARY_PATH); 353 354 #ifdef RTLD_ARCH_SUBDIR 355 _rtld_add_paths(execname, &_rtld_default_paths, 356 RTLD_DEFAULT_LIBRARY_PATH "/" RTLD_ARCH_SUBDIR); 357 #endif 358 359 /* Make the object list empty. */ 360 _rtld_objlist = NULL; 361 _rtld_objtail = &_rtld_objlist; 362 _rtld_objcount = 0; 363 364 _rtld_debug.r_brk = _rtld_debug_state; 365 _rtld_debug.r_state = RT_CONSISTENT; 366 } 367 368 /* 369 * Cleanup procedure. It will be called (by the atexit() mechanism) just 370 * before the process exits. 371 */ 372 static void 373 _rtld_exit(void) 374 { 375 sigset_t mask; 376 377 dbg(("rtld_exit()")); 378 379 _rtld_exclusive_enter(&mask); 380 381 _rtld_call_fini_functions(&mask, 1); 382 383 _rtld_exclusive_exit(&mask); 384 } 385 386 __dso_public void * 387 _dlauxinfo(void) 388 { 389 return auxinfo; 390 } 391 392 /* 393 * Main entry point for dynamic linking. The argument is the stack 394 * pointer. The stack is expected to be laid out as described in the 395 * SVR4 ABI specification, Intel 386 Processor Supplement. Specifically, 396 * the stack pointer points to a word containing ARGC. Following that 397 * in the stack is a null-terminated sequence of pointers to argument 398 * strings. Then comes a null-terminated sequence of pointers to 399 * environment strings. Finally, there is a sequence of "auxiliary 400 * vector" entries. 401 * 402 * This function returns the entry point for the main program, the dynamic 403 * linker's exit procedure in sp[0], and a pointer to the main object in 404 * sp[1]. 405 */ 406 Elf_Addr 407 _rtld(Elf_Addr *sp, Elf_Addr relocbase) 408 { 409 const AuxInfo *pAUX_base, *pAUX_entry, *pAUX_execfd, *pAUX_phdr, 410 *pAUX_phent, *pAUX_phnum, *pAUX_euid, *pAUX_egid, 411 *pAUX_ruid, *pAUX_rgid; 412 const AuxInfo *pAUX_pagesz; 413 char **env, **oenvp; 414 const AuxInfo *auxp; 415 Obj_Entry *obj; 416 Elf_Addr *const osp = sp; 417 bool bind_now = 0; 418 const char *ld_bind_now, *ld_preload, *ld_library_path; 419 const char **argv; 420 const char *execname; 421 long argc; 422 const char **real___progname; 423 const Obj_Entry **real___mainprog_obj; 424 char ***real_environ; 425 sigset_t mask; 426 #ifdef DEBUG 427 const char *ld_debug; 428 #endif 429 #ifdef RTLD_DEBUG 430 int i = 0; 431 #endif 432 433 /* 434 * On entry, the dynamic linker itself has not been relocated yet. 435 * Be very careful not to reference any global data until after 436 * _rtld_init has returned. It is OK to reference file-scope statics 437 * and string constants, and to call static and global functions. 438 */ 439 /* Find the auxiliary vector on the stack. */ 440 /* first Elf_Word reserved to address of exit routine */ 441 #if defined(RTLD_DEBUG) 442 debug = 1; 443 dbg(("sp = %p, argc = %ld, argv = %p <%s> relocbase %p", sp, 444 (long)sp[2], &sp[3], (char *) sp[3], (void *)relocbase)); 445 #ifndef __x86_64__ 446 dbg(("got is at %p, dynamic is at %p", _GLOBAL_OFFSET_TABLE_, 447 &_DYNAMIC)); 448 #endif 449 #endif 450 451 sp += 2; /* skip over return argument space */ 452 argv = (const char **) &sp[1]; 453 argc = *(long *)sp; 454 sp += 2 + argc; /* Skip over argc, arguments, and NULL 455 * terminator */ 456 env = (char **) sp; 457 while (*sp++ != 0) { /* Skip over environment, and NULL terminator */ 458 #if defined(RTLD_DEBUG) 459 dbg(("env[%d] = %p %s", i++, (void *)sp[-1], (char *)sp[-1])); 460 #endif 461 } 462 auxinfo = (AuxInfo *) sp; 463 464 pAUX_base = pAUX_entry = pAUX_execfd = NULL; 465 pAUX_phdr = pAUX_phent = pAUX_phnum = NULL; 466 pAUX_euid = pAUX_ruid = pAUX_egid = pAUX_rgid = NULL; 467 pAUX_pagesz = NULL; 468 469 execname = NULL; 470 471 /* Digest the auxiliary vector. */ 472 for (auxp = auxinfo; auxp->a_type != AT_NULL; ++auxp) { 473 switch (auxp->a_type) { 474 case AT_BASE: 475 pAUX_base = auxp; 476 break; 477 case AT_ENTRY: 478 pAUX_entry = auxp; 479 break; 480 case AT_EXECFD: 481 pAUX_execfd = auxp; 482 break; 483 case AT_PHDR: 484 pAUX_phdr = auxp; 485 break; 486 case AT_PHENT: 487 pAUX_phent = auxp; 488 break; 489 case AT_PHNUM: 490 pAUX_phnum = auxp; 491 break; 492 #ifdef AT_EUID 493 case AT_EUID: 494 pAUX_euid = auxp; 495 break; 496 case AT_RUID: 497 pAUX_ruid = auxp; 498 break; 499 case AT_EGID: 500 pAUX_egid = auxp; 501 break; 502 case AT_RGID: 503 pAUX_rgid = auxp; 504 break; 505 #endif 506 #ifdef AT_SUN_EXECNAME 507 case AT_SUN_EXECNAME: 508 execname = (const char *)(const void *)auxp->a_v; 509 break; 510 #endif 511 case AT_PAGESZ: 512 pAUX_pagesz = auxp; 513 break; 514 } 515 } 516 517 /* Initialize and relocate ourselves. */ 518 if (pAUX_base == NULL) { 519 _rtld_error("Bad pAUX_base"); 520 _rtld_die(); 521 } 522 assert(pAUX_pagesz != NULL); 523 _rtld_pagesz = (int)pAUX_pagesz->a_v; 524 _rtld_init((caddr_t)pAUX_base->a_v, (caddr_t)relocbase, execname); 525 526 __progname = _rtld_objself.path; 527 environ = env; 528 529 _rtld_trust = ((pAUX_euid ? (uid_t)pAUX_euid->a_v : geteuid()) == 530 (pAUX_ruid ? (uid_t)pAUX_ruid->a_v : getuid())) && 531 ((pAUX_egid ? (gid_t)pAUX_egid->a_v : getegid()) == 532 (pAUX_rgid ? (gid_t)pAUX_rgid->a_v : getgid())); 533 534 #ifdef DEBUG 535 ld_debug = NULL; 536 #endif 537 ld_bind_now = NULL; 538 ld_library_path = NULL; 539 ld_preload = NULL; 540 /* 541 * Inline avoid using normal getenv/unsetenv here as the libc 542 * code is quite a bit more complicated. 543 */ 544 for (oenvp = env; *env != NULL; ++env) { 545 static const char bind_var[] = "LD_BIND_NOW="; 546 static const char debug_var[] = "LD_DEBUG="; 547 static const char path_var[] = "LD_LIBRARY_PATH="; 548 static const char preload_var[] = "LD_PRELOAD="; 549 #define LEN(x) (sizeof(x) - 1) 550 551 if ((*env)[0] != 'L' || (*env)[1] != 'D') { 552 /* 553 * Special case to skip most entries without 554 * the more expensive calls to strncmp. 555 */ 556 *oenvp++ = *env; 557 } else if (strncmp(*env, debug_var, LEN(debug_var)) == 0) { 558 if (_rtld_trust) { 559 #ifdef DEBUG 560 ld_debug = *env + LEN(debug_var); 561 #endif 562 *oenvp++ = *env; 563 } 564 } else if (strncmp(*env, bind_var, LEN(bind_var)) == 0) { 565 ld_bind_now = *env + LEN(bind_var); 566 } else if (strncmp(*env, path_var, LEN(path_var)) == 0) { 567 if (_rtld_trust) { 568 ld_library_path = *env + LEN(path_var); 569 *oenvp++ = *env; 570 } 571 } else if (strncmp(*env, preload_var, LEN(preload_var)) == 0) { 572 if (_rtld_trust) { 573 ld_preload = *env + LEN(preload_var); 574 *oenvp++ = *env; 575 } 576 } else { 577 *oenvp++ = *env; 578 } 579 #undef LEN 580 } 581 *oenvp++ = NULL; 582 583 if (ld_bind_now != NULL && *ld_bind_now != '\0') 584 bind_now = true; 585 if (_rtld_trust) { 586 #ifdef DEBUG 587 #ifdef RTLD_DEBUG 588 debug = 0; 589 #endif 590 if (ld_debug != NULL && *ld_debug != '\0') 591 debug = 1; 592 #endif 593 _rtld_add_paths(execname, &_rtld_paths, ld_library_path); 594 } else { 595 execname = NULL; 596 } 597 _rtld_process_hints(execname, &_rtld_paths, &_rtld_xforms, 598 _PATH_LD_HINTS); 599 dbg(("dynamic linker is initialized, mapbase=%p, relocbase=%p", 600 _rtld_objself.mapbase, _rtld_objself.relocbase)); 601 602 /* 603 * Load the main program, or process its program header if it is 604 * already loaded. 605 */ 606 if (pAUX_execfd != NULL) { /* Load the main program. */ 607 int fd = pAUX_execfd->a_v; 608 const char *obj_name = argv[0] ? argv[0] : "main program"; 609 dbg(("loading main program")); 610 _rtld_objmain = _rtld_map_object(obj_name, fd, NULL); 611 close(fd); 612 if (_rtld_objmain == NULL) 613 _rtld_die(); 614 } else { /* Main program already loaded. */ 615 const Elf_Phdr *phdr; 616 int phnum; 617 caddr_t entry; 618 619 dbg(("processing main program's program header")); 620 assert(pAUX_phdr != NULL); 621 phdr = (const Elf_Phdr *) pAUX_phdr->a_v; 622 assert(pAUX_phnum != NULL); 623 phnum = pAUX_phnum->a_v; 624 assert(pAUX_phent != NULL); 625 assert(pAUX_phent->a_v == sizeof(Elf_Phdr)); 626 assert(pAUX_entry != NULL); 627 entry = (caddr_t) pAUX_entry->a_v; 628 _rtld_objmain = _rtld_digest_phdr(phdr, phnum, entry); 629 _rtld_objmain->path = xstrdup(argv[0] ? argv[0] : 630 "main program"); 631 _rtld_objmain->pathlen = strlen(_rtld_objmain->path); 632 } 633 634 _rtld_objmain->mainprog = true; 635 636 /* 637 * Get the actual dynamic linker pathname from the executable if 638 * possible. (It should always be possible.) That ensures that 639 * gdb will find the right dynamic linker even if a non-standard 640 * one is being used. 641 */ 642 if (_rtld_objmain->interp != NULL && 643 strcmp(_rtld_objmain->interp, _rtld_objself.path) != 0) { 644 _rtld_objself.path = xstrdup(_rtld_objmain->interp); 645 _rtld_objself.pathlen = strlen(_rtld_objself.path); 646 } 647 dbg(("actual dynamic linker is %s", _rtld_objself.path)); 648 649 _rtld_digest_dynamic(execname, _rtld_objmain); 650 651 /* Link the main program into the list of objects. */ 652 *_rtld_objtail = _rtld_objmain; 653 _rtld_objtail = &_rtld_objmain->next; 654 _rtld_objcount++; 655 _rtld_objloads++; 656 657 _rtld_linkmap_add(_rtld_objmain); 658 _rtld_linkmap_add(&_rtld_objself); 659 660 ++_rtld_objmain->refcount; 661 _rtld_objmain->mainref = 1; 662 _rtld_objlist_push_tail(&_rtld_list_main, _rtld_objmain); 663 664 if (ld_preload) { 665 /* 666 * Pre-load user-specified objects after the main program 667 * but before any shared object dependencies. 668 */ 669 dbg(("preloading objects")); 670 if (_rtld_preload(ld_preload) == -1) 671 _rtld_die(); 672 } 673 674 dbg(("loading needed objects")); 675 if (_rtld_load_needed_objects(_rtld_objmain, _RTLD_MAIN) == -1) 676 _rtld_die(); 677 678 dbg(("checking for required versions")); 679 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) { 680 if (_rtld_verify_object_versions(obj) == -1) 681 _rtld_die(); 682 } 683 684 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II) 685 dbg(("initializing initial Thread Local Storage offsets")); 686 /* 687 * All initial objects get the TLS space from the static block. 688 */ 689 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) 690 _rtld_tls_offset_allocate(obj); 691 #endif 692 693 dbg(("relocating objects")); 694 if (_rtld_relocate_objects(_rtld_objmain, bind_now) == -1) 695 _rtld_die(); 696 697 dbg(("doing copy relocations")); 698 if (_rtld_do_copy_relocations(_rtld_objmain) == -1) 699 _rtld_die(); 700 701 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II) 702 dbg(("initializing Thread Local Storage for main thread")); 703 /* 704 * Set up TLS area for the main thread. 705 * This has to be done after all relocations are processed, 706 * since .tdata may contain relocations. 707 */ 708 _rtld_tls_initial_allocation(); 709 #endif 710 711 /* 712 * Set the __progname, environ and, __mainprog_obj before 713 * calling anything that might use them. 714 */ 715 real___progname = _rtld_objmain_sym("__progname"); 716 if (real___progname) { 717 if (argv[0] != NULL) { 718 if ((*real___progname = strrchr(argv[0], '/')) == NULL) 719 (*real___progname) = argv[0]; 720 else 721 (*real___progname)++; 722 } else { 723 (*real___progname) = NULL; 724 } 725 } 726 real_environ = _rtld_objmain_sym("environ"); 727 if (real_environ) 728 *real_environ = environ; 729 /* 730 * Set __mainprog_obj for old binaries. 731 */ 732 real___mainprog_obj = _rtld_objmain_sym("__mainprog_obj"); 733 if (real___mainprog_obj) 734 *real___mainprog_obj = _rtld_objmain; 735 736 _rtld_exclusive_enter(&mask); 737 738 dbg(("calling _init functions")); 739 _rtld_call_init_functions(&mask); 740 741 dbg(("control at program entry point = %p, obj = %p, exit = %p", 742 _rtld_objmain->entry, _rtld_objmain, _rtld_exit)); 743 744 _rtld_exclusive_exit(&mask); 745 746 /* 747 * Return with the entry point and the exit procedure in at the top 748 * of stack. 749 */ 750 751 _rtld_debug_state(); /* say hello to gdb! */ 752 753 ((void **) osp)[0] = _rtld_exit; 754 ((void **) osp)[1] = _rtld_objmain; 755 return (Elf_Addr) _rtld_objmain->entry; 756 } 757 758 void 759 _rtld_die(void) 760 { 761 const char *msg = dlerror(); 762 763 if (msg == NULL) 764 msg = "Fatal error"; 765 xerrx(1, "%s", msg); 766 } 767 768 static Obj_Entry * 769 _rtld_dlcheck(void *handle) 770 { 771 Obj_Entry *obj; 772 773 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) 774 if (obj == (Obj_Entry *) handle) 775 break; 776 777 if (obj == NULL || obj->dl_refcount == 0) { 778 _rtld_error("Invalid shared object handle %p", handle); 779 return NULL; 780 } 781 return obj; 782 } 783 784 static void 785 _rtld_initlist_visit(Objlist* list, Obj_Entry *obj, int rev) 786 { 787 Needed_Entry* elm; 788 789 /* dbg(("_rtld_initlist_visit(%s)", obj->path)); */ 790 791 if (obj->init_done) 792 return; 793 obj->init_done = 1; 794 795 for (elm = obj->needed; elm != NULL; elm = elm->next) { 796 if (elm->obj != NULL) { 797 _rtld_initlist_visit(list, elm->obj, rev); 798 } 799 } 800 801 if (rev) { 802 _rtld_objlist_push_head(list, obj); 803 } else { 804 _rtld_objlist_push_tail(list, obj); 805 } 806 } 807 808 static void 809 _rtld_initlist_tsort(Objlist* list, int rev) 810 { 811 dbg(("_rtld_initlist_tsort")); 812 813 Obj_Entry* obj; 814 815 for (obj = _rtld_objlist->next; obj; obj = obj->next) { 816 obj->init_done = 0; 817 } 818 819 for (obj = _rtld_objlist->next; obj; obj = obj->next) { 820 _rtld_initlist_visit(list, obj, rev); 821 } 822 } 823 824 static void 825 _rtld_init_dag(Obj_Entry *root) 826 { 827 828 _rtld_init_dag1(root, root); 829 } 830 831 static void 832 _rtld_init_dag1(Obj_Entry *root, Obj_Entry *obj) 833 { 834 const Needed_Entry *needed; 835 836 if (!obj->mainref) { 837 if (_rtld_objlist_find(&obj->dldags, root)) 838 return; 839 dbg(("add %p (%s) to %p (%s) DAG", obj, obj->path, root, 840 root->path)); 841 _rtld_objlist_push_tail(&obj->dldags, root); 842 _rtld_objlist_push_tail(&root->dagmembers, obj); 843 } 844 for (needed = obj->needed; needed != NULL; needed = needed->next) 845 if (needed->obj != NULL) 846 _rtld_init_dag1(root, needed->obj); 847 } 848 849 /* 850 * Note, this is called only for objects loaded by dlopen(). 851 */ 852 static void 853 _rtld_unload_object(sigset_t *mask, Obj_Entry *root, bool do_fini_funcs) 854 { 855 856 _rtld_unref_dag(root); 857 if (root->refcount == 0) { /* We are finished with some objects. */ 858 Obj_Entry *obj; 859 Obj_Entry **linkp; 860 Objlist_Entry *elm; 861 862 /* Finalize objects that are about to be unmapped. */ 863 if (do_fini_funcs) 864 _rtld_call_fini_functions(mask, 0); 865 866 /* Remove the DAG from all objects' DAG lists. */ 867 SIMPLEQ_FOREACH(elm, &root->dagmembers, link) 868 _rtld_objlist_remove(&elm->obj->dldags, root); 869 870 /* Remove the DAG from the RTLD_GLOBAL list. */ 871 if (root->globalref) { 872 root->globalref = 0; 873 _rtld_objlist_remove(&_rtld_list_global, root); 874 } 875 876 /* Unmap all objects that are no longer referenced. */ 877 linkp = &_rtld_objlist->next; 878 while ((obj = *linkp) != NULL) { 879 if (obj->refcount == 0) { 880 dbg(("unloading \"%s\"", obj->path)); 881 if (obj->ehdr != MAP_FAILED) 882 munmap(obj->ehdr, _rtld_pagesz); 883 munmap(obj->mapbase, obj->mapsize); 884 _rtld_objlist_remove(&_rtld_list_global, obj); 885 _rtld_linkmap_delete(obj); 886 *linkp = obj->next; 887 _rtld_objcount--; 888 _rtld_obj_free(obj); 889 } else 890 linkp = &obj->next; 891 } 892 _rtld_objtail = linkp; 893 } 894 } 895 896 void 897 _rtld_ref_dag(Obj_Entry *root) 898 { 899 const Needed_Entry *needed; 900 901 assert(root); 902 903 ++root->refcount; 904 905 dbg(("incremented reference on \"%s\" (%d)", root->path, 906 root->refcount)); 907 for (needed = root->needed; needed != NULL; 908 needed = needed->next) { 909 if (needed->obj != NULL) 910 _rtld_ref_dag(needed->obj); 911 } 912 } 913 914 static void 915 _rtld_unref_dag(Obj_Entry *root) 916 { 917 918 assert(root); 919 assert(root->refcount != 0); 920 921 --root->refcount; 922 dbg(("decremented reference on \"%s\" (%d)", root->path, 923 root->refcount)); 924 925 if (root->refcount == 0) { 926 const Needed_Entry *needed; 927 928 for (needed = root->needed; needed != NULL; 929 needed = needed->next) { 930 if (needed->obj != NULL) 931 _rtld_unref_dag(needed->obj); 932 } 933 } 934 } 935 936 __strong_alias(__dlclose,dlclose) 937 int 938 dlclose(void *handle) 939 { 940 Obj_Entry *root; 941 sigset_t mask; 942 943 dbg(("dlclose of %p", handle)); 944 945 _rtld_exclusive_enter(&mask); 946 947 root = _rtld_dlcheck(handle); 948 949 if (root == NULL) { 950 _rtld_exclusive_exit(&mask); 951 return -1; 952 } 953 954 _rtld_debug.r_state = RT_DELETE; 955 _rtld_debug_state(); 956 957 --root->dl_refcount; 958 _rtld_unload_object(&mask, root, true); 959 960 _rtld_debug.r_state = RT_CONSISTENT; 961 _rtld_debug_state(); 962 963 _rtld_exclusive_exit(&mask); 964 965 return 0; 966 } 967 968 __strong_alias(__dlerror,dlerror) 969 char * 970 dlerror(void) 971 { 972 char *msg = error_message; 973 974 error_message = NULL; 975 return msg; 976 } 977 978 __strong_alias(__dlopen,dlopen) 979 void * 980 dlopen(const char *name, int mode) 981 { 982 Obj_Entry **old_obj_tail = _rtld_objtail; 983 Obj_Entry *obj = NULL; 984 int flags = _RTLD_DLOPEN; 985 bool nodelete; 986 bool now; 987 sigset_t mask; 988 int result; 989 990 dbg(("dlopen of %s %d", name, mode)); 991 992 _rtld_exclusive_enter(&mask); 993 994 flags |= (mode & RTLD_GLOBAL) ? _RTLD_GLOBAL : 0; 995 flags |= (mode & RTLD_NOLOAD) ? _RTLD_NOLOAD : 0; 996 997 nodelete = (mode & RTLD_NODELETE) ? true : false; 998 now = ((mode & RTLD_MODEMASK) == RTLD_NOW) ? true : false; 999 1000 _rtld_debug.r_state = RT_ADD; 1001 _rtld_debug_state(); 1002 1003 if (name == NULL) { 1004 obj = _rtld_objmain; 1005 obj->refcount++; 1006 } else 1007 obj = _rtld_load_library(name, _rtld_objmain, flags); 1008 1009 1010 if (obj != NULL) { 1011 ++obj->dl_refcount; 1012 if (*old_obj_tail != NULL) { /* We loaded something new. */ 1013 assert(*old_obj_tail == obj); 1014 1015 result = _rtld_load_needed_objects(obj, flags); 1016 if (result != -1) { 1017 Objlist_Entry *entry; 1018 _rtld_init_dag(obj); 1019 SIMPLEQ_FOREACH(entry, &obj->dagmembers, link) { 1020 result = _rtld_verify_object_versions(entry->obj); 1021 if (result == -1) 1022 break; 1023 } 1024 } 1025 if (result == -1 || _rtld_relocate_objects(obj, 1026 (now || obj->z_now)) == -1) { 1027 _rtld_unload_object(&mask, obj, false); 1028 obj->dl_refcount--; 1029 obj = NULL; 1030 } else { 1031 _rtld_call_init_functions(&mask); 1032 } 1033 } 1034 if (obj != NULL) { 1035 if ((nodelete || obj->z_nodelete) && !obj->ref_nodel) { 1036 dbg(("dlopen obj %s nodelete", obj->path)); 1037 _rtld_ref_dag(obj); 1038 obj->z_nodelete = obj->ref_nodel = true; 1039 } 1040 } 1041 } 1042 _rtld_debug.r_state = RT_CONSISTENT; 1043 _rtld_debug_state(); 1044 1045 _rtld_exclusive_exit(&mask); 1046 1047 return obj; 1048 } 1049 1050 /* 1051 * Find a symbol in the main program. 1052 */ 1053 void * 1054 _rtld_objmain_sym(const char *name) 1055 { 1056 unsigned long hash; 1057 const Elf_Sym *def; 1058 const Obj_Entry *obj; 1059 DoneList donelist; 1060 1061 hash = _rtld_elf_hash(name); 1062 obj = _rtld_objmain; 1063 _rtld_donelist_init(&donelist); 1064 1065 def = _rtld_symlook_list(name, hash, &_rtld_list_main, &obj, 0, 1066 NULL, &donelist); 1067 1068 if (def != NULL) 1069 return obj->relocbase + def->st_value; 1070 return NULL; 1071 } 1072 1073 #ifdef __powerpc__ 1074 static void * 1075 hackish_return_address(void) 1076 { 1077 return __builtin_return_address(1); 1078 } 1079 #endif 1080 1081 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1082 #define lookup_mutex_enter() _rtld_exclusive_enter(&mask) 1083 #define lookup_mutex_exit() _rtld_exclusive_exit(&mask) 1084 #else 1085 #define lookup_mutex_enter() _rtld_shared_enter() 1086 #define lookup_mutex_exit() _rtld_shared_exit() 1087 #endif 1088 1089 static void * 1090 do_dlsym(void *handle, const char *name, const Ver_Entry *ventry, void *retaddr) 1091 { 1092 const Obj_Entry *obj; 1093 unsigned long hash; 1094 const Elf_Sym *def; 1095 const Obj_Entry *defobj; 1096 DoneList donelist; 1097 const u_int flags = SYMLOOK_DLSYM | SYMLOOK_IN_PLT; 1098 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1099 sigset_t mask; 1100 #endif 1101 1102 lookup_mutex_enter(); 1103 1104 hash = _rtld_elf_hash(name); 1105 def = NULL; 1106 defobj = NULL; 1107 1108 switch ((intptr_t)handle) { 1109 case (intptr_t)NULL: 1110 case (intptr_t)RTLD_NEXT: 1111 case (intptr_t)RTLD_DEFAULT: 1112 case (intptr_t)RTLD_SELF: 1113 if ((obj = _rtld_obj_from_addr(retaddr)) == NULL) { 1114 _rtld_error("Cannot determine caller's shared object"); 1115 lookup_mutex_exit(); 1116 return NULL; 1117 } 1118 1119 switch ((intptr_t)handle) { 1120 case (intptr_t)NULL: /* Just the caller's shared object. */ 1121 def = _rtld_symlook_obj(name, hash, obj, flags, ventry); 1122 defobj = obj; 1123 break; 1124 1125 case (intptr_t)RTLD_NEXT: /* Objects after callers */ 1126 obj = obj->next; 1127 /*FALLTHROUGH*/ 1128 1129 case (intptr_t)RTLD_SELF: /* Caller included */ 1130 for (; obj; obj = obj->next) { 1131 if ((def = _rtld_symlook_obj(name, hash, obj, 1132 flags, ventry)) != NULL) { 1133 defobj = obj; 1134 break; 1135 } 1136 } 1137 break; 1138 1139 case (intptr_t)RTLD_DEFAULT: 1140 def = _rtld_symlook_default(name, hash, obj, &defobj, 1141 flags, ventry); 1142 break; 1143 1144 default: 1145 abort(); 1146 } 1147 break; 1148 1149 default: 1150 if ((obj = _rtld_dlcheck(handle)) == NULL) { 1151 lookup_mutex_exit(); 1152 return NULL; 1153 } 1154 1155 _rtld_donelist_init(&donelist); 1156 1157 if (obj->mainprog) { 1158 /* Search main program and all libraries loaded by it */ 1159 def = _rtld_symlook_list(name, hash, &_rtld_list_main, 1160 &defobj, flags, ventry, &donelist); 1161 } else { 1162 Needed_Entry fake; 1163 DoneList depth; 1164 1165 /* Search the object and all the libraries loaded by it. */ 1166 fake.next = NULL; 1167 fake.obj = __UNCONST(obj); 1168 fake.name = 0; 1169 1170 _rtld_donelist_init(&depth); 1171 def = _rtld_symlook_needed(name, hash, &fake, &defobj, 1172 flags, ventry, &donelist, &depth); 1173 } 1174 1175 break; 1176 } 1177 1178 if (def != NULL) { 1179 void *p; 1180 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1181 if (ELF_ST_TYPE(def->st_info) == STT_FUNC) { 1182 p = (void *)_rtld_function_descriptor_alloc(defobj, 1183 def, 0); 1184 lookup_mutex_exit(); 1185 return p; 1186 } 1187 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 1188 p = defobj->relocbase + def->st_value; 1189 lookup_mutex_exit(); 1190 return p; 1191 } 1192 1193 _rtld_error("Undefined symbol \"%s\"", name); 1194 lookup_mutex_exit(); 1195 return NULL; 1196 } 1197 1198 __strong_alias(__dlsym,dlsym) 1199 void * 1200 dlsym(void *handle, const char *name) 1201 { 1202 void *retaddr; 1203 1204 dbg(("dlsym of %s in %p", name, handle)); 1205 1206 #ifdef __powerpc__ 1207 retaddr = hackish_return_address(); 1208 #else 1209 retaddr = __builtin_return_address(0); 1210 #endif 1211 return do_dlsym(handle, name, NULL, retaddr); 1212 } 1213 1214 __strong_alias(__dlvsym,dlvsym) 1215 void * 1216 dlvsym(void *handle, const char *name, const char *version) 1217 { 1218 Ver_Entry *ventry = NULL; 1219 Ver_Entry ver_entry; 1220 void *retaddr; 1221 1222 dbg(("dlvsym of %s@%s in %p", name, version ? version : NULL, handle)); 1223 1224 if (version != NULL) { 1225 ver_entry.name = version; 1226 ver_entry.file = NULL; 1227 ver_entry.hash = _rtld_elf_hash(version); 1228 ver_entry.flags = 0; 1229 ventry = &ver_entry; 1230 } 1231 #ifdef __powerpc__ 1232 retaddr = hackish_return_address(); 1233 #else 1234 retaddr = __builtin_return_address(0); 1235 #endif 1236 return do_dlsym(handle, name, ventry, retaddr); 1237 } 1238 1239 __strong_alias(__dladdr,dladdr) 1240 int 1241 dladdr(const void *addr, Dl_info *info) 1242 { 1243 const Obj_Entry *obj; 1244 const Elf_Sym *def, *best_def; 1245 void *symbol_addr; 1246 unsigned long symoffset; 1247 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1248 sigset_t mask; 1249 #endif 1250 1251 dbg(("dladdr of %p", addr)); 1252 1253 lookup_mutex_enter(); 1254 1255 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1256 addr = _rtld_function_descriptor_function(addr); 1257 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 1258 1259 obj = _rtld_obj_from_addr(addr); 1260 if (obj == NULL) { 1261 _rtld_error("No shared object contains address"); 1262 lookup_mutex_enter(); 1263 return 0; 1264 } 1265 info->dli_fname = obj->path; 1266 info->dli_fbase = obj->mapbase; 1267 info->dli_saddr = (void *)0; 1268 info->dli_sname = NULL; 1269 1270 /* 1271 * Walk the symbol list looking for the symbol whose address is 1272 * closest to the address sent in. 1273 */ 1274 best_def = NULL; 1275 for (symoffset = 0; symoffset < obj->nchains; symoffset++) { 1276 def = obj->symtab + symoffset; 1277 1278 /* 1279 * For skip the symbol if st_shndx is either SHN_UNDEF or 1280 * SHN_COMMON. 1281 */ 1282 if (def->st_shndx == SHN_UNDEF || def->st_shndx == SHN_COMMON) 1283 continue; 1284 1285 /* 1286 * If the symbol is greater than the specified address, or if it 1287 * is further away from addr than the current nearest symbol, 1288 * then reject it. 1289 */ 1290 symbol_addr = obj->relocbase + def->st_value; 1291 if (symbol_addr > addr || symbol_addr < info->dli_saddr) 1292 continue; 1293 1294 /* Update our idea of the nearest symbol. */ 1295 info->dli_sname = obj->strtab + def->st_name; 1296 info->dli_saddr = symbol_addr; 1297 best_def = def; 1298 1299 1300 /* Exact match? */ 1301 if (info->dli_saddr == addr) 1302 break; 1303 } 1304 1305 #ifdef __HAVE_FUNCTION_DESCRIPTORS 1306 if (best_def != NULL && ELF_ST_TYPE(best_def->st_info) == STT_FUNC) 1307 info->dli_saddr = (void *)_rtld_function_descriptor_alloc(obj, 1308 best_def, 0); 1309 #else 1310 __USE(best_def); 1311 #endif /* __HAVE_FUNCTION_DESCRIPTORS */ 1312 1313 lookup_mutex_exit(); 1314 return 1; 1315 } 1316 1317 __strong_alias(__dlinfo,dlinfo) 1318 int 1319 dlinfo(void *handle, int req, void *v) 1320 { 1321 const Obj_Entry *obj; 1322 void *retaddr; 1323 1324 dbg(("dlinfo for %p %d", handle, req)); 1325 1326 _rtld_shared_enter(); 1327 1328 if (handle == RTLD_SELF) { 1329 #ifdef __powerpc__ 1330 retaddr = hackish_return_address(); 1331 #else 1332 retaddr = __builtin_return_address(0); 1333 #endif 1334 if ((obj = _rtld_obj_from_addr(retaddr)) == NULL) { 1335 _rtld_error("Cannot determine caller's shared object"); 1336 _rtld_shared_exit(); 1337 return -1; 1338 } 1339 } else { 1340 if ((obj = _rtld_dlcheck(handle)) == NULL) { 1341 _rtld_shared_exit(); 1342 return -1; 1343 } 1344 } 1345 1346 switch (req) { 1347 case RTLD_DI_LINKMAP: 1348 { 1349 const struct link_map **map = v; 1350 1351 *map = &obj->linkmap; 1352 break; 1353 } 1354 1355 default: 1356 _rtld_error("Invalid request"); 1357 _rtld_shared_exit(); 1358 return -1; 1359 } 1360 1361 _rtld_shared_exit(); 1362 return 0; 1363 } 1364 1365 __strong_alias(__dl_iterate_phdr,dl_iterate_phdr); 1366 int 1367 dl_iterate_phdr(int (*callback)(struct dl_phdr_info *, size_t, void *), void *param) 1368 { 1369 struct dl_phdr_info phdr_info; 1370 const Obj_Entry *obj; 1371 int error = 0; 1372 1373 dbg(("dl_iterate_phdr")); 1374 1375 _rtld_shared_enter(); 1376 1377 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) { 1378 phdr_info.dlpi_addr = (Elf_Addr)obj->relocbase; 1379 /* XXX: wrong but not fixing it yet */ 1380 phdr_info.dlpi_name = SIMPLEQ_FIRST(&obj->names) ? 1381 SIMPLEQ_FIRST(&obj->names)->name : obj->path; 1382 phdr_info.dlpi_phdr = obj->phdr; 1383 phdr_info.dlpi_phnum = obj->phsize / sizeof(obj->phdr[0]); 1384 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II) 1385 phdr_info.dlpi_tls_modid = obj->tlsindex; 1386 phdr_info.dlpi_tls_data = obj->tlsinit; 1387 #else 1388 phdr_info.dlpi_tls_modid = 0; 1389 phdr_info.dlpi_tls_data = 0; 1390 #endif 1391 phdr_info.dlpi_adds = _rtld_objloads; 1392 phdr_info.dlpi_subs = _rtld_objloads - _rtld_objcount; 1393 1394 /* XXXlocking: exit point */ 1395 error = callback(&phdr_info, sizeof(phdr_info), param); 1396 if (error) 1397 break; 1398 } 1399 1400 _rtld_shared_exit(); 1401 return error; 1402 } 1403 1404 /* 1405 * Error reporting function. Use it like printf. If formats the message 1406 * into a buffer, and sets things up so that the next call to dlerror() 1407 * will return the message. 1408 */ 1409 void 1410 _rtld_error(const char *fmt,...) 1411 { 1412 static char buf[512]; 1413 va_list ap; 1414 1415 va_start(ap, fmt); 1416 xvsnprintf(buf, sizeof buf, fmt, ap); 1417 error_message = buf; 1418 va_end(ap); 1419 } 1420 1421 void 1422 _rtld_debug_state(void) 1423 { 1424 1425 /* Prevent optimizer from removing calls to this function */ 1426 __insn_barrier(); 1427 } 1428 1429 void 1430 _rtld_linkmap_add(Obj_Entry *obj) 1431 { 1432 struct link_map *l = &obj->linkmap; 1433 struct link_map *prev; 1434 1435 obj->linkmap.l_name = obj->path; 1436 obj->linkmap.l_addr = obj->relocbase; 1437 obj->linkmap.l_ld = obj->dynamic; 1438 #ifdef __mips__ 1439 /* XXX This field is not standard and will be removed eventually. */ 1440 obj->linkmap.l_offs = obj->relocbase; 1441 #endif 1442 1443 if (_rtld_debug.r_map == NULL) { 1444 _rtld_debug.r_map = l; 1445 return; 1446 } 1447 1448 /* 1449 * Scan to the end of the list, but not past the entry for the 1450 * dynamic linker, which we want to keep at the very end. 1451 */ 1452 for (prev = _rtld_debug.r_map; 1453 prev->l_next != NULL && prev->l_next != &_rtld_objself.linkmap; 1454 prev = prev->l_next); 1455 1456 l->l_prev = prev; 1457 l->l_next = prev->l_next; 1458 if (l->l_next != NULL) 1459 l->l_next->l_prev = l; 1460 prev->l_next = l; 1461 } 1462 1463 void 1464 _rtld_linkmap_delete(Obj_Entry *obj) 1465 { 1466 struct link_map *l = &obj->linkmap; 1467 1468 if (l->l_prev == NULL) { 1469 if ((_rtld_debug.r_map = l->l_next) != NULL) 1470 l->l_next->l_prev = NULL; 1471 return; 1472 } 1473 if ((l->l_prev->l_next = l->l_next) != NULL) 1474 l->l_next->l_prev = l->l_prev; 1475 } 1476 1477 static Obj_Entry * 1478 _rtld_obj_from_addr(const void *addr) 1479 { 1480 Obj_Entry *obj; 1481 1482 for (obj = _rtld_objlist; obj != NULL; obj = obj->next) { 1483 if (addr < (void *) obj->mapbase) 1484 continue; 1485 if (addr < (void *) (obj->mapbase + obj->mapsize)) 1486 return obj; 1487 } 1488 return NULL; 1489 } 1490 1491 static void 1492 _rtld_objlist_clear(Objlist *list) 1493 { 1494 while (!SIMPLEQ_EMPTY(list)) { 1495 Objlist_Entry* elm = SIMPLEQ_FIRST(list); 1496 SIMPLEQ_REMOVE_HEAD(list, link); 1497 xfree(elm); 1498 } 1499 } 1500 1501 static void 1502 _rtld_objlist_remove(Objlist *list, Obj_Entry *obj) 1503 { 1504 Objlist_Entry *elm; 1505 1506 if ((elm = _rtld_objlist_find(list, obj)) != NULL) { 1507 SIMPLEQ_REMOVE(list, elm, Struct_Objlist_Entry, link); 1508 xfree(elm); 1509 } 1510 } 1511 1512 #if defined(__minix) 1513 void _rtld_shared_enter(void) {} 1514 void _rtld_shared_exit(void) {} 1515 void _rtld_exclusive_enter(sigset_t *mask) {} 1516 void _rtld_exclusive_exit(sigset_t *mask) {} 1517 #else 1518 #define RTLD_EXCLUSIVE_MASK 0x80000000U 1519 static volatile unsigned int _rtld_mutex; 1520 static volatile unsigned int _rtld_waiter_exclusive; 1521 static volatile unsigned int _rtld_waiter_shared; 1522 1523 void 1524 _rtld_shared_enter(void) 1525 { 1526 unsigned int cur; 1527 lwpid_t waiter, self = 0; 1528 1529 membar_enter(); 1530 1531 for (;;) { 1532 cur = _rtld_mutex; 1533 /* 1534 * First check if we are currently not exclusively locked. 1535 */ 1536 if ((cur & RTLD_EXCLUSIVE_MASK) == 0) { 1537 /* Yes, so increment use counter */ 1538 if (atomic_cas_uint(&_rtld_mutex, cur, cur + 1) != cur) 1539 continue; 1540 return; 1541 } 1542 /* 1543 * Someone has an exclusive lock. Puts us on the waiter list. 1544 */ 1545 if (!self) 1546 self = _lwp_self(); 1547 if (cur == (self | RTLD_EXCLUSIVE_MASK)) { 1548 if (_rtld_mutex_may_recurse) 1549 return; 1550 _rtld_error("dead lock detected"); 1551 _rtld_die(); 1552 } 1553 waiter = atomic_swap_uint(&_rtld_waiter_shared, self); 1554 /* 1555 * Check for race against _rtld_exclusive_exit before sleeping. 1556 */ 1557 if ((_rtld_mutex & RTLD_EXCLUSIVE_MASK) || 1558 _rtld_waiter_exclusive) 1559 _lwp_park(NULL, 0, __UNVOLATILE(&_rtld_mutex), NULL); 1560 /* Try to remove us from the waiter list. */ 1561 atomic_cas_uint(&_rtld_waiter_shared, self, 0); 1562 if (waiter) 1563 _lwp_unpark(waiter, __UNVOLATILE(&_rtld_mutex)); 1564 } 1565 } 1566 1567 void 1568 _rtld_shared_exit(void) 1569 { 1570 lwpid_t waiter; 1571 1572 /* 1573 * Shared lock taken after an exclusive lock. 1574 * Just assume this is a partial recursion. 1575 */ 1576 if (_rtld_mutex & RTLD_EXCLUSIVE_MASK) 1577 return; 1578 1579 /* 1580 * Wakeup LWPs waiting for an exclusive lock if this is the last 1581 * LWP on the shared lock. 1582 */ 1583 if (atomic_dec_uint_nv(&_rtld_mutex)) 1584 return; 1585 if ((waiter = _rtld_waiter_exclusive) != 0) 1586 _lwp_unpark(waiter, __UNVOLATILE(&_rtld_mutex)); 1587 1588 membar_exit(); 1589 } 1590 1591 void 1592 _rtld_exclusive_enter(sigset_t *mask) 1593 { 1594 lwpid_t waiter, self = _lwp_self(); 1595 unsigned int locked_value = (unsigned int)self | RTLD_EXCLUSIVE_MASK; 1596 unsigned int cur; 1597 sigset_t blockmask; 1598 1599 sigfillset(&blockmask); 1600 sigdelset(&blockmask, SIGTRAP); /* Allow the debugger */ 1601 sigprocmask(SIG_BLOCK, &blockmask, mask); 1602 1603 membar_enter(); 1604 1605 for (;;) { 1606 if (atomic_cas_uint(&_rtld_mutex, 0, locked_value) == 0) 1607 break; 1608 waiter = atomic_swap_uint(&_rtld_waiter_exclusive, self); 1609 cur = _rtld_mutex; 1610 if (cur == locked_value) { 1611 _rtld_error("dead lock detected"); 1612 _rtld_die(); 1613 } 1614 if (cur) 1615 _lwp_park(NULL, 0, __UNVOLATILE(&_rtld_mutex), NULL); 1616 atomic_cas_uint(&_rtld_waiter_exclusive, self, 0); 1617 if (waiter) 1618 _lwp_unpark(waiter, __UNVOLATILE(&_rtld_mutex)); 1619 } 1620 } 1621 1622 void 1623 _rtld_exclusive_exit(sigset_t *mask) 1624 { 1625 lwpid_t waiter; 1626 1627 _rtld_mutex = 0; 1628 if ((waiter = _rtld_waiter_exclusive) != 0) 1629 _lwp_unpark(waiter, __UNVOLATILE(&_rtld_mutex)); 1630 1631 if ((waiter = _rtld_waiter_shared) != 0) 1632 _lwp_unpark(waiter, __UNVOLATILE(&_rtld_mutex)); 1633 1634 membar_exit(); 1635 sigprocmask(SIG_SETMASK, mask, NULL); 1636 } 1637 #endif /* !defined(__minix) */ 1638