| /* |
| * Copyright (C) 2016 The Android Open Source Project |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
| * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
| * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| */ |
| |
| #include "linker_soinfo.h" |
| |
| #include <dlfcn.h> |
| #include <elf.h> |
| #include <string.h> |
| #include <sys/stat.h> |
| #include <unistd.h> |
| |
| #include <async_safe/log.h> |
| |
| #include "linker_debug.h" |
| #include "linker_globals.h" |
| #include "linker_logger.h" |
| #include "linker_utils.h" |
| |
| // TODO(dimitry): These functions are currently located in linker.cpp - find a better place for it |
| bool find_verdef_version_index(const soinfo* si, const version_info* vi, ElfW(Versym)* versym); |
| ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr); |
| uint32_t get_application_target_sdk_version(); |
| |
| soinfo::soinfo(android_namespace_t* ns, const char* realpath, |
| const struct stat* file_stat, off64_t file_offset, |
| int rtld_flags) { |
| memset(this, 0, sizeof(*this)); |
| |
| if (realpath != nullptr) { |
| realpath_ = realpath; |
| } |
| |
| flags_ = FLAG_NEW_SOINFO; |
| version_ = SOINFO_VERSION; |
| |
| if (file_stat != nullptr) { |
| this->st_dev_ = file_stat->st_dev; |
| this->st_ino_ = file_stat->st_ino; |
| this->file_offset_ = file_offset; |
| } |
| |
| this->rtld_flags_ = rtld_flags; |
| this->primary_namespace_ = ns; |
| } |
| |
| soinfo::~soinfo() { |
| g_soinfo_handles_map.erase(handle_); |
| } |
| |
| void soinfo::set_dt_runpath(const char* path) { |
| if (!has_min_version(3)) { |
| return; |
| } |
| |
| std::vector<std::string> runpaths; |
| |
| split_path(path, ":", &runpaths); |
| |
| std::string origin = dirname(get_realpath()); |
| // FIXME: add $LIB and $PLATFORM. |
| std::vector<std::pair<std::string, std::string>> params = {{"ORIGIN", origin}}; |
| for (auto&& s : runpaths) { |
| format_string(&s, params); |
| } |
| |
| resolve_paths(runpaths, &dt_runpath_); |
| } |
| |
| const ElfW(Versym)* soinfo::get_versym(size_t n) const { |
| if (has_min_version(2) && versym_ != nullptr) { |
| return versym_ + n; |
| } |
| |
| return nullptr; |
| } |
| |
| ElfW(Addr) soinfo::get_verneed_ptr() const { |
| if (has_min_version(2)) { |
| return verneed_ptr_; |
| } |
| |
| return 0; |
| } |
| |
| size_t soinfo::get_verneed_cnt() const { |
| if (has_min_version(2)) { |
| return verneed_cnt_; |
| } |
| |
| return 0; |
| } |
| |
| ElfW(Addr) soinfo::get_verdef_ptr() const { |
| if (has_min_version(2)) { |
| return verdef_ptr_; |
| } |
| |
| return 0; |
| } |
| |
| size_t soinfo::get_verdef_cnt() const { |
| if (has_min_version(2)) { |
| return verdef_cnt_; |
| } |
| |
| return 0; |
| } |
| |
| bool soinfo::find_symbol_by_name(SymbolName& symbol_name, |
| const version_info* vi, |
| const ElfW(Sym)** symbol) const { |
| uint32_t symbol_index; |
| bool success = |
| is_gnu_hash() ? |
| gnu_lookup(symbol_name, vi, &symbol_index) : |
| elf_lookup(symbol_name, vi, &symbol_index); |
| |
| if (success) { |
| *symbol = symbol_index == 0 ? nullptr : symtab_ + symbol_index; |
| } |
| |
| return success; |
| } |
| |
| static bool is_symbol_global_and_defined(const soinfo* si, const ElfW(Sym)* s) { |
| if (ELF_ST_BIND(s->st_info) == STB_GLOBAL || |
| ELF_ST_BIND(s->st_info) == STB_WEAK) { |
| return s->st_shndx != SHN_UNDEF; |
| } else if (ELF_ST_BIND(s->st_info) != STB_LOCAL) { |
| DL_WARN("Warning: unexpected ST_BIND value: %d for \"%s\" in \"%s\" (ignoring)", |
| ELF_ST_BIND(s->st_info), si->get_string(s->st_name), si->get_realpath()); |
| } |
| |
| return false; |
| } |
| |
| static const ElfW(Versym) kVersymHiddenBit = 0x8000; |
| |
| static inline bool is_versym_hidden(const ElfW(Versym)* versym) { |
| // the symbol is hidden if bit 15 of versym is set. |
| return versym != nullptr && (*versym & kVersymHiddenBit) != 0; |
| } |
| |
| static inline bool check_symbol_version(const ElfW(Versym) verneed, |
| const ElfW(Versym)* verdef) { |
| return verneed == kVersymNotNeeded || |
| verdef == nullptr || |
| verneed == (*verdef & ~kVersymHiddenBit); |
| } |
| |
| bool soinfo::gnu_lookup(SymbolName& symbol_name, |
| const version_info* vi, |
| uint32_t* symbol_index) const { |
| uint32_t hash = symbol_name.gnu_hash(); |
| uint32_t h2 = hash >> gnu_shift2_; |
| |
| uint32_t bloom_mask_bits = sizeof(ElfW(Addr))*8; |
| uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_; |
| ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num]; |
| |
| *symbol_index = 0; |
| |
| TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)", |
| symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
| |
| // test against bloom filter |
| if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) { |
| TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
| symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
| |
| return true; |
| } |
| |
| // bloom test says "probably yes"... |
| uint32_t n = gnu_bucket_[hash % gnu_nbucket_]; |
| |
| if (n == 0) { |
| TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
| symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
| |
| return true; |
| } |
| |
| // lookup versym for the version definition in this library |
| // note the difference between "version is not requested" (vi == nullptr) |
| // and "version not found". In the first case verneed is kVersymNotNeeded |
| // which implies that the default version can be accepted; the second case results in |
| // verneed = 1 (kVersymGlobal) and implies that we should ignore versioned symbols |
| // for this library and consider only *global* ones. |
| ElfW(Versym) verneed = 0; |
| if (!find_verdef_version_index(this, vi, &verneed)) { |
| return false; |
| } |
| |
| do { |
| ElfW(Sym)* s = symtab_ + n; |
| const ElfW(Versym)* verdef = get_versym(n); |
| // skip hidden versions when verneed == kVersymNotNeeded (0) |
| if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) { |
| continue; |
| } |
| if (((gnu_chain_[n] ^ hash) >> 1) == 0 && |
| check_symbol_version(verneed, verdef) && |
| strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 && |
| is_symbol_global_and_defined(this, s)) { |
| TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd", |
| symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value), |
| static_cast<size_t>(s->st_size)); |
| *symbol_index = n; |
| return true; |
| } |
| } while ((gnu_chain_[n++] & 1) == 0); |
| |
| TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
| symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
| |
| return true; |
| } |
| |
| bool soinfo::elf_lookup(SymbolName& symbol_name, |
| const version_info* vi, |
| uint32_t* symbol_index) const { |
| uint32_t hash = symbol_name.elf_hash(); |
| |
| TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd", |
| symbol_name.get_name(), get_realpath(), |
| reinterpret_cast<void*>(base), hash, hash % nbucket_); |
| |
| ElfW(Versym) verneed = 0; |
| if (!find_verdef_version_index(this, vi, &verneed)) { |
| return false; |
| } |
| |
| for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) { |
| ElfW(Sym)* s = symtab_ + n; |
| const ElfW(Versym)* verdef = get_versym(n); |
| |
| // skip hidden versions when verneed == 0 |
| if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) { |
| continue; |
| } |
| |
| if (check_symbol_version(verneed, verdef) && |
| strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 && |
| is_symbol_global_and_defined(this, s)) { |
| TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd", |
| symbol_name.get_name(), get_realpath(), |
| reinterpret_cast<void*>(s->st_value), |
| static_cast<size_t>(s->st_size)); |
| *symbol_index = n; |
| return true; |
| } |
| } |
| |
| TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd", |
| symbol_name.get_name(), get_realpath(), |
| reinterpret_cast<void*>(base), hash, hash % nbucket_); |
| |
| *symbol_index = 0; |
| return true; |
| } |
| |
| ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) { |
| return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr); |
| } |
| |
| static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) { |
| return sym->st_shndx != SHN_UNDEF && |
| soaddr >= sym->st_value && |
| soaddr < sym->st_value + sym->st_size; |
| } |
| |
| ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) { |
| ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias; |
| |
| for (size_t i = 0; i < gnu_nbucket_; ++i) { |
| uint32_t n = gnu_bucket_[i]; |
| |
| if (n == 0) { |
| continue; |
| } |
| |
| do { |
| ElfW(Sym)* sym = symtab_ + n; |
| if (symbol_matches_soaddr(sym, soaddr)) { |
| return sym; |
| } |
| } while ((gnu_chain_[n++] & 1) == 0); |
| } |
| |
| return nullptr; |
| } |
| |
| ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) { |
| ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias; |
| |
| // Search the library's symbol table for any defined symbol which |
| // contains this address. |
| for (size_t i = 0; i < nchain_; ++i) { |
| ElfW(Sym)* sym = symtab_ + i; |
| if (symbol_matches_soaddr(sym, soaddr)) { |
| return sym; |
| } |
| } |
| |
| return nullptr; |
| } |
| |
| static void call_function(const char* function_name __unused, |
| linker_ctor_function_t function, |
| const char* realpath __unused) { |
| if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) { |
| return; |
| } |
| |
| TRACE("[ Calling c-tor %s @ %p for '%s' ]", function_name, function, realpath); |
| function(g_argc, g_argv, g_envp); |
| TRACE("[ Done calling c-tor %s @ %p for '%s' ]", function_name, function, realpath); |
| } |
| |
| static void call_function(const char* function_name __unused, |
| linker_dtor_function_t function, |
| const char* realpath __unused) { |
| if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) { |
| return; |
| } |
| |
| TRACE("[ Calling d-tor %s @ %p for '%s' ]", function_name, function, realpath); |
| function(); |
| TRACE("[ Done calling d-tor %s @ %p for '%s' ]", function_name, function, realpath); |
| } |
| |
| template <typename F> |
| static void call_array(const char* array_name __unused, |
| F* functions, |
| size_t count, |
| bool reverse, |
| const char* realpath) { |
| if (functions == nullptr) { |
| return; |
| } |
| |
| TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, realpath); |
| |
| int begin = reverse ? (count - 1) : 0; |
| int end = reverse ? -1 : count; |
| int step = reverse ? -1 : 1; |
| |
| for (int i = begin; i != end; i += step) { |
| TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]); |
| call_function("function", functions[i], realpath); |
| } |
| |
| TRACE("[ Done calling %s for '%s' ]", array_name, realpath); |
| } |
| |
| void soinfo::call_pre_init_constructors() { |
| // DT_PREINIT_ARRAY functions are called before any other constructors for executables, |
| // but ignored in a shared library. |
| call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false, get_realpath()); |
| } |
| |
| void soinfo::call_constructors() { |
| if (constructors_called) { |
| return; |
| } |
| |
| // We set constructors_called before actually calling the constructors, otherwise it doesn't |
| // protect against recursive constructor calls. One simple example of constructor recursion |
| // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so: |
| // 1. The program depends on libc, so libc's constructor is called here. |
| // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so. |
| // 3. dlopen() calls the constructors on the newly created |
| // soinfo for libc_malloc_debug_leak.so. |
| // 4. The debug .so depends on libc, so CallConstructors is |
| // called again with the libc soinfo. If it doesn't trigger the early- |
| // out above, the libc constructor will be called again (recursively!). |
| constructors_called = true; |
| |
| if (!is_main_executable() && preinit_array_ != nullptr) { |
| // The GNU dynamic linker silently ignores these, but we warn the developer. |
| PRINT("\"%s\": ignoring DT_PREINIT_ARRAY in shared library!", get_realpath()); |
| } |
| |
| get_children().for_each([] (soinfo* si) { |
| si->call_constructors(); |
| }); |
| |
| if (!is_linker()) { |
| bionic_trace_begin((std::string("calling constructors: ") + get_realpath()).c_str()); |
| } |
| |
| // DT_INIT should be called before DT_INIT_ARRAY if both are present. |
| call_function("DT_INIT", init_func_, get_realpath()); |
| call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false, get_realpath()); |
| |
| if (!is_linker()) { |
| bionic_trace_end(); |
| } |
| } |
| |
| void soinfo::call_destructors() { |
| if (!constructors_called) { |
| return; |
| } |
| |
| ScopedTrace trace((std::string("calling destructors: ") + get_realpath()).c_str()); |
| |
| // DT_FINI_ARRAY must be parsed in reverse order. |
| call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true, get_realpath()); |
| |
| // DT_FINI should be called after DT_FINI_ARRAY if both are present. |
| call_function("DT_FINI", fini_func_, get_realpath()); |
| } |
| |
| void soinfo::add_child(soinfo* child) { |
| if (has_min_version(0)) { |
| child->parents_.push_back(this); |
| this->children_.push_back(child); |
| } |
| } |
| |
| void soinfo::remove_all_links() { |
| if (!has_min_version(0)) { |
| return; |
| } |
| |
| // 1. Untie connected soinfos from 'this'. |
| children_.for_each([&] (soinfo* child) { |
| child->parents_.remove_if([&] (const soinfo* parent) { |
| return parent == this; |
| }); |
| }); |
| |
| parents_.for_each([&] (soinfo* parent) { |
| parent->children_.remove_if([&] (const soinfo* child) { |
| return child == this; |
| }); |
| }); |
| |
| // 2. Remove from the primary namespace |
| primary_namespace_->remove_soinfo(this); |
| primary_namespace_ = nullptr; |
| |
| // 3. Remove from secondary namespaces |
| secondary_namespaces_.for_each([&](android_namespace_t* ns) { |
| ns->remove_soinfo(this); |
| }); |
| |
| |
| // 4. Once everything untied - clear local lists. |
| parents_.clear(); |
| children_.clear(); |
| secondary_namespaces_.clear(); |
| } |
| |
| dev_t soinfo::get_st_dev() const { |
| if (has_min_version(0)) { |
| return st_dev_; |
| } |
| |
| return 0; |
| }; |
| |
| ino_t soinfo::get_st_ino() const { |
| if (has_min_version(0)) { |
| return st_ino_; |
| } |
| |
| return 0; |
| } |
| |
| off64_t soinfo::get_file_offset() const { |
| if (has_min_version(1)) { |
| return file_offset_; |
| } |
| |
| return 0; |
| } |
| |
| uint32_t soinfo::get_rtld_flags() const { |
| if (has_min_version(1)) { |
| return rtld_flags_; |
| } |
| |
| return 0; |
| } |
| |
| uint32_t soinfo::get_dt_flags_1() const { |
| if (has_min_version(1)) { |
| return dt_flags_1_; |
| } |
| |
| return 0; |
| } |
| |
| void soinfo::set_dt_flags_1(uint32_t dt_flags_1) { |
| if (has_min_version(1)) { |
| if ((dt_flags_1 & DF_1_GLOBAL) != 0) { |
| rtld_flags_ |= RTLD_GLOBAL; |
| } |
| |
| if ((dt_flags_1 & DF_1_NODELETE) != 0) { |
| rtld_flags_ |= RTLD_NODELETE; |
| } |
| |
| dt_flags_1_ = dt_flags_1; |
| } |
| } |
| |
| void soinfo::set_nodelete() { |
| rtld_flags_ |= RTLD_NODELETE; |
| } |
| |
| void soinfo::set_tls_nodelete() { |
| flags_ |= FLAG_TLS_NODELETE; |
| } |
| |
| void soinfo::unset_tls_nodelete() { |
| flags_ &= ~FLAG_TLS_NODELETE; |
| } |
| |
| const char* soinfo::get_realpath() const { |
| #if defined(__work_around_b_24465209__) |
| if (has_min_version(2)) { |
| return realpath_.c_str(); |
| } else { |
| return old_name_; |
| } |
| #else |
| return realpath_.c_str(); |
| #endif |
| } |
| |
| void soinfo::set_soname(const char* soname) { |
| #if defined(__work_around_b_24465209__) |
| if (has_min_version(2)) { |
| soname_ = soname; |
| } |
| strlcpy(old_name_, soname_, sizeof(old_name_)); |
| #else |
| soname_ = soname; |
| #endif |
| } |
| |
| const char* soinfo::get_soname() const { |
| #if defined(__work_around_b_24465209__) |
| if (has_min_version(2)) { |
| return soname_; |
| } else { |
| return old_name_; |
| } |
| #else |
| return soname_; |
| #endif |
| } |
| |
| // This is a return on get_children()/get_parents() if |
| // 'this->flags' does not have FLAG_NEW_SOINFO set. |
| static soinfo_list_t g_empty_list; |
| |
| soinfo_list_t& soinfo::get_children() { |
| if (has_min_version(0)) { |
| return children_; |
| } |
| |
| return g_empty_list; |
| } |
| |
| const soinfo_list_t& soinfo::get_children() const { |
| if (has_min_version(0)) { |
| return children_; |
| } |
| |
| return g_empty_list; |
| } |
| |
| soinfo_list_t& soinfo::get_parents() { |
| if (has_min_version(0)) { |
| return parents_; |
| } |
| |
| return g_empty_list; |
| } |
| |
| static std::vector<std::string> g_empty_runpath; |
| |
| const std::vector<std::string>& soinfo::get_dt_runpath() const { |
| if (has_min_version(3)) { |
| return dt_runpath_; |
| } |
| |
| return g_empty_runpath; |
| } |
| |
| android_namespace_t* soinfo::get_primary_namespace() { |
| if (has_min_version(3)) { |
| return primary_namespace_; |
| } |
| |
| return &g_default_namespace; |
| } |
| |
| void soinfo::add_secondary_namespace(android_namespace_t* secondary_ns) { |
| CHECK(has_min_version(3)); |
| secondary_namespaces_.push_back(secondary_ns); |
| } |
| |
| android_namespace_list_t& soinfo::get_secondary_namespaces() { |
| CHECK(has_min_version(3)); |
| return secondary_namespaces_; |
| } |
| |
| ElfW(Addr) soinfo::resolve_symbol_address(const ElfW(Sym)* s) const { |
| if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) { |
| return call_ifunc_resolver(s->st_value + load_bias); |
| } |
| |
| return static_cast<ElfW(Addr)>(s->st_value + load_bias); |
| } |
| |
| const char* soinfo::get_string(ElfW(Word) index) const { |
| if (has_min_version(1) && (index >= strtab_size_)) { |
| async_safe_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d", |
| get_realpath(), strtab_size_, index); |
| } |
| |
| return strtab_ + index; |
| } |
| |
| bool soinfo::is_gnu_hash() const { |
| return (flags_ & FLAG_GNU_HASH) != 0; |
| } |
| |
| bool soinfo::can_unload() const { |
| return !is_linked() || |
| ( |
| (get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0 && |
| (flags_ & FLAG_TLS_NODELETE) == 0 |
| ); |
| } |
| |
| bool soinfo::is_linked() const { |
| return (flags_ & FLAG_LINKED) != 0; |
| } |
| |
| bool soinfo::is_image_linked() const { |
| return (flags_ & FLAG_IMAGE_LINKED) != 0; |
| } |
| |
| bool soinfo::is_main_executable() const { |
| return (flags_ & FLAG_EXE) != 0; |
| } |
| |
| bool soinfo::is_linker() const { |
| return (flags_ & FLAG_LINKER) != 0; |
| } |
| |
| void soinfo::set_linked() { |
| flags_ |= FLAG_LINKED; |
| } |
| |
| void soinfo::set_image_linked() { |
| flags_ |= FLAG_IMAGE_LINKED; |
| } |
| |
| void soinfo::set_linker_flag() { |
| flags_ |= FLAG_LINKER; |
| } |
| |
| void soinfo::set_main_executable() { |
| flags_ |= FLAG_EXE; |
| } |
| |
| size_t soinfo::increment_ref_count() { |
| return ++local_group_root_->ref_count_; |
| } |
| |
| size_t soinfo::decrement_ref_count() { |
| return --local_group_root_->ref_count_; |
| } |
| |
| size_t soinfo::get_ref_count() const { |
| return local_group_root_->ref_count_; |
| } |
| |
| soinfo* soinfo::get_local_group_root() const { |
| return local_group_root_; |
| } |
| |
| void soinfo::set_mapped_by_caller(bool mapped_by_caller) { |
| if (mapped_by_caller) { |
| flags_ |= FLAG_MAPPED_BY_CALLER; |
| } else { |
| flags_ &= ~FLAG_MAPPED_BY_CALLER; |
| } |
| } |
| |
| bool soinfo::is_mapped_by_caller() const { |
| return (flags_ & FLAG_MAPPED_BY_CALLER) != 0; |
| } |
| |
| // This function returns api-level at the time of |
| // dlopen/load. Note that libraries opened by system |
| // will always have 'current' api level. |
| uint32_t soinfo::get_target_sdk_version() const { |
| if (!has_min_version(2)) { |
| return __ANDROID_API__; |
| } |
| |
| return local_group_root_->target_sdk_version_; |
| } |
| |
| uintptr_t soinfo::get_handle() const { |
| CHECK(has_min_version(3)); |
| CHECK(handle_ != 0); |
| return handle_; |
| } |
| |
| void* soinfo::to_handle() { |
| if (get_application_target_sdk_version() < __ANDROID_API_N__ || !has_min_version(3)) { |
| return this; |
| } |
| |
| return reinterpret_cast<void*>(get_handle()); |
| } |
| |
| void soinfo::generate_handle() { |
| CHECK(has_min_version(3)); |
| CHECK(handle_ == 0); // Make sure this is the first call |
| |
| // Make sure the handle is unique and does not collide |
| // with special values which are RTLD_DEFAULT and RTLD_NEXT. |
| do { |
| arc4random_buf(&handle_, sizeof(handle_)); |
| // the least significant bit for the handle is always 1 |
| // making it easy to test the type of handle passed to |
| // dl* functions. |
| handle_ = handle_ | 1; |
| } while (handle_ == reinterpret_cast<uintptr_t>(RTLD_DEFAULT) || |
| handle_ == reinterpret_cast<uintptr_t>(RTLD_NEXT) || |
| g_soinfo_handles_map.find(handle_) != g_soinfo_handles_map.end()); |
| |
| g_soinfo_handles_map[handle_] = this; |
| } |
| |
| // TODO(dimitry): Move SymbolName methods to a separate file. |
| |
| uint32_t calculate_elf_hash(const char* name) { |
| const uint8_t* name_bytes = reinterpret_cast<const uint8_t*>(name); |
| uint32_t h = 0, g; |
| |
| while (*name_bytes) { |
| h = (h << 4) + *name_bytes++; |
| g = h & 0xf0000000; |
| h ^= g; |
| h ^= g >> 24; |
| } |
| |
| return h; |
| } |
| |
| uint32_t SymbolName::elf_hash() { |
| if (!has_elf_hash_) { |
| elf_hash_ = calculate_elf_hash(name_); |
| has_elf_hash_ = true; |
| } |
| |
| return elf_hash_; |
| } |
| |
| uint32_t SymbolName::gnu_hash() { |
| if (!has_gnu_hash_) { |
| uint32_t h = 5381; |
| const uint8_t* name = reinterpret_cast<const uint8_t*>(name_); |
| while (*name != 0) { |
| h += (h << 5) + *name++; // h*33 + c = h + h * 32 + c = h + h << 5 + c |
| } |
| |
| gnu_hash_ = h; |
| has_gnu_hash_ = true; |
| } |
| |
| return gnu_hash_; |
| } |