Merge "Add extra strchr testing."
[android-sdk/platform-bionic.git] / linker / linker.cpp
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  */
29 #include <dlfcn.h>
30 #include <errno.h>
31 #include <fcntl.h>
32 #include <inttypes.h>
33 #include <pthread.h>
34 #include <stdio.h>
35 #include <stdlib.h>
36 #include <string.h>
37 #include <sys/mman.h>
38 #include <sys/stat.h>
39 #include <unistd.h>
41 // Private C library headers.
42 #include "private/bionic_tls.h"
43 #include "private/KernelArgumentBlock.h"
44 #include "private/ScopedPthreadMutexLocker.h"
46 #include "linker.h"
47 #include "linker_debug.h"
48 #include "linker_environ.h"
49 #include "linker_phdr.h"
50 #include "linker_allocator.h"
52 /* >>> IMPORTANT NOTE - READ ME BEFORE MODIFYING <<<
53  *
54  * Do NOT use malloc() and friends or pthread_*() code here.
55  * Don't use printf() either; it's caused mysterious memory
56  * corruption in the past.
57  * The linker runs before we bring up libc and it's easiest
58  * to make sure it does not depend on any complex libc features
59  *
60  * open issues / todo:
61  *
62  * - are we doing everything we should for ARM_COPY relocations?
63  * - cleaner error reporting
64  * - after linking, set as much stuff as possible to READONLY
65  *   and NOEXEC
66  */
68 #if defined(__LP64__)
69 #define SEARCH_NAME(x) x
70 #else
71 // Nvidia drivers are relying on the bug:
72 // http://code.google.com/p/android/issues/detail?id=6670
73 // so we continue to use base-name lookup for lp32
74 static const char* get_base_name(const char* name) {
75   const char* bname = strrchr(name, '/');
76   return bname ? bname + 1 : name;
77 }
78 #define SEARCH_NAME(x) get_base_name(x)
79 #endif
81 static bool soinfo_link_image(soinfo* si, const android_dlextinfo* extinfo);
82 static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
84 static LinkerAllocator<soinfo> g_soinfo_allocator;
85 static LinkerAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
87 static soinfo* solist;
88 static soinfo* sonext;
89 static soinfo* somain; /* main process, always the one after libdl_info */
91 static const char* const kDefaultLdPaths[] = {
92 #if defined(__LP64__)
93   "/vendor/lib64",
94   "/system/lib64",
95 #else
96   "/vendor/lib",
97   "/system/lib",
98 #endif
99   NULL
100 };
102 #define LDPATH_BUFSIZE (LDPATH_MAX*64)
103 #define LDPATH_MAX 8
105 #define LDPRELOAD_BUFSIZE (LDPRELOAD_MAX*64)
106 #define LDPRELOAD_MAX 8
108 static char g_ld_library_paths_buffer[LDPATH_BUFSIZE];
109 static const char* g_ld_library_paths[LDPATH_MAX + 1];
111 static char g_ld_preloads_buffer[LDPRELOAD_BUFSIZE];
112 static const char* g_ld_preload_names[LDPRELOAD_MAX + 1];
114 static soinfo* g_ld_preloads[LDPRELOAD_MAX + 1];
116 __LIBC_HIDDEN__ int g_ld_debug_verbosity;
118 __LIBC_HIDDEN__ abort_msg_t* g_abort_message = NULL; // For debuggerd.
120 enum RelocationKind {
121     kRelocAbsolute = 0,
122     kRelocRelative,
123     kRelocCopy,
124     kRelocSymbol,
125     kRelocMax
126 };
128 #if STATS
129 struct linker_stats_t {
130     int count[kRelocMax];
131 };
133 static linker_stats_t linker_stats;
135 static void count_relocation(RelocationKind kind) {
136     ++linker_stats.count[kind];
138 #else
139 static void count_relocation(RelocationKind) {
141 #endif
143 #if COUNT_PAGES
144 static unsigned bitmask[4096];
145 #if defined(__LP64__)
146 #define MARK(offset) \
147     do { \
148         if ((((offset) >> 12) >> 5) < 4096) \
149             bitmask[((offset) >> 12) >> 5] |= (1 << (((offset) >> 12) & 31)); \
150     } while (0)
151 #else
152 #define MARK(offset) \
153     do { \
154         bitmask[((offset) >> 12) >> 3] |= (1 << (((offset) >> 12) & 7)); \
155     } while (0)
156 #endif
157 #else
158 #define MARK(x) do {} while (0)
159 #endif
161 // You shouldn't try to call memory-allocating functions in the dynamic linker.
162 // Guard against the most obvious ones.
163 #define DISALLOW_ALLOCATION(return_type, name, ...) \
164     return_type name __VA_ARGS__ \
165     { \
166         const char* msg = "ERROR: " #name " called from the dynamic linker!\n"; \
167         __libc_format_log(ANDROID_LOG_FATAL, "linker", "%s", msg); \
168         write(2, msg, strlen(msg)); \
169         abort(); \
170     }
171 DISALLOW_ALLOCATION(void*, malloc, (size_t u __unused));
172 DISALLOW_ALLOCATION(void, free, (void* u __unused));
173 DISALLOW_ALLOCATION(void*, realloc, (void* u1 __unused, size_t u2 __unused));
174 DISALLOW_ALLOCATION(void*, calloc, (size_t u1 __unused, size_t u2 __unused));
176 static char tmp_err_buf[768];
177 static char __linker_dl_err_buf[768];
179 char* linker_get_error_buffer() {
180   return &__linker_dl_err_buf[0];
183 size_t linker_get_error_buffer_size() {
184   return sizeof(__linker_dl_err_buf);
187 /*
188  * This function is an empty stub where GDB locates a breakpoint to get notified
189  * about linker activity.
190  */
191 extern "C" void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity();
193 static pthread_mutex_t g__r_debug_mutex = PTHREAD_MUTEX_INITIALIZER;
194 static r_debug _r_debug = {1, NULL, reinterpret_cast<uintptr_t>(&rtld_db_dlactivity), r_debug::RT_CONSISTENT, 0};
195 static link_map* r_debug_tail = 0;
197 static void insert_soinfo_into_debug_map(soinfo* info) {
198     // Copy the necessary fields into the debug structure.
199     link_map* map = &(info->link_map_head);
200     map->l_addr = info->load_bias;
201     map->l_name = reinterpret_cast<char*>(info->name);
202     map->l_ld = info->dynamic;
204     /* Stick the new library at the end of the list.
205      * gdb tends to care more about libc than it does
206      * about leaf libraries, and ordering it this way
207      * reduces the back-and-forth over the wire.
208      */
209     if (r_debug_tail) {
210         r_debug_tail->l_next = map;
211         map->l_prev = r_debug_tail;
212         map->l_next = 0;
213     } else {
214         _r_debug.r_map = map;
215         map->l_prev = 0;
216         map->l_next = 0;
217     }
218     r_debug_tail = map;
221 static void remove_soinfo_from_debug_map(soinfo* info) {
222     link_map* map = &(info->link_map_head);
224     if (r_debug_tail == map) {
225         r_debug_tail = map->l_prev;
226     }
228     if (map->l_prev) {
229         map->l_prev->l_next = map->l_next;
230     }
231     if (map->l_next) {
232         map->l_next->l_prev = map->l_prev;
233     }
236 static void notify_gdb_of_load(soinfo* info) {
237     if (info->flags & FLAG_EXE) {
238         // GDB already knows about the main executable
239         return;
240     }
242     ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
244     _r_debug.r_state = r_debug::RT_ADD;
245     rtld_db_dlactivity();
247     insert_soinfo_into_debug_map(info);
249     _r_debug.r_state = r_debug::RT_CONSISTENT;
250     rtld_db_dlactivity();
253 static void notify_gdb_of_unload(soinfo* info) {
254     if (info->flags & FLAG_EXE) {
255         // GDB already knows about the main executable
256         return;
257     }
259     ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
261     _r_debug.r_state = r_debug::RT_DELETE;
262     rtld_db_dlactivity();
264     remove_soinfo_from_debug_map(info);
266     _r_debug.r_state = r_debug::RT_CONSISTENT;
267     rtld_db_dlactivity();
270 void notify_gdb_of_libraries() {
271   _r_debug.r_state = r_debug::RT_ADD;
272   rtld_db_dlactivity();
273   _r_debug.r_state = r_debug::RT_CONSISTENT;
274   rtld_db_dlactivity();
277 LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {
278   return g_soinfo_links_allocator.alloc();
281 void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {
282   g_soinfo_links_allocator.free(entry);
285 static void protect_data(int protection) {
286   g_soinfo_allocator.protect_all(protection);
287   g_soinfo_links_allocator.protect_all(protection);
290 static soinfo* soinfo_alloc(const char* name, struct stat* file_stat) {
291   if (strlen(name) >= SOINFO_NAME_LEN) {
292     DL_ERR("library name \"%s\" too long", name);
293     return NULL;
294   }
296   soinfo* si = g_soinfo_allocator.alloc();
298   // Initialize the new element.
299   memset(si, 0, sizeof(soinfo));
300   strlcpy(si->name, name, sizeof(si->name));
301   si->flags = FLAG_NEW_SOINFO;
303   if (file_stat != NULL) {
304     si->set_st_dev(file_stat->st_dev);
305     si->set_st_ino(file_stat->st_ino);
306   }
308   sonext->next = si;
309   sonext = si;
311   TRACE("name %s: allocated soinfo @ %p", name, si);
312   return si;
315 static void soinfo_free(soinfo* si) {
316     if (si == NULL) {
317         return;
318     }
320     if (si->base != 0 && si->size != 0) {
321       munmap(reinterpret_cast<void*>(si->base), si->size);
322     }
324     soinfo *prev = NULL, *trav;
326     TRACE("name %s: freeing soinfo @ %p", si->name, si);
328     for (trav = solist; trav != NULL; trav = trav->next) {
329         if (trav == si)
330             break;
331         prev = trav;
332     }
333     if (trav == NULL) {
334         /* si was not in solist */
335         DL_ERR("name \"%s\" is not in solist!", si->name);
336         return;
337     }
339     // clear links to/from si
340     si->remove_all_links();
342     /* prev will never be NULL, because the first entry in solist is
343        always the static libdl_info.
344     */
345     prev->next = si->next;
346     if (si == sonext) {
347         sonext = prev;
348     }
350     g_soinfo_allocator.free(si);
354 static void parse_path(const char* path, const char* delimiters,
355                        const char** array, char* buf, size_t buf_size, size_t max_count) {
356   if (path == NULL) {
357     return;
358   }
360   size_t len = strlcpy(buf, path, buf_size);
362   size_t i = 0;
363   char* buf_p = buf;
364   while (i < max_count && (array[i] = strsep(&buf_p, delimiters))) {
365     if (*array[i] != '\0') {
366       ++i;
367     }
368   }
370   // Forget the last path if we had to truncate; this occurs if the 2nd to
371   // last char isn't '\0' (i.e. wasn't originally a delimiter).
372   if (i > 0 && len >= buf_size && buf[buf_size - 2] != '\0') {
373     array[i - 1] = NULL;
374   } else {
375     array[i] = NULL;
376   }
379 static void parse_LD_LIBRARY_PATH(const char* path) {
380   parse_path(path, ":", g_ld_library_paths,
381              g_ld_library_paths_buffer, sizeof(g_ld_library_paths_buffer), LDPATH_MAX);
384 static void parse_LD_PRELOAD(const char* path) {
385   // We have historically supported ':' as well as ' ' in LD_PRELOAD.
386   parse_path(path, " :", g_ld_preload_names,
387              g_ld_preloads_buffer, sizeof(g_ld_preloads_buffer), LDPRELOAD_MAX);
390 #if defined(__arm__)
392 /* For a given PC, find the .so that it belongs to.
393  * Returns the base address of the .ARM.exidx section
394  * for that .so, and the number of 8-byte entries
395  * in that section (via *pcount).
396  *
397  * Intended to be called by libc's __gnu_Unwind_Find_exidx().
398  *
399  * This function is exposed via dlfcn.cpp and libdl.so.
400  */
401 _Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {
402     unsigned addr = (unsigned)pc;
404     for (soinfo* si = solist; si != 0; si = si->next) {
405         if ((addr >= si->base) && (addr < (si->base + si->size))) {
406             *pcount = si->ARM_exidx_count;
407             return (_Unwind_Ptr)si->ARM_exidx;
408         }
409     }
410     *pcount = 0;
411     return NULL;
414 #endif
416 /* Here, we only have to provide a callback to iterate across all the
417  * loaded libraries. gcc_eh does the rest. */
418 int dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {
419     int rv = 0;
420     for (soinfo* si = solist; si != NULL; si = si->next) {
421         dl_phdr_info dl_info;
422         dl_info.dlpi_addr = si->link_map_head.l_addr;
423         dl_info.dlpi_name = si->link_map_head.l_name;
424         dl_info.dlpi_phdr = si->phdr;
425         dl_info.dlpi_phnum = si->phnum;
426         rv = cb(&dl_info, sizeof(dl_phdr_info), data);
427         if (rv != 0) {
428             break;
429         }
430     }
431     return rv;
434 static ElfW(Sym)* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) {
435   ElfW(Sym)* symtab = si->symtab;
436   const char* strtab = si->strtab;
438   TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p %x %zd",
439              name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket);
441   for (unsigned n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]) {
442     ElfW(Sym)* s = symtab + n;
443     if (strcmp(strtab + s->st_name, name)) continue;
445     /* only concern ourselves with global and weak symbol definitions */
446     switch (ELF_ST_BIND(s->st_info)) {
447       case STB_GLOBAL:
448       case STB_WEAK:
449         if (s->st_shndx == SHN_UNDEF) {
450         continue;
451       }
453       TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
454                  name, si->name, reinterpret_cast<void*>(s->st_value),
455                  static_cast<size_t>(s->st_size));
456       return s;
457     }
458   }
460   return NULL;
463 static unsigned elfhash(const char* _name) {
464     const unsigned char* name = reinterpret_cast<const unsigned char*>(_name);
465     unsigned h = 0, g;
467     while (*name) {
468         h = (h << 4) + *name++;
469         g = h & 0xf0000000;
470         h ^= g;
471         h ^= g >> 24;
472     }
473     return h;
476 static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, soinfo* needed[]) {
477     unsigned elf_hash = elfhash(name);
478     ElfW(Sym)* s = NULL;
480     if (si != NULL && somain != NULL) {
481         /*
482          * Local scope is executable scope. Just start looking into it right away
483          * for the shortcut.
484          */
486         if (si == somain) {
487             s = soinfo_elf_lookup(si, elf_hash, name);
488             if (s != NULL) {
489                 *lsi = si;
490                 goto done;
491             }
492         } else {
493             /* Order of symbol lookup is controlled by DT_SYMBOLIC flag */
495             /*
496              * If this object was built with symbolic relocations disabled, the
497              * first place to look to resolve external references is the main
498              * executable.
499              */
501             if (!si->has_DT_SYMBOLIC) {
502                 DEBUG("%s: looking up %s in executable %s",
503                       si->name, name, somain->name);
504                 s = soinfo_elf_lookup(somain, elf_hash, name);
505                 if (s != NULL) {
506                     *lsi = somain;
507                     goto done;
508                 }
509             }
511             /* Look for symbols in the local scope (the object who is
512              * searching). This happens with C++ templates on x86 for some
513              * reason.
514              *
515              * Notes on weak symbols:
516              * The ELF specs are ambiguous about treatment of weak definitions in
517              * dynamic linking.  Some systems return the first definition found
518              * and some the first non-weak definition.   This is system dependent.
519              * Here we return the first definition found for simplicity.  */
521             s = soinfo_elf_lookup(si, elf_hash, name);
522             if (s != NULL) {
523                 *lsi = si;
524                 goto done;
525             }
527             /*
528              * If this object was built with -Bsymbolic and symbol is not found
529              * in the local scope, try to find the symbol in the main executable.
530              */
532             if (si->has_DT_SYMBOLIC) {
533                 DEBUG("%s: looking up %s in executable %s after local scope",
534                       si->name, name, somain->name);
535                 s = soinfo_elf_lookup(somain, elf_hash, name);
536                 if (s != NULL) {
537                     *lsi = somain;
538                     goto done;
539                 }
540             }
541         }
542     }
544     /* Next, look for it in the preloads list */
545     for (int i = 0; g_ld_preloads[i] != NULL; i++) {
546         s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);
547         if (s != NULL) {
548             *lsi = g_ld_preloads[i];
549             goto done;
550         }
551     }
553     for (int i = 0; needed[i] != NULL; i++) {
554         DEBUG("%s: looking up %s in %s",
555               si->name, name, needed[i]->name);
556         s = soinfo_elf_lookup(needed[i], elf_hash, name);
557         if (s != NULL) {
558             *lsi = needed[i];
559             goto done;
560         }
561     }
563 done:
564     if (s != NULL) {
565         TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, "
566                    "found in %s, base = %p, load bias = %p",
567                    si->name, name, reinterpret_cast<void*>(s->st_value),
568                    (*lsi)->name, reinterpret_cast<void*>((*lsi)->base),
569                    reinterpret_cast<void*>((*lsi)->load_bias));
570         return s;
571     }
573     return NULL;
576 /* This is used by dlsym(3).  It performs symbol lookup only within the
577    specified soinfo object and not in any of its dependencies.
579    TODO: Only looking in the specified soinfo seems wrong. dlsym(3) says
580    that it should do a breadth first search through the dependency
581    tree. This agrees with the ELF spec (aka System V Application
582    Binary Interface) where in Chapter 5 it discuss resolving "Shared
583    Object Dependencies" in breadth first search order.
584  */
585 ElfW(Sym)* dlsym_handle_lookup(soinfo* si, const char* name) {
586     return soinfo_elf_lookup(si, elfhash(name), name);
589 /* This is used by dlsym(3) to performs a global symbol lookup. If the
590    start value is null (for RTLD_DEFAULT), the search starts at the
591    beginning of the global solist. Otherwise the search starts at the
592    specified soinfo (for RTLD_NEXT).
593  */
594 ElfW(Sym)* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) {
595   unsigned elf_hash = elfhash(name);
597   if (start == NULL) {
598     start = solist;
599   }
601   ElfW(Sym)* s = NULL;
602   for (soinfo* si = start; (s == NULL) && (si != NULL); si = si->next) {
603     s = soinfo_elf_lookup(si, elf_hash, name);
604     if (s != NULL) {
605       *found = si;
606       break;
607     }
608   }
610   if (s != NULL) {
611     TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p",
612                name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));
613   }
615   return s;
618 soinfo* find_containing_library(const void* p) {
619   ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);
620   for (soinfo* si = solist; si != NULL; si = si->next) {
621     if (address >= si->base && address - si->base < si->size) {
622       return si;
623     }
624   }
625   return NULL;
628 ElfW(Sym)* dladdr_find_symbol(soinfo* si, const void* addr) {
629   ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - si->base;
631   // Search the library's symbol table for any defined symbol which
632   // contains this address.
633   for (size_t i = 0; i < si->nchain; ++i) {
634     ElfW(Sym)* sym = &si->symtab[i];
635     if (sym->st_shndx != SHN_UNDEF &&
636         soaddr >= sym->st_value &&
637         soaddr < sym->st_value + sym->st_size) {
638       return sym;
639     }
640   }
642   return NULL;
645 static int open_library_on_path(const char* name, const char* const paths[]) {
646   char buf[512];
647   for (size_t i = 0; paths[i] != NULL; ++i) {
648     int n = __libc_format_buffer(buf, sizeof(buf), "%s/%s", paths[i], name);
649     if (n < 0 || n >= static_cast<int>(sizeof(buf))) {
650       PRINT("Warning: ignoring very long library path: %s/%s", paths[i], name);
651       continue;
652     }
653     int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
654     if (fd != -1) {
655       return fd;
656     }
657   }
658   return -1;
661 static int open_library(const char* name) {
662   TRACE("[ opening %s ]", name);
664   // If the name contains a slash, we should attempt to open it directly and not search the paths.
665   if (strchr(name, '/') != NULL) {
666     int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC));
667     if (fd != -1) {
668       return fd;
669     }
670     // ...but nvidia binary blobs (at least) rely on this behavior, so fall through for now.
671 #if defined(__LP64__)
672     return -1;
673 #endif
674   }
676   // Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths.
677   int fd = open_library_on_path(name, g_ld_library_paths);
678   if (fd == -1) {
679     fd = open_library_on_path(name, kDefaultLdPaths);
680   }
681   return fd;
684 static soinfo* load_library(const char* name, int dlflags, const android_dlextinfo* extinfo) {
685     // Open the file.
686     int fd = open_library(name);
687     if (fd == -1) {
688         DL_ERR("library \"%s\" not found", name);
689         return NULL;
690     }
692     ElfReader elf_reader(name, fd);
694     struct stat file_stat;
695     if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) {
696       DL_ERR("unable to stat file for the library %s: %s", name, strerror(errno));
697       return NULL;
698     }
700     // Check for symlink and other situations where
701     // file can have different names.
702     for (soinfo* si = solist; si != NULL; si = si->next) {
703       if (si->get_st_dev() != 0 &&
704           si->get_st_ino() != 0 &&
705           si->get_st_dev() == file_stat.st_dev &&
706           si->get_st_ino() == file_stat.st_ino) {
707         TRACE("library \"%s\" is already loaded under different name/path \"%s\" - will return existing soinfo", name, si->name);
708         return si;
709       }
710     }
712     if ((dlflags & RTLD_NOLOAD) != 0) {
713       return NULL;
714     }
716     // Read the ELF header and load the segments.
717     if (!elf_reader.Load(extinfo)) {
718         return NULL;
719     }
721     soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat);
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->phnum = elf_reader.phdr_count();
729     si->phdr = elf_reader.loaded_phdr();
731     // At this point we know that whatever is loaded @ base is a valid ELF
732     // shared library whose segments are properly mapped in.
733     TRACE("[ find_library_internal base=%p size=%zu name='%s' ]",
734           reinterpret_cast<void*>(si->base), si->size, si->name);
736     if (!soinfo_link_image(si, extinfo)) {
737       soinfo_free(si);
738       return NULL;
739     }
741     return si;
744 static soinfo *find_loaded_library_by_name(const char* name) {
745   const char* search_name = SEARCH_NAME(name);
746   for (soinfo* si = solist; si != NULL; si = si->next) {
747     if (!strcmp(search_name, si->name)) {
748       return si;
749     }
750   }
751   return NULL;
754 static soinfo* find_library_internal(const char* name, int dlflags, const android_dlextinfo* extinfo) {
755   if (name == NULL) {
756     return somain;
757   }
759   soinfo* si = find_loaded_library_by_name(name);
761   // Library might still be loaded, the accurate detection
762   // of this fact is done by load_library
763   if (si == NULL) {
764     TRACE("[ '%s' has not been found by name.  Trying harder...]", name);
765     si = load_library(name, dlflags, extinfo);
766   }
768   if (si != NULL && (si->flags & FLAG_LINKED) == 0) {
769     DL_ERR("recursive link to \"%s\"", si->name);
770     return NULL;
771   }
773   return si;
776 static soinfo* find_library(const char* name, int dlflags, const android_dlextinfo* extinfo) {
777   soinfo* si = find_library_internal(name, dlflags, extinfo);
778   if (si != NULL) {
779     si->ref_count++;
780   }
781   return si;
784 static void soinfo_unload(soinfo* si) {
785   if (si->ref_count == 1) {
786     TRACE("unloading '%s'", si->name);
787     si->CallDestructors();
789     if ((si->flags | FLAG_NEW_SOINFO) != 0) {
790       si->get_children().for_each([&] (soinfo* child) {
791         TRACE("%s needs to unload %s", si->name, child->name);
792         soinfo_unload(child);
793       });
794     } else {
795       for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
796         if (d->d_tag == DT_NEEDED) {
797           const char* library_name = si->strtab + d->d_un.d_val;
798           TRACE("%s needs to unload %s", si->name, library_name);
799           soinfo* needed = find_library(library_name, RTLD_NOLOAD, NULL);
800           if (needed != NULL) {
801             soinfo_unload(needed);
802           } else {
803             // Not found: for example if symlink was deleted between dlopen and dlclose
804             // Since we cannot really handle errors at this point - print and continue.
805             PRINT("warning: couldn't find %s needed by %s on unload.", library_name, si->name);
806           }
807         }
808       }
809     }
811     notify_gdb_of_unload(si);
812     si->ref_count = 0;
813     soinfo_free(si);
814   } else {
815     si->ref_count--;
816     TRACE("not unloading '%s', decrementing ref_count to %zd", si->name, si->ref_count);
817   }
820 void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
821   snprintf(buffer, buffer_size, "%s:%s", kDefaultLdPaths[0], kDefaultLdPaths[1]);
824 void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
825   if (!get_AT_SECURE()) {
826     parse_LD_LIBRARY_PATH(ld_library_path);
827   }
830 soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo) {
831   if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NOLOAD)) != 0) {
832     DL_ERR("invalid flags to dlopen: %x", flags);
833     return NULL;
834   }
835   if (extinfo != NULL && ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0)) {
836     DL_ERR("invalid extended flags to android_dlopen_ext: %x", extinfo->flags);
837     return NULL;
838   }
839   protect_data(PROT_READ | PROT_WRITE);
840   soinfo* si = find_library(name, flags, extinfo);
841   if (si != NULL) {
842     si->CallConstructors();
843   }
844   protect_data(PROT_READ);
845   return si;
848 void do_dlclose(soinfo* si) {
849   protect_data(PROT_READ | PROT_WRITE);
850   soinfo_unload(si);
851   protect_data(PROT_READ);
854 #if defined(USE_RELA)
855 static int soinfo_relocate(soinfo* si, ElfW(Rela)* rela, unsigned count, soinfo* needed[]) {
856   ElfW(Sym)* s;
857   soinfo* lsi;
859   for (size_t idx = 0; idx < count; ++idx, ++rela) {
860     unsigned type = ELFW(R_TYPE)(rela->r_info);
861     unsigned sym = ELFW(R_SYM)(rela->r_info);
862     ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rela->r_offset + si->load_bias);
863     ElfW(Addr) sym_addr = 0;
864     const char* sym_name = NULL;
866     DEBUG("Processing '%s' relocation at index %zd", si->name, idx);
867     if (type == 0) { // R_*_NONE
868       continue;
869     }
870     if (sym != 0) {
871       sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);
872       s = soinfo_do_lookup(si, sym_name, &lsi, needed);
873       if (s == NULL) {
874         // We only allow an undefined symbol if this is a weak reference...
875         s = &si->symtab[sym];
876         if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
877           DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name);
878           return -1;
879         }
881         /* IHI0044C AAELF 4.5.1.1:
883            Libraries are not searched to resolve weak references.
884            It is not an error for a weak reference to remain unsatisfied.
886            During linking, the value of an undefined weak reference is:
887            - Zero if the relocation type is absolute
888            - The address of the place if the relocation is pc-relative
889            - The address of nominal base address if the relocation
890              type is base-relative.
891          */
893         switch (type) {
894 #if defined(__aarch64__)
895         case R_AARCH64_JUMP_SLOT:
896         case R_AARCH64_GLOB_DAT:
897         case R_AARCH64_ABS64:
898         case R_AARCH64_ABS32:
899         case R_AARCH64_ABS16:
900         case R_AARCH64_RELATIVE:
901           /*
902            * The sym_addr was initialized to be zero above, or the relocation
903            * code below does not care about value of sym_addr.
904            * No need to do anything.
905            */
906           break;
907 #elif defined(__x86_64__)
908         case R_X86_64_JUMP_SLOT:
909         case R_X86_64_GLOB_DAT:
910         case R_X86_64_32:
911         case R_X86_64_64:
912         case R_X86_64_RELATIVE:
913           // No need to do anything.
914           break;
915         case R_X86_64_PC32:
916           sym_addr = reloc;
917           break;
918 #endif
919         default:
920           DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rela, idx);
921           return -1;
922         }
923       } else {
924         // We got a definition.
925         sym_addr = static_cast<ElfW(Addr)>(s->st_value + lsi->load_bias);
926       }
927       count_relocation(kRelocSymbol);
928     } else {
929       s = NULL;
930     }
932     switch (type) {
933 #if defined(__aarch64__)
934     case R_AARCH64_JUMP_SLOT:
935         count_relocation(kRelocAbsolute);
936         MARK(rela->r_offset);
937         TRACE_TYPE(RELO, "RELO JMP_SLOT %16llx <- %16llx %s\n",
938                    reloc, (sym_addr + rela->r_addend), sym_name);
939         *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + rela->r_addend);
940         break;
941     case R_AARCH64_GLOB_DAT:
942         count_relocation(kRelocAbsolute);
943         MARK(rela->r_offset);
944         TRACE_TYPE(RELO, "RELO GLOB_DAT %16llx <- %16llx %s\n",
945                    reloc, (sym_addr + rela->r_addend), sym_name);
946         *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + rela->r_addend);
947         break;
948     case R_AARCH64_ABS64:
949         count_relocation(kRelocAbsolute);
950         MARK(rela->r_offset);
951         TRACE_TYPE(RELO, "RELO ABS64 %16llx <- %16llx %s\n",
952                    reloc, (sym_addr + rela->r_addend), sym_name);
953         *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
954         break;
955     case R_AARCH64_ABS32:
956         count_relocation(kRelocAbsolute);
957         MARK(rela->r_offset);
958         TRACE_TYPE(RELO, "RELO ABS32 %16llx <- %16llx %s\n",
959                    reloc, (sym_addr + rela->r_addend), sym_name);
960         if ((static_cast<ElfW(Addr)>(INT32_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend))) &&
961             ((*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)) <= static_cast<ElfW(Addr)>(UINT32_MAX))) {
962             *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
963         } else {
964             DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
965                    (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)),
966                    static_cast<ElfW(Addr)>(INT32_MIN),
967                    static_cast<ElfW(Addr)>(UINT32_MAX));
968             return -1;
969         }
970         break;
971     case R_AARCH64_ABS16:
972         count_relocation(kRelocAbsolute);
973         MARK(rela->r_offset);
974         TRACE_TYPE(RELO, "RELO ABS16 %16llx <- %16llx %s\n",
975                    reloc, (sym_addr + rela->r_addend), sym_name);
976         if ((static_cast<ElfW(Addr)>(INT16_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend))) &&
977             ((*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)) <= static_cast<ElfW(Addr)>(UINT16_MAX))) {
978             *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
979         } else {
980             DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
981                    (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)),
982                    static_cast<ElfW(Addr)>(INT16_MIN),
983                    static_cast<ElfW(Addr)>(UINT16_MAX));
984             return -1;
985         }
986         break;
987     case R_AARCH64_PREL64:
988         count_relocation(kRelocRelative);
989         MARK(rela->r_offset);
990         TRACE_TYPE(RELO, "RELO REL64 %16llx <- %16llx - %16llx %s\n",
991                    reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
992         *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend) - rela->r_offset;
993         break;
994     case R_AARCH64_PREL32:
995         count_relocation(kRelocRelative);
996         MARK(rela->r_offset);
997         TRACE_TYPE(RELO, "RELO REL32 %16llx <- %16llx - %16llx %s\n",
998                    reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
999         if ((static_cast<ElfW(Addr)>(INT32_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset))) &&
1000             ((*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)) <= static_cast<ElfW(Addr)>(UINT32_MAX))) {
1001             *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + rela->r_addend) - rela->r_offset);
1002         } else {
1003             DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1004                    (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)),
1005                    static_cast<ElfW(Addr)>(INT32_MIN),
1006                    static_cast<ElfW(Addr)>(UINT32_MAX));
1007             return -1;
1008         }
1009         break;
1010     case R_AARCH64_PREL16:
1011         count_relocation(kRelocRelative);
1012         MARK(rela->r_offset);
1013         TRACE_TYPE(RELO, "RELO REL16 %16llx <- %16llx - %16llx %s\n",
1014                    reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
1015         if ((static_cast<ElfW(Addr)>(INT16_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset))) &&
1016             ((*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)) <= static_cast<ElfW(Addr)>(UINT16_MAX))) {
1017             *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + rela->r_addend) - rela->r_offset);
1018         } else {
1019             DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1020                    (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)),
1021                    static_cast<ElfW(Addr)>(INT16_MIN),
1022                    static_cast<ElfW(Addr)>(UINT16_MAX));
1023             return -1;
1024         }
1025         break;
1027     case R_AARCH64_RELATIVE:
1028         count_relocation(kRelocRelative);
1029         MARK(rela->r_offset);
1030         if (sym) {
1031             DL_ERR("odd RELATIVE form...");
1032             return -1;
1033         }
1034         TRACE_TYPE(RELO, "RELO RELATIVE %16llx <- %16llx\n",
1035                    reloc, (si->base + rela->r_addend));
1036         *reinterpret_cast<ElfW(Addr)*>(reloc) = (si->base + rela->r_addend);
1037         break;
1039     case R_AARCH64_COPY:
1040         if ((si->flags & FLAG_EXE) == 0) {
1041             /*
1042               * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
1043               *
1044               * Section 4.7.1.10 "Dynamic relocations"
1045               * R_AARCH64_COPY may only appear in executable objects where e_type is
1046               * set to ET_EXEC.
1047               *
1048               * FLAG_EXE is set for both ET_DYN and ET_EXEC executables.
1049               * We should explicitly disallow ET_DYN executables from having
1050               * R_AARCH64_COPY relocations.
1051               */
1052             DL_ERR("%s R_AARCH64_COPY relocations only supported for ET_EXEC", si->name);
1053             return -1;
1054         }
1055         count_relocation(kRelocCopy);
1056         MARK(rela->r_offset);
1057         TRACE_TYPE(RELO, "RELO COPY %16llx <- %lld @ %16llx %s\n",
1058                    reloc,
1059                    s->st_size,
1060                    (sym_addr + rela->r_addend),
1061                    sym_name);
1062         if (reloc == (sym_addr + rela->r_addend)) {
1063             ElfW(Sym)* src = soinfo_do_lookup(NULL, sym_name, &lsi, needed);
1065             if (src == NULL) {
1066                 DL_ERR("%s R_AARCH64_COPY relocation source cannot be resolved", si->name);
1067                 return -1;
1068             }
1069             if (lsi->has_DT_SYMBOLIC) {
1070                 DL_ERR("%s invalid R_AARCH64_COPY relocation against DT_SYMBOLIC shared "
1071                        "library %s (built with -Bsymbolic?)", si->name, lsi->name);
1072                 return -1;
1073             }
1074             if (s->st_size < src->st_size) {
1075                 DL_ERR("%s R_AARCH64_COPY relocation size mismatch (%lld < %lld)",
1076                        si->name, s->st_size, src->st_size);
1077                 return -1;
1078             }
1079             memcpy(reinterpret_cast<void*>(reloc),
1080                    reinterpret_cast<void*>(src->st_value + lsi->load_bias), src->st_size);
1081         } else {
1082             DL_ERR("%s R_AARCH64_COPY relocation target cannot be resolved", si->name);
1083             return -1;
1084         }
1085         break;
1086     case R_AARCH64_TLS_TPREL64:
1087         TRACE_TYPE(RELO, "RELO TLS_TPREL64 *** %16llx <- %16llx - %16llx\n",
1088                    reloc, (sym_addr + rela->r_addend), rela->r_offset);
1089         break;
1090     case R_AARCH64_TLS_DTPREL32:
1091         TRACE_TYPE(RELO, "RELO TLS_DTPREL32 *** %16llx <- %16llx - %16llx\n",
1092                    reloc, (sym_addr + rela->r_addend), rela->r_offset);
1093         break;
1094 #elif defined(__x86_64__)
1095     case R_X86_64_JUMP_SLOT:
1096       count_relocation(kRelocAbsolute);
1097       MARK(rela->r_offset);
1098       TRACE_TYPE(RELO, "RELO JMP_SLOT %08zx <- %08zx %s", static_cast<size_t>(reloc),
1099                  static_cast<size_t>(sym_addr + rela->r_addend), sym_name);
1100       *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
1101       break;
1102     case R_X86_64_GLOB_DAT:
1103       count_relocation(kRelocAbsolute);
1104       MARK(rela->r_offset);
1105       TRACE_TYPE(RELO, "RELO GLOB_DAT %08zx <- %08zx %s", static_cast<size_t>(reloc),
1106                  static_cast<size_t>(sym_addr + rela->r_addend), sym_name);
1107       *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
1108       break;
1109     case R_X86_64_RELATIVE:
1110       count_relocation(kRelocRelative);
1111       MARK(rela->r_offset);
1112       if (sym) {
1113         DL_ERR("odd RELATIVE form...");
1114         return -1;
1115       }
1116       TRACE_TYPE(RELO, "RELO RELATIVE %08zx <- +%08zx", static_cast<size_t>(reloc),
1117                  static_cast<size_t>(si->base));
1118       *reinterpret_cast<ElfW(Addr)*>(reloc) = si->base + rela->r_addend;
1119       break;
1120     case R_X86_64_32:
1121       count_relocation(kRelocRelative);
1122       MARK(rela->r_offset);
1123       TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
1124                  static_cast<size_t>(sym_addr), sym_name);
1125       *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
1126       break;
1127     case R_X86_64_64:
1128       count_relocation(kRelocRelative);
1129       MARK(rela->r_offset);
1130       TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
1131                  static_cast<size_t>(sym_addr), sym_name);
1132       *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
1133       break;
1134     case R_X86_64_PC32:
1135       count_relocation(kRelocRelative);
1136       MARK(rela->r_offset);
1137       TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s",
1138                  static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc),
1139                  static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name);
1140       *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend - reloc;
1141       break;
1142 #endif
1144     default:
1145       DL_ERR("unknown reloc type %d @ %p (%zu)", type, rela, idx);
1146       return -1;
1147     }
1148   }
1149   return 0;
1152 #else // REL, not RELA.
1154 static int soinfo_relocate(soinfo* si, ElfW(Rel)* rel, unsigned count, soinfo* needed[]) {
1155     ElfW(Sym)* s;
1156     soinfo* lsi;
1158     for (size_t idx = 0; idx < count; ++idx, ++rel) {
1159         unsigned type = ELFW(R_TYPE)(rel->r_info);
1160         // TODO: don't use unsigned for 'sym'. Use uint32_t or ElfW(Addr) instead.
1161         unsigned sym = ELFW(R_SYM)(rel->r_info);
1162         ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + si->load_bias);
1163         ElfW(Addr) sym_addr = 0;
1164         const char* sym_name = NULL;
1166         DEBUG("Processing '%s' relocation at index %zd", si->name, idx);
1167         if (type == 0) { // R_*_NONE
1168             continue;
1169         }
1170         if (sym != 0) {
1171             sym_name = reinterpret_cast<const char*>(si->strtab + si->symtab[sym].st_name);
1172             s = soinfo_do_lookup(si, sym_name, &lsi, needed);
1173             if (s == NULL) {
1174                 // We only allow an undefined symbol if this is a weak reference...
1175                 s = &si->symtab[sym];
1176                 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
1177                     DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, si->name);
1178                     return -1;
1179                 }
1181                 /* IHI0044C AAELF 4.5.1.1:
1183                    Libraries are not searched to resolve weak references.
1184                    It is not an error for a weak reference to remain
1185                    unsatisfied.
1187                    During linking, the value of an undefined weak reference is:
1188                    - Zero if the relocation type is absolute
1189                    - The address of the place if the relocation is pc-relative
1190                    - The address of nominal base address if the relocation
1191                      type is base-relative.
1192                   */
1194                 switch (type) {
1195 #if defined(__arm__)
1196                 case R_ARM_JUMP_SLOT:
1197                 case R_ARM_GLOB_DAT:
1198                 case R_ARM_ABS32:
1199                 case R_ARM_RELATIVE:    /* Don't care. */
1200                     // sym_addr was initialized to be zero above or relocation
1201                     // code below does not care about value of sym_addr.
1202                     // No need to do anything.
1203                     break;
1204 #elif defined(__i386__)
1205                 case R_386_JMP_SLOT:
1206                 case R_386_GLOB_DAT:
1207                 case R_386_32:
1208                 case R_386_RELATIVE:    /* Don't care. */
1209                     // sym_addr was initialized to be zero above or relocation
1210                     // code below does not care about value of sym_addr.
1211                     // No need to do anything.
1212                     break;
1213                 case R_386_PC32:
1214                     sym_addr = reloc;
1215                     break;
1216 #endif
1218 #if defined(__arm__)
1219                 case R_ARM_COPY:
1220                     // Fall through. Can't really copy if weak symbol is not found at run-time.
1221 #endif
1222                 default:
1223                     DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rel, idx);
1224                     return -1;
1225                 }
1226             } else {
1227                 // We got a definition.
1228                 sym_addr = static_cast<ElfW(Addr)>(s->st_value + lsi->load_bias);
1229             }
1230             count_relocation(kRelocSymbol);
1231         } else {
1232             s = NULL;
1233         }
1235         switch (type) {
1236 #if defined(__arm__)
1237         case R_ARM_JUMP_SLOT:
1238             count_relocation(kRelocAbsolute);
1239             MARK(rel->r_offset);
1240             TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name);
1241             *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
1242             break;
1243         case R_ARM_GLOB_DAT:
1244             count_relocation(kRelocAbsolute);
1245             MARK(rel->r_offset);
1246             TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name);
1247             *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
1248             break;
1249         case R_ARM_ABS32:
1250             count_relocation(kRelocAbsolute);
1251             MARK(rel->r_offset);
1252             TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name);
1253             *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
1254             break;
1255         case R_ARM_REL32:
1256             count_relocation(kRelocRelative);
1257             MARK(rel->r_offset);
1258             TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s",
1259                        reloc, sym_addr, rel->r_offset, sym_name);
1260             *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
1261             break;
1262         case R_ARM_COPY:
1263             if ((si->flags & FLAG_EXE) == 0) {
1264                 /*
1265                  * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
1266                  *
1267                  * Section 4.7.1.10 "Dynamic relocations"
1268                  * R_ARM_COPY may only appear in executable objects where e_type is
1269                  * set to ET_EXEC.
1270                  *
1271                  * TODO: FLAG_EXE is set for both ET_DYN and ET_EXEC executables.
1272                  * We should explicitly disallow ET_DYN executables from having
1273                  * R_ARM_COPY relocations.
1274                  */
1275                 DL_ERR("%s R_ARM_COPY relocations only supported for ET_EXEC", si->name);
1276                 return -1;
1277             }
1278             count_relocation(kRelocCopy);
1279             MARK(rel->r_offset);
1280             TRACE_TYPE(RELO, "RELO %08x <- %d @ %08x %s", reloc, s->st_size, sym_addr, sym_name);
1281             if (reloc == sym_addr) {
1282                 ElfW(Sym)* src = soinfo_do_lookup(NULL, sym_name, &lsi, needed);
1284                 if (src == NULL) {
1285                     DL_ERR("%s R_ARM_COPY relocation source cannot be resolved", si->name);
1286                     return -1;
1287                 }
1288                 if (lsi->has_DT_SYMBOLIC) {
1289                     DL_ERR("%s invalid R_ARM_COPY relocation against DT_SYMBOLIC shared "
1290                            "library %s (built with -Bsymbolic?)", si->name, lsi->name);
1291                     return -1;
1292                 }
1293                 if (s->st_size < src->st_size) {
1294                     DL_ERR("%s R_ARM_COPY relocation size mismatch (%d < %d)",
1295                            si->name, s->st_size, src->st_size);
1296                     return -1;
1297                 }
1298                 memcpy(reinterpret_cast<void*>(reloc),
1299                        reinterpret_cast<void*>(src->st_value + lsi->load_bias), src->st_size);
1300             } else {
1301                 DL_ERR("%s R_ARM_COPY relocation target cannot be resolved", si->name);
1302                 return -1;
1303             }
1304             break;
1305 #elif defined(__i386__)
1306         case R_386_JMP_SLOT:
1307             count_relocation(kRelocAbsolute);
1308             MARK(rel->r_offset);
1309             TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name);
1310             *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
1311             break;
1312         case R_386_GLOB_DAT:
1313             count_relocation(kRelocAbsolute);
1314             MARK(rel->r_offset);
1315             TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name);
1316             *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
1317             break;
1318         case R_386_32:
1319             count_relocation(kRelocRelative);
1320             MARK(rel->r_offset);
1321             TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name);
1322             *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
1323             break;
1324         case R_386_PC32:
1325             count_relocation(kRelocRelative);
1326             MARK(rel->r_offset);
1327             TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s",
1328                        reloc, (sym_addr - reloc), sym_addr, reloc, sym_name);
1329             *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr - reloc);
1330             break;
1331 #elif defined(__mips__)
1332         case R_MIPS_REL32:
1333 #if defined(__LP64__)
1334             // MIPS Elf64_Rel entries contain compound relocations
1335             // We only handle the R_MIPS_NONE|R_MIPS_64|R_MIPS_REL32 case
1336             if (ELF64_R_TYPE2(rel->r_info) != R_MIPS_64 ||
1337                 ELF64_R_TYPE3(rel->r_info) != R_MIPS_NONE) {
1338                 DL_ERR("Unexpected compound relocation type:%d type2:%d type3:%d @ %p (%zu)",
1339                        type, (unsigned)ELF64_R_TYPE2(rel->r_info),
1340                        (unsigned)ELF64_R_TYPE3(rel->r_info), rel, idx);
1341                 return -1;
1342             }
1343 #endif
1344             count_relocation(kRelocAbsolute);
1345             MARK(rel->r_offset);
1346             TRACE_TYPE(RELO, "RELO REL32 %08zx <- %08zx %s", static_cast<size_t>(reloc),
1347                        static_cast<size_t>(sym_addr), sym_name ? sym_name : "*SECTIONHDR*");
1348             if (s) {
1349                 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
1350             } else {
1351                 *reinterpret_cast<ElfW(Addr)*>(reloc) += si->base;
1352             }
1353             break;
1354 #endif
1356 #if defined(__arm__)
1357         case R_ARM_RELATIVE:
1358 #elif defined(__i386__)
1359         case R_386_RELATIVE:
1360 #endif
1361             count_relocation(kRelocRelative);
1362             MARK(rel->r_offset);
1363             if (sym) {
1364                 DL_ERR("odd RELATIVE form...");
1365                 return -1;
1366             }
1367             TRACE_TYPE(RELO, "RELO RELATIVE %p <- +%p",
1368                        reinterpret_cast<void*>(reloc), reinterpret_cast<void*>(si->base));
1369             *reinterpret_cast<ElfW(Addr)*>(reloc) += si->base;
1370             break;
1372         default:
1373             DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
1374             return -1;
1375         }
1376     }
1377     return 0;
1379 #endif
1381 #if defined(__mips__)
1382 static bool mips_relocate_got(soinfo* si, soinfo* needed[]) {
1383     ElfW(Addr)** got = si->plt_got;
1384     if (got == NULL) {
1385         return true;
1386     }
1387     unsigned local_gotno = si->mips_local_gotno;
1388     unsigned gotsym = si->mips_gotsym;
1389     unsigned symtabno = si->mips_symtabno;
1390     ElfW(Sym)* symtab = si->symtab;
1392     // got[0] is the address of the lazy resolver function.
1393     // got[1] may be used for a GNU extension.
1394     // Set it to a recognizable address in case someone calls it (should be _rtld_bind_start).
1395     // FIXME: maybe this should be in a separate routine?
1396     if ((si->flags & FLAG_LINKER) == 0) {
1397         size_t g = 0;
1398         got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadbeef);
1399         if (reinterpret_cast<intptr_t>(got[g]) < 0) {
1400             got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadfeed);
1401         }
1402         // Relocate the local GOT entries.
1403         for (; g < local_gotno; g++) {
1404             got[g] = reinterpret_cast<ElfW(Addr)*>(reinterpret_cast<uintptr_t>(got[g]) + si->load_bias);
1405         }
1406     }
1408     // Now for the global GOT entries...
1409     ElfW(Sym)* sym = symtab + gotsym;
1410     got = si->plt_got + local_gotno;
1411     for (size_t g = gotsym; g < symtabno; g++, sym++, got++) {
1412         // This is an undefined reference... try to locate it.
1413         const char* sym_name = si->strtab + sym->st_name;
1414         soinfo* lsi;
1415         ElfW(Sym)* s = soinfo_do_lookup(si, sym_name, &lsi, needed);
1416         if (s == NULL) {
1417             // We only allow an undefined symbol if this is a weak reference.
1418             s = &symtab[g];
1419             if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
1420                 DL_ERR("cannot locate \"%s\"...", sym_name);
1421                 return false;
1422             }
1423             *got = 0;
1424         } else {
1425             // FIXME: is this sufficient?
1426             // For reference see NetBSD link loader
1427             // 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
1428             *got = reinterpret_cast<ElfW(Addr)*>(lsi->load_bias + s->st_value);
1429         }
1430     }
1431     return true;
1433 #endif
1435 void soinfo::CallArray(const char* array_name __unused, linker_function_t* functions, size_t count, bool reverse) {
1436   if (functions == NULL) {
1437     return;
1438   }
1440   TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, name);
1442   int begin = reverse ? (count - 1) : 0;
1443   int end = reverse ? -1 : count;
1444   int step = reverse ? -1 : 1;
1446   for (int i = begin; i != end; i += step) {
1447     TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
1448     CallFunction("function", functions[i]);
1449   }
1451   TRACE("[ Done calling %s for '%s' ]", array_name, name);
1454 void soinfo::CallFunction(const char* function_name __unused, linker_function_t function) {
1455   if (function == NULL || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
1456     return;
1457   }
1459   TRACE("[ Calling %s @ %p for '%s' ]", function_name, function, name);
1460   function();
1461   TRACE("[ Done calling %s @ %p for '%s' ]", function_name, function, name);
1463   // The function may have called dlopen(3) or dlclose(3), so we need to ensure our data structures
1464   // are still writable. This happens with our debug malloc (see http://b/7941716).
1465   protect_data(PROT_READ | PROT_WRITE);
1468 void soinfo::CallPreInitConstructors() {
1469   // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
1470   // but ignored in a shared library.
1471   CallArray("DT_PREINIT_ARRAY", preinit_array, preinit_array_count, false);
1474 void soinfo::CallConstructors() {
1475   if (constructors_called) {
1476     return;
1477   }
1479   // We set constructors_called before actually calling the constructors, otherwise it doesn't
1480   // protect against recursive constructor calls. One simple example of constructor recursion
1481   // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
1482   // 1. The program depends on libc, so libc's constructor is called here.
1483   // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
1484   // 3. dlopen() calls the constructors on the newly created
1485   //    soinfo for libc_malloc_debug_leak.so.
1486   // 4. The debug .so depends on libc, so CallConstructors is
1487   //    called again with the libc soinfo. If it doesn't trigger the early-
1488   //    out above, the libc constructor will be called again (recursively!).
1489   constructors_called = true;
1491   if ((flags & FLAG_EXE) == 0 && preinit_array != NULL) {
1492     // The GNU dynamic linker silently ignores these, but we warn the developer.
1493     PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!",
1494           name, preinit_array_count);
1495   }
1497   get_children().for_each([] (soinfo* si) {
1498     si->CallConstructors();
1499   });
1501   TRACE("\"%s\": calling constructors", name);
1503   // DT_INIT should be called before DT_INIT_ARRAY if both are present.
1504   CallFunction("DT_INIT", init_func);
1505   CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
1508 void soinfo::CallDestructors() {
1509   TRACE("\"%s\": calling destructors", name);
1511   // DT_FINI_ARRAY must be parsed in reverse order.
1512   CallArray("DT_FINI_ARRAY", fini_array, fini_array_count, true);
1514   // DT_FINI should be called after DT_FINI_ARRAY if both are present.
1515   CallFunction("DT_FINI", fini_func);
1517   // This is needed on second call to dlopen
1518   // after library has been unloaded with RTLD_NODELETE
1519   constructors_called = false;
1522 void soinfo::add_child(soinfo* child) {
1523   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1524     return;
1525   }
1527   this->children.push_front(child);
1528   child->parents.push_front(this);
1531 void soinfo::remove_all_links() {
1532   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1533     return;
1534   }
1536   // 1. Untie connected soinfos from 'this'.
1537   children.for_each([&] (soinfo* child) {
1538     child->parents.remove_if([&] (const soinfo* parent) {
1539       return parent == this;
1540     });
1541   });
1543   parents.for_each([&] (soinfo* parent) {
1544     parent->children.for_each([&] (const soinfo* child) {
1545       return child == this;
1546     });
1547   });
1549   // 2. Once everything untied - clear local lists.
1550   parents.clear();
1551   children.clear();
1554 void soinfo::set_st_dev(dev_t dev) {
1555   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1556     return;
1557   }
1559   st_dev = dev;
1562 void soinfo::set_st_ino(ino_t ino) {
1563   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1564     return;
1565   }
1567   st_ino = ino;
1570 dev_t soinfo::get_st_dev() {
1571   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1572     return 0;
1573   }
1575   return st_dev;
1576 };
1578 ino_t soinfo::get_st_ino() {
1579   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1580     return 0;
1581   }
1583   return st_ino;
1586 // This is a return on get_children() in case
1587 // 'this->flags' does not have FLAG_NEW_SOINFO set.
1588 static soinfo::soinfo_list_t g_empty_list;
1590 soinfo::soinfo_list_t& soinfo::get_children() {
1591   if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1592     return g_empty_list;
1593   }
1595   return this->children;
1598 /* Force any of the closed stdin, stdout and stderr to be associated with
1599    /dev/null. */
1600 static int nullify_closed_stdio() {
1601     int dev_null, i, status;
1602     int return_value = 0;
1604     dev_null = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
1605     if (dev_null < 0) {
1606         DL_ERR("cannot open /dev/null: %s", strerror(errno));
1607         return -1;
1608     }
1609     TRACE("[ Opened /dev/null file-descriptor=%d]", dev_null);
1611     /* If any of the stdio file descriptors is valid and not associated
1612        with /dev/null, dup /dev/null to it.  */
1613     for (i = 0; i < 3; i++) {
1614         /* If it is /dev/null already, we are done. */
1615         if (i == dev_null) {
1616             continue;
1617         }
1619         TRACE("[ Nullifying stdio file descriptor %d]", i);
1620         status = TEMP_FAILURE_RETRY(fcntl(i, F_GETFL));
1622         /* If file is opened, we are good. */
1623         if (status != -1) {
1624             continue;
1625         }
1627         /* The only error we allow is that the file descriptor does not
1628            exist, in which case we dup /dev/null to it. */
1629         if (errno != EBADF) {
1630             DL_ERR("fcntl failed: %s", strerror(errno));
1631             return_value = -1;
1632             continue;
1633         }
1635         /* Try dupping /dev/null to this stdio file descriptor and
1636            repeat if there is a signal.  Note that any errors in closing
1637            the stdio descriptor are lost.  */
1638         status = TEMP_FAILURE_RETRY(dup2(dev_null, i));
1639         if (status < 0) {
1640             DL_ERR("dup2 failed: %s", strerror(errno));
1641             return_value = -1;
1642             continue;
1643         }
1644     }
1646     /* If /dev/null is not one of the stdio file descriptors, close it. */
1647     if (dev_null > 2) {
1648         TRACE("[ Closing /dev/null file-descriptor=%d]", dev_null);
1649         status = TEMP_FAILURE_RETRY(close(dev_null));
1650         if (status == -1) {
1651             DL_ERR("close failed: %s", strerror(errno));
1652             return_value = -1;
1653         }
1654     }
1656     return return_value;
1659 static bool soinfo_link_image(soinfo* si, const android_dlextinfo* extinfo) {
1660     /* "base" might wrap around UINT32_MAX. */
1661     ElfW(Addr) base = si->load_bias;
1662     const ElfW(Phdr)* phdr = si->phdr;
1663     int phnum = si->phnum;
1664     bool relocating_linker = (si->flags & FLAG_LINKER) != 0;
1666     /* We can't debug anything until the linker is relocated */
1667     if (!relocating_linker) {
1668         INFO("[ linking %s ]", si->name);
1669         DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(si->base), si->flags);
1670     }
1672     /* Extract dynamic section */
1673     size_t dynamic_count;
1674     ElfW(Word) dynamic_flags;
1675     phdr_table_get_dynamic_section(phdr, phnum, base, &si->dynamic,
1676                                    &dynamic_count, &dynamic_flags);
1677     if (si->dynamic == NULL) {
1678         if (!relocating_linker) {
1679             DL_ERR("missing PT_DYNAMIC in \"%s\"", si->name);
1680         }
1681         return false;
1682     } else {
1683         if (!relocating_linker) {
1684             DEBUG("dynamic = %p", si->dynamic);
1685         }
1686     }
1688 #if defined(__arm__)
1689     (void) phdr_table_get_arm_exidx(phdr, phnum, base,
1690                                     &si->ARM_exidx, &si->ARM_exidx_count);
1691 #endif
1693     // Extract useful information from dynamic section.
1694     uint32_t needed_count = 0;
1695     for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
1696         DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p",
1697               d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
1698         switch (d->d_tag) {
1699         case DT_HASH:
1700             si->nbucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[0];
1701             si->nchain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr)[1];
1702             si->bucket = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8);
1703             si->chain = reinterpret_cast<uint32_t*>(base + d->d_un.d_ptr + 8 + si->nbucket * 4);
1704             break;
1705         case DT_STRTAB:
1706             si->strtab = reinterpret_cast<const char*>(base + d->d_un.d_ptr);
1707             break;
1708         case DT_SYMTAB:
1709             si->symtab = reinterpret_cast<ElfW(Sym)*>(base + d->d_un.d_ptr);
1710             break;
1711 #if !defined(__LP64__)
1712         case DT_PLTREL:
1713             if (d->d_un.d_val != DT_REL) {
1714                 DL_ERR("unsupported DT_RELA in \"%s\"", si->name);
1715                 return false;
1716             }
1717             break;
1718 #endif
1719         case DT_JMPREL:
1720 #if defined(USE_RELA)
1721             si->plt_rela = reinterpret_cast<ElfW(Rela)*>(base + d->d_un.d_ptr);
1722 #else
1723             si->plt_rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
1724 #endif
1725             break;
1726         case DT_PLTRELSZ:
1727 #if defined(USE_RELA)
1728             si->plt_rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
1729 #else
1730             si->plt_rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
1731 #endif
1732             break;
1733 #if defined(__mips__)
1734         case DT_PLTGOT:
1735             // Used by mips and mips64.
1736             si->plt_got = reinterpret_cast<ElfW(Addr)**>(base + d->d_un.d_ptr);
1737             break;
1738 #endif
1739         case DT_DEBUG:
1740             // Set the DT_DEBUG entry to the address of _r_debug for GDB
1741             // if the dynamic table is writable
1742 // FIXME: not working currently for N64
1743 // The flags for the LOAD and DYNAMIC program headers do not agree.
1744 // The LOAD section containng the dynamic table has been mapped as
1745 // read-only, but the DYNAMIC header claims it is writable.
1746 #if !(defined(__mips__) && defined(__LP64__))
1747             if ((dynamic_flags & PF_W) != 0) {
1748                 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
1749             }
1750             break;
1751 #endif
1752 #if defined(USE_RELA)
1753          case DT_RELA:
1754             si->rela = reinterpret_cast<ElfW(Rela)*>(base + d->d_un.d_ptr);
1755             break;
1756          case DT_RELASZ:
1757             si->rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
1758             break;
1759         case DT_REL:
1760             DL_ERR("unsupported DT_REL in \"%s\"", si->name);
1761             return false;
1762         case DT_RELSZ:
1763             DL_ERR("unsupported DT_RELSZ in \"%s\"", si->name);
1764             return false;
1765 #else
1766         case DT_REL:
1767             si->rel = reinterpret_cast<ElfW(Rel)*>(base + d->d_un.d_ptr);
1768             break;
1769         case DT_RELSZ:
1770             si->rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
1771             break;
1772          case DT_RELA:
1773             DL_ERR("unsupported DT_RELA in \"%s\"", si->name);
1774             return false;
1775 #endif
1776         case DT_INIT:
1777             si->init_func = reinterpret_cast<linker_function_t>(base + d->d_un.d_ptr);
1778             DEBUG("%s constructors (DT_INIT) found at %p", si->name, si->init_func);
1779             break;
1780         case DT_FINI:
1781             si->fini_func = reinterpret_cast<linker_function_t>(base + d->d_un.d_ptr);
1782             DEBUG("%s destructors (DT_FINI) found at %p", si->name, si->fini_func);
1783             break;
1784         case DT_INIT_ARRAY:
1785             si->init_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr);
1786             DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", si->name, si->init_array);
1787             break;
1788         case DT_INIT_ARRAYSZ:
1789             si->init_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
1790             break;
1791         case DT_FINI_ARRAY:
1792             si->fini_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr);
1793             DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", si->name, si->fini_array);
1794             break;
1795         case DT_FINI_ARRAYSZ:
1796             si->fini_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
1797             break;
1798         case DT_PREINIT_ARRAY:
1799             si->preinit_array = reinterpret_cast<linker_function_t*>(base + d->d_un.d_ptr);
1800             DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", si->name, si->preinit_array);
1801             break;
1802         case DT_PREINIT_ARRAYSZ:
1803             si->preinit_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
1804             break;
1805         case DT_TEXTREL:
1806 #if defined(__LP64__)
1807             DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", si->name);
1808             return false;
1809 #else
1810             si->has_text_relocations = true;
1811             break;
1812 #endif
1813         case DT_SYMBOLIC:
1814             si->has_DT_SYMBOLIC = true;
1815             break;
1816         case DT_NEEDED:
1817             ++needed_count;
1818             break;
1819         case DT_FLAGS:
1820             if (d->d_un.d_val & DF_TEXTREL) {
1821 #if defined(__LP64__)
1822                 DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", si->name);
1823                 return false;
1824 #else
1825                 si->has_text_relocations = true;
1826 #endif
1827             }
1828             if (d->d_un.d_val & DF_SYMBOLIC) {
1829                 si->has_DT_SYMBOLIC = true;
1830             }
1831             break;
1832 #if defined(__mips__)
1833         case DT_STRSZ:
1834         case DT_SYMENT:
1835         case DT_RELENT:
1836              break;
1837         case DT_MIPS_RLD_MAP:
1838             // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB.
1839             {
1840               r_debug** dp = reinterpret_cast<r_debug**>(base + d->d_un.d_ptr);
1841               *dp = &_r_debug;
1842             }
1843             break;
1844         case DT_MIPS_RLD_VERSION:
1845         case DT_MIPS_FLAGS:
1846         case DT_MIPS_BASE_ADDRESS:
1847         case DT_MIPS_UNREFEXTNO:
1848             break;
1850         case DT_MIPS_SYMTABNO:
1851             si->mips_symtabno = d->d_un.d_val;
1852             break;
1854         case DT_MIPS_LOCAL_GOTNO:
1855             si->mips_local_gotno = d->d_un.d_val;
1856             break;
1858         case DT_MIPS_GOTSYM:
1859             si->mips_gotsym = d->d_un.d_val;
1860             break;
1861 #endif
1863         default:
1864             DEBUG("Unused DT entry: type %p arg %p",
1865                   reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
1866             break;
1867         }
1868     }
1870     DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p",
1871           reinterpret_cast<void*>(si->base), si->strtab, si->symtab);
1873     // Sanity checks.
1874     if (relocating_linker && needed_count != 0) {
1875         DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
1876         return false;
1877     }
1878     if (si->nbucket == 0) {
1879         DL_ERR("empty/missing DT_HASH in \"%s\" (built with --hash-style=gnu?)", si->name);
1880         return false;
1881     }
1882     if (si->strtab == 0) {
1883         DL_ERR("empty/missing DT_STRTAB in \"%s\"", si->name);
1884         return false;
1885     }
1886     if (si->symtab == 0) {
1887         DL_ERR("empty/missing DT_SYMTAB in \"%s\"", si->name);
1888         return false;
1889     }
1891     // If this is the main executable, then load all of the libraries from LD_PRELOAD now.
1892     if (si->flags & FLAG_EXE) {
1893         memset(g_ld_preloads, 0, sizeof(g_ld_preloads));
1894         size_t preload_count = 0;
1895         for (size_t i = 0; g_ld_preload_names[i] != NULL; i++) {
1896             soinfo* lsi = find_library(g_ld_preload_names[i], 0, NULL);
1897             if (lsi != NULL) {
1898                 g_ld_preloads[preload_count++] = lsi;
1899             } else {
1900                 // As with glibc, failure to load an LD_PRELOAD library is just a warning.
1901                 DL_WARN("could not load library \"%s\" from LD_PRELOAD for \"%s\"; caused by %s",
1902                         g_ld_preload_names[i], si->name, linker_get_error_buffer());
1903             }
1904         }
1905     }
1907     soinfo** needed = reinterpret_cast<soinfo**>(alloca((1 + needed_count) * sizeof(soinfo*)));
1908     soinfo** pneeded = needed;
1910     for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
1911         if (d->d_tag == DT_NEEDED) {
1912             const char* library_name = si->strtab + d->d_un.d_val;
1913             DEBUG("%s needs %s", si->name, library_name);
1914             soinfo* lsi = find_library(library_name, 0, NULL);
1915             if (lsi == NULL) {
1916                 strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf));
1917                 DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s",
1918                        library_name, si->name, tmp_err_buf);
1919                 return false;
1920             }
1922             si->add_child(lsi);
1923             *pneeded++ = lsi;
1924         }
1925     }
1926     *pneeded = NULL;
1928 #if !defined(__LP64__)
1929     if (si->has_text_relocations) {
1930         // Make segments writable to allow text relocations to work properly. We will later call
1931         // phdr_table_protect_segments() after all of them are applied and all constructors are run.
1932 #if !defined(__i386__) // The platform itself has too many text relocations on x86.
1933         DL_WARN("%s has text relocations. This is wasting memory and prevents "
1934                 "security hardening. Please fix.", si->name);
1935 #endif
1936         if (phdr_table_unprotect_segments(si->phdr, si->phnum, si->load_bias) < 0) {
1937             DL_ERR("can't unprotect loadable segments for \"%s\": %s",
1938                    si->name, strerror(errno));
1939             return false;
1940         }
1941     }
1942 #endif
1944 #if defined(USE_RELA)
1945     if (si->plt_rela != NULL) {
1946         DEBUG("[ relocating %s plt ]\n", si->name);
1947         if (soinfo_relocate(si, si->plt_rela, si->plt_rela_count, needed)) {
1948             return false;
1949         }
1950     }
1951     if (si->rela != NULL) {
1952         DEBUG("[ relocating %s ]\n", si->name);
1953         if (soinfo_relocate(si, si->rela, si->rela_count, needed)) {
1954             return false;
1955         }
1956     }
1957 #else
1958     if (si->plt_rel != NULL) {
1959         DEBUG("[ relocating %s plt ]", si->name);
1960         if (soinfo_relocate(si, si->plt_rel, si->plt_rel_count, needed)) {
1961             return false;
1962         }
1963     }
1964     if (si->rel != NULL) {
1965         DEBUG("[ relocating %s ]", si->name);
1966         if (soinfo_relocate(si, si->rel, si->rel_count, needed)) {
1967             return false;
1968         }
1969     }
1970 #endif
1972 #if defined(__mips__)
1973     if (!mips_relocate_got(si, needed)) {
1974         return false;
1975     }
1976 #endif
1978     si->flags |= FLAG_LINKED;
1979     DEBUG("[ finished linking %s ]", si->name);
1981 #if !defined(__LP64__)
1982     if (si->has_text_relocations) {
1983         // All relocations are done, we can protect our segments back to read-only.
1984         if (phdr_table_protect_segments(si->phdr, si->phnum, si->load_bias) < 0) {
1985             DL_ERR("can't protect segments for \"%s\": %s",
1986                    si->name, strerror(errno));
1987             return false;
1988         }
1989     }
1990 #endif
1992     /* We can also turn on GNU RELRO protection */
1993     if (phdr_table_protect_gnu_relro(si->phdr, si->phnum, si->load_bias) < 0) {
1994         DL_ERR("can't enable GNU RELRO protection for \"%s\": %s",
1995                si->name, strerror(errno));
1996         return false;
1997     }
1999     /* Handle serializing/sharing the RELRO segment */
2000     if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
2001       if (phdr_table_serialize_gnu_relro(si->phdr, si->phnum, si->load_bias,
2002                                          extinfo->relro_fd) < 0) {
2003         DL_ERR("failed serializing GNU RELRO section for \"%s\": %s",
2004                si->name, strerror(errno));
2005         return false;
2006       }
2007     } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
2008       if (phdr_table_map_gnu_relro(si->phdr, si->phnum, si->load_bias,
2009                                    extinfo->relro_fd) < 0) {
2010         DL_ERR("failed mapping GNU RELRO section for \"%s\": %s",
2011                si->name, strerror(errno));
2012         return false;
2013       }
2014     }
2016     notify_gdb_of_load(si);
2017     return true;
2020 /*
2021  * This function add vdso to internal dso list.
2022  * It helps to stack unwinding through signal handlers.
2023  * Also, it makes bionic more like glibc.
2024  */
2025 static void add_vdso(KernelArgumentBlock& args __unused) {
2026 #if defined(AT_SYSINFO_EHDR)
2027   ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR));
2028   if (ehdr_vdso == NULL) {
2029     return;
2030   }
2032   soinfo* si = soinfo_alloc("[vdso]", NULL);
2034   si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff);
2035   si->phnum = ehdr_vdso->e_phnum;
2036   si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso);
2037   si->size = phdr_table_get_load_size(si->phdr, si->phnum);
2038   si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
2040   soinfo_link_image(si, NULL);
2041 #endif
2044 /*
2045  * This is linker soinfo for GDB. See details below.
2046  */
2047 static soinfo linker_soinfo_for_gdb;
2049 /* gdb expects the linker to be in the debug shared object list.
2050  * Without this, gdb has trouble locating the linker's ".text"
2051  * and ".plt" sections. Gdb could also potentially use this to
2052  * relocate the offset of our exported 'rtld_db_dlactivity' symbol.
2053  * Don't use soinfo_alloc(), because the linker shouldn't
2054  * be on the soinfo list.
2055  */
2056 static void init_linker_info_for_gdb(ElfW(Addr) linker_base) {
2057 #if defined(__LP64__)
2058   strlcpy(linker_soinfo_for_gdb.name, "/system/bin/linker64", sizeof(linker_soinfo_for_gdb.name));
2059 #else
2060   strlcpy(linker_soinfo_for_gdb.name, "/system/bin/linker", sizeof(linker_soinfo_for_gdb.name));
2061 #endif
2062   linker_soinfo_for_gdb.flags = FLAG_NEW_SOINFO;
2063   linker_soinfo_for_gdb.base = linker_base;
2065   /*
2066    * Set the dynamic field in the link map otherwise gdb will complain with
2067    * the following:
2068    *   warning: .dynamic section for "/system/bin/linker" is not at the
2069    *   expected address (wrong library or version mismatch?)
2070    */
2071   ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base);
2072   ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff);
2073   phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
2074                                  &linker_soinfo_for_gdb.dynamic, NULL, NULL);
2075   insert_soinfo_into_debug_map(&linker_soinfo_for_gdb);
2078 /*
2079  * This code is called after the linker has linked itself and
2080  * fixed it's own GOT. It is safe to make references to externs
2081  * and other non-local data at this point.
2082  */
2083 static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW(Addr) linker_base) {
2084     /* NOTE: we store the args pointer on a special location
2085      *       of the temporary TLS area in order to pass it to
2086      *       the C Library's runtime initializer.
2087      *
2088      *       The initializer must clear the slot and reset the TLS
2089      *       to point to a different location to ensure that no other
2090      *       shared library constructor can access it.
2091      */
2092   __libc_init_tls(args);
2094 #if TIMING
2095     struct timeval t0, t1;
2096     gettimeofday(&t0, 0);
2097 #endif
2099     // Initialize environment functions, and get to the ELF aux vectors table.
2100     linker_env_init(args);
2102     // If this is a setuid/setgid program, close the security hole described in
2103     // ftp://ftp.freebsd.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-02:23.stdio.asc
2104     if (get_AT_SECURE()) {
2105         nullify_closed_stdio();
2106     }
2108     debuggerd_init();
2110     // Get a few environment variables.
2111     const char* LD_DEBUG = linker_env_get("LD_DEBUG");
2112     if (LD_DEBUG != NULL) {
2113       g_ld_debug_verbosity = atoi(LD_DEBUG);
2114     }
2116     // Normally, these are cleaned by linker_env_init, but the test
2117     // doesn't cost us anything.
2118     const char* ldpath_env = NULL;
2119     const char* ldpreload_env = NULL;
2120     if (!get_AT_SECURE()) {
2121       ldpath_env = linker_env_get("LD_LIBRARY_PATH");
2122       ldpreload_env = linker_env_get("LD_PRELOAD");
2123     }
2125     // Linker does not call constructors for its own
2126     // global variables so we need to initialize
2127     // the allocators explicitly.
2128     g_soinfo_allocator.init();
2129     g_soinfo_links_allocator.init();
2131     INFO("[ android linker & debugger ]");
2133     soinfo* si = soinfo_alloc(args.argv[0], NULL);
2134     if (si == NULL) {
2135         exit(EXIT_FAILURE);
2136     }
2138     /* bootstrap the link map, the main exe always needs to be first */
2139     si->flags |= FLAG_EXE;
2140     link_map* map = &(si->link_map_head);
2142     map->l_addr = 0;
2143     map->l_name = args.argv[0];
2144     map->l_prev = NULL;
2145     map->l_next = NULL;
2147     _r_debug.r_map = map;
2148     r_debug_tail = map;
2150     init_linker_info_for_gdb(linker_base);
2152     // Extract information passed from the kernel.
2153     si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
2154     si->phnum = args.getauxval(AT_PHNUM);
2155     si->entry = args.getauxval(AT_ENTRY);
2157     /* Compute the value of si->base. We can't rely on the fact that
2158      * the first entry is the PHDR because this will not be true
2159      * for certain executables (e.g. some in the NDK unit test suite)
2160      */
2161     si->base = 0;
2162     si->size = phdr_table_get_load_size(si->phdr, si->phnum);
2163     si->load_bias = 0;
2164     for (size_t i = 0; i < si->phnum; ++i) {
2165       if (si->phdr[i].p_type == PT_PHDR) {
2166         si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
2167         si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
2168         break;
2169       }
2170     }
2171     si->dynamic = NULL;
2172     si->ref_count = 1;
2174 #if defined(__LP64__)
2175     ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);
2176     if (elf_hdr->e_type != ET_DYN) {
2177         __libc_format_fd(2, "error: only position independent executables (PIE) are supported.\n");
2178         exit(EXIT_FAILURE);
2179     }
2180 #endif
2182     // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
2183     parse_LD_LIBRARY_PATH(ldpath_env);
2184     parse_LD_PRELOAD(ldpreload_env);
2186     somain = si;
2188     if (!soinfo_link_image(si, NULL)) {
2189         __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
2190         exit(EXIT_FAILURE);
2191     }
2193     add_vdso(args);
2195     si->CallPreInitConstructors();
2197     for (size_t i = 0; g_ld_preloads[i] != NULL; ++i) {
2198         g_ld_preloads[i]->CallConstructors();
2199     }
2201     /* After the link_image, the si->load_bias is initialized.
2202      * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
2203      * We need to update this value for so exe here. So Unwind_Backtrace
2204      * for some arch like x86 could work correctly within so exe.
2205      */
2206     map->l_addr = si->load_bias;
2207     si->CallConstructors();
2209 #if TIMING
2210     gettimeofday(&t1, NULL);
2211     PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) (
2212                (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
2213                (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)));
2214 #endif
2215 #if STATS
2216     PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0],
2217            linker_stats.count[kRelocAbsolute],
2218            linker_stats.count[kRelocRelative],
2219            linker_stats.count[kRelocCopy],
2220            linker_stats.count[kRelocSymbol]);
2221 #endif
2222 #if COUNT_PAGES
2223     {
2224         unsigned n;
2225         unsigned i;
2226         unsigned count = 0;
2227         for (n = 0; n < 4096; n++) {
2228             if (bitmask[n]) {
2229                 unsigned x = bitmask[n];
2230 #if defined(__LP64__)
2231                 for (i = 0; i < 32; i++) {
2232 #else
2233                 for (i = 0; i < 8; i++) {
2234 #endif
2235                     if (x & 1) {
2236                         count++;
2237                     }
2238                     x >>= 1;
2239                 }
2240             }
2241         }
2242         PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4);
2243     }
2244 #endif
2246 #if TIMING || STATS || COUNT_PAGES
2247     fflush(stdout);
2248 #endif
2250     TRACE("[ Ready to execute '%s' @ %p ]", si->name, reinterpret_cast<void*>(si->entry));
2251     return si->entry;
2254 /* Compute the load-bias of an existing executable. This shall only
2255  * be used to compute the load bias of an executable or shared library
2256  * that was loaded by the kernel itself.
2257  *
2258  * Input:
2259  *    elf    -> address of ELF header, assumed to be at the start of the file.
2260  * Return:
2261  *    load bias, i.e. add the value of any p_vaddr in the file to get
2262  *    the corresponding address in memory.
2263  */
2264 static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) {
2265   ElfW(Addr) offset = elf->e_phoff;
2266   const ElfW(Phdr)* phdr_table = reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
2267   const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;
2269   for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) {
2270     if (phdr->p_type == PT_LOAD) {
2271       return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;
2272     }
2273   }
2274   return 0;
2277 /*
2278  * This is the entry point for the linker, called from begin.S. This
2279  * method is responsible for fixing the linker's own relocations, and
2280  * then calling __linker_init_post_relocation().
2281  *
2282  * Because this method is called before the linker has fixed it's own
2283  * relocations, any attempt to reference an extern variable, extern
2284  * function, or other GOT reference will generate a segfault.
2285  */
2286 extern "C" ElfW(Addr) __linker_init(void* raw_args) {
2287   // Initialize static variables.
2288   solist = get_libdl_info();
2289   sonext = get_libdl_info();
2291   KernelArgumentBlock args(raw_args);
2293   ElfW(Addr) linker_addr = args.getauxval(AT_BASE);
2294   ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
2295   ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);
2297   soinfo linker_so;
2298   memset(&linker_so, 0, sizeof(soinfo));
2300   strcpy(linker_so.name, "[dynamic linker]");
2301   linker_so.base = linker_addr;
2302   linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
2303   linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
2304   linker_so.dynamic = NULL;
2305   linker_so.phdr = phdr;
2306   linker_so.phnum = elf_hdr->e_phnum;
2307   linker_so.flags |= FLAG_LINKER;
2309   if (!soinfo_link_image(&linker_so, NULL)) {
2310     // It would be nice to print an error message, but if the linker
2311     // can't link itself, there's no guarantee that we'll be able to
2312     // call write() (because it involves a GOT reference). We may as
2313     // well try though...
2314     const char* msg = "CANNOT LINK EXECUTABLE: ";
2315     write(2, msg, strlen(msg));
2316     write(2, __linker_dl_err_buf, strlen(__linker_dl_err_buf));
2317     write(2, "\n", 1);
2318     _exit(EXIT_FAILURE);
2319   }
2321   // We have successfully fixed our own relocations. It's safe to run
2322   // the main part of the linker now.
2323   args.abort_message_ptr = &g_abort_message;
2324   ElfW(Addr) start_address = __linker_init_post_relocation(args, linker_addr);
2326   protect_data(PROT_READ);
2328   // Return the address that the calling assembly stub should jump to.
2329   return start_address;