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,
215 const struct stat* file_stat, off64_t file_offset,
216 int rtld_flags) {
217 memset(this, 0, sizeof(*this));
218
219 if (realpath != nullptr) {
220 realpath_ = realpath;
221 }
222
223 flags_ = FLAG_NEW_SOINFO;
224 version_ = SOINFO_VERSION;
225
226 if (file_stat != nullptr) {
227 this->st_dev_ = file_stat->st_dev;
228 this->st_ino_ = file_stat->st_ino;
229 this->file_offset_ = file_offset;
230 }
231
232 this->rtld_flags_ = rtld_flags;
233 this->primary_namespace_ = ns;
234 }
235
~soinfo()236 soinfo::~soinfo() {
237 g_soinfo_handles_map.erase(handle_);
238 }
239
set_dt_runpath(const char * path)240 void soinfo::set_dt_runpath(const char* path) {
241 if (!has_min_version(3)) {
242 return;
243 }
244
245 std::vector<std::string> runpaths;
246
247 split_path(path, ":", &runpaths);
248
249 std::string origin = dirname(get_realpath());
250 // FIXME: add $PLATFORM.
251 std::vector<std::pair<std::string, std::string>> params = {
252 {"ORIGIN", origin},
253 {"LIB", kLibPath},
254 };
255 for (auto&& s : runpaths) {
256 format_string(&s, params);
257 }
258
259 resolve_paths(runpaths, &dt_runpath_);
260 }
261
ElfW(Versym)262 const ElfW(Versym)* soinfo::get_versym(size_t n) const {
263 auto table = get_versym_table();
264 return table ? table + n : nullptr;
265 }
266
ElfW(Addr)267 ElfW(Addr) soinfo::get_verneed_ptr() const {
268 if (has_min_version(2)) {
269 return verneed_ptr_;
270 }
271
272 return 0;
273 }
274
get_verneed_cnt() const275 size_t soinfo::get_verneed_cnt() const {
276 if (has_min_version(2)) {
277 return verneed_cnt_;
278 }
279
280 return 0;
281 }
282
ElfW(Addr)283 ElfW(Addr) soinfo::get_verdef_ptr() const {
284 if (has_min_version(2)) {
285 return verdef_ptr_;
286 }
287
288 return 0;
289 }
290
get_verdef_cnt() const291 size_t soinfo::get_verdef_cnt() const {
292 if (has_min_version(2)) {
293 return verdef_cnt_;
294 }
295
296 return 0;
297 }
298
get_lookup_lib()299 SymbolLookupLib soinfo::get_lookup_lib() {
300 SymbolLookupLib result {};
301 result.si_ = this;
302
303 // For libs that only have SysV hashes, leave the gnu_bloom_filter_ field NULL to signal that
304 // the fallback code path is needed.
305 if (!is_gnu_hash()) {
306 return result;
307 }
308
309 result.gnu_maskwords_ = gnu_maskwords_;
310 result.gnu_shift2_ = gnu_shift2_;
311 result.gnu_bloom_filter_ = gnu_bloom_filter_;
312
313 result.strtab_ = strtab_;
314 result.strtab_size_ = strtab_size_;
315 result.symtab_ = symtab_;
316 result.versym_ = get_versym_table();
317
318 result.gnu_chain_ = gnu_chain_;
319 result.gnu_nbucket_ = gnu_nbucket_;
320 result.gnu_bucket_ = gnu_bucket_;
321
322 return result;
323 }
324
ElfW(Sym)325 const ElfW(Sym)* soinfo::find_symbol_by_name(SymbolName& symbol_name,
326 const version_info* vi) const {
327 return is_gnu_hash() ? gnu_lookup(symbol_name, vi) : elf_lookup(symbol_name, vi);
328 }
329
ElfW(Sym)330 const ElfW(Sym)* soinfo::gnu_lookup(SymbolName& symbol_name, const version_info* vi) const {
331 const uint32_t hash = symbol_name.gnu_hash();
332
333 constexpr uint32_t kBloomMaskBits = sizeof(ElfW(Addr)) * 8;
334 const uint32_t word_num = (hash / kBloomMaskBits) & gnu_maskwords_;
335 const ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
336 const uint32_t h1 = hash % kBloomMaskBits;
337 const uint32_t h2 = (hash >> gnu_shift2_) % kBloomMaskBits;
338
339 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
340 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
341
342 // test against bloom filter
343 if ((1 & (bloom_word >> h1) & (bloom_word >> h2)) == 0) {
344 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
345 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
346
347 return nullptr;
348 }
349
350 // bloom test says "probably yes"...
351 uint32_t n = gnu_bucket_[hash % gnu_nbucket_];
352
353 if (n == 0) {
354 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
355 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
356
357 return nullptr;
358 }
359
360 const ElfW(Versym) verneed = find_verdef_version_index(this, vi);
361 const ElfW(Versym)* versym = get_versym_table();
362
363 do {
364 ElfW(Sym)* s = symtab_ + n;
365 if (((gnu_chain_[n] ^ hash) >> 1) == 0 &&
366 check_symbol_version(versym, n, verneed) &&
367 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
368 is_symbol_global_and_defined(this, s)) {
369 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
370 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value),
371 static_cast<size_t>(s->st_size));
372 return symtab_ + n;
373 }
374 } while ((gnu_chain_[n++] & 1) == 0);
375
376 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
377 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
378
379 return nullptr;
380 }
381
ElfW(Sym)382 const ElfW(Sym)* soinfo::elf_lookup(SymbolName& symbol_name, const version_info* vi) const {
383 uint32_t hash = symbol_name.elf_hash();
384
385 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd",
386 symbol_name.get_name(), get_realpath(),
387 reinterpret_cast<void*>(base), hash, hash % nbucket_);
388
389 const ElfW(Versym) verneed = find_verdef_version_index(this, vi);
390 const ElfW(Versym)* versym = get_versym_table();
391
392 for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) {
393 ElfW(Sym)* s = symtab_ + n;
394
395 if (check_symbol_version(versym, n, verneed) &&
396 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
397 is_symbol_global_and_defined(this, s)) {
398 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
399 symbol_name.get_name(), get_realpath(),
400 reinterpret_cast<void*>(s->st_value),
401 static_cast<size_t>(s->st_size));
402 return symtab_ + n;
403 }
404 }
405
406 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
407 symbol_name.get_name(), get_realpath(),
408 reinterpret_cast<void*>(base), hash, hash % nbucket_);
409
410 return nullptr;
411 }
412
ElfW(Sym)413 ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) {
414 return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr);
415 }
416
symbol_matches_soaddr(const ElfW (Sym)* sym,ElfW (Addr)soaddr)417 static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) {
418 // Skip TLS symbols. A TLS symbol's value is relative to the start of the TLS segment rather than
419 // to the start of the solib. The solib only reserves space for the initialized part of the TLS
420 // segment. (i.e. .tdata is followed by .tbss, and .tbss overlaps other sections.)
421 return sym->st_shndx != SHN_UNDEF &&
422 ELF_ST_TYPE(sym->st_info) != STT_TLS &&
423 soaddr >= sym->st_value &&
424 soaddr < sym->st_value + sym->st_size;
425 }
426
ElfW(Sym)427 ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
428 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
429
430 for (size_t i = 0; i < gnu_nbucket_; ++i) {
431 uint32_t n = gnu_bucket_[i];
432
433 if (n == 0) {
434 continue;
435 }
436
437 do {
438 ElfW(Sym)* sym = symtab_ + n;
439 if (symbol_matches_soaddr(sym, soaddr)) {
440 return sym;
441 }
442 } while ((gnu_chain_[n++] & 1) == 0);
443 }
444
445 return nullptr;
446 }
447
ElfW(Sym)448 ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) {
449 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
450
451 // Search the library's symbol table for any defined symbol which
452 // contains this address.
453 for (size_t i = 0; i < nchain_; ++i) {
454 ElfW(Sym)* sym = symtab_ + i;
455 if (symbol_matches_soaddr(sym, soaddr)) {
456 return sym;
457 }
458 }
459
460 return nullptr;
461 }
462
call_function(const char * function_name __unused,linker_ctor_function_t function,const char * realpath __unused)463 static void call_function(const char* function_name __unused,
464 linker_ctor_function_t function,
465 const char* realpath __unused) {
466 if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
467 return;
468 }
469
470 TRACE("[ Calling c-tor %s @ %p for '%s' ]", function_name, function, realpath);
471 function(g_argc, g_argv, g_envp);
472 TRACE("[ Done calling c-tor %s @ %p for '%s' ]", function_name, function, realpath);
473 }
474
call_function(const char * function_name __unused,linker_dtor_function_t function,const char * realpath __unused)475 static void call_function(const char* function_name __unused,
476 linker_dtor_function_t function,
477 const char* realpath __unused) {
478 if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
479 return;
480 }
481
482 TRACE("[ Calling d-tor %s @ %p for '%s' ]", function_name, function, realpath);
483 function();
484 TRACE("[ Done calling d-tor %s @ %p for '%s' ]", function_name, function, realpath);
485 }
486
487 template <typename F>
call_array(const char * array_name __unused,F * functions,size_t count,bool reverse,const char * realpath)488 static inline void call_array(const char* array_name __unused, F* functions, size_t count,
489 bool reverse, const char* realpath) {
490 if (functions == nullptr) {
491 return;
492 }
493
494 TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, realpath);
495
496 int begin = reverse ? (count - 1) : 0;
497 int end = reverse ? -1 : count;
498 int step = reverse ? -1 : 1;
499
500 for (int i = begin; i != end; i += step) {
501 TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
502 call_function("function", functions[i], realpath);
503 }
504
505 TRACE("[ Done calling %s for '%s' ]", array_name, realpath);
506 }
507
call_pre_init_constructors()508 void soinfo::call_pre_init_constructors() {
509 if (g_is_ldd) return;
510
511 // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
512 // but ignored in a shared library.
513 call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false, get_realpath());
514 }
515
call_constructors()516 void soinfo::call_constructors() {
517 if (constructors_called || g_is_ldd) {
518 return;
519 }
520
521 // We set constructors_called before actually calling the constructors, otherwise it doesn't
522 // protect against recursive constructor calls. One simple example of constructor recursion
523 // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
524 // 1. The program depends on libc, so libc's constructor is called here.
525 // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
526 // 3. dlopen() calls the constructors on the newly created
527 // soinfo for libc_malloc_debug_leak.so.
528 // 4. The debug .so depends on libc, so CallConstructors is
529 // called again with the libc soinfo. If it doesn't trigger the early-
530 // out above, the libc constructor will be called again (recursively!).
531 constructors_called = true;
532
533 if (!is_main_executable() && preinit_array_ != nullptr) {
534 // The GNU dynamic linker silently ignores these, but we warn the developer.
535 PRINT("\"%s\": ignoring DT_PREINIT_ARRAY in shared library!", get_realpath());
536 }
537
538 get_children().for_each([] (soinfo* si) {
539 si->call_constructors();
540 });
541
542 if (!is_linker()) {
543 bionic_trace_begin((std::string("calling constructors: ") + get_realpath()).c_str());
544 }
545
546 // DT_INIT should be called before DT_INIT_ARRAY if both are present.
547 call_function("DT_INIT", init_func_, get_realpath());
548 call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false, get_realpath());
549
550 if (!is_linker()) {
551 bionic_trace_end();
552 }
553 }
554
call_destructors()555 void soinfo::call_destructors() {
556 if (!constructors_called) {
557 return;
558 }
559
560 ScopedTrace trace((std::string("calling destructors: ") + get_realpath()).c_str());
561
562 // DT_FINI_ARRAY must be parsed in reverse order.
563 call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true, get_realpath());
564
565 // DT_FINI should be called after DT_FINI_ARRAY if both are present.
566 call_function("DT_FINI", fini_func_, get_realpath());
567 }
568
add_child(soinfo * child)569 void soinfo::add_child(soinfo* child) {
570 if (has_min_version(0)) {
571 child->parents_.push_back(this);
572 this->children_.push_back(child);
573 }
574 }
575
remove_all_links()576 void soinfo::remove_all_links() {
577 if (!has_min_version(0)) {
578 return;
579 }
580
581 // 1. Untie connected soinfos from 'this'.
582 children_.for_each([&] (soinfo* child) {
583 child->parents_.remove_if([&] (const soinfo* parent) {
584 return parent == this;
585 });
586 });
587
588 parents_.for_each([&] (soinfo* parent) {
589 parent->children_.remove_if([&] (const soinfo* child) {
590 return child == this;
591 });
592 });
593
594 // 2. Remove from the primary namespace
595 primary_namespace_->remove_soinfo(this);
596 primary_namespace_ = nullptr;
597
598 // 3. Remove from secondary namespaces
599 secondary_namespaces_.for_each([&](android_namespace_t* ns) {
600 ns->remove_soinfo(this);
601 });
602
603
604 // 4. Once everything untied - clear local lists.
605 parents_.clear();
606 children_.clear();
607 secondary_namespaces_.clear();
608 }
609
get_st_dev() const610 dev_t soinfo::get_st_dev() const {
611 if (has_min_version(0)) {
612 return st_dev_;
613 }
614
615 return 0;
616 };
617
get_st_ino() const618 ino_t soinfo::get_st_ino() const {
619 if (has_min_version(0)) {
620 return st_ino_;
621 }
622
623 return 0;
624 }
625
get_file_offset() const626 off64_t soinfo::get_file_offset() const {
627 if (has_min_version(1)) {
628 return file_offset_;
629 }
630
631 return 0;
632 }
633
get_rtld_flags() const634 uint32_t soinfo::get_rtld_flags() const {
635 if (has_min_version(1)) {
636 return rtld_flags_;
637 }
638
639 return 0;
640 }
641
get_dt_flags_1() const642 uint32_t soinfo::get_dt_flags_1() const {
643 if (has_min_version(1)) {
644 return dt_flags_1_;
645 }
646
647 return 0;
648 }
649
set_dt_flags_1(uint32_t dt_flags_1)650 void soinfo::set_dt_flags_1(uint32_t dt_flags_1) {
651 if (has_min_version(1)) {
652 if ((dt_flags_1 & DF_1_GLOBAL) != 0) {
653 rtld_flags_ |= RTLD_GLOBAL;
654 }
655
656 if ((dt_flags_1 & DF_1_NODELETE) != 0) {
657 rtld_flags_ |= RTLD_NODELETE;
658 }
659
660 dt_flags_1_ = dt_flags_1;
661 }
662 }
663
set_nodelete()664 void soinfo::set_nodelete() {
665 rtld_flags_ |= RTLD_NODELETE;
666 }
667
set_realpath(const char * path)668 void soinfo::set_realpath(const char* path) {
669 #if defined(__work_around_b_24465209__)
670 if (has_min_version(2)) {
671 realpath_ = path;
672 }
673 #else
674 realpath_ = path;
675 #endif
676 }
677
get_realpath() const678 const char* soinfo::get_realpath() const {
679 #if defined(__work_around_b_24465209__)
680 if (has_min_version(2)) {
681 return realpath_.c_str();
682 } else {
683 return old_name_;
684 }
685 #else
686 return realpath_.c_str();
687 #endif
688 }
689
set_soname(const char * soname)690 void soinfo::set_soname(const char* soname) {
691 #if defined(__work_around_b_24465209__)
692 if (has_min_version(2)) {
693 soname_ = soname;
694 }
695 strlcpy(old_name_, soname_.c_str(), sizeof(old_name_));
696 #else
697 soname_ = soname;
698 #endif
699 }
700
get_soname() const701 const char* soinfo::get_soname() const {
702 #if defined(__work_around_b_24465209__)
703 if (has_min_version(2)) {
704 return soname_.c_str();
705 } else {
706 return old_name_;
707 }
708 #else
709 return soname_.c_str();
710 #endif
711 }
712
713 // This is a return on get_children()/get_parents() if
714 // 'this->flags' does not have FLAG_NEW_SOINFO set.
715 static soinfo_list_t g_empty_list;
716
get_children()717 soinfo_list_t& soinfo::get_children() {
718 if (has_min_version(0)) {
719 return children_;
720 }
721
722 return g_empty_list;
723 }
724
get_children() const725 const soinfo_list_t& soinfo::get_children() const {
726 if (has_min_version(0)) {
727 return children_;
728 }
729
730 return g_empty_list;
731 }
732
get_parents()733 soinfo_list_t& soinfo::get_parents() {
734 if (has_min_version(0)) {
735 return parents_;
736 }
737
738 return g_empty_list;
739 }
740
741 static std::vector<std::string> g_empty_runpath;
742
get_dt_runpath() const743 const std::vector<std::string>& soinfo::get_dt_runpath() const {
744 if (has_min_version(3)) {
745 return dt_runpath_;
746 }
747
748 return g_empty_runpath;
749 }
750
get_primary_namespace()751 android_namespace_t* soinfo::get_primary_namespace() {
752 if (has_min_version(3)) {
753 return primary_namespace_;
754 }
755
756 return &g_default_namespace;
757 }
758
add_secondary_namespace(android_namespace_t * secondary_ns)759 void soinfo::add_secondary_namespace(android_namespace_t* secondary_ns) {
760 CHECK(has_min_version(3));
761 secondary_namespaces_.push_back(secondary_ns);
762 }
763
get_secondary_namespaces()764 android_namespace_list_t& soinfo::get_secondary_namespaces() {
765 CHECK(has_min_version(3));
766 return secondary_namespaces_;
767 }
768
get_string(ElfW (Word)index) const769 const char* soinfo::get_string(ElfW(Word) index) const {
770 if (has_min_version(1) && (index >= strtab_size_)) {
771 async_safe_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d",
772 get_realpath(), strtab_size_, index);
773 }
774
775 return strtab_ + index;
776 }
777
is_gnu_hash() const778 bool soinfo::is_gnu_hash() const {
779 return (flags_ & FLAG_GNU_HASH) != 0;
780 }
781
can_unload() const782 bool soinfo::can_unload() const {
783 return !is_linked() ||
784 (
785 (get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0
786 );
787 }
788
is_linked() const789 bool soinfo::is_linked() const {
790 return (flags_ & FLAG_LINKED) != 0;
791 }
792
is_image_linked() const793 bool soinfo::is_image_linked() const {
794 return (flags_ & FLAG_IMAGE_LINKED) != 0;
795 }
796
is_main_executable() const797 bool soinfo::is_main_executable() const {
798 return (flags_ & FLAG_EXE) != 0;
799 }
800
is_linker() const801 bool soinfo::is_linker() const {
802 return (flags_ & FLAG_LINKER) != 0;
803 }
804
set_linked()805 void soinfo::set_linked() {
806 flags_ |= FLAG_LINKED;
807 }
808
set_image_linked()809 void soinfo::set_image_linked() {
810 flags_ |= FLAG_IMAGE_LINKED;
811 }
812
set_linker_flag()813 void soinfo::set_linker_flag() {
814 flags_ |= FLAG_LINKER;
815 }
816
set_main_executable()817 void soinfo::set_main_executable() {
818 flags_ |= FLAG_EXE;
819 }
820
increment_ref_count()821 size_t soinfo::increment_ref_count() {
822 return ++local_group_root_->ref_count_;
823 }
824
decrement_ref_count()825 size_t soinfo::decrement_ref_count() {
826 return --local_group_root_->ref_count_;
827 }
828
get_ref_count() const829 size_t soinfo::get_ref_count() const {
830 return local_group_root_->ref_count_;
831 }
832
get_local_group_root() const833 soinfo* soinfo::get_local_group_root() const {
834 return local_group_root_;
835 }
836
set_mapped_by_caller(bool mapped_by_caller)837 void soinfo::set_mapped_by_caller(bool mapped_by_caller) {
838 if (mapped_by_caller) {
839 flags_ |= FLAG_MAPPED_BY_CALLER;
840 } else {
841 flags_ &= ~FLAG_MAPPED_BY_CALLER;
842 }
843 }
844
is_mapped_by_caller() const845 bool soinfo::is_mapped_by_caller() const {
846 return (flags_ & FLAG_MAPPED_BY_CALLER) != 0;
847 }
848
849 // This function returns api-level at the time of
850 // dlopen/load. Note that libraries opened by system
851 // will always have 'current' api level.
get_target_sdk_version() const852 int soinfo::get_target_sdk_version() const {
853 if (!has_min_version(2)) {
854 return __ANDROID_API__;
855 }
856
857 return local_group_root_->target_sdk_version_;
858 }
859
get_handle() const860 uintptr_t soinfo::get_handle() const {
861 CHECK(has_min_version(3));
862 CHECK(handle_ != 0);
863 return handle_;
864 }
865
to_handle()866 void* soinfo::to_handle() {
867 if (get_application_target_sdk_version() < 24 || !has_min_version(3)) {
868 return this;
869 }
870
871 return reinterpret_cast<void*>(get_handle());
872 }
873
generate_handle()874 void soinfo::generate_handle() {
875 CHECK(has_min_version(3));
876 CHECK(handle_ == 0); // Make sure this is the first call
877
878 // Make sure the handle is unique and does not collide
879 // with special values which are RTLD_DEFAULT and RTLD_NEXT.
880 do {
881 if (!is_first_stage_init()) {
882 arc4random_buf(&handle_, sizeof(handle_));
883 } else {
884 // arc4random* is not available in init because /dev/urandom hasn't yet been
885 // created. So, when running with init, use the monotonically increasing
886 // numbers as handles
887 handle_ += 2;
888 }
889 // the least significant bit for the handle is always 1
890 // making it easy to test the type of handle passed to
891 // dl* functions.
892 handle_ = handle_ | 1;
893 } while (handle_ == reinterpret_cast<uintptr_t>(RTLD_DEFAULT) ||
894 handle_ == reinterpret_cast<uintptr_t>(RTLD_NEXT) ||
895 g_soinfo_handles_map.find(handle_) != g_soinfo_handles_map.end());
896
897 g_soinfo_handles_map[handle_] = this;
898 }
899
set_gap_start(ElfW (Addr)gap_start)900 void soinfo::set_gap_start(ElfW(Addr) gap_start) {
901 CHECK(has_min_version(6));
902 gap_start_ = gap_start;
903 }
ElfW(Addr)904 ElfW(Addr) soinfo::get_gap_start() const {
905 CHECK(has_min_version(6));
906 return gap_start_;
907 }
908
set_gap_size(size_t gap_size)909 void soinfo::set_gap_size(size_t gap_size) {
910 CHECK(has_min_version(6));
911 gap_size_ = gap_size;
912 }
get_gap_size() const913 size_t soinfo::get_gap_size() const {
914 CHECK(has_min_version(6));
915 return gap_size_;
916 }
917
918 // TODO(dimitry): Move SymbolName methods to a separate file.
919
calculate_elf_hash(const char * name)920 uint32_t calculate_elf_hash(const char* name) {
921 const uint8_t* name_bytes = reinterpret_cast<const uint8_t*>(name);
922 uint32_t h = 0, g;
923
924 while (*name_bytes) {
925 h = (h << 4) + *name_bytes++;
926 g = h & 0xf0000000;
927 h ^= g;
928 h ^= g >> 24;
929 }
930
931 return h;
932 }
933
elf_hash()934 uint32_t SymbolName::elf_hash() {
935 if (!has_elf_hash_) {
936 elf_hash_ = calculate_elf_hash(name_);
937 has_elf_hash_ = true;
938 }
939
940 return elf_hash_;
941 }
942
gnu_hash()943 uint32_t SymbolName::gnu_hash() {
944 if (!has_gnu_hash_) {
945 gnu_hash_ = calculate_gnu_hash(name_).first;
946 has_gnu_hash_ = true;
947 }
948
949 return gnu_hash_;
950 }
951