From c0133a73b6f37b88afc8dafb6f63af03cbb708f6 Mon Sep 17 00:00:00 2001 From: Dmitriy Ivanov Date: Fri, 5 Sep 2014 14:57:59 -0700 Subject: [PATCH] Revert "Load libraries in breadth-first order" This reverts commit a3ad450a2e3fb6b3fe359683b247eba20896f646. (cherry picked from commit 498eb18b82a425f9f30132e4832f327b2ee0e545) Change-Id: Iec7eab83d0c0ed1604e1e8ea3f9e9d0ce1d29680 --- libc/private/UniquePtr.h | 140 --------- linker/dlfcn.cpp | 1 - linker/linker.cpp | 431 ++++++++++----------------- linker/linker.h | 2 - linker/linker_phdr.cpp | 29 +- linker/linker_phdr.h | 3 +- tests/Android.mk | 1 - tests/dlfcn_test.cpp | 49 --- tests/libs/Android.mk | 154 ---------- tests/libs/dlopen_testlib_answer.cpp | 25 -- tests/uniqueptr_test.cpp | 101 ------- 11 files changed, 178 insertions(+), 758 deletions(-) delete mode 100644 libc/private/UniquePtr.h delete mode 100644 tests/libs/dlopen_testlib_answer.cpp delete mode 100644 tests/uniqueptr_test.cpp diff --git a/libc/private/UniquePtr.h b/libc/private/UniquePtr.h deleted file mode 100644 index 5ac7599a0..000000000 --- a/libc/private/UniquePtr.h +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright (C) 2010 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef UNIQUE_PTR_H_included -#define UNIQUE_PTR_H_included - -// Default deleter for pointer types. -template -struct DefaultDelete { - enum { type_must_be_complete = sizeof(T) }; - DefaultDelete() {} - void operator()(T* p) const { - delete p; - } -}; - -// Default deleter for array types. -template -struct DefaultDelete { - enum { type_must_be_complete = sizeof(T) }; - void operator()(T* p) const { - delete[] p; - } -}; - -// A smart pointer that deletes the given pointer on destruction. -// Equivalent to C++0x's std::unique_ptr (a combination of boost::scoped_ptr -// and boost::scoped_array). -// Named to be in keeping with Android style but also to avoid -// collision with any other implementation, until we can switch over -// to unique_ptr. -// Use thus: -// UniquePtr c(new C); -template > -class UniquePtr { -public: - // Construct a new UniquePtr, taking ownership of the given raw pointer. - explicit UniquePtr(T* ptr = nullptr) : mPtr(ptr) { } - - UniquePtr(UniquePtr&& that) { - mPtr = that.mPtr; - that.mPtr = nullptr; - } - - ~UniquePtr() { - reset(); - } - - // Accessors. - T& operator*() const { return *mPtr; } - T* operator->() const { return mPtr; } - T* get() const { return mPtr; } - - // Returns the raw pointer and hands over ownership to the caller. - // The pointer will not be deleted by UniquePtr. - T* release() __attribute__((warn_unused_result)) { - T* result = mPtr; - mPtr = nullptr; - return result; - } - - // Takes ownership of the given raw pointer. - // If this smart pointer previously owned a different raw pointer, that - // raw pointer will be freed. - void reset(T* ptr = nullptr) { - if (ptr != mPtr) { - D()(mPtr); - mPtr = ptr; - } - } - -private: - // The raw pointer. - T* mPtr; - - // Comparing unique pointers is probably a mistake, since they're unique. - template bool operator==(const UniquePtr& p) const = delete; - template bool operator!=(const UniquePtr& p) const = delete; - - // Disallow copy and assignment. - UniquePtr(const UniquePtr&) = delete; - void operator=(const UniquePtr&) = delete; -}; - -// Partial specialization for array types. Like std::unique_ptr, this removes -// operator* and operator-> but adds operator[]. -template -class UniquePtr { -public: - explicit UniquePtr(T* ptr = NULL) : mPtr(ptr) { - } - UniquePtr(UniquePtr&& that) { - mPtr = that.mPtr; - that.mPtr = nullptr; - } - - ~UniquePtr() { - reset(); - } - - T& operator[](size_t i) const { - return mPtr[i]; - } - T* get() const { return mPtr; } - - T* release() __attribute__((warn_unused_result)) { - T* result = mPtr; - mPtr = NULL; - return result; - } - - void reset(T* ptr = NULL) { - if (ptr != mPtr) { - D()(mPtr); - mPtr = ptr; - } - } - -private: - T* mPtr; - - // Disallow copy and assignment. - UniquePtr(const UniquePtr&) = delete; - void operator=(const UniquePtr&) = delete; -}; - -#endif // UNIQUE_PTR_H_included diff --git a/linker/dlfcn.cpp b/linker/dlfcn.cpp index 3024b3c29..38484d995 100644 --- a/linker/dlfcn.cpp +++ b/linker/dlfcn.cpp @@ -245,7 +245,6 @@ soinfo* get_libdl_info() { __libdl_info.bucket = g_libdl_buckets; __libdl_info.chain = g_libdl_chains; __libdl_info.has_DT_SYMBOLIC = true; - __libdl_info.ref_count = 1; } return &__libdl_info; diff --git a/linker/linker.cpp b/linker/linker.cpp index ac470a54b..2186b3d30 100644 --- a/linker/linker.cpp +++ b/linker/linker.cpp @@ -44,8 +44,6 @@ #include "private/KernelArgumentBlock.h" #include "private/ScopedPthreadMutexLocker.h" #include "private/ScopedFd.h" -#include "private/ScopeGuard.h" -#include "private/UniquePtr.h" #include "linker.h" #include "linker_debug.h" @@ -172,6 +170,7 @@ DISALLOW_ALLOCATION(void, free, (void* u __unused)); DISALLOW_ALLOCATION(void*, realloc, (void* u1 __unused, size_t u2 __unused)); DISALLOW_ALLOCATION(void*, calloc, (size_t u1 __unused, size_t u2 __unused)); +static char tmp_err_buf[768]; static char __linker_dl_err_buf[768]; char* linker_get_error_buffer() { @@ -513,7 +512,7 @@ static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi) { unsigned elf_hash = elfhash(name); ElfW(Sym)* s = nullptr; - if (somain != nullptr) { + if (si != nullptr && somain != nullptr) { /* * Local scope is executable scope. Just start looking into it right away * for the shortcut. @@ -658,47 +657,22 @@ class TypeBasedAllocator { } }; -class LoadTask { - public: - struct deleter_t { - void operator()(LoadTask* t) { - TypeBasedAllocator::free(t); - } - }; - - typedef UniquePtr unique_ptr; - - static deleter_t deleter; - - static LoadTask* create(const char* name, soinfo* needed_by) { - LoadTask* ptr = TypeBasedAllocator::alloc(); - return new (ptr) LoadTask(name, needed_by); - } - - const char* get_name() { - return name_; - } - - soinfo* get_needed_by() { - return needed_by_; - } - private: - LoadTask(const char* name, soinfo* needed_by) - : name_(name), needed_by_(needed_by) {} - - const char* name_; - soinfo* needed_by_; - - DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask); -}; - template using linked_list_t = LinkedList>>; typedef linked_list_t SoinfoLinkedList; -typedef linked_list_t StringLinkedList; -typedef linked_list_t LoadTaskList; +static LinkerAllocator> g_soinfo_list_allocator_rw; +class SoinfoListAllocatorRW { + public: + static LinkedListEntry* alloc() { + return g_soinfo_list_allocator_rw.alloc(); + } + + static void free(LinkedListEntry* ptr) { + g_soinfo_list_allocator_rw.free(ptr); + } +}; // This is used by dlsym(3). It performs symbol lookup only within the // specified soinfo object and its dependencies in breadth first order. @@ -824,80 +798,73 @@ static int open_library(const char* name) { return fd; } -template -static void for_each_dt_needed(const soinfo* si, F action) { - for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) { - if (d->d_tag == DT_NEEDED) { - action(si->strtab + d->d_un.d_val); +static soinfo* load_library(const char* name, int dlflags, const android_dlextinfo* extinfo) { + int fd = -1; + ScopedFd file_guard(-1); + + if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) { + fd = extinfo->library_fd; + } else { + // Open the file. + fd = open_library(name); + if (fd == -1) { + DL_ERR("library \"%s\" not found", name); + return nullptr; + } + + file_guard.reset(fd); } - } -} -static soinfo* load_library(LoadTaskList& load_tasks, const char* name, int dlflags, const android_dlextinfo* extinfo) { - int fd = -1; - ScopedFd file_guard(-1); + ElfReader elf_reader(name, fd); - if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) { - fd = extinfo->library_fd; - } else { - // Open the file. - fd = open_library(name); - if (fd == -1) { - DL_ERR("library \"%s\" not found", name); + struct stat file_stat; + if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) { + DL_ERR("unable to stat file for the library %s: %s", name, strerror(errno)); return nullptr; } - file_guard.reset(fd); - } - - struct stat file_stat; - if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) { - DL_ERR("unable to stat file for the library %s: %s", name, strerror(errno)); - return nullptr; - } - - // Check for symlink and other situations where - // file can have different names. - for (soinfo* si = solist; si != nullptr; si = si->next) { - if (si->get_st_dev() != 0 && - si->get_st_ino() != 0 && - si->get_st_dev() == file_stat.st_dev && - si->get_st_ino() == file_stat.st_ino) { - TRACE("library \"%s\" is already loaded under different name/path \"%s\" - will return existing soinfo", name, si->name); - return si; + // Check for symlink and other situations where + // file can have different names. + for (soinfo* si = solist; si != nullptr; si = si->next) { + if (si->get_st_dev() != 0 && + si->get_st_ino() != 0 && + si->get_st_dev() == file_stat.st_dev && + si->get_st_ino() == file_stat.st_ino) { + TRACE("library \"%s\" is already loaded under different name/path \"%s\" - will return existing soinfo", name, si->name); + return si; + } } - } - if ((dlflags & RTLD_NOLOAD) != 0) { - return nullptr; - } + if ((dlflags & RTLD_NOLOAD) != 0) { + return nullptr; + } - // Read the ELF header and load the segments. - ElfReader elf_reader(name, fd); - if (!elf_reader.Load(extinfo)) { - return nullptr; - } + // Read the ELF header and load the segments. + if (!elf_reader.Load(extinfo)) { + return nullptr; + } - soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat); - if (si == nullptr) { - return nullptr; - } - si->base = elf_reader.load_start(); - si->size = elf_reader.load_size(); - si->load_bias = elf_reader.load_bias(); - si->phnum = elf_reader.phdr_count(); - si->phdr = elf_reader.loaded_phdr(); + soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat); + if (si == nullptr) { + return nullptr; + } + si->base = elf_reader.load_start(); + si->size = elf_reader.load_size(); + si->load_bias = elf_reader.load_bias(); + si->phnum = elf_reader.phdr_count(); + si->phdr = elf_reader.loaded_phdr(); - if (!si->PrelinkImage()) { - soinfo_free(si); - return nullptr; - } + // At this point we know that whatever is loaded @ base is a valid ELF + // shared library whose segments are properly mapped in. + TRACE("[ load_library base=%p size=%zu name='%s' ]", + reinterpret_cast(si->base), si->size, si->name); - for_each_dt_needed(si, [&] (const char* name) { - load_tasks.push_back(LoadTask::create(name, si)); - }); + if (!si->LinkImage(extinfo)) { + soinfo_free(si); + return nullptr; + } - return si; + return si; } static soinfo *find_loaded_library_by_name(const char* name) { @@ -910,122 +877,33 @@ static soinfo *find_loaded_library_by_name(const char* name) { return nullptr; } -static soinfo* find_library_internal(LoadTaskList& load_tasks, const char* name, int dlflags, const android_dlextinfo* extinfo) { +static soinfo* find_library_internal(const char* name, int dlflags, const android_dlextinfo* extinfo) { + if (name == nullptr) { + return somain; + } soinfo* si = find_loaded_library_by_name(name); // Library might still be loaded, the accurate detection - // of this fact is done by load_library. + // of this fact is done by load_library if (si == nullptr) { TRACE("[ '%s' has not been found by name. Trying harder...]", name); - si = load_library(load_tasks, name, dlflags, extinfo); + si = load_library(name, dlflags, extinfo); + } + + if (si != nullptr && (si->flags & FLAG_LINKED) == 0) { + DL_ERR("recursive link to \"%s\"", si->name); + return nullptr; } return si; } -static void soinfo_unload(soinfo* si); - -static bool is_recursive(soinfo* si, soinfo* parent) { - if (parent == nullptr) { - return false; - } - - if (si == parent) { - DL_ERR("recursive link to \"%s\"", si->name); - return true; - } - - return !parent->get_parents().visit([&](soinfo* grandparent) { - return !is_recursive(si, grandparent); - }); -} - -static bool find_libraries(const char* const library_names[], size_t library_names_size, soinfo* soinfos[], - soinfo* ld_preloads[], size_t ld_preloads_size, int dlflags, const android_dlextinfo* extinfo) { - // Step 0: prepare. - LoadTaskList load_tasks; - for (size_t i = 0; i < library_names_size; ++i) { - const char* name = library_names[i]; - load_tasks.push_back(LoadTask::create(name, nullptr)); - } - - // Libraries added to this list in reverse order so that we can - // start linking from bottom-up - see step 2. - SoinfoLinkedList found_libs; - size_t soinfos_size = 0; - - auto failure_guard = create_scope_guard([&]() { - // Housekeeping - load_tasks.for_each([] (LoadTask* t) { - LoadTask::deleter(t); - }); - - for (size_t i = 0; iget_name(), dlflags, extinfo); - if (si == nullptr) { - return false; - } - - soinfo* needed_by = task->get_needed_by(); - - if (is_recursive(si, needed_by)) { - soinfo_free(si); - return false; - } - - si->ref_count++; - if (needed_by != nullptr) { - needed_by->add_child(si); - } - found_libs.push_front(si); - - // When ld_preloads is not null first - // ld_preloads_size libs are in fact ld_preloads. - if (ld_preloads != nullptr && soinfos_size < ld_preloads_size) { - ld_preloads[soinfos_size] = si; - } - - if (soinfos_sizeflags & FLAG_LINKED) == 0) { - if (!si->LinkImage(extinfo)) { - return false; - } - si->flags |= FLAG_LINKED; - } - } - - // All is well - found_libs and load_tasks are empty at this point - // and all libs are successfully linked. - failure_guard.disable(); - return true; -} - static soinfo* find_library(const char* name, int dlflags, const android_dlextinfo* extinfo) { - if (name == nullptr) { - somain->ref_count++; - return somain; + soinfo* si = find_library_internal(name, dlflags, extinfo); + if (si != nullptr) { + si->ref_count++; } - - soinfo* si; - - if (!find_libraries(&name, 1, &si, nullptr, 0, dlflags, extinfo)) { - return nullptr; - } - return si; } @@ -1047,17 +925,20 @@ static void soinfo_unload(soinfo* si) { soinfo_unload(children[i]); } } else { - for_each_dt_needed(si, [&] (const char* library_name) { - TRACE("deprecated (old format of soinfo): %s needs to unload %s", si->name, library_name); - soinfo* needed = find_library(library_name, RTLD_NOLOAD, nullptr); - if (needed != nullptr) { - soinfo_unload(needed); - } else { - // Not found: for example if symlink was deleted between dlopen and dlclose - // Since we cannot really handle errors at this point - print and continue. - PRINT("warning: couldn't find %s needed by %s on unload.", library_name, si->name); + for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) { + if (d->d_tag == DT_NEEDED) { + const char* library_name = si->strtab + d->d_un.d_val; + TRACE("%s needs to unload %s", si->name, library_name); + soinfo* needed = find_library(library_name, RTLD_NOLOAD, nullptr); + if (needed != nullptr) { + soinfo_unload(needed); + } else { + // Not found: for example if symlink was deleted between dlopen and dlclose + // Since we cannot really handle errors at this point - print and continue. + PRINT("warning: couldn't find %s needed by %s on unload.", library_name, si->name); + } } - }); + } } notify_gdb_of_unload(si); @@ -1166,6 +1047,9 @@ static void soinfo_ifunc_relocate(soinfo* si, ElfW(Rela)* rela, unsigned count) #if defined(USE_RELA) int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) { + ElfW(Sym)* s; + soinfo* lsi; + for (size_t idx = 0; idx < count; ++idx, ++rela) { unsigned type = ELFW(R_TYPE)(rela->r_info); unsigned sym = ELFW(R_SYM)(rela->r_info); @@ -1177,10 +1061,6 @@ int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) { if (type == 0) { // R_*_NONE continue; } - - ElfW(Sym)* s = nullptr; - soinfo* lsi = nullptr; - if (sym != 0) { sym_name = reinterpret_cast(strtab + symtab[sym].st_name); s = soinfo_do_lookup(this, sym_name, &lsi); @@ -1239,6 +1119,8 @@ int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) { sym_addr = static_cast(s->st_value + lsi->load_bias); } count_relocation(kRelocSymbol); + } else { + s = nullptr; } switch (type) { @@ -1432,6 +1314,9 @@ int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) { #else // REL, not RELA. int soinfo::Relocate(ElfW(Rel)* rel, unsigned count) { + ElfW(Sym)* s; + soinfo* lsi; + for (size_t idx = 0; idx < count; ++idx, ++rel) { unsigned type = ELFW(R_TYPE)(rel->r_info); // TODO: don't use unsigned for 'sym'. Use uint32_t or ElfW(Addr) instead. @@ -1444,10 +1329,6 @@ int soinfo::Relocate(ElfW(Rel)* rel, unsigned count) { if (type == 0) { // R_*_NONE continue; } - - ElfW(Sym)* s = nullptr; - soinfo* lsi = nullptr; - if (sym != 0) { sym_name = reinterpret_cast(strtab + symtab[sym].st_name); s = soinfo_do_lookup(this, sym_name, &lsi); @@ -1509,6 +1390,8 @@ int soinfo::Relocate(ElfW(Rel)* rel, unsigned count) { sym_addr = static_cast(s->st_value + lsi->load_bias); } count_relocation(kRelocSymbol); + } else { + s = nullptr; } switch (type) { @@ -1663,7 +1546,7 @@ static bool mips_relocate_got(soinfo* si) { for (size_t g = gotsym; g < symtabno; g++, sym++, got++) { // This is an undefined reference... try to locate it. const char* sym_name = si->strtab + sym->st_name; - soinfo* lsi = nullptr; + soinfo* lsi; ElfW(Sym)* s = soinfo_do_lookup(si, sym_name, &lsi); if (s == nullptr) { // We only allow an undefined symbol if this is a weak reference. @@ -1760,9 +1643,6 @@ void soinfo::CallConstructors() { } void soinfo::CallDestructors() { - if (!constructors_called) { - return; - } TRACE("\"%s\": calling destructors", name); // DT_FINI_ARRAY must be parsed in reverse order. @@ -1848,7 +1728,7 @@ bool soinfo::get_has_ifuncs() { return false; } -// This is a return on get_children()/get_parents() if +// This is a return on get_children() in case // 'this->flags' does not have FLAG_NEW_SOINFO set. static soinfo::soinfo_list_t g_empty_list; @@ -1860,14 +1740,6 @@ soinfo::soinfo_list_t& soinfo::get_children() { return g_empty_list; } -soinfo::soinfo_list_t& soinfo::get_parents() { - if ((this->flags & FLAG_NEW_SOINFO) == 0) { - return g_empty_list; - } - - return this->parents; -} - /* Force any of the closed stdin, stdout and stderr to be associated with /dev/null. */ static int nullify_closed_stdio() { @@ -1929,18 +1801,20 @@ static int nullify_closed_stdio() { return return_value; } -bool soinfo::PrelinkImage() { - phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic); - - /* We can't log anything until the linker is relocated */ +bool soinfo::LinkImage(const android_dlextinfo* extinfo) { bool relocating_linker = (flags & FLAG_LINKER) != 0; + + /* We can't debug anything until the linker is relocated */ if (!relocating_linker) { INFO("[ linking %s ]", name); DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast(base), flags); } /* Extract dynamic section */ - ElfW(Word) dynamic_flags = phdr->p_flags; + size_t dynamic_count; + ElfW(Word) dynamic_flags; + phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, + &dynamic_count, &dynamic_flags); if (dynamic == nullptr) { if (!relocating_linker) { DL_ERR("missing PT_DYNAMIC in \"%s\"", name); @@ -2008,7 +1882,7 @@ bool soinfo::PrelinkImage() { // if the dynamic table is writable // FIXME: not working currently for N64 // The flags for the LOAD and DYNAMIC program headers do not agree. -// The LOAD section containing the dynamic table has been mapped as +// The LOAD section containng the dynamic table has been mapped as // read-only, but the DYNAMIC header claims it is writable. #if !(defined(__mips__) && defined(__LP64__)) if ((dynamic_flags & PF_W) != 0) { @@ -2154,10 +2028,38 @@ bool soinfo::PrelinkImage() { DL_ERR("empty/missing DT_SYMTAB in \"%s\"", name); return false; } - return true; -} -bool soinfo::LinkImage(const android_dlextinfo* extinfo) { + // If this is the main executable, then load all of the libraries from LD_PRELOAD now. + if (flags & FLAG_EXE) { + memset(g_ld_preloads, 0, sizeof(g_ld_preloads)); + size_t preload_count = 0; + for (size_t i = 0; g_ld_preload_names[i] != nullptr; i++) { + soinfo* lsi = find_library(g_ld_preload_names[i], 0, nullptr); + if (lsi != nullptr) { + g_ld_preloads[preload_count++] = lsi; + } else { + // As with glibc, failure to load an LD_PRELOAD library is just a warning. + DL_WARN("could not load library \"%s\" from LD_PRELOAD for \"%s\"; caused by %s", + g_ld_preload_names[i], name, linker_get_error_buffer()); + } + } + } + + for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) { + if (d->d_tag == DT_NEEDED) { + const char* library_name = strtab + d->d_un.d_val; + DEBUG("%s needs %s", name, library_name); + soinfo* lsi = find_library(library_name, 0, nullptr); + if (lsi == nullptr) { + strlcpy(tmp_err_buf, linker_get_error_buffer(), sizeof(tmp_err_buf)); + DL_ERR("could not load library \"%s\" needed by \"%s\"; caused by %s", + library_name, name, tmp_err_buf); + return false; + } + + add_child(lsi); + } + } #if !defined(__LP64__) if (has_text_relocations) { @@ -2219,6 +2121,7 @@ bool soinfo::LinkImage(const android_dlextinfo* extinfo) { } #endif + flags |= FLAG_LINKED; DEBUG("[ finished linking %s ]", name); #if !defined(__LP64__) @@ -2280,7 +2183,6 @@ static void add_vdso(KernelArgumentBlock& args __unused) { si->size = phdr_table_get_load_size(si->phdr, si->phnum); si->load_bias = get_elf_exec_load_bias(ehdr_vdso); - si->PrelinkImage(); si->LinkImage(nullptr); #endif } @@ -2314,7 +2216,7 @@ static void init_linker_info_for_gdb(ElfW(Addr) linker_base) { ElfW(Ehdr)* elf_hdr = reinterpret_cast(linker_base); ElfW(Phdr)* phdr = reinterpret_cast(linker_base + elf_hdr->e_phoff); phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base, - &linker_soinfo_for_gdb.dynamic); + &linker_soinfo_for_gdb.dynamic, nullptr, nullptr); insert_soinfo_into_debug_map(&linker_soinfo_for_gdb); } @@ -2410,37 +2312,6 @@ static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW( somain = si; - si->PrelinkImage(); - - // Load ld_preloads and dependencies. - StringLinkedList needed_library_name_list; - size_t needed_libraries_count = 0; - size_t ld_preloads_count = 0; - while (g_ld_preload_names[ld_preloads_count] != nullptr) { - needed_library_name_list.push_back(g_ld_preload_names[ld_preloads_count++]); - ++needed_libraries_count; - } - - for_each_dt_needed(si, [&](const char* name) { - needed_library_name_list.push_back(name); - ++needed_libraries_count; - }); - - const char* needed_library_names[needed_libraries_count]; - soinfo* needed_library_si[needed_libraries_count]; - - memset(needed_library_names, 0, sizeof(needed_library_names)); - needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count); - - if (needed_libraries_count > 0 && !find_libraries(needed_library_names, needed_libraries_count, needed_library_si, g_ld_preloads, ld_preloads_count, 0, nullptr)) { - __libc_format_fd(2, "CANNOT LINK EXECUTABLE DEPENDENCIES: %s\n", linker_get_error_buffer()); - exit(EXIT_FAILURE); - } - - for (size_t i = 0; iadd_child(needed_library_si[i]); - } - if (!si->LinkImage(nullptr)) { __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); exit(EXIT_FAILURE); @@ -2450,7 +2321,11 @@ static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW( si->CallPreInitConstructors(); - /* After the PrelinkImage, the si->load_bias is initialized. + for (size_t i = 0; g_ld_preloads[i] != nullptr; ++i) { + g_ld_preloads[i]->CallConstructors(); + } + + /* After the LinkImage, the si->load_bias is initialized. * For so lib, the map->l_addr will be updated in notify_gdb_of_load. * We need to update this value for so exe here. So Unwind_Backtrace * for some arch like x86 could work correctly within so exe. @@ -2565,7 +2440,7 @@ extern "C" ElfW(Addr) __linker_init(void* raw_args) { linker_so.phnum = elf_hdr->e_phnum; linker_so.flags |= FLAG_LINKER; - if (!(linker_so.PrelinkImage() && linker_so.LinkImage(nullptr))) { + if (!linker_so.LinkImage(nullptr)) { // It would be nice to print an error message, but if the linker // can't link itself, there's no guarantee that we'll be able to // call write() (because it involves a GOT reference). We may as diff --git a/linker/linker.h b/linker/linker.h index 3024d3ab2..6547d685e 100644 --- a/linker/linker.h +++ b/linker/linker.h @@ -204,7 +204,6 @@ struct soinfo { void CallConstructors(); void CallDestructors(); void CallPreInitConstructors(); - bool PrelinkImage(); bool LinkImage(const android_dlextinfo* extinfo); void add_child(soinfo* child); @@ -218,7 +217,6 @@ struct soinfo { bool get_has_ifuncs(); soinfo_list_t& get_children(); - soinfo_list_t& get_parents(); bool inline has_min_version(uint32_t min_version) { return (flags & FLAG_NEW_SOINFO) != 0 && version >= min_version; diff --git a/linker/linker_phdr.cpp b/linker/linker_phdr.cpp index 436517271..1bbd57778 100644 --- a/linker/linker_phdr.cpp +++ b/linker/linker_phdr.cpp @@ -702,17 +702,34 @@ int phdr_table_get_arm_exidx(const ElfW(Phdr)* phdr_table, size_t phdr_count, * load_bias -> load bias * Output: * dynamic -> address of table in memory (null on failure). + * dynamic_count -> number of items in table (0 on failure). + * dynamic_flags -> protection flags for section (unset on failure) * Return: * void */ void phdr_table_get_dynamic_section(const ElfW(Phdr)* phdr_table, size_t phdr_count, - ElfW(Addr) load_bias, ElfW(Dyn)** dynamic) { - *dynamic = nullptr; - for (const ElfW(Phdr)* phdr = phdr_table, *phdr_limit = phdr + phdr_count; phdr < phdr_limit; phdr++) { - if (phdr->p_type == PT_DYNAMIC) { - *dynamic = reinterpret_cast(load_bias + phdr->p_vaddr); - return; + ElfW(Addr) load_bias, + ElfW(Dyn)** dynamic, size_t* dynamic_count, ElfW(Word)* dynamic_flags) { + const ElfW(Phdr)* phdr = phdr_table; + const ElfW(Phdr)* phdr_limit = phdr + phdr_count; + + for (phdr = phdr_table; phdr < phdr_limit; phdr++) { + if (phdr->p_type != PT_DYNAMIC) { + continue; } + + *dynamic = reinterpret_cast(load_bias + phdr->p_vaddr); + if (dynamic_count) { + *dynamic_count = (unsigned)(phdr->p_memsz / 8); + } + if (dynamic_flags) { + *dynamic_flags = phdr->p_flags; + } + return; + } + *dynamic = nullptr; + if (dynamic_count) { + *dynamic_count = 0; } } diff --git a/linker/linker_phdr.h b/linker/linker_phdr.h index d4c3ce85f..50708a0e6 100644 --- a/linker/linker_phdr.h +++ b/linker/linker_phdr.h @@ -101,6 +101,7 @@ int phdr_table_get_arm_exidx(const ElfW(Phdr)* phdr_table, size_t phdr_count, El #endif void phdr_table_get_dynamic_section(const ElfW(Phdr)* phdr_table, size_t phdr_count, - ElfW(Addr) load_bias, ElfW(Dyn)** dynamic); + ElfW(Addr) load_bias, + ElfW(Dyn)** dynamic, size_t* dynamic_count, ElfW(Word)* dynamic_flags); #endif /* LINKER_PHDR_H */ diff --git a/tests/Android.mk b/tests/Android.mk index 69ff8110a..38509654c 100644 --- a/tests/Android.mk +++ b/tests/Android.mk @@ -112,7 +112,6 @@ libBionicStandardTests_src_files := \ system_properties_test.cpp \ time_test.cpp \ uchar_test.cpp \ - uniqueptr_test.cpp \ unistd_test.cpp \ wchar_test.cpp \ diff --git a/tests/dlfcn_test.cpp b/tests/dlfcn_test.cpp index fb3bfc511..15ba3414c 100644 --- a/tests/dlfcn_test.cpp +++ b/tests/dlfcn_test.cpp @@ -158,55 +158,6 @@ TEST(dlfcn, dlopen_check_relocation_dt_needed_order) { ASSERT_EQ(1, fn()); } -TEST(dlfcn, dlopen_check_order) { - // Here is how the test library and its dt_needed - // libraries are arranged - // - // libtest_check_order.so - // | - // +-> libtest_check_order_1_left.so - // | | - // | +-> libtest_check_order_a.so - // | | - // | +-> libtest_check_order_b.so - // | - // +-> libtest_check_order_2_right.so - // | | - // | +-> libtest_check_order_d.so - // | | - // | +-> libtest_check_order_b.so - // | - // +-> libtest_check_order_3_c.so - // - // load order should be (1, 2, 3, a, b, d) - // - // get_answer() is defined in (2, 3, a, b, c) - // get_answer2() is defined in (b, d) - void* sym = dlsym(RTLD_DEFAULT, "dlopen_test_get_answer"); - ASSERT_TRUE(sym == nullptr); - void* handle = dlopen("libtest_check_order.so", RTLD_NOW); - ASSERT_TRUE(handle != nullptr); - typedef int (*fn_t) (void); - fn_t fn, fn2; - fn = reinterpret_cast(dlsym(RTLD_DEFAULT, "dlopen_test_get_answer")); - ASSERT_TRUE(fn != NULL); - fn2 = reinterpret_cast(dlsym(RTLD_DEFAULT, "dlopen_test_get_answer2")); - ASSERT_TRUE(fn2 != NULL); - - ASSERT_EQ(42, fn()); - ASSERT_EQ(43, fn2()); - dlclose(handle); -} - -// libtest_with_dependency_loop.so -> libtest_with_dependency_loop_a.so -> -// libtest_with_dependency_loop_b.so -> libtest_with_dependency_loop_c.so -> -// libtest_with_dependency_loop_a.so -TEST(dlfcn, dlopen_check_loop) { - void* handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW); - ASSERT_TRUE(handle == NULL); - ASSERT_STREQ("dlopen failed: recursive link to \"libtest_with_dependency_loop_a.so\"", dlerror()); -} - TEST(dlfcn, dlopen_failure) { void* self = dlopen("/does/not/exist", RTLD_NOW); ASSERT_TRUE(self == NULL); diff --git a/tests/libs/Android.mk b/tests/libs/Android.mk index 21681eec9..20bc263b0 100644 --- a/tests/libs/Android.mk +++ b/tests/libs/Android.mk @@ -101,160 +101,6 @@ build_type := target build_target := SHARED_LIBRARY include $(TEST_PATH)/Android.build.mk -# ----------------------------------------------------------------------------- -# Libraries used by dlfcn tests to verify correct load order: -# libtest_check_order_2_right.so -# ----------------------------------------------------------------------------- -libtest_check_order_2_right_src_files := \ - dlopen_testlib_answer.cpp - -libtest_check_order_2_right_cflags := -D__ANSWER=42 -module := libtest_check_order_2_right -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_a.so -# ----------------------------------------------------------------------------- -libtest_check_order_a_src_files := \ - dlopen_testlib_answer.cpp - -libtest_check_order_a_cflags := -D__ANSWER=1 -module := libtest_check_order_a -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_b.so -# ----------------------------------------------------------------------------- -libtest_check_order_b_src_files := \ - dlopen_testlib_answer.cpp - -libtest_check_order_b_cflags := -D__ANSWER=2 -D__ANSWER2=43 -module := libtest_check_order_b -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_c.so -# ----------------------------------------------------------------------------- -libtest_check_order_3_c_src_files := \ - dlopen_testlib_answer.cpp - -libtest_check_order_3_c_cflags := -D__ANSWER=3 -module := libtest_check_order_3_c -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_d.so -# ----------------------------------------------------------------------------- -libtest_check_order_d_src_files := \ - dlopen_testlib_answer.cpp - -libtest_check_order_d_shared_libraries := libtest_check_order_b -libtest_check_order_d_cflags := -D__ANSWER=4 -D__ANSWER2=4 -module := libtest_check_order_d -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_left.so -# ----------------------------------------------------------------------------- -libtest_check_order_1_left_src_files := \ - empty.cpp - -libtest_check_order_1_left_shared_libraries := libtest_check_order_a libtest_check_order_b - -module := libtest_check_order_1_left -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order.so -# ----------------------------------------------------------------------------- -libtest_check_order_src_files := \ - empty.cpp - -libtest_check_order_shared_libraries := libtest_check_order_1_left \ - libtest_check_order_2_right libtest_check_order_3_c - -module := libtest_check_order -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# Library with dependency loop used by dlfcn tests -# -# libtest_with_dependency_loop -> a -> b -> c -> a -# ----------------------------------------------------------------------------- -libtest_with_dependency_loop_src_files := empty.cpp - -libtest_with_dependency_loop_shared_libraries := \ - libtest_with_dependency_loop_a - -module := libtest_with_dependency_loop -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_with_dependency_loop_a.so -# ----------------------------------------------------------------------------- -libtest_with_dependency_loop_a_src_files := empty.cpp - -libtest_with_dependency_loop_a_shared_libraries := \ - libtest_with_dependency_loop_b_tmp - -module := libtest_with_dependency_loop_a -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_with_dependency_loop_b.so -# -# this is temporary placeholder - will be removed -# ----------------------------------------------------------------------------- -libtest_with_dependency_loop_b_tmp_src_files := empty.cpp -libtest_with_dependency_loop_b_tmp_ldflags := -Wl,-soname=libtest_with_dependency_loop_b.so - -module := libtest_with_dependency_loop_b_tmp -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_with_dependency_loop_b.so -# ----------------------------------------------------------------------------- -libtest_with_dependency_loop_b_src_files := empty.cpp -libtest_with_dependency_loop_b_shared_libraries := libtest_with_dependency_loop_c - -module := libtest_with_dependency_loop_b -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - -# ----------------------------------------------------------------------------- -# libtest_with_dependency_loop_c.so -# ----------------------------------------------------------------------------- -libtest_with_dependency_loop_c_src_files := empty.cpp - -libtest_with_dependency_loop_c_shared_libraries := \ - libtest_with_dependency_loop_a - -module := libtest_with_dependency_loop_c -build_type := target -build_target := SHARED_LIBRARY -include $(TEST_PATH)/Android.build.mk - # ----------------------------------------------------------------------------- # libtest_relo_check_dt_needed_order.so # | diff --git a/tests/libs/dlopen_testlib_answer.cpp b/tests/libs/dlopen_testlib_answer.cpp deleted file mode 100644 index a4d75046e..000000000 --- a/tests/libs/dlopen_testlib_answer.cpp +++ /dev/null @@ -1,25 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int dlopen_test_get_answer() { - return __ANSWER; -} - -#ifdef __ANSWER2 -extern "C" int dlopen_test_get_answer2() { - return __ANSWER2; -} -#endif diff --git a/tests/uniqueptr_test.cpp b/tests/uniqueptr_test.cpp deleted file mode 100644 index 4b6608af2..000000000 --- a/tests/uniqueptr_test.cpp +++ /dev/null @@ -1,101 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include - -#include - -static int cCount = 0; -struct C { - C() { ++cCount; } - ~C() { --cCount; } -}; - -static bool freed = false; -struct Freer { - void operator() (int* p) { - ASSERT_EQ(123, *p); - free(p); - freed = true; - } -}; - -TEST(UniquePtr, smoke) { - // - // UniquePtr tests... - // - - // Can we free a single object? - { - UniquePtr c(new C); - ASSERT_TRUE(cCount == 1); - } - ASSERT_TRUE(cCount == 0); - // Does release work? - C* rawC; - { - UniquePtr c(new C); - ASSERT_TRUE(cCount == 1); - rawC = c.release(); - } - ASSERT_TRUE(cCount == 1); - delete rawC; - // Does reset work? - { - UniquePtr c(new C); - ASSERT_TRUE(cCount == 1); - c.reset(new C); - ASSERT_TRUE(cCount == 1); - } - ASSERT_TRUE(cCount == 0); - - // - // UniquePtr tests... - // - - // Can we free an array? - { - UniquePtr cs(new C[4]); - ASSERT_TRUE(cCount == 4); - } - ASSERT_TRUE(cCount == 0); - // Does release work? - { - UniquePtr c(new C[4]); - ASSERT_TRUE(cCount == 4); - rawC = c.release(); - } - ASSERT_TRUE(cCount == 4); - delete[] rawC; - // Does reset work? - { - UniquePtr c(new C[4]); - ASSERT_TRUE(cCount == 4); - c.reset(new C[2]); - ASSERT_TRUE(cCount == 2); - } - ASSERT_TRUE(cCount == 0); - - // - // Custom deleter tests... - // - ASSERT_TRUE(!freed); - { - UniquePtr i(reinterpret_cast(malloc(sizeof(int)))); - *i = 123; - } - ASSERT_TRUE(freed); -}