• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2016 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 "linker_soinfo.h"
30 
31 #include <dlfcn.h>
32 #include <elf.h>
33 #include <string.h>
34 #include <sys/stat.h>
35 #include <unistd.h>
36 
37 #include <async_safe/log.h>
38 
39 #include "linker.h"
40 #include "linker_config.h"
41 #include "linker_debug.h"
42 #include "linker_globals.h"
43 #include "linker_gnu_hash.h"
44 #include "linker_logger.h"
45 #include "linker_relocate.h"
46 #include "linker_utils.h"
47 
48 // Enable the slow lookup path if symbol lookups should be logged.
is_lookup_tracing_enabled()49 static bool is_lookup_tracing_enabled() {
50   return g_ld_debug_verbosity > LINKER_VERBOSITY_TRACE && DO_TRACE_LOOKUP;
51 }
52 
SymbolLookupList(soinfo * si)53 SymbolLookupList::SymbolLookupList(soinfo* si)
54     : sole_lib_(si->get_lookup_lib()), begin_(&sole_lib_), end_(&sole_lib_ + 1) {
55   CHECK(si != nullptr);
56   slow_path_count_ += is_lookup_tracing_enabled();
57   slow_path_count_ += sole_lib_.needs_sysv_lookup();
58 }
59 
SymbolLookupList(const soinfo_list_t & global_group,const soinfo_list_t & local_group)60 SymbolLookupList::SymbolLookupList(const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
61   slow_path_count_ += is_lookup_tracing_enabled();
62   libs_.reserve(1 + global_group.size() + local_group.size());
63 
64   // Reserve a space in front for DT_SYMBOLIC lookup.
65   libs_.push_back(SymbolLookupLib {});
66 
67   global_group.for_each([this](soinfo* si) {
68     libs_.push_back(si->get_lookup_lib());
69     slow_path_count_ += libs_.back().needs_sysv_lookup();
70   });
71 
72   local_group.for_each([this](soinfo* si) {
73     libs_.push_back(si->get_lookup_lib());
74     slow_path_count_ += libs_.back().needs_sysv_lookup();
75   });
76 
77   begin_ = &libs_[1];
78   end_ = &libs_[0] + libs_.size();
79 }
80 
81 /* "This element's presence in a shared object library alters the dynamic linker's
82  * symbol resolution algorithm for references within the library. Instead of starting
83  * a symbol search with the executable file, the dynamic linker starts from the shared
84  * object itself. If the shared object fails to supply the referenced symbol, the
85  * dynamic linker then searches the executable file and other shared objects as usual."
86  *
87  * http://www.sco.com/developers/gabi/2012-12-31/ch5.dynamic.html
88  *
89  * Note that this is unlikely since static linker avoids generating
90  * relocations for -Bsymbolic linked dynamic executables.
91  */
set_dt_symbolic_lib(soinfo * lib)92 void SymbolLookupList::set_dt_symbolic_lib(soinfo* lib) {
93   CHECK(!libs_.empty());
94   slow_path_count_ -= libs_[0].needs_sysv_lookup();
95   libs_[0] = lib ? lib->get_lookup_lib() : SymbolLookupLib();
96   slow_path_count_ += libs_[0].needs_sysv_lookup();
97   begin_ = lib ? &libs_[0] : &libs_[1];
98 }
99 
100 // Check whether a requested version matches the version on a symbol definition. There are a few
101 // special cases:
102 //  - If the defining DSO has no version info at all, then any version matches.
103 //  - If no version is requested (vi==nullptr, verneed==kVersymNotNeeded), then any non-hidden
104 //    version matches.
105 //  - If the requested version is not defined by the DSO, then verneed is kVersymGlobal, and only
106 //    global symbol definitions match. (This special case is handled as part of the ordinary case
107 //    where the version must match exactly.)
check_symbol_version(const ElfW (Versym)* ver_table,uint32_t sym_idx,const ElfW (Versym)verneed)108 static inline bool check_symbol_version(const ElfW(Versym)* ver_table, uint32_t sym_idx,
109                                         const ElfW(Versym) verneed) {
110   if (ver_table == nullptr) return true;
111   const uint32_t verdef = ver_table[sym_idx];
112   return (verneed == kVersymNotNeeded) ?
113       !(verdef & kVersymHiddenBit) :
114       verneed == (verdef & ~kVersymHiddenBit);
115 }
116 
117 template <bool IsGeneral>
ElfW(Sym)118 __attribute__((noinline)) static const ElfW(Sym)*
119 soinfo_do_lookup_impl(const char* name, const version_info* vi,
120                       soinfo** si_found_in, const SymbolLookupList& lookup_list) {
121   const auto [ hash, name_len ] = calculate_gnu_hash(name);
122   constexpr uint32_t kBloomMaskBits = sizeof(ElfW(Addr)) * 8;
123   SymbolName elf_symbol_name(name);
124 
125   const SymbolLookupLib* end = lookup_list.end();
126   const SymbolLookupLib* it = lookup_list.begin();
127 
128   while (true) {
129     const SymbolLookupLib* lib;
130     uint32_t sym_idx;
131 
132     // Iterate over libraries until we find one whose Bloom filter matches the symbol we're
133     // searching for.
134     while (true) {
135       if (it == end) return nullptr;
136       lib = it++;
137 
138       if (IsGeneral && lib->needs_sysv_lookup()) {
139         if (const ElfW(Sym)* sym = lib->si_->find_symbol_by_name(elf_symbol_name, vi)) {
140           *si_found_in = lib->si_;
141           return sym;
142         }
143         continue;
144       }
145 
146       if (IsGeneral) {
147         TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
148                    name, lib->si_->get_realpath(), reinterpret_cast<void*>(lib->si_->base));
149       }
150 
151       const uint32_t word_num = (hash / kBloomMaskBits) & lib->gnu_maskwords_;
152       const ElfW(Addr) bloom_word = lib->gnu_bloom_filter_[word_num];
153       const uint32_t h1 = hash % kBloomMaskBits;
154       const uint32_t h2 = (hash >> lib->gnu_shift2_) % kBloomMaskBits;
155 
156       if ((1 & (bloom_word >> h1) & (bloom_word >> h2)) == 1) {
157         sym_idx = lib->gnu_bucket_[hash % lib->gnu_nbucket_];
158         if (sym_idx != 0) {
159           break;
160         }
161       }
162 
163       if (IsGeneral) {
164         TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
165                    name, lib->si_->get_realpath(), reinterpret_cast<void*>(lib->si_->base));
166       }
167     }
168 
169     // Search the library's hash table chain.
170     ElfW(Versym) verneed = kVersymNotNeeded;
171     bool calculated_verneed = false;
172 
173     uint32_t chain_value = 0;
174     const ElfW(Sym)* sym = nullptr;
175 
176     do {
177       sym = lib->symtab_ + sym_idx;
178       chain_value = lib->gnu_chain_[sym_idx];
179       if ((chain_value >> 1) == (hash >> 1)) {
180         if (vi != nullptr && !calculated_verneed) {
181           calculated_verneed = true;
182           verneed = find_verdef_version_index(lib->si_, vi);
183         }
184         if (check_symbol_version(lib->versym_, sym_idx, verneed) &&
185             static_cast<size_t>(sym->st_name) + name_len + 1 <= lib->strtab_size_ &&
186             memcmp(lib->strtab_ + sym->st_name, name, name_len + 1) == 0 &&
187             is_symbol_global_and_defined(lib->si_, sym)) {
188           *si_found_in = lib->si_;
189           if (IsGeneral) {
190             TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
191                        name, lib->si_->get_realpath(), reinterpret_cast<void*>(sym->st_value),
192                        static_cast<size_t>(sym->st_size));
193           }
194           return sym;
195         }
196       }
197       ++sym_idx;
198     } while ((chain_value & 1) == 0);
199 
200     if (IsGeneral) {
201       TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
202                  name, lib->si_->get_realpath(), reinterpret_cast<void*>(lib->si_->base));
203     }
204   }
205 }
206 
ElfW(Sym)207 const ElfW(Sym)* soinfo_do_lookup(const char* name, const version_info* vi,
208                                   soinfo** si_found_in, const SymbolLookupList& lookup_list) {
209   return lookup_list.needs_slow_path() ?
210       soinfo_do_lookup_impl<true>(name, vi, si_found_in, lookup_list) :
211       soinfo_do_lookup_impl<false>(name, vi, si_found_in, lookup_list);
212 }
213 
soinfo(android_namespace_t * ns,const char * realpath,const struct stat * file_stat,off64_t file_offset,int rtld_flags)214 soinfo::soinfo(android_namespace_t* ns, const char* realpath, const struct stat* file_stat,
215                off64_t file_offset, int rtld_flags) {
216   if (realpath != nullptr) {
217     realpath_ = realpath;
218   }
219 
220   flags_ = FLAG_NEW_SOINFO;
221   version_ = SOINFO_VERSION;
222 
223   if (file_stat != nullptr) {
224     this->st_dev_ = file_stat->st_dev;
225     this->st_ino_ = file_stat->st_ino;
226     this->file_offset_ = file_offset;
227   }
228 
229   this->rtld_flags_ = rtld_flags;
230   this->primary_namespace_ = ns;
231 }
232 
~soinfo()233 soinfo::~soinfo() {
234   g_soinfo_handles_map.erase(handle_);
235 }
236 
set_dt_runpath(const char * path)237 void soinfo::set_dt_runpath(const char* path) {
238   if (!has_min_version(3)) {
239     return;
240   }
241 
242   std::vector<std::string> runpaths;
243 
244   split_path(path, ":", &runpaths);
245 
246   std::string origin = dirname(get_realpath());
247   // FIXME: add $PLATFORM.
248   std::vector<std::pair<std::string, std::string>> params = {
249     {"ORIGIN", origin},
250     {"LIB", kLibPath},
251   };
252   for (auto&& s : runpaths) {
253     format_string(&s, params);
254   }
255 
256   resolve_paths(runpaths, &dt_runpath_);
257 }
258 
ElfW(Versym)259 const ElfW(Versym)* soinfo::get_versym(size_t n) const {
260   auto table = get_versym_table();
261   return table ? table + n : nullptr;
262 }
263 
ElfW(Addr)264 ElfW(Addr) soinfo::get_verneed_ptr() const {
265   if (has_min_version(2)) {
266     return verneed_ptr_;
267   }
268 
269   return 0;
270 }
271 
get_verneed_cnt() const272 size_t soinfo::get_verneed_cnt() const {
273   if (has_min_version(2)) {
274     return verneed_cnt_;
275   }
276 
277   return 0;
278 }
279 
ElfW(Addr)280 ElfW(Addr) soinfo::get_verdef_ptr() const {
281   if (has_min_version(2)) {
282     return verdef_ptr_;
283   }
284 
285   return 0;
286 }
287 
get_verdef_cnt() const288 size_t soinfo::get_verdef_cnt() const {
289   if (has_min_version(2)) {
290     return verdef_cnt_;
291   }
292 
293   return 0;
294 }
295 
get_lookup_lib()296 SymbolLookupLib soinfo::get_lookup_lib() {
297   SymbolLookupLib result {};
298   result.si_ = this;
299 
300   // For libs that only have SysV hashes, leave the gnu_bloom_filter_ field NULL to signal that
301   // the fallback code path is needed.
302   if (!is_gnu_hash()) {
303     return result;
304   }
305 
306   result.gnu_maskwords_ = gnu_maskwords_;
307   result.gnu_shift2_ = gnu_shift2_;
308   result.gnu_bloom_filter_ = gnu_bloom_filter_;
309 
310   result.strtab_ = strtab_;
311   result.strtab_size_ = strtab_size_;
312   result.symtab_ = symtab_;
313   result.versym_ = get_versym_table();
314 
315   result.gnu_chain_ = gnu_chain_;
316   result.gnu_nbucket_ = gnu_nbucket_;
317   result.gnu_bucket_ = gnu_bucket_;
318 
319   return result;
320 }
321 
ElfW(Sym)322 const ElfW(Sym)* soinfo::find_symbol_by_name(SymbolName& symbol_name,
323                                              const version_info* vi) const {
324   return is_gnu_hash() ? gnu_lookup(symbol_name, vi) : elf_lookup(symbol_name, vi);
325 }
326 
ElfW(Sym)327 const ElfW(Sym)* soinfo::gnu_lookup(SymbolName& symbol_name, const version_info* vi) const {
328   const uint32_t hash = symbol_name.gnu_hash();
329 
330   constexpr uint32_t kBloomMaskBits = sizeof(ElfW(Addr)) * 8;
331   const uint32_t word_num = (hash / kBloomMaskBits) & gnu_maskwords_;
332   const ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
333   const uint32_t h1 = hash % kBloomMaskBits;
334   const uint32_t h2 = (hash >> gnu_shift2_) % kBloomMaskBits;
335 
336   TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
337       symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
338 
339   // test against bloom filter
340   if ((1 & (bloom_word >> h1) & (bloom_word >> h2)) == 0) {
341     TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
342         symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
343 
344     return nullptr;
345   }
346 
347   // bloom test says "probably yes"...
348   uint32_t n = gnu_bucket_[hash % gnu_nbucket_];
349 
350   if (n == 0) {
351     TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
352         symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
353 
354     return nullptr;
355   }
356 
357   const ElfW(Versym) verneed = find_verdef_version_index(this, vi);
358   const ElfW(Versym)* versym = get_versym_table();
359 
360   do {
361     ElfW(Sym)* s = symtab_ + n;
362     if (((gnu_chain_[n] ^ hash) >> 1) == 0 &&
363         check_symbol_version(versym, n, verneed) &&
364         strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
365         is_symbol_global_and_defined(this, s)) {
366       TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
367           symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value),
368           static_cast<size_t>(s->st_size));
369       return symtab_ + n;
370     }
371   } while ((gnu_chain_[n++] & 1) == 0);
372 
373   TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
374              symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
375 
376   return nullptr;
377 }
378 
ElfW(Sym)379 const ElfW(Sym)* soinfo::elf_lookup(SymbolName& symbol_name, const version_info* vi) const {
380   uint32_t hash = symbol_name.elf_hash();
381 
382   TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd",
383              symbol_name.get_name(), get_realpath(),
384              reinterpret_cast<void*>(base), hash, hash % nbucket_);
385 
386   const ElfW(Versym) verneed = find_verdef_version_index(this, vi);
387   const ElfW(Versym)* versym = get_versym_table();
388 
389   for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) {
390     ElfW(Sym)* s = symtab_ + n;
391 
392     if (check_symbol_version(versym, n, verneed) &&
393         strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
394         is_symbol_global_and_defined(this, s)) {
395       TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
396                  symbol_name.get_name(), get_realpath(),
397                  reinterpret_cast<void*>(s->st_value),
398                  static_cast<size_t>(s->st_size));
399       return symtab_ + n;
400     }
401   }
402 
403   TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
404              symbol_name.get_name(), get_realpath(),
405              reinterpret_cast<void*>(base), hash, hash % nbucket_);
406 
407   return nullptr;
408 }
409 
ElfW(Sym)410 ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) {
411   return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr);
412 }
413 
symbol_matches_soaddr(const ElfW (Sym)* sym,ElfW (Addr)soaddr)414 static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) {
415   // Skip TLS symbols. A TLS symbol's value is relative to the start of the TLS segment rather than
416   // to the start of the solib. The solib only reserves space for the initialized part of the TLS
417   // segment. (i.e. .tdata is followed by .tbss, and .tbss overlaps other sections.)
418   return sym->st_shndx != SHN_UNDEF &&
419       ELF_ST_TYPE(sym->st_info) != STT_TLS &&
420       soaddr >= sym->st_value &&
421       soaddr < sym->st_value + sym->st_size;
422 }
423 
ElfW(Sym)424 ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
425   ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
426 
427   for (size_t i = 0; i < gnu_nbucket_; ++i) {
428     uint32_t n = gnu_bucket_[i];
429 
430     if (n == 0) {
431       continue;
432     }
433 
434     do {
435       ElfW(Sym)* sym = symtab_ + n;
436       if (symbol_matches_soaddr(sym, soaddr)) {
437         return sym;
438       }
439     } while ((gnu_chain_[n++] & 1) == 0);
440   }
441 
442   return nullptr;
443 }
444 
ElfW(Sym)445 ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) {
446   ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
447 
448   // Search the library's symbol table for any defined symbol which
449   // contains this address.
450   for (size_t i = 0; i < nchain_; ++i) {
451     ElfW(Sym)* sym = symtab_ + i;
452     if (symbol_matches_soaddr(sym, soaddr)) {
453       return sym;
454     }
455   }
456 
457   return nullptr;
458 }
459 
call_function(const char * function_name __unused,linker_ctor_function_t function,const char * realpath __unused)460 static void call_function(const char* function_name __unused,
461                           linker_ctor_function_t function,
462                           const char* realpath __unused) {
463   if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
464     return;
465   }
466 
467   TRACE("[ Calling c-tor %s @ %p for '%s' ]", function_name, function, realpath);
468   function(g_argc, g_argv, g_envp);
469   TRACE("[ Done calling c-tor %s @ %p for '%s' ]", function_name, function, realpath);
470 }
471 
call_function(const char * function_name __unused,linker_dtor_function_t function,const char * realpath __unused)472 static void call_function(const char* function_name __unused,
473                           linker_dtor_function_t function,
474                           const char* realpath __unused) {
475   if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
476     return;
477   }
478 
479   TRACE("[ Calling d-tor %s @ %p for '%s' ]", function_name, function, realpath);
480   function();
481   TRACE("[ Done calling d-tor %s @ %p for '%s' ]", function_name, function, realpath);
482 }
483 
484 template <typename F>
call_array(const char * array_name __unused,F * functions,size_t count,bool reverse,const char * realpath)485 static inline void call_array(const char* array_name __unused, F* functions, size_t count,
486                               bool reverse, const char* realpath) {
487   if (functions == nullptr) {
488     return;
489   }
490 
491   TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, realpath);
492 
493   int begin = reverse ? (count - 1) : 0;
494   int end = reverse ? -1 : count;
495   int step = reverse ? -1 : 1;
496 
497   for (int i = begin; i != end; i += step) {
498     TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
499     call_function("function", functions[i], realpath);
500   }
501 
502   TRACE("[ Done calling %s for '%s' ]", array_name, realpath);
503 }
504 
call_pre_init_constructors()505 void soinfo::call_pre_init_constructors() {
506   // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
507   // but ignored in a shared library.
508   call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false, get_realpath());
509 }
510 
call_constructors()511 void soinfo::call_constructors() {
512   if (constructors_called) {
513     return;
514   }
515 
516   // We set constructors_called before actually calling the constructors, otherwise it doesn't
517   // protect against recursive constructor calls. One simple example of constructor recursion
518   // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
519   // 1. The program depends on libc, so libc's constructor is called here.
520   // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
521   // 3. dlopen() calls the constructors on the newly created
522   //    soinfo for libc_malloc_debug_leak.so.
523   // 4. The debug .so depends on libc, so CallConstructors is
524   //    called again with the libc soinfo. If it doesn't trigger the early-
525   //    out above, the libc constructor will be called again (recursively!).
526   constructors_called = true;
527 
528   if (!is_main_executable() && preinit_array_ != nullptr) {
529     // The GNU dynamic linker silently ignores these, but we warn the developer.
530     PRINT("\"%s\": ignoring DT_PREINIT_ARRAY in shared library!", get_realpath());
531   }
532 
533   get_children().for_each([] (soinfo* si) {
534     si->call_constructors();
535   });
536 
537   if (!is_linker()) {
538     bionic_trace_begin((std::string("calling constructors: ") + get_realpath()).c_str());
539   }
540 
541   // DT_INIT should be called before DT_INIT_ARRAY if both are present.
542   call_function("DT_INIT", init_func_, get_realpath());
543   call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false, get_realpath());
544 
545   if (!is_linker()) {
546     bionic_trace_end();
547   }
548 }
549 
call_destructors()550 void soinfo::call_destructors() {
551   if (!constructors_called) {
552     return;
553   }
554 
555   ScopedTrace trace((std::string("calling destructors: ") + get_realpath()).c_str());
556 
557   // DT_FINI_ARRAY must be parsed in reverse order.
558   call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true, get_realpath());
559 
560   // DT_FINI should be called after DT_FINI_ARRAY if both are present.
561   call_function("DT_FINI", fini_func_, get_realpath());
562 }
563 
add_child(soinfo * child)564 void soinfo::add_child(soinfo* child) {
565   if (has_min_version(0)) {
566     child->parents_.push_back(this);
567     this->children_.push_back(child);
568   }
569 }
570 
remove_all_links()571 void soinfo::remove_all_links() {
572   if (!has_min_version(0)) {
573     return;
574   }
575 
576   // 1. Untie connected soinfos from 'this'.
577   children_.for_each([&] (soinfo* child) {
578     child->parents_.remove_if([&] (const soinfo* parent) {
579       return parent == this;
580     });
581   });
582 
583   parents_.for_each([&] (soinfo* parent) {
584     parent->children_.remove_if([&] (const soinfo* child) {
585       return child == this;
586     });
587   });
588 
589   // 2. Remove from the primary namespace
590   primary_namespace_->remove_soinfo(this);
591   primary_namespace_ = nullptr;
592 
593   // 3. Remove from secondary namespaces
594   secondary_namespaces_.for_each([&](android_namespace_t* ns) {
595     ns->remove_soinfo(this);
596   });
597 
598 
599   // 4. Once everything untied - clear local lists.
600   parents_.clear();
601   children_.clear();
602   secondary_namespaces_.clear();
603 }
604 
get_st_dev() const605 dev_t soinfo::get_st_dev() const {
606   if (has_min_version(0)) {
607     return st_dev_;
608   }
609 
610   return 0;
611 };
612 
get_st_ino() const613 ino_t soinfo::get_st_ino() const {
614   if (has_min_version(0)) {
615     return st_ino_;
616   }
617 
618   return 0;
619 }
620 
get_file_offset() const621 off64_t soinfo::get_file_offset() const {
622   if (has_min_version(1)) {
623     return file_offset_;
624   }
625 
626   return 0;
627 }
628 
get_rtld_flags() const629 uint32_t soinfo::get_rtld_flags() const {
630   if (has_min_version(1)) {
631     return rtld_flags_;
632   }
633 
634   return 0;
635 }
636 
get_dt_flags_1() const637 uint32_t soinfo::get_dt_flags_1() const {
638   if (has_min_version(1)) {
639     return dt_flags_1_;
640   }
641 
642   return 0;
643 }
644 
set_dt_flags_1(uint32_t dt_flags_1)645 void soinfo::set_dt_flags_1(uint32_t dt_flags_1) {
646   if (has_min_version(1)) {
647     if ((dt_flags_1 & DF_1_GLOBAL) != 0) {
648       rtld_flags_ |= RTLD_GLOBAL;
649     }
650 
651     if ((dt_flags_1 & DF_1_NODELETE) != 0) {
652       rtld_flags_ |= RTLD_NODELETE;
653     }
654 
655     dt_flags_1_ = dt_flags_1;
656   }
657 }
658 
set_nodelete()659 void soinfo::set_nodelete() {
660   rtld_flags_ |= RTLD_NODELETE;
661 }
662 
set_realpath(const char * path)663 void soinfo::set_realpath(const char* path) {
664 #if defined(__work_around_b_24465209__)
665   if (has_min_version(2)) {
666     realpath_ = path;
667   }
668 #else
669   realpath_ = path;
670 #endif
671 }
672 
get_realpath() const673 const char* soinfo::get_realpath() const {
674 #if defined(__work_around_b_24465209__)
675   if (has_min_version(2)) {
676     return realpath_.c_str();
677   } else {
678     return old_name_;
679   }
680 #else
681   return realpath_.c_str();
682 #endif
683 }
684 
set_soname(const char * soname)685 void soinfo::set_soname(const char* soname) {
686 #if defined(__work_around_b_24465209__)
687   if (has_min_version(2)) {
688     soname_ = soname;
689   }
690   strlcpy(old_name_, soname_.c_str(), sizeof(old_name_));
691 #else
692   soname_ = soname;
693 #endif
694 }
695 
get_soname() const696 const char* soinfo::get_soname() const {
697 #if defined(__work_around_b_24465209__)
698   if (has_min_version(2)) {
699     return soname_.c_str();
700   } else {
701     return old_name_;
702   }
703 #else
704   return soname_.c_str();
705 #endif
706 }
707 
708 // This is a return on get_children()/get_parents() if
709 // 'this->flags' does not have FLAG_NEW_SOINFO set.
710 static soinfo_list_t g_empty_list;
711 
get_children()712 soinfo_list_t& soinfo::get_children() {
713   if (has_min_version(0)) {
714     return children_;
715   }
716 
717   return g_empty_list;
718 }
719 
get_children() const720 const soinfo_list_t& soinfo::get_children() const {
721   if (has_min_version(0)) {
722     return children_;
723   }
724 
725   return g_empty_list;
726 }
727 
get_parents()728 soinfo_list_t& soinfo::get_parents() {
729   if (has_min_version(0)) {
730     return parents_;
731   }
732 
733   return g_empty_list;
734 }
735 
736 static std::vector<std::string> g_empty_runpath;
737 
get_dt_runpath() const738 const std::vector<std::string>& soinfo::get_dt_runpath() const {
739   if (has_min_version(3)) {
740     return dt_runpath_;
741   }
742 
743   return g_empty_runpath;
744 }
745 
get_primary_namespace()746 android_namespace_t* soinfo::get_primary_namespace() {
747   if (has_min_version(3)) {
748     return primary_namespace_;
749   }
750 
751   return &g_default_namespace;
752 }
753 
add_secondary_namespace(android_namespace_t * secondary_ns)754 void soinfo::add_secondary_namespace(android_namespace_t* secondary_ns) {
755   CHECK(has_min_version(3));
756   secondary_namespaces_.push_back(secondary_ns);
757 }
758 
get_secondary_namespaces()759 android_namespace_list_t& soinfo::get_secondary_namespaces() {
760   CHECK(has_min_version(3));
761   return secondary_namespaces_;
762 }
763 
get_string(ElfW (Word)index) const764 const char* soinfo::get_string(ElfW(Word) index) const {
765   if (has_min_version(1) && (index >= strtab_size_)) {
766     async_safe_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d",
767         get_realpath(), strtab_size_, index);
768   }
769 
770   return strtab_ + index;
771 }
772 
is_gnu_hash() const773 bool soinfo::is_gnu_hash() const {
774   return (flags_ & FLAG_GNU_HASH) != 0;
775 }
776 
can_unload() const777 bool soinfo::can_unload() const {
778   return !is_linked() ||
779          (
780              (get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0
781          );
782 }
783 
is_linked() const784 bool soinfo::is_linked() const {
785   return (flags_ & FLAG_LINKED) != 0;
786 }
787 
is_image_linked() const788 bool soinfo::is_image_linked() const {
789   return (flags_ & FLAG_IMAGE_LINKED) != 0;
790 }
791 
is_main_executable() const792 bool soinfo::is_main_executable() const {
793   return (flags_ & FLAG_EXE) != 0;
794 }
795 
is_linker() const796 bool soinfo::is_linker() const {
797   return (flags_ & FLAG_LINKER) != 0;
798 }
799 
set_linked()800 void soinfo::set_linked() {
801   flags_ |= FLAG_LINKED;
802 }
803 
set_image_linked()804 void soinfo::set_image_linked() {
805   flags_ |= FLAG_IMAGE_LINKED;
806 }
807 
set_linker_flag()808 void soinfo::set_linker_flag() {
809   flags_ |= FLAG_LINKER;
810 }
811 
set_main_executable()812 void soinfo::set_main_executable() {
813   flags_ |= FLAG_EXE;
814 }
815 
increment_ref_count()816 size_t soinfo::increment_ref_count() {
817   return ++local_group_root_->ref_count_;
818 }
819 
decrement_ref_count()820 size_t soinfo::decrement_ref_count() {
821   return --local_group_root_->ref_count_;
822 }
823 
get_ref_count() const824 size_t soinfo::get_ref_count() const {
825   return local_group_root_->ref_count_;
826 }
827 
get_local_group_root() const828 soinfo* soinfo::get_local_group_root() const {
829   return local_group_root_;
830 }
831 
set_mapped_by_caller(bool mapped_by_caller)832 void soinfo::set_mapped_by_caller(bool mapped_by_caller) {
833   if (mapped_by_caller) {
834     flags_ |= FLAG_MAPPED_BY_CALLER;
835   } else {
836     flags_ &= ~FLAG_MAPPED_BY_CALLER;
837   }
838 }
839 
is_mapped_by_caller() const840 bool soinfo::is_mapped_by_caller() const {
841   return (flags_ & FLAG_MAPPED_BY_CALLER) != 0;
842 }
843 
844 // This function returns api-level at the time of
845 // dlopen/load. Note that libraries opened by system
846 // will always have 'current' api level.
get_target_sdk_version() const847 int soinfo::get_target_sdk_version() const {
848   if (!has_min_version(2)) {
849     return __ANDROID_API__;
850   }
851 
852   return local_group_root_->target_sdk_version_;
853 }
854 
get_handle() const855 uintptr_t soinfo::get_handle() const {
856   CHECK(has_min_version(3));
857   CHECK(handle_ != 0);
858   return handle_;
859 }
860 
to_handle()861 void* soinfo::to_handle() {
862   if (get_application_target_sdk_version() < 24 || !has_min_version(3)) {
863     return this;
864   }
865 
866   return reinterpret_cast<void*>(get_handle());
867 }
868 
generate_handle()869 void soinfo::generate_handle() {
870   CHECK(has_min_version(3));
871   CHECK(handle_ == 0); // Make sure this is the first call
872 
873   // Make sure the handle is unique and does not collide
874   // with special values which are RTLD_DEFAULT and RTLD_NEXT.
875   do {
876     if (!is_first_stage_init()) {
877       arc4random_buf(&handle_, sizeof(handle_));
878     } else {
879       // arc4random* is not available in init because /dev/urandom hasn't yet been
880       // created. So, when running with init, use the monotonically increasing
881       // numbers as handles
882       handle_ += 2;
883     }
884     // the least significant bit for the handle is always 1
885     // making it easy to test the type of handle passed to
886     // dl* functions.
887     handle_ = handle_ | 1;
888   } while (handle_ == reinterpret_cast<uintptr_t>(RTLD_DEFAULT) ||
889            handle_ == reinterpret_cast<uintptr_t>(RTLD_NEXT) ||
890            g_soinfo_handles_map.find(handle_) != g_soinfo_handles_map.end());
891 
892   g_soinfo_handles_map[handle_] = this;
893 }
894 
set_gap_start(ElfW (Addr)gap_start)895 void soinfo::set_gap_start(ElfW(Addr) gap_start) {
896   CHECK(has_min_version(6));
897   gap_start_ = gap_start;
898 }
ElfW(Addr)899 ElfW(Addr) soinfo::get_gap_start() const {
900   CHECK(has_min_version(6));
901   return gap_start_;
902 }
903 
set_gap_size(size_t gap_size)904 void soinfo::set_gap_size(size_t gap_size) {
905   CHECK(has_min_version(6));
906   gap_size_ = gap_size;
907 }
get_gap_size() const908 size_t soinfo::get_gap_size() const {
909   CHECK(has_min_version(6));
910   return gap_size_;
911 }
912 
913 // TODO(dimitry): Move SymbolName methods to a separate file.
914 
calculate_elf_hash(const char * name)915 uint32_t calculate_elf_hash(const char* name) {
916   const uint8_t* name_bytes = reinterpret_cast<const uint8_t*>(name);
917   uint32_t h = 0, g;
918 
919   while (*name_bytes) {
920     h = (h << 4) + *name_bytes++;
921     g = h & 0xf0000000;
922     h ^= g;
923     h ^= g >> 24;
924   }
925 
926   return h;
927 }
928 
elf_hash()929 uint32_t SymbolName::elf_hash() {
930   if (!has_elf_hash_) {
931     elf_hash_ = calculate_elf_hash(name_);
932     has_elf_hash_ = true;
933   }
934 
935   return elf_hash_;
936 }
937 
gnu_hash()938 uint32_t SymbolName::gnu_hash() {
939   if (!has_gnu_hash_) {
940     gnu_hash_ = calculate_gnu_hash(name_).first;
941     has_gnu_hash_ = true;
942   }
943 
944   return gnu_hash_;
945 }
946