linker.cpp revision e4d792adb8d6f9228b9ac9dc1ad7f43b271f085f
1/* 2 * Copyright (C) 2008, 2009 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29#include <dlfcn.h> 30#include <errno.h> 31#include <fcntl.h> 32#include <linux/auxvec.h> 33#include <pthread.h> 34#include <stdio.h> 35#include <stdlib.h> 36#include <string.h> 37#include <sys/atomics.h> 38#include <sys/mman.h> 39#include <sys/stat.h> 40#include <unistd.h> 41 42// Private C library headers. 43#include "private/bionic_tls.h" 44#include "private/KernelArgumentBlock.h" 45#include "private/ScopedPthreadMutexLocker.h" 46 47#include "linker.h" 48#include "linker_debug.h" 49#include "linker_environ.h" 50#include "linker_phdr.h" 51 52/* Assume average path length of 64 and max 8 paths */ 53#define LDPATH_BUFSIZE 512 54#define LDPATH_MAX 8 55 56#define LDPRELOAD_BUFSIZE 512 57#define LDPRELOAD_MAX 8 58 59/* >>> IMPORTANT NOTE - READ ME BEFORE MODIFYING <<< 60 * 61 * Do NOT use malloc() and friends or pthread_*() code here. 62 * Don't use printf() either; it's caused mysterious memory 63 * corruption in the past. 64 * The linker runs before we bring up libc and it's easiest 65 * to make sure it does not depend on any complex libc features 66 * 67 * open issues / todo: 68 * 69 * - are we doing everything we should for ARM_COPY relocations? 70 * - cleaner error reporting 71 * - after linking, set as much stuff as possible to READONLY 72 * and NOEXEC 73 */ 74 75static bool soinfo_link_image(soinfo* si); 76 77// We can't use malloc(3) in the dynamic linker. We use a linked list of anonymous 78// maps, each a single page in size. The pages are broken up into as many struct soinfo 79// objects as will fit, and they're all threaded together on a free list. 80#define SOINFO_PER_POOL ((PAGE_SIZE - sizeof(soinfo_pool_t*)) / sizeof(soinfo)) 81struct soinfo_pool_t { 82 soinfo_pool_t* next; 83 soinfo info[SOINFO_PER_POOL]; 84}; 85static struct soinfo_pool_t* gSoInfoPools = NULL; 86static soinfo* gSoInfoFreeList = NULL; 87 88static soinfo* solist = &libdl_info; 89static soinfo* sonext = &libdl_info; 90static soinfo* somain; /* main process, always the one after libdl_info */ 91 92static const char* const gSoPaths[] = { 93#if defined(__LP64__) 94 "/vendor/lib64", 95 "/system/lib64", 96#else 97 "/vendor/lib", 98 "/system/lib", 99#endif 100 NULL 101}; 102 103static char gLdPathsBuffer[LDPATH_BUFSIZE]; 104static const char* gLdPaths[LDPATH_MAX + 1]; 105 106static char gLdPreloadsBuffer[LDPRELOAD_BUFSIZE]; 107static const char* gLdPreloadNames[LDPRELOAD_MAX + 1]; 108 109static soinfo* gLdPreloads[LDPRELOAD_MAX + 1]; 110 111__LIBC_HIDDEN__ int gLdDebugVerbosity; 112 113__LIBC_HIDDEN__ abort_msg_t* gAbortMessage = NULL; // For debuggerd. 114 115enum RelocationKind { 116 kRelocAbsolute = 0, 117 kRelocRelative, 118 kRelocCopy, 119 kRelocSymbol, 120 kRelocMax 121}; 122 123#if STATS 124struct linker_stats_t { 125 int count[kRelocMax]; 126}; 127 128static linker_stats_t linker_stats; 129 130static void count_relocation(RelocationKind kind) { 131 ++linker_stats.count[kind]; 132} 133#else 134static void count_relocation(RelocationKind) { 135} 136#endif 137 138#if COUNT_PAGES 139static unsigned bitmask[4096]; 140#define MARK(offset) \ 141 do { \ 142 bitmask[((offset) >> 12) >> 3] |= (1 << (((offset) >> 12) & 7)); \ 143 } while(0) 144#else 145#define MARK(x) do {} while (0) 146#endif 147 148// You shouldn't try to call memory-allocating functions in the dynamic linker. 149// Guard against the most obvious ones. 150#define DISALLOW_ALLOCATION(return_type, name, ...) \ 151 return_type name __VA_ARGS__ \ 152 { \ 153 const char* msg = "ERROR: " #name " called from the dynamic linker!\n"; \ 154 __libc_format_log(ANDROID_LOG_FATAL, "linker", "%s", msg); \ 155 write(2, msg, strlen(msg)); \ 156 abort(); \ 157 } 158#define UNUSED __attribute__((unused)) 159DISALLOW_ALLOCATION(void*, malloc, (size_t u UNUSED)); 160DISALLOW_ALLOCATION(void, free, (void* u UNUSED)); 161DISALLOW_ALLOCATION(void*, realloc, (void* u1 UNUSED, size_t u2 UNUSED)); 162DISALLOW_ALLOCATION(void*, calloc, (size_t u1 UNUSED, size_t u2 UNUSED)); 163 164static char tmp_err_buf[768]; 165static char __linker_dl_err_buf[768]; 166 167char* linker_get_error_buffer() { 168 return &__linker_dl_err_buf[0]; 169} 170 171size_t linker_get_error_buffer_size() { 172 return sizeof(__linker_dl_err_buf); 173} 174 175/* 176 * This function is an empty stub where GDB locates a breakpoint to get notified 177 * about linker activity. 178 */ 179extern "C" void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity(); 180 181static r_debug _r_debug = {1, NULL, &rtld_db_dlactivity, RT_CONSISTENT, 0}; 182static link_map_t* r_debug_tail = 0; 183 184static pthread_mutex_t gDebugMutex = PTHREAD_MUTEX_INITIALIZER; 185 186static void insert_soinfo_into_debug_map(soinfo * info) { 187 // Copy the necessary fields into the debug structure. 188 link_map_t* map = &(info->link_map); 189 map->l_addr = info->base; 190 map->l_name = (char*) info->name; 191 map->l_ld = (uintptr_t)info->dynamic; 192 193 /* Stick the new library at the end of the list. 194 * gdb tends to care more about libc than it does 195 * about leaf libraries, and ordering it this way 196 * reduces the back-and-forth over the wire. 197 */ 198 if (r_debug_tail) { 199 r_debug_tail->l_next = map; 200 map->l_prev = r_debug_tail; 201 map->l_next = 0; 202 } else { 203 _r_debug.r_map = map; 204 map->l_prev = 0; 205 map->l_next = 0; 206 } 207 r_debug_tail = map; 208} 209 210static void remove_soinfo_from_debug_map(soinfo* info) { 211 link_map_t* map = &(info->link_map); 212 213 if (r_debug_tail == map) { 214 r_debug_tail = map->l_prev; 215 } 216 217 if (map->l_prev) { 218 map->l_prev->l_next = map->l_next; 219 } 220 if (map->l_next) { 221 map->l_next->l_prev = map->l_prev; 222 } 223} 224 225static void notify_gdb_of_load(soinfo* info) { 226 if (info->flags & FLAG_EXE) { 227 // GDB already knows about the main executable 228 return; 229 } 230 231 ScopedPthreadMutexLocker locker(&gDebugMutex); 232 233 _r_debug.r_state = RT_ADD; 234 rtld_db_dlactivity(); 235 236 insert_soinfo_into_debug_map(info); 237 238 _r_debug.r_state = RT_CONSISTENT; 239 rtld_db_dlactivity(); 240} 241 242static void notify_gdb_of_unload(soinfo* info) { 243 if (info->flags & FLAG_EXE) { 244 // GDB already knows about the main executable 245 return; 246 } 247 248 ScopedPthreadMutexLocker locker(&gDebugMutex); 249 250 _r_debug.r_state = RT_DELETE; 251 rtld_db_dlactivity(); 252 253 remove_soinfo_from_debug_map(info); 254 255 _r_debug.r_state = RT_CONSISTENT; 256 rtld_db_dlactivity(); 257} 258 259void notify_gdb_of_libraries() { 260 _r_debug.r_state = RT_ADD; 261 rtld_db_dlactivity(); 262 _r_debug.r_state = RT_CONSISTENT; 263 rtld_db_dlactivity(); 264} 265 266static bool ensure_free_list_non_empty() { 267 if (gSoInfoFreeList != NULL) { 268 return true; 269 } 270 271 // Allocate a new pool. 272 soinfo_pool_t* pool = reinterpret_cast<soinfo_pool_t*>(mmap(NULL, sizeof(*pool), 273 PROT_READ|PROT_WRITE, 274 MAP_PRIVATE|MAP_ANONYMOUS, 0, 0)); 275 if (pool == MAP_FAILED) { 276 return false; 277 } 278 279 // Add the pool to our list of pools. 280 pool->next = gSoInfoPools; 281 gSoInfoPools = pool; 282 283 // Chain the entries in the new pool onto the free list. 284 gSoInfoFreeList = &pool->info[0]; 285 soinfo* next = NULL; 286 for (int i = SOINFO_PER_POOL - 1; i >= 0; --i) { 287 pool->info[i].next = next; 288 next = &pool->info[i]; 289 } 290 291 return true; 292} 293 294static void set_soinfo_pool_protection(int protection) { 295 for (soinfo_pool_t* p = gSoInfoPools; p != NULL; p = p->next) { 296 if (mprotect(p, sizeof(*p), protection) == -1) { 297 abort(); // Can't happen. 298 } 299 } 300} 301 302static soinfo* soinfo_alloc(const char* name) { 303 if (strlen(name) >= SOINFO_NAME_LEN) { 304 DL_ERR("library name \"%s\" too long", name); 305 return NULL; 306 } 307 308 if (!ensure_free_list_non_empty()) { 309 DL_ERR("out of memory when loading \"%s\"", name); 310 return NULL; 311 } 312 313 // Take the head element off the free list. 314 soinfo* si = gSoInfoFreeList; 315 gSoInfoFreeList = gSoInfoFreeList->next; 316 317 // Initialize the new element. 318 memset(si, 0, sizeof(soinfo)); 319 strlcpy(si->name, name, sizeof(si->name)); 320 sonext->next = si; 321 sonext = si; 322 323 TRACE("name %s: allocated soinfo @ %p", name, si); 324 return si; 325} 326 327static void soinfo_free(soinfo* si) 328{ 329 if (si == NULL) { 330 return; 331 } 332 333 soinfo *prev = NULL, *trav; 334 335 TRACE("name %s: freeing soinfo @ %p", si->name, si); 336 337 for (trav = solist; trav != NULL; trav = trav->next) { 338 if (trav == si) 339 break; 340 prev = trav; 341 } 342 if (trav == NULL) { 343 /* si was not in solist */ 344 DL_ERR("name \"%s\" is not in solist!", si->name); 345 return; 346 } 347 348 /* prev will never be NULL, because the first entry in solist is 349 always the static libdl_info. 350 */ 351 prev->next = si->next; 352 if (si == sonext) { 353 sonext = prev; 354 } 355 si->next = gSoInfoFreeList; 356 gSoInfoFreeList = si; 357} 358 359 360static void parse_path(const char* path, const char* delimiters, 361 const char** array, char* buf, size_t buf_size, size_t max_count) { 362 if (path == NULL) { 363 return; 364 } 365 366 size_t len = strlcpy(buf, path, buf_size); 367 368 size_t i = 0; 369 char* buf_p = buf; 370 while (i < max_count && (array[i] = strsep(&buf_p, delimiters))) { 371 if (*array[i] != '\0') { 372 ++i; 373 } 374 } 375 376 // Forget the last path if we had to truncate; this occurs if the 2nd to 377 // last char isn't '\0' (i.e. wasn't originally a delimiter). 378 if (i > 0 && len >= buf_size && buf[buf_size - 2] != '\0') { 379 array[i - 1] = NULL; 380 } else { 381 array[i] = NULL; 382 } 383} 384 385static void parse_LD_LIBRARY_PATH(const char* path) { 386 parse_path(path, ":", gLdPaths, 387 gLdPathsBuffer, sizeof(gLdPathsBuffer), LDPATH_MAX); 388} 389 390static void parse_LD_PRELOAD(const char* path) { 391 // We have historically supported ':' as well as ' ' in LD_PRELOAD. 392 parse_path(path, " :", gLdPreloadNames, 393 gLdPreloadsBuffer, sizeof(gLdPreloadsBuffer), LDPRELOAD_MAX); 394} 395 396#if defined(__arm__) 397 398/* For a given PC, find the .so that it belongs to. 399 * Returns the base address of the .ARM.exidx section 400 * for that .so, and the number of 8-byte entries 401 * in that section (via *pcount). 402 * 403 * Intended to be called by libc's __gnu_Unwind_Find_exidx(). 404 * 405 * This function is exposed via dlfcn.cpp and libdl.so. 406 */ 407_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int *pcount) 408{ 409 soinfo *si; 410 unsigned addr = (unsigned)pc; 411 412 for (si = solist; si != 0; si = si->next) { 413 if ((addr >= si->base) && (addr < (si->base + si->size))) { 414 *pcount = si->ARM_exidx_count; 415 return (_Unwind_Ptr)si->ARM_exidx; 416 } 417 } 418 *pcount = 0; 419 return NULL; 420} 421 422#endif 423 424/* Here, we only have to provide a callback to iterate across all the 425 * loaded libraries. gcc_eh does the rest. */ 426int 427dl_iterate_phdr(int (*cb)(dl_phdr_info *info, size_t size, void *data), 428 void *data) 429{ 430 int rv = 0; 431 for (soinfo* si = solist; si != NULL; si = si->next) { 432 dl_phdr_info dl_info; 433 dl_info.dlpi_addr = si->link_map.l_addr; 434 dl_info.dlpi_name = si->link_map.l_name; 435 dl_info.dlpi_phdr = si->phdr; 436 dl_info.dlpi_phnum = si->phnum; 437 rv = cb(&dl_info, sizeof(dl_phdr_info), data); 438 if (rv != 0) { 439 break; 440 } 441 } 442 return rv; 443} 444 445static Elf_Sym* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) { 446 Elf_Sym* symtab = si->symtab; 447 const char* strtab = si->strtab; 448 449 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p %x %zd", 450 name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket); 451 452 for (unsigned n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]) { 453 Elf_Sym* s = symtab + n; 454 if (strcmp(strtab + s->st_name, name)) continue; 455 456 /* only concern ourselves with global and weak symbol definitions */ 457 switch (ELF_ST_BIND(s->st_info)) { 458 case STB_GLOBAL: 459 case STB_WEAK: 460 if (s->st_shndx == SHN_UNDEF) { 461 continue; 462 } 463 464 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd", 465 name, si->name, reinterpret_cast<void*>(s->st_value), 466 static_cast<size_t>(s->st_size)); 467 return s; 468 } 469 } 470 471 return NULL; 472} 473 474static unsigned elfhash(const char* _name) { 475 const unsigned char* name = (const unsigned char*) _name; 476 unsigned h = 0, g; 477 478 while(*name) { 479 h = (h << 4) + *name++; 480 g = h & 0xf0000000; 481 h ^= g; 482 h ^= g >> 24; 483 } 484 return h; 485} 486 487static Elf_Sym* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, soinfo* needed[]) { 488 unsigned elf_hash = elfhash(name); 489 Elf_Sym* s = NULL; 490 491 if (si != NULL && somain != NULL) { 492 493 /* 494 * Local scope is executable scope. Just start looking into it right away 495 * for the shortcut. 496 */ 497 498 if (si == somain) { 499 s = soinfo_elf_lookup(si, elf_hash, name); 500 if (s != NULL) { 501 *lsi = si; 502 goto done; 503 } 504 } else { 505 /* Order of symbol lookup is controlled by DT_SYMBOLIC flag */ 506 507 /* 508 * If this object was built with symbolic relocations disabled, the 509 * first place to look to resolve external references is the main 510 * executable. 511 */ 512 513 if (!si->has_DT_SYMBOLIC) { 514 DEBUG("%s: looking up %s in executable %s", 515 si->name, name, somain->name); 516 s = soinfo_elf_lookup(somain, elf_hash, name); 517 if (s != NULL) { 518 *lsi = somain; 519 goto done; 520 } 521 } 522 523 /* Look for symbols in the local scope (the object who is 524 * searching). This happens with C++ templates on x86 for some 525 * reason. 526 * 527 * Notes on weak symbols: 528 * The ELF specs are ambiguous about treatment of weak definitions in 529 * dynamic linking. Some systems return the first definition found 530 * and some the first non-weak definition. This is system dependent. 531 * Here we return the first definition found for simplicity. */ 532 533 s = soinfo_elf_lookup(si, elf_hash, name); 534 if (s != NULL) { 535 *lsi = si; 536 goto done; 537 } 538 539 /* 540 * If this object was built with -Bsymbolic and symbol is not found 541 * in the local scope, try to find the symbol in the main executable. 542 */ 543 544 if (si->has_DT_SYMBOLIC) { 545 DEBUG("%s: looking up %s in executable %s after local scope", 546 si->name, name, somain->name); 547 s = soinfo_elf_lookup(somain, elf_hash, name); 548 if (s != NULL) { 549 *lsi = somain; 550 goto done; 551 } 552 } 553 } 554 } 555 556 /* Next, look for it in the preloads list */ 557 for (int i = 0; gLdPreloads[i] != NULL; i++) { 558 s = soinfo_elf_lookup(gLdPreloads[i], elf_hash, name); 559 if (s != NULL) { 560 *lsi = gLdPreloads[i]; 561 goto done; 562 } 563 } 564 565 for (int i = 0; needed[i] != NULL; i++) { 566 DEBUG("%s: looking up %s in %s", 567 si->name, name, needed[i]->name); 568 s = soinfo_elf_lookup(needed[i], elf_hash, name); 569 if (s != NULL) { 570 *lsi = needed[i]; 571 goto done; 572 } 573 } 574 575done: 576 if (s != NULL) { 577 TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, " 578 "found in %s, base = %p, load bias = %p", 579 si->name, name, reinterpret_cast<void*>(s->st_value), 580 (*lsi)->name, reinterpret_cast<void*>((*lsi)->base), 581 reinterpret_cast<void*>((*lsi)->load_bias)); 582 return s; 583 } 584 585 return NULL; 586} 587 588/* This is used by dlsym(3). It performs symbol lookup only within the 589 specified soinfo object and not in any of its dependencies. 590 591 TODO: Only looking in the specified soinfo seems wrong. dlsym(3) says 592 that it should do a breadth first search through the dependency 593 tree. This agrees with the ELF spec (aka System V Application 594 Binary Interface) where in Chapter 5 it discuss resolving "Shared 595 Object Dependencies" in breadth first search order. 596 */ 597Elf_Sym* dlsym_handle_lookup(soinfo* si, const char* name) { 598 return soinfo_elf_lookup(si, elfhash(name), name); 599} 600 601/* This is used by dlsym(3) to performs a global symbol lookup. If the 602 start value is null (for RTLD_DEFAULT), the search starts at the 603 beginning of the global solist. Otherwise the search starts at the 604 specified soinfo (for RTLD_NEXT). 605 */ 606Elf_Sym* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) { 607 unsigned elf_hash = elfhash(name); 608 609 if (start == NULL) { 610 start = solist; 611 } 612 613 Elf_Sym* s = NULL; 614 for (soinfo* si = start; (s == NULL) && (si != NULL); si = si->next) { 615 s = soinfo_elf_lookup(si, elf_hash, name); 616 if (s != NULL) { 617 *found = si; 618 break; 619 } 620 } 621 622 if (s != NULL) { 623 TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p", 624 name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base)); 625 } 626 627 return s; 628} 629 630soinfo* find_containing_library(const void* p) { 631 Elf_Addr address = reinterpret_cast<Elf_Addr>(p); 632 for (soinfo* si = solist; si != NULL; si = si->next) { 633 if (address >= si->base && address - si->base < si->size) { 634 return si; 635 } 636 } 637 return NULL; 638} 639 640Elf_Sym* dladdr_find_symbol(soinfo* si, const void* addr) { 641 Elf_Addr soaddr = reinterpret_cast<Elf_Addr>(addr) - si->base; 642 643 // Search the library's symbol table for any defined symbol which 644 // contains this address. 645 for (size_t i = 0; i < si->nchain; ++i) { 646 Elf_Sym* sym = &si->symtab[i]; 647 if (sym->st_shndx != SHN_UNDEF && 648 soaddr >= sym->st_value && 649 soaddr < sym->st_value + sym->st_size) { 650 return sym; 651 } 652 } 653 654 return NULL; 655} 656 657#if 0 658static void dump(soinfo* si) 659{ 660 Elf_Sym* s = si->symtab; 661 for (unsigned n = 0; n < si->nchain; n++) { 662 TRACE("%04d> %08x: %02x %04x %08x %08x %s", n, s, 663 s->st_info, s->st_shndx, s->st_value, s->st_size, 664 si->strtab + s->st_name); 665 s++; 666 } 667} 668#endif 669 670static int open_library_on_path(const char* name, const char* const paths[]) { 671 char buf[512]; 672 for (size_t i = 0; paths[i] != NULL; ++i) { 673 int n = __libc_format_buffer(buf, sizeof(buf), "%s/%s", paths[i], name); 674 if (n < 0 || n >= static_cast<int>(sizeof(buf))) { 675 PRINT("Warning: ignoring very long library path: %s/%s", paths[i], name); 676 continue; 677 } 678 int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC)); 679 if (fd != -1) { 680 return fd; 681 } 682 } 683 return -1; 684} 685 686static int open_library(const char* name) { 687 TRACE("[ opening %s ]", name); 688 689 // If the name contains a slash, we should attempt to open it directly and not search the paths. 690 if (strchr(name, '/') != NULL) { 691 int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC)); 692 if (fd != -1) { 693 return fd; 694 } 695 // ...but nvidia binary blobs (at least) rely on this behavior, so fall through for now. 696 } 697 698 // Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths. 699 int fd = open_library_on_path(name, gLdPaths); 700 if (fd == -1) { 701 fd = open_library_on_path(name, gSoPaths); 702 } 703 return fd; 704} 705 706static soinfo* load_library(const char* name) { 707 // Open the file. 708 int fd = open_library(name); 709 if (fd == -1) { 710 DL_ERR("library \"%s\" not found", name); 711 return NULL; 712 } 713 714 // Read the ELF header and load the segments. 715 ElfReader elf_reader(name, fd); 716 if (!elf_reader.Load()) { 717 return NULL; 718 } 719 720 const char* bname = strrchr(name, '/'); 721 soinfo* si = soinfo_alloc(bname ? bname + 1 : name); 722 if (si == NULL) { 723 return NULL; 724 } 725 si->base = elf_reader.load_start(); 726 si->size = elf_reader.load_size(); 727 si->load_bias = elf_reader.load_bias(); 728 si->flags = 0; 729 si->entry = 0; 730 si->dynamic = NULL; 731 si->phnum = elf_reader.phdr_count(); 732 si->phdr = elf_reader.loaded_phdr(); 733 return si; 734} 735 736static soinfo *find_loaded_library(const char *name) 737{ 738 soinfo *si; 739 const char *bname; 740 741 // TODO: don't use basename only for determining libraries 742 // http://code.google.com/p/android/issues/detail?id=6670 743 744 bname = strrchr(name, '/'); 745 bname = bname ? bname + 1 : name; 746 747 for (si = solist; si != NULL; si = si->next) { 748 if (!strcmp(bname, si->name)) { 749 return si; 750 } 751 } 752 return NULL; 753} 754 755static soinfo* find_library_internal(const char* name) { 756 if (name == NULL) { 757 return somain; 758 } 759 760 soinfo* si = find_loaded_library(name); 761 if (si != NULL) { 762 if (si->flags & FLAG_LINKED) { 763 return si; 764 } 765 DL_ERR("OOPS: recursive link to \"%s\"", si->name); 766 return NULL; 767 } 768 769 TRACE("[ '%s' has not been loaded yet. Locating...]", name); 770 si = load_library(name); 771 if (si == NULL) { 772 return NULL; 773 } 774 775 // At this point we know that whatever is loaded @ base is a valid ELF 776 // shared library whose segments are properly mapped in. 777 TRACE("[ init_library base=%p sz=0x%08x name='%s' ]", 778 reinterpret_cast<void*>(si->base), si->size, si->name); 779 780 if (!soinfo_link_image(si)) { 781 munmap(reinterpret_cast<void*>(si->base), si->size); 782 soinfo_free(si); 783 return NULL; 784 } 785 786 return si; 787} 788 789static soinfo* find_library(const char* name) { 790 soinfo* si = find_library_internal(name); 791 if (si != NULL) { 792 si->ref_count++; 793 } 794 return si; 795} 796 797static int soinfo_unload(soinfo* si) { 798 if (si->ref_count == 1) { 799 TRACE("unloading '%s'", si->name); 800 si->CallDestructors(); 801 802 for (Elf_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) { 803 if (d->d_tag == DT_NEEDED) { 804 const char* library_name = si->strtab + d->d_un.d_val; 805 TRACE("%s needs to unload %s", si->name, library_name); 806 soinfo_unload(find_loaded_library(library_name)); 807 } 808 } 809 810 munmap(reinterpret_cast<void*>(si->base), si->size); 811 notify_gdb_of_unload(si); 812 soinfo_free(si); 813 si->ref_count = 0; 814 } else { 815 si->ref_count--; 816 TRACE("not unloading '%s', decrementing ref_count to %zd", si->name, si->ref_count); 817 } 818 return 0; 819} 820 821void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) { 822 if (!get_AT_SECURE()) { 823 parse_LD_LIBRARY_PATH(ld_library_path); 824 } 825} 826 827soinfo* do_dlopen(const char* name, int flags) { 828 if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL)) != 0) { 829 DL_ERR("invalid flags to dlopen: %x", flags); 830 return NULL; 831 } 832 set_soinfo_pool_protection(PROT_READ | PROT_WRITE); 833 soinfo* si = find_library(name); 834 if (si != NULL) { 835 si->CallConstructors(); 836 } 837 set_soinfo_pool_protection(PROT_READ); 838 return si; 839} 840 841int do_dlclose(soinfo* si) { 842 set_soinfo_pool_protection(PROT_READ | PROT_WRITE); 843 int result = soinfo_unload(si); 844 set_soinfo_pool_protection(PROT_READ); 845 return result; 846} 847 848#if defined(USE_RELA) 849static int soinfo_relocate_a(soinfo* si, Elf_Rela* rela, unsigned count, soinfo* needed[]) { 850 Elf_Sym* symtab = si->symtab; 851 const char* strtab = si->strtab; 852 Elf_Sym* s; 853 Elf_Rela* start = rela; 854 soinfo* lsi; 855 856 for (size_t idx = 0; idx < count; ++idx, ++rela) { 857 unsigned type = ELF_R_TYPE(rela->r_info); 858 unsigned sym = ELF_R_SYM(rela->r_info); 859 Elf_Addr reloc = static_cast<Elf_Addr>(rela->r_offset + si->load_bias); 860 Elf_Addr sym_addr = 0; 861 char* sym_name = NULL; 862 863 DEBUG("Processing '%s' relocation at index %zd", si->name, idx); 864 if (type == 0) { // R_*_NONE 865 continue; 866 } 867 if (sym != 0) { 868 sym_name = (char *)(strtab + symtab[sym].st_name); 869 s = soinfo_do_lookup(si, sym_name, &lsi, needed); 870 if (s == NULL) { 871 // We only allow an undefined symbol if this is a weak reference... 872 s = &symtab[sym]; 873 if (ELF_ST_BIND(s->st_info) != STB_WEAK) { 874 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name); 875 return -1; 876 } 877 878 /* IHI0044C AAELF 4.5.1.1: 879 880 Libraries are not searched to resolve weak references. 881 It is not an error for a weak reference to remain unsatisfied. 882 883 During linking, the value of an undefined weak reference is: 884 - Zero if the relocation type is absolute 885 - The address of the place if the relocation is pc-relative 886 - The address of nominal base address if the relocation 887 type is base-relative. 888 */ 889 890 switch (type) { 891#if defined(__x86_64__) 892 case R_X86_64_JUMP_SLOT: 893 case R_X86_64_GLOB_DAT: 894 case R_X86_64_32: 895 case R_X86_64_RELATIVE: 896 // No need to do anything. 897 break; 898 case R_X86_64_PC32: 899 sym_addr = reloc; 900 break; 901#endif 902 903 default: 904 DL_ERR("unknown weak reloc type %d @ %p (%d)", type, rela, (int) (rela - start)); 905 return -1; 906 } 907 } else { 908 // We got a definition. 909 sym_addr = static_cast<Elf_Addr>(s->st_value + lsi->load_bias); 910 } 911 count_relocation(kRelocSymbol); 912 } else { 913 s = NULL; 914 } 915 916 switch (type) { 917#if defined(__x86_64__) 918 case R_X86_64_JUMP_SLOT: 919 count_relocation(kRelocAbsolute); 920 MARK(rela->r_offset); 921 TRACE_TYPE(RELO, "RELO JMP_SLOT %08zx <- %08zx %s", static_cast<size_t>(reloc), 922 static_cast<size_t>(sym_addr + rela->r_addend), sym_name); 923 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr + rela->r_addend; 924 break; 925 case R_X86_64_GLOB_DAT: 926 count_relocation(kRelocAbsolute); 927 MARK(rela->r_offset); 928 TRACE_TYPE(RELO, "RELO GLOB_DAT %08zx <- %08zx %s", static_cast<size_t>(reloc), 929 static_cast<size_t>(sym_addr + rela->r_addend), sym_name); 930 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr + rela->r_addend; 931 break; 932 case R_X86_64_RELATIVE: 933 count_relocation(kRelocRelative); 934 MARK(rela->r_offset); 935 if (sym) { 936 DL_ERR("odd RELATIVE form..."); 937 return -1; 938 } 939 TRACE_TYPE(RELO, "RELO RELATIVE %08zx <- +%08zx", static_cast<size_t>(reloc), 940 static_cast<size_t>(si->base)); 941 *reinterpret_cast<Elf_Addr*>(reloc) = si->base + rela->r_addend; 942 break; 943 case R_X86_64_32: 944 count_relocation(kRelocRelative); 945 MARK(rela->r_offset); 946 TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc), 947 static_cast<size_t>(sym_addr), sym_name); 948 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr + rela->r_addend; 949 break; 950 case R_X86_64_64: 951 count_relocation(kRelocRelative); 952 MARK(rela->r_offset); 953 TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc), 954 static_cast<size_t>(sym_addr), sym_name); 955 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr + rela->r_addend; 956 break; 957 case R_X86_64_PC32: 958 count_relocation(kRelocRelative); 959 MARK(rela->r_offset); 960 TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s", 961 static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc), 962 static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name); 963 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr + rela->r_addend - reloc; 964 break; 965#endif 966 default: 967 DL_ERR("unknown reloc type %d @ %p (%d)", type, rela, (int) (rela - start)); 968 return -1; 969 } 970 } 971 return 0; 972} 973#else 974static int soinfo_relocate(soinfo* si, Elf_Rel* rel, unsigned count, 975 soinfo* needed[]) 976{ 977 Elf_Sym* symtab = si->symtab; 978 const char* strtab = si->strtab; 979 Elf_Sym* s; 980 Elf_Rel* start = rel; 981 soinfo* lsi; 982 983 for (size_t idx = 0; idx < count; ++idx, ++rel) { 984 unsigned type = ELF_R_TYPE(rel->r_info); 985 // TODO: don't use unsigned for 'sym'. Use uint32_t or Elf_Addr instead. 986 unsigned sym = ELF_R_SYM(rel->r_info); 987 Elf_Addr reloc = static_cast<Elf_Addr>(rel->r_offset + si->load_bias); 988 Elf_Addr sym_addr = 0; 989 char* sym_name = NULL; 990 991 DEBUG("Processing '%s' relocation at index %zd", si->name, idx); 992 if (type == 0) { // R_*_NONE 993 continue; 994 } 995 if (sym != 0) { 996 sym_name = (char *)(strtab + symtab[sym].st_name); 997 s = soinfo_do_lookup(si, sym_name, &lsi, needed); 998 if (s == NULL) { 999 // We only allow an undefined symbol if this is a weak reference... 1000 s = &symtab[sym]; 1001 if (ELF_ST_BIND(s->st_info) != STB_WEAK) { 1002 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name); 1003 return -1; 1004 } 1005 1006 /* IHI0044C AAELF 4.5.1.1: 1007 1008 Libraries are not searched to resolve weak references. 1009 It is not an error for a weak reference to remain 1010 unsatisfied. 1011 1012 During linking, the value of an undefined weak reference is: 1013 - Zero if the relocation type is absolute 1014 - The address of the place if the relocation is pc-relative 1015 - The address of nominal base address if the relocation 1016 type is base-relative. 1017 */ 1018 1019 switch (type) { 1020#if defined(__arm__) 1021 case R_ARM_JUMP_SLOT: 1022 case R_ARM_GLOB_DAT: 1023 case R_ARM_ABS32: 1024 case R_ARM_RELATIVE: /* Don't care. */ 1025 // sym_addr was initialized to be zero above or relocation 1026 // code below does not care about value of sym_addr. 1027 // No need to do anything. 1028 break; 1029#elif defined(__i386__) 1030 case R_386_JMP_SLOT: 1031 case R_386_GLOB_DAT: 1032 case R_386_32: 1033 case R_386_RELATIVE: /* Don't care. */ 1034 // sym_addr was initialized to be zero above or relocation 1035 // code below does not care about value of sym_addr. 1036 // No need to do anything. 1037 break; 1038 case R_386_PC32: 1039 sym_addr = reloc; 1040 break; 1041#endif 1042 1043#if defined(__arm__) 1044 case R_ARM_COPY: 1045 // Fall through. Can't really copy if weak symbol is not found at run-time. 1046#endif 1047 default: 1048 DL_ERR("unknown weak reloc type %d @ %p (%d)", type, rel, (int) (rel - start)); 1049 return -1; 1050 } 1051 } else { 1052 // We got a definition. 1053 sym_addr = static_cast<Elf_Addr>(s->st_value + lsi->load_bias); 1054 } 1055 count_relocation(kRelocSymbol); 1056 } else { 1057 s = NULL; 1058 } 1059 1060 switch (type) { 1061#if defined(__arm__) 1062 case R_ARM_JUMP_SLOT: 1063 count_relocation(kRelocAbsolute); 1064 MARK(rel->r_offset); 1065 TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name); 1066 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr; 1067 break; 1068 case R_ARM_GLOB_DAT: 1069 count_relocation(kRelocAbsolute); 1070 MARK(rel->r_offset); 1071 TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name); 1072 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr; 1073 break; 1074 case R_ARM_ABS32: 1075 count_relocation(kRelocAbsolute); 1076 MARK(rel->r_offset); 1077 TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name); 1078 *reinterpret_cast<Elf_Addr*>(reloc) += sym_addr; 1079 break; 1080 case R_ARM_REL32: 1081 count_relocation(kRelocRelative); 1082 MARK(rel->r_offset); 1083 TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s", 1084 reloc, sym_addr, rel->r_offset, sym_name); 1085 *reinterpret_cast<Elf_Addr*>(reloc) += sym_addr - rel->r_offset; 1086 break; 1087 case R_ARM_COPY: 1088 if ((si->flags & FLAG_EXE) == 0) { 1089 /* 1090 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf 1091 * 1092 * Section 4.7.1.10 "Dynamic relocations" 1093 * R_ARM_COPY may only appear in executable objects where e_type is 1094 * set to ET_EXEC. 1095 * 1096 * TODO: FLAG_EXE is set for both ET_DYN and ET_EXEC executables. 1097 * We should explicitly disallow ET_DYN executables from having 1098 * R_ARM_COPY relocations. 1099 */ 1100 DL_ERR("%s R_ARM_COPY relocations only supported for ET_EXEC", si->name); 1101 return -1; 1102 } 1103 count_relocation(kRelocCopy); 1104 MARK(rel->r_offset); 1105 TRACE_TYPE(RELO, "RELO %08x <- %d @ %08x %s", reloc, s->st_size, sym_addr, sym_name); 1106 if (reloc == sym_addr) { 1107 Elf_Sym *src = soinfo_do_lookup(NULL, sym_name, &lsi, needed); 1108 1109 if (src == NULL) { 1110 DL_ERR("%s R_ARM_COPY relocation source cannot be resolved", si->name); 1111 return -1; 1112 } 1113 if (lsi->has_DT_SYMBOLIC) { 1114 DL_ERR("%s invalid R_ARM_COPY relocation against DT_SYMBOLIC shared " 1115 "library %s (built with -Bsymbolic?)", si->name, lsi->name); 1116 return -1; 1117 } 1118 if (s->st_size < src->st_size) { 1119 DL_ERR("%s R_ARM_COPY relocation size mismatch (%d < %d)", 1120 si->name, s->st_size, src->st_size); 1121 return -1; 1122 } 1123 memcpy((void*)reloc, (void*)(src->st_value + lsi->load_bias), src->st_size); 1124 } else { 1125 DL_ERR("%s R_ARM_COPY relocation target cannot be resolved", si->name); 1126 return -1; 1127 } 1128 break; 1129#elif defined(__i386__) 1130 case R_386_JMP_SLOT: 1131 count_relocation(kRelocAbsolute); 1132 MARK(rel->r_offset); 1133 TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name); 1134 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr; 1135 break; 1136 case R_386_GLOB_DAT: 1137 count_relocation(kRelocAbsolute); 1138 MARK(rel->r_offset); 1139 TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name); 1140 *reinterpret_cast<Elf_Addr*>(reloc) = sym_addr; 1141 break; 1142 case R_386_32: 1143 count_relocation(kRelocRelative); 1144 MARK(rel->r_offset); 1145 TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name); 1146 *reinterpret_cast<Elf_Addr*>(reloc) += sym_addr; 1147 break; 1148 case R_386_PC32: 1149 count_relocation(kRelocRelative); 1150 MARK(rel->r_offset); 1151 TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s", 1152 reloc, (sym_addr - reloc), sym_addr, reloc, sym_name); 1153 *reinterpret_cast<Elf_Addr*>(reloc) += (sym_addr - reloc); 1154 break; 1155#elif defined(__mips__) 1156 case R_MIPS_REL32: 1157 count_relocation(kRelocAbsolute); 1158 MARK(rel->r_offset); 1159 TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x %s", 1160 reloc, sym_addr, (sym_name) ? sym_name : "*SECTIONHDR*"); 1161 if (s) { 1162 *reinterpret_cast<Elf_Addr*>(reloc) += sym_addr; 1163 } else { 1164 *reinterpret_cast<Elf_Addr*>(reloc) += si->base; 1165 } 1166 break; 1167#endif 1168 1169#if defined(__arm__) 1170 case R_ARM_RELATIVE: 1171#elif defined(__i386__) 1172 case R_386_RELATIVE: 1173#endif 1174 count_relocation(kRelocRelative); 1175 MARK(rel->r_offset); 1176 if (sym) { 1177 DL_ERR("odd RELATIVE form..."); 1178 return -1; 1179 } 1180 TRACE_TYPE(RELO, "RELO RELATIVE %p <- +%p", 1181 reinterpret_cast<void*>(reloc), reinterpret_cast<void*>(si->base)); 1182 *reinterpret_cast<Elf_Addr*>(reloc) += si->base; 1183 break; 1184 1185 default: 1186 DL_ERR("unknown reloc type %d @ %p (%d)", type, rel, (int) (rel - start)); 1187 return -1; 1188 } 1189 } 1190 return 0; 1191} 1192#endif 1193 1194#if defined(__mips__) 1195static bool mips_relocate_got(soinfo* si, soinfo* needed[]) { 1196 unsigned* got = si->plt_got; 1197 if (got == NULL) { 1198 return true; 1199 } 1200 unsigned local_gotno = si->mips_local_gotno; 1201 unsigned gotsym = si->mips_gotsym; 1202 unsigned symtabno = si->mips_symtabno; 1203 Elf_Sym* symtab = si->symtab; 1204 1205 /* 1206 * got[0] is address of lazy resolver function 1207 * got[1] may be used for a GNU extension 1208 * set it to a recognizable address in case someone calls it 1209 * (should be _rtld_bind_start) 1210 * FIXME: maybe this should be in a separate routine 1211 */ 1212 1213 if ((si->flags & FLAG_LINKER) == 0) { 1214 size_t g = 0; 1215 got[g++] = 0xdeadbeef; 1216 if (got[g] & 0x80000000) { 1217 got[g++] = 0xdeadfeed; 1218 } 1219 /* 1220 * Relocate the local GOT entries need to be relocated 1221 */ 1222 for (; g < local_gotno; g++) { 1223 got[g] += si->load_bias; 1224 } 1225 } 1226 1227 /* Now for the global GOT entries */ 1228 Elf_Sym* sym = symtab + gotsym; 1229 got = si->plt_got + local_gotno; 1230 for (size_t g = gotsym; g < symtabno; g++, sym++, got++) { 1231 const char* sym_name; 1232 Elf_Sym* s; 1233 soinfo* lsi; 1234 1235 /* This is an undefined reference... try to locate it */ 1236 sym_name = si->strtab + sym->st_name; 1237 s = soinfo_do_lookup(si, sym_name, &lsi, needed); 1238 if (s == NULL) { 1239 /* We only allow an undefined symbol if this is a weak 1240 reference.. */ 1241 s = &symtab[g]; 1242 if (ELF_ST_BIND(s->st_info) != STB_WEAK) { 1243 DL_ERR("cannot locate \"%s\"...", sym_name); 1244 return false; 1245 } 1246 *got = 0; 1247 } 1248 else { 1249 /* FIXME: is this sufficient? 1250 * For reference see NetBSD link loader 1251 * http://cvsweb.netbsd.org/bsdweb.cgi/src/libexec/ld.elf_so/arch/mips/mips_reloc.c?rev=1.53&content-type=text/x-cvsweb-markup 1252 */ 1253 *got = lsi->load_bias + s->st_value; 1254 } 1255 } 1256 return true; 1257} 1258#endif 1259 1260void soinfo::CallArray(const char* array_name UNUSED, linker_function_t* functions, size_t count, bool reverse) { 1261 if (functions == NULL) { 1262 return; 1263 } 1264 1265 TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, name); 1266 1267 int begin = reverse ? (count - 1) : 0; 1268 int end = reverse ? -1 : count; 1269 int step = reverse ? -1 : 1; 1270 1271 for (int i = begin; i != end; i += step) { 1272 TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]); 1273 CallFunction("function", functions[i]); 1274 } 1275 1276 TRACE("[ Done calling %s for '%s' ]", array_name, name); 1277} 1278 1279void soinfo::CallFunction(const char* function_name UNUSED, linker_function_t function) { 1280 if (function == NULL || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) { 1281 return; 1282 } 1283 1284 TRACE("[ Calling %s @ %p for '%s' ]", function_name, function, name); 1285 function(); 1286 TRACE("[ Done calling %s @ %p for '%s' ]", function_name, function, name); 1287 1288 // The function may have called dlopen(3) or dlclose(3), so we need to ensure our data structures 1289 // are still writable. This happens with our debug malloc (see http://b/7941716). 1290 set_soinfo_pool_protection(PROT_READ | PROT_WRITE); 1291} 1292 1293void soinfo::CallPreInitConstructors() { 1294 // DT_PREINIT_ARRAY functions are called before any other constructors for executables, 1295 // but ignored in a shared library. 1296 CallArray("DT_PREINIT_ARRAY", preinit_array, preinit_array_count, false); 1297} 1298 1299void soinfo::CallConstructors() { 1300 if (constructors_called) { 1301 return; 1302 } 1303 1304 // We set constructors_called before actually calling the constructors, otherwise it doesn't 1305 // protect against recursive constructor calls. One simple example of constructor recursion 1306 // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so: 1307 // 1. The program depends on libc, so libc's constructor is called here. 1308 // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so. 1309 // 3. dlopen() calls the constructors on the newly created 1310 // soinfo for libc_malloc_debug_leak.so. 1311 // 4. The debug .so depends on libc, so CallConstructors is 1312 // called again with the libc soinfo. If it doesn't trigger the early- 1313 // out above, the libc constructor will be called again (recursively!). 1314 constructors_called = true; 1315 1316 if ((flags & FLAG_EXE) == 0 && preinit_array != NULL) { 1317 // The GNU dynamic linker silently ignores these, but we warn the developer. 1318 PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!", 1319 name, preinit_array_count); 1320 } 1321 1322 if (dynamic != NULL) { 1323 for (Elf_Dyn* d = dynamic; d->d_tag != DT_NULL; ++d) { 1324 if (d->d_tag == DT_NEEDED) { 1325 const char* library_name = strtab + d->d_un.d_val; 1326 TRACE("\"%s\": calling constructors in DT_NEEDED \"%s\"", name, library_name); 1327 find_loaded_library(library_name)->CallConstructors(); 1328 } 1329 } 1330 } 1331 1332 TRACE("\"%s\": calling constructors", name); 1333 1334 // DT_INIT should be called before DT_INIT_ARRAY if both are present. 1335 CallFunction("DT_INIT", init_func); 1336 CallArray("DT_INIT_ARRAY", init_array, init_array_count, false); 1337} 1338 1339void soinfo::CallDestructors() { 1340 TRACE("\"%s\": calling destructors", name); 1341 1342 // DT_FINI_ARRAY must be parsed in reverse order. 1343 CallArray("DT_FINI_ARRAY", fini_array, fini_array_count, true); 1344 1345 // DT_FINI should be called after DT_FINI_ARRAY if both are present. 1346 CallFunction("DT_FINI", fini_func); 1347} 1348 1349/* Force any of the closed stdin, stdout and stderr to be associated with 1350 /dev/null. */ 1351static int nullify_closed_stdio() { 1352 int dev_null, i, status; 1353 int return_value = 0; 1354 1355 dev_null = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR)); 1356 if (dev_null < 0) { 1357 DL_ERR("cannot open /dev/null: %s", strerror(errno)); 1358 return -1; 1359 } 1360 TRACE("[ Opened /dev/null file-descriptor=%d]", dev_null); 1361 1362 /* If any of the stdio file descriptors is valid and not associated 1363 with /dev/null, dup /dev/null to it. */ 1364 for (i = 0; i < 3; i++) { 1365 /* If it is /dev/null already, we are done. */ 1366 if (i == dev_null) { 1367 continue; 1368 } 1369 1370 TRACE("[ Nullifying stdio file descriptor %d]", i); 1371 status = TEMP_FAILURE_RETRY(fcntl(i, F_GETFL)); 1372 1373 /* If file is opened, we are good. */ 1374 if (status != -1) { 1375 continue; 1376 } 1377 1378 /* The only error we allow is that the file descriptor does not 1379 exist, in which case we dup /dev/null to it. */ 1380 if (errno != EBADF) { 1381 DL_ERR("fcntl failed: %s", strerror(errno)); 1382 return_value = -1; 1383 continue; 1384 } 1385 1386 /* Try dupping /dev/null to this stdio file descriptor and 1387 repeat if there is a signal. Note that any errors in closing 1388 the stdio descriptor are lost. */ 1389 status = TEMP_FAILURE_RETRY(dup2(dev_null, i)); 1390 if (status < 0) { 1391 DL_ERR("dup2 failed: %s", strerror(errno)); 1392 return_value = -1; 1393 continue; 1394 } 1395 } 1396 1397 /* If /dev/null is not one of the stdio file descriptors, close it. */ 1398 if (dev_null > 2) { 1399 TRACE("[ Closing /dev/null file-descriptor=%d]", dev_null); 1400 status = TEMP_FAILURE_RETRY(close(dev_null)); 1401 if (status == -1) { 1402 DL_ERR("close failed: %s", strerror(errno)); 1403 return_value = -1; 1404 } 1405 } 1406 1407 return return_value; 1408} 1409 1410static bool soinfo_link_image(soinfo* si) { 1411 /* "base" might wrap around UINT32_MAX. */ 1412 Elf_Addr base = si->load_bias; 1413 const Elf_Phdr *phdr = si->phdr; 1414 int phnum = si->phnum; 1415 bool relocating_linker = (si->flags & FLAG_LINKER) != 0; 1416 1417 /* We can't debug anything until the linker is relocated */ 1418 if (!relocating_linker) { 1419 INFO("[ linking %s ]", si->name); 1420 DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(si->base), si->flags); 1421 } 1422 1423 /* Extract dynamic section */ 1424 size_t dynamic_count; 1425 Elf_Word dynamic_flags; 1426 phdr_table_get_dynamic_section(phdr, phnum, base, &si->dynamic, 1427 &dynamic_count, &dynamic_flags); 1428 if (si->dynamic == NULL) { 1429 if (!relocating_linker) { 1430 DL_ERR("missing PT_DYNAMIC in \"%s\"", si->name); 1431 } 1432 return false; 1433 } else { 1434 if (!relocating_linker) { 1435 DEBUG("dynamic = %p", si->dynamic); 1436 } 1437 } 1438 1439#if defined(__arm__) 1440 (void) phdr_table_get_arm_exidx(phdr, phnum, base, 1441 &si->ARM_exidx, &si->ARM_exidx_count); 1442#endif 1443 1444 // Extract useful information from dynamic section. 1445 uint32_t needed_count = 0; 1446 for (Elf_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) { 1447 DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p", 1448 d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val)); 1449 switch (d->d_tag) { 1450 case DT_HASH: 1451 si->nbucket = ((unsigned *) (base + d->d_un.d_ptr))[0]; 1452 si->nchain = ((unsigned *) (base + d->d_un.d_ptr))[1]; 1453 si->bucket = (unsigned *) (base + d->d_un.d_ptr + 8); 1454 si->chain = (unsigned *) (base + d->d_un.d_ptr + 8 + si->nbucket * 4); 1455 break; 1456 case DT_STRTAB: 1457 si->strtab = (const char *) (base + d->d_un.d_ptr); 1458 break; 1459 case DT_SYMTAB: 1460 si->symtab = (Elf_Sym *) (base + d->d_un.d_ptr); 1461 break; 1462#if !defined(__LP64__) 1463 case DT_PLTREL: 1464 if (d->d_un.d_val != DT_REL) { 1465 DL_ERR("unsupported DT_RELA in \"%s\"", si->name); 1466 return false; 1467 } 1468 break; 1469#endif 1470 case DT_JMPREL: 1471#if defined(USE_RELA) 1472 si->plt_rela = (Elf_Rela*) (base + d->d_un.d_ptr); 1473#else 1474 si->plt_rel = (Elf_Rel*) (base + d->d_un.d_ptr); 1475#endif 1476 break; 1477 case DT_PLTRELSZ: 1478#if defined(USE_RELA) 1479 si->plt_rela_count = d->d_un.d_val / sizeof(Elf_Rela); 1480#else 1481 si->plt_rel_count = d->d_un.d_val / sizeof(Elf_Rel); 1482#endif 1483 break; 1484#if !defined(__LP64__) 1485 case DT_PLTGOT: 1486 // Used by 32-bit MIPS. 1487 si->plt_got = (unsigned *)(base + d->d_un.d_ptr); 1488 break; 1489#endif 1490 case DT_DEBUG: 1491 // Set the DT_DEBUG entry to the address of _r_debug for GDB 1492 // if the dynamic table is writable 1493 if ((dynamic_flags & PF_W) != 0) { 1494 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug); 1495 } 1496 break; 1497#if defined(USE_RELA) 1498 case DT_RELA: 1499 si->rela = (Elf_Rela*) (base + d->d_un.d_ptr); 1500 break; 1501 case DT_RELASZ: 1502 si->rela_count = d->d_un.d_val / sizeof(Elf_Rela); 1503 break; 1504 case DT_REL: 1505 DL_ERR("unsupported DT_REL in \"%s\"", si->name); 1506 return false; 1507 case DT_RELSZ: 1508 DL_ERR("unsupported DT_RELSZ in \"%s\"", si->name); 1509 return false; 1510#else 1511 case DT_REL: 1512 si->rel = (Elf_Rel*) (base + d->d_un.d_ptr); 1513 break; 1514 case DT_RELSZ: 1515 si->rel_count = d->d_un.d_val / sizeof(Elf_Rel); 1516 break; 1517 case DT_RELA: 1518 DL_ERR("unsupported DT_RELA in \"%s\"", si->name); 1519 return false; 1520#endif 1521 case DT_INIT: 1522 si->init_func = reinterpret_cast<linker_function_t>(base + d->d_un.d_ptr); 1523 DEBUG("%s constructors (DT_INIT) found at %p", si->name, si->init_func); 1524 break; 1525 case DT_FINI: 1526 si->fini_func = reinterpret_cast<linker_function_t>(base + d->d_un.d_ptr); 1527 DEBUG("%s destructors (DT_FINI) found at %p", si->name, si->fini_func); 1528 break; 1529 case DT_INIT_ARRAY: 1530 si->init_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr); 1531 DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", si->name, si->init_array); 1532 break; 1533 case DT_INIT_ARRAYSZ: 1534 si->init_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf_Addr); 1535 break; 1536 case DT_FINI_ARRAY: 1537 si->fini_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr); 1538 DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", si->name, si->fini_array); 1539 break; 1540 case DT_FINI_ARRAYSZ: 1541 si->fini_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf_Addr); 1542 break; 1543 case DT_PREINIT_ARRAY: 1544 si->preinit_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr); 1545 DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", si->name, si->preinit_array); 1546 break; 1547 case DT_PREINIT_ARRAYSZ: 1548 si->preinit_array_count = ((unsigned)d->d_un.d_val) / sizeof(Elf_Addr); 1549 break; 1550 case DT_TEXTREL: 1551#if defined(__LP64__) 1552 DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", si->name); 1553 return false; 1554#else 1555 si->has_text_relocations = true; 1556 break; 1557#endif 1558 case DT_SYMBOLIC: 1559 si->has_DT_SYMBOLIC = true; 1560 break; 1561 case DT_NEEDED: 1562 ++needed_count; 1563 break; 1564 case DT_FLAGS: 1565 if (d->d_un.d_val & DF_TEXTREL) { 1566#if defined(__LP64__) 1567 DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", si->name); 1568 return false; 1569#else 1570 si->has_text_relocations = true; 1571#endif 1572 } 1573 if (d->d_un.d_val & DF_SYMBOLIC) { 1574 si->has_DT_SYMBOLIC = true; 1575 } 1576 break; 1577#if defined(__mips__) 1578 case DT_STRSZ: 1579 case DT_SYMENT: 1580 case DT_RELENT: 1581 break; 1582 case DT_MIPS_RLD_MAP: 1583 // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB. 1584 { 1585 r_debug** dp = (r_debug**) d->d_un.d_ptr; 1586 *dp = &_r_debug; 1587 } 1588 break; 1589 case DT_MIPS_RLD_VERSION: 1590 case DT_MIPS_FLAGS: 1591 case DT_MIPS_BASE_ADDRESS: 1592 case DT_MIPS_UNREFEXTNO: 1593 break; 1594 1595 case DT_MIPS_SYMTABNO: 1596 si->mips_symtabno = d->d_un.d_val; 1597 break; 1598 1599 case DT_MIPS_LOCAL_GOTNO: 1600 si->mips_local_gotno = d->d_un.d_val; 1601 break; 1602 1603 case DT_MIPS_GOTSYM: 1604 si->mips_gotsym = d->d_un.d_val; 1605 break; 1606#endif 1607 1608 default: 1609 DEBUG("Unused DT entry: type %p arg %p", 1610 reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val)); 1611 break; 1612 } 1613 } 1614 1615 DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p", 1616 reinterpret_cast<void*>(si->base), si->strtab, si->symtab); 1617 1618 // Sanity checks. 1619 if (relocating_linker && needed_count != 0) { 1620 DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries"); 1621 return false; 1622 } 1623 if (si->nbucket == 0) { 1624 DL_ERR("empty/missing DT_HASH in \"%s\" (built with --hash-style=gnu?)", si->name); 1625 return false; 1626 } 1627 if (si->strtab == 0) { 1628 DL_ERR("empty/missing DT_STRTAB in \"%s\"", si->name); 1629 return false; 1630 } 1631 if (si->symtab == 0) { 1632 DL_ERR("empty/missing DT_SYMTAB in \"%s\"", si->name); 1633 return false; 1634 } 1635 1636 // If this is the main executable, then load all of the libraries from LD_PRELOAD now. 1637 if (si->flags & FLAG_EXE) { 1638 memset(gLdPreloads, 0, sizeof(gLdPreloads)); 1639 size_t preload_count = 0; 1640 for (size_t i = 0; gLdPreloadNames[i] != NULL; i++) { 1641 soinfo* lsi = find_library(gLdPreloadNames[i]); 1642 if (lsi != NULL) { 1643 gLdPreloads[preload_count++] = lsi; 1644 } else { 1645 // As with glibc, failure to load an LD_PRELOAD library is just a warning. 1646 DL_WARN("could not load library \"%s\" from LD_PRELOAD for \"%s\"; caused by %s", 1647 gLdPreloadNames[i], si->name, linker_get_error_buffer()); 1648 } 1649 } 1650 } 1651 1652 soinfo** needed = (soinfo**) alloca((1 + needed_count) * sizeof(soinfo*)); 1653 soinfo** pneeded = needed; 1654 1655 for (Elf_Dyn* d = si->dynamic; d->d_tag != DT_NULL; ++d) { 1656 if (d->d_tag == DT_NEEDED) { 1657 const char* library_name = si->strtab + d->d_un.d_val; 1658 DEBUG("%s needs %s", si->name, library_name); 1659 soinfo* lsi = find_library(library_name); 1660 if (lsi == NULL) { 1661 strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf)); 1662 DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s", 1663 library_name, si->name, tmp_err_buf); 1664 return false; 1665 } 1666 *pneeded++ = lsi; 1667 } 1668 } 1669 *pneeded = NULL; 1670 1671#if !defined(__LP64__) 1672 if (si->has_text_relocations) { 1673 // Make segments writable to allow text relocations to work properly. We will later call 1674 // phdr_table_protect_segments() after all of them are applied and all constructors are run. 1675 DL_WARN("%s has text relocations. This is wasting memory and prevents " 1676 "security hardening. Please fix.", si->name); 1677 if (phdr_table_unprotect_segments(si->phdr, si->phnum, si->load_bias) < 0) { 1678 DL_ERR("can't unprotect loadable segments for \"%s\": %s", 1679 si->name, strerror(errno)); 1680 return false; 1681 } 1682 } 1683#endif 1684 1685#if defined(USE_RELA) 1686 if (si->plt_rela != NULL) { 1687 DEBUG("[ relocating %s plt ]\n", si->name ); 1688 if (soinfo_relocate_a(si, si->plt_rela, si->plt_rela_count, needed)) { 1689 return false; 1690 } 1691 } 1692 if (si->rela != NULL) { 1693 DEBUG("[ relocating %s ]\n", si->name ); 1694 if (soinfo_relocate_a(si, si->rela, si->rela_count, needed)) { 1695 return false; 1696 } 1697 } 1698#else 1699 if (si->plt_rel != NULL) { 1700 DEBUG("[ relocating %s plt ]", si->name ); 1701 if (soinfo_relocate(si, si->plt_rel, si->plt_rel_count, needed)) { 1702 return false; 1703 } 1704 } 1705 if (si->rel != NULL) { 1706 DEBUG("[ relocating %s ]", si->name ); 1707 if (soinfo_relocate(si, si->rel, si->rel_count, needed)) { 1708 return false; 1709 } 1710 } 1711#endif 1712 1713#if defined(__mips__) 1714 if (!mips_relocate_got(si, needed)) { 1715 return false; 1716 } 1717#endif 1718 1719 si->flags |= FLAG_LINKED; 1720 DEBUG("[ finished linking %s ]", si->name); 1721 1722#if !defined(__LP64__) 1723 if (si->has_text_relocations) { 1724 // All relocations are done, we can protect our segments back to read-only. 1725 if (phdr_table_protect_segments(si->phdr, si->phnum, si->load_bias) < 0) { 1726 DL_ERR("can't protect segments for \"%s\": %s", 1727 si->name, strerror(errno)); 1728 return false; 1729 } 1730 } 1731#endif 1732 1733 /* We can also turn on GNU RELRO protection */ 1734 if (phdr_table_protect_gnu_relro(si->phdr, si->phnum, si->load_bias) < 0) { 1735 DL_ERR("can't enable GNU RELRO protection for \"%s\": %s", 1736 si->name, strerror(errno)); 1737 return false; 1738 } 1739 1740 notify_gdb_of_load(si); 1741 return true; 1742} 1743 1744/* 1745 * This function add vdso to internal dso list. 1746 * It helps to stack unwinding through signal handlers. 1747 * Also, it makes bionic more like glibc. 1748 */ 1749static void add_vdso(KernelArgumentBlock& args UNUSED) { 1750#if defined(AT_SYSINFO_EHDR) 1751 Elf_Ehdr* ehdr_vdso = reinterpret_cast<Elf_Ehdr*>(args.getauxval(AT_SYSINFO_EHDR)); 1752 1753 soinfo* si = soinfo_alloc("[vdso]"); 1754 si->phdr = reinterpret_cast<Elf_Phdr*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff); 1755 si->phnum = ehdr_vdso->e_phnum; 1756 si->link_map.l_name = si->name; 1757 for (size_t i = 0; i < si->phnum; ++i) { 1758 if (si->phdr[i].p_type == PT_LOAD) { 1759 si->link_map.l_addr = reinterpret_cast<Elf_Addr>(ehdr_vdso) - si->phdr[i].p_vaddr; 1760 break; 1761 } 1762 } 1763#endif 1764} 1765 1766/* 1767 * This code is called after the linker has linked itself and 1768 * fixed it's own GOT. It is safe to make references to externs 1769 * and other non-local data at this point. 1770 */ 1771static Elf_Addr __linker_init_post_relocation(KernelArgumentBlock& args, Elf_Addr linker_base) { 1772 /* NOTE: we store the args pointer on a special location 1773 * of the temporary TLS area in order to pass it to 1774 * the C Library's runtime initializer. 1775 * 1776 * The initializer must clear the slot and reset the TLS 1777 * to point to a different location to ensure that no other 1778 * shared library constructor can access it. 1779 */ 1780 __libc_init_tls(args); 1781 1782#if TIMING 1783 struct timeval t0, t1; 1784 gettimeofday(&t0, 0); 1785#endif 1786 1787 // Initialize environment functions, and get to the ELF aux vectors table. 1788 linker_env_init(args); 1789 1790 // If this is a setuid/setgid program, close the security hole described in 1791 // ftp://ftp.freebsd.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-02:23.stdio.asc 1792 if (get_AT_SECURE()) { 1793 nullify_closed_stdio(); 1794 } 1795 1796 debuggerd_init(); 1797 1798 // Get a few environment variables. 1799 const char* LD_DEBUG = linker_env_get("LD_DEBUG"); 1800 if (LD_DEBUG != NULL) { 1801 gLdDebugVerbosity = atoi(LD_DEBUG); 1802 } 1803 1804 // Normally, these are cleaned by linker_env_init, but the test 1805 // doesn't cost us anything. 1806 const char* ldpath_env = NULL; 1807 const char* ldpreload_env = NULL; 1808 if (!get_AT_SECURE()) { 1809 ldpath_env = linker_env_get("LD_LIBRARY_PATH"); 1810 ldpreload_env = linker_env_get("LD_PRELOAD"); 1811 } 1812 1813 INFO("[ android linker & debugger ]"); 1814 1815 soinfo* si = soinfo_alloc(args.argv[0]); 1816 if (si == NULL) { 1817 exit(EXIT_FAILURE); 1818 } 1819 1820 /* bootstrap the link map, the main exe always needs to be first */ 1821 si->flags |= FLAG_EXE; 1822 link_map_t* map = &(si->link_map); 1823 1824 map->l_addr = 0; 1825 map->l_name = args.argv[0]; 1826 map->l_prev = NULL; 1827 map->l_next = NULL; 1828 1829 _r_debug.r_map = map; 1830 r_debug_tail = map; 1831 1832 /* gdb expects the linker to be in the debug shared object list. 1833 * Without this, gdb has trouble locating the linker's ".text" 1834 * and ".plt" sections. Gdb could also potentially use this to 1835 * relocate the offset of our exported 'rtld_db_dlactivity' symbol. 1836 * Don't use soinfo_alloc(), because the linker shouldn't 1837 * be on the soinfo list. 1838 */ 1839 { 1840 static soinfo linker_soinfo; 1841#if defined(__LP64__) 1842 strlcpy(linker_soinfo.name, "/system/bin/linker64", sizeof(linker_soinfo.name)); 1843#else 1844 strlcpy(linker_soinfo.name, "/system/bin/linker", sizeof(linker_soinfo.name)); 1845#endif 1846 linker_soinfo.flags = 0; 1847 linker_soinfo.base = linker_base; 1848 1849 /* 1850 * Set the dynamic field in the link map otherwise gdb will complain with 1851 * the following: 1852 * warning: .dynamic section for "/system/bin/linker" is not at the 1853 * expected address (wrong library or version mismatch?) 1854 */ 1855 Elf_Ehdr *elf_hdr = (Elf_Ehdr *) linker_base; 1856 Elf_Phdr *phdr = (Elf_Phdr*)((unsigned char*) linker_base + elf_hdr->e_phoff); 1857 phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base, 1858 &linker_soinfo.dynamic, NULL, NULL); 1859 insert_soinfo_into_debug_map(&linker_soinfo); 1860 } 1861 1862 // Extract information passed from the kernel. 1863 si->phdr = reinterpret_cast<Elf_Phdr*>(args.getauxval(AT_PHDR)); 1864 si->phnum = args.getauxval(AT_PHNUM); 1865 si->entry = args.getauxval(AT_ENTRY); 1866 1867 /* Compute the value of si->base. We can't rely on the fact that 1868 * the first entry is the PHDR because this will not be true 1869 * for certain executables (e.g. some in the NDK unit test suite) 1870 */ 1871 si->base = 0; 1872 si->size = phdr_table_get_load_size(si->phdr, si->phnum); 1873 si->load_bias = 0; 1874 for (size_t i = 0; i < si->phnum; ++i) { 1875 if (si->phdr[i].p_type == PT_PHDR) { 1876 si->load_bias = reinterpret_cast<Elf_Addr>(si->phdr) - si->phdr[i].p_vaddr; 1877 si->base = reinterpret_cast<Elf_Addr>(si->phdr) - si->phdr[i].p_offset; 1878 break; 1879 } 1880 } 1881 si->dynamic = NULL; 1882 si->ref_count = 1; 1883 1884 // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid). 1885 parse_LD_LIBRARY_PATH(ldpath_env); 1886 parse_LD_PRELOAD(ldpreload_env); 1887 1888 somain = si; 1889 1890 if (!soinfo_link_image(si)) { 1891 __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); 1892 exit(EXIT_FAILURE); 1893 } 1894 1895 add_vdso(args); 1896 1897 si->CallPreInitConstructors(); 1898 1899 for (size_t i = 0; gLdPreloads[i] != NULL; ++i) { 1900 gLdPreloads[i]->CallConstructors(); 1901 } 1902 1903 /* After the link_image, the si->load_bias is initialized. 1904 * For so lib, the map->l_addr will be updated in notify_gdb_of_load. 1905 * We need to update this value for so exe here. So Unwind_Backtrace 1906 * for some arch like x86 could work correctly within so exe. 1907 */ 1908 map->l_addr = si->load_bias; 1909 si->CallConstructors(); 1910 1911#if TIMING 1912 gettimeofday(&t1,NULL); 1913 PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) ( 1914 (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) - 1915 (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec) 1916 )); 1917#endif 1918#if STATS 1919 PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0], 1920 linker_stats.count[kRelocAbsolute], 1921 linker_stats.count[kRelocRelative], 1922 linker_stats.count[kRelocCopy], 1923 linker_stats.count[kRelocSymbol]); 1924#endif 1925#if COUNT_PAGES 1926 { 1927 unsigned n; 1928 unsigned i; 1929 unsigned count = 0; 1930 for (n = 0; n < 4096; n++) { 1931 if (bitmask[n]) { 1932 unsigned x = bitmask[n]; 1933 for (i = 0; i < 8; i++) { 1934 if (x & 1) { 1935 count++; 1936 } 1937 x >>= 1; 1938 } 1939 } 1940 } 1941 PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4); 1942 } 1943#endif 1944 1945#if TIMING || STATS || COUNT_PAGES 1946 fflush(stdout); 1947#endif 1948 1949 TRACE("[ Ready to execute '%s' @ %p ]", si->name, reinterpret_cast<void*>(si->entry)); 1950 return si->entry; 1951} 1952 1953/* Compute the load-bias of an existing executable. This shall only 1954 * be used to compute the load bias of an executable or shared library 1955 * that was loaded by the kernel itself. 1956 * 1957 * Input: 1958 * elf -> address of ELF header, assumed to be at the start of the file. 1959 * Return: 1960 * load bias, i.e. add the value of any p_vaddr in the file to get 1961 * the corresponding address in memory. 1962 */ 1963static Elf_Addr get_elf_exec_load_bias(const Elf_Ehdr* elf) { 1964 Elf_Addr offset = elf->e_phoff; 1965 const Elf_Phdr* phdr_table = (const Elf_Phdr*)((char*)elf + offset); 1966 const Elf_Phdr* phdr_end = phdr_table + elf->e_phnum; 1967 1968 for (const Elf_Phdr* phdr = phdr_table; phdr < phdr_end; phdr++) { 1969 if (phdr->p_type == PT_LOAD) { 1970 return reinterpret_cast<Elf_Addr>(elf) + phdr->p_offset - phdr->p_vaddr; 1971 } 1972 } 1973 return 0; 1974} 1975 1976/* 1977 * This is the entry point for the linker, called from begin.S. This 1978 * method is responsible for fixing the linker's own relocations, and 1979 * then calling __linker_init_post_relocation(). 1980 * 1981 * Because this method is called before the linker has fixed it's own 1982 * relocations, any attempt to reference an extern variable, extern 1983 * function, or other GOT reference will generate a segfault. 1984 */ 1985extern "C" Elf_Addr __linker_init(void* raw_args) { 1986 KernelArgumentBlock args(raw_args); 1987 1988 Elf_Addr linker_addr = args.getauxval(AT_BASE); 1989 1990 Elf_Ehdr* elf_hdr = reinterpret_cast<Elf_Ehdr*>(linker_addr); 1991 Elf_Phdr* phdr = (Elf_Phdr*)((unsigned char*) linker_addr + elf_hdr->e_phoff); 1992 1993 soinfo linker_so; 1994 memset(&linker_so, 0, sizeof(soinfo)); 1995 1996 linker_so.base = linker_addr; 1997 linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum); 1998 linker_so.load_bias = get_elf_exec_load_bias(elf_hdr); 1999 linker_so.dynamic = NULL; 2000 linker_so.phdr = phdr; 2001 linker_so.phnum = elf_hdr->e_phnum; 2002 linker_so.flags |= FLAG_LINKER; 2003 2004 if (!soinfo_link_image(&linker_so)) { 2005 // It would be nice to print an error message, but if the linker 2006 // can't link itself, there's no guarantee that we'll be able to 2007 // call write() (because it involves a GOT reference). 2008 // 2009 // This situation should never occur unless the linker itself 2010 // is corrupt. 2011 exit(EXIT_FAILURE); 2012 } 2013 2014 // We have successfully fixed our own relocations. It's safe to run 2015 // the main part of the linker now. 2016 args.abort_message_ptr = &gAbortMessage; 2017 Elf_Addr start_address = __linker_init_post_relocation(args, linker_addr); 2018 2019 set_soinfo_pool_protection(PROT_READ); 2020 2021 // Return the address that the calling assembly stub should jump to. 2022 return start_address; 2023} 2024