The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1 | /* |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2 | * Copyright (C) 2008 The Android Open Source Project |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 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 | |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 29 | #include <android/api-level.h> |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 30 | #include <dlfcn.h> |
| 31 | #include <errno.h> |
| 32 | #include <fcntl.h> |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 33 | #include <inttypes.h> |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 34 | #include <pthread.h> |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 35 | #include <stdio.h> |
| 36 | #include <stdlib.h> |
| 37 | #include <string.h> |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 38 | #include <sys/mman.h> |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 39 | #include <sys/param.h> |
Dmitriy Ivanov | cf92738 | 2015-10-14 11:15:45 -0700 | [diff] [blame] | 40 | #include <sys/prctl.h> |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 41 | #include <unistd.h> |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 42 | |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 43 | #include <new> |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 44 | #include <string> |
| 45 | #include <vector> |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 46 | |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 47 | // Private C library headers. |
Elliott Hughes | eb847bc | 2013-10-09 15:50:50 -0700 | [diff] [blame] | 48 | #include "private/bionic_tls.h" |
| 49 | #include "private/KernelArgumentBlock.h" |
| 50 | #include "private/ScopedPthreadMutexLocker.h" |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 51 | #include "private/ScopeGuard.h" |
| 52 | #include "private/UniquePtr.h" |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 53 | |
| 54 | #include "linker.h" |
Dmitriy Ivanov | c9ce70d | 2015-03-10 15:30:26 -0700 | [diff] [blame] | 55 | #include "linker_block_allocator.h" |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 56 | #include "linker_debug.h" |
Dmitriy Ivanov | 18870d3 | 2015-04-22 13:10:04 -0700 | [diff] [blame] | 57 | #include "linker_sleb128.h" |
David 'Digit' Turner | 23363ed | 2012-06-18 18:13:49 +0200 | [diff] [blame] | 58 | #include "linker_phdr.h" |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 59 | #include "linker_relocs.h" |
Dmitriy Ivanov | fa26eee | 2015-02-03 16:06:47 -0800 | [diff] [blame] | 60 | #include "linker_reloc_iterators.h" |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 61 | #include "ziparchive/zip_archive.h" |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 62 | |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 63 | extern void __libc_init_AT_SECURE(KernelArgumentBlock&); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 64 | |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 65 | // Override macros to use C++ style casts. |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 66 | #undef ELF_ST_TYPE |
| 67 | #define ELF_ST_TYPE(x) (static_cast<uint32_t>(x) & 0xf) |
| 68 | |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 69 | static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 70 | |
Dmitriy Ivanov | 600bc3c | 2015-03-10 15:43:50 -0700 | [diff] [blame] | 71 | static LinkerTypeAllocator<soinfo> g_soinfo_allocator; |
| 72 | static LinkerTypeAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator; |
Magnus Malmborn | ba98d92 | 2012-09-12 13:00:55 +0200 | [diff] [blame] | 73 | |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 74 | static soinfo* solist; |
| 75 | static soinfo* sonext; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 76 | static soinfo* somain; // main process, always the one after libdl_info |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 77 | |
Elliott Hughes | 1728b23 | 2014-05-14 10:02:03 -0700 | [diff] [blame] | 78 | static const char* const kDefaultLdPaths[] = { |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 79 | #if defined(__LP64__) |
Elliott Hughes | 011bc0b | 2013-10-08 14:27:10 -0700 | [diff] [blame] | 80 | "/vendor/lib64", |
| 81 | "/system/lib64", |
| 82 | #else |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 83 | "/vendor/lib", |
| 84 | "/system/lib", |
Elliott Hughes | 011bc0b | 2013-10-08 14:27:10 -0700 | [diff] [blame] | 85 | #endif |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 86 | nullptr |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 87 | }; |
David Bartley | bc3a5c2 | 2009-06-02 18:27:28 -0700 | [diff] [blame] | 88 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 89 | static const ElfW(Versym) kVersymNotNeeded = 0; |
| 90 | static const ElfW(Versym) kVersymGlobal = 1; |
| 91 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 92 | static std::vector<std::string> g_ld_library_paths; |
| 93 | static std::vector<std::string> g_ld_preload_names; |
Elliott Hughes | a4aafd1 | 2014-01-13 16:37:47 -0800 | [diff] [blame] | 94 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 95 | static std::vector<soinfo*> g_ld_preloads; |
Matt Fischer | 4fd42c1 | 2009-12-31 12:09:10 -0600 | [diff] [blame] | 96 | |
Elliott Hughes | 1728b23 | 2014-05-14 10:02:03 -0700 | [diff] [blame] | 97 | __LIBC_HIDDEN__ int g_ld_debug_verbosity; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 98 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 99 | __LIBC_HIDDEN__ abort_msg_t* g_abort_message = nullptr; // For debuggerd. |
Elliott Hughes | 0d787c1 | 2013-04-04 13:46:46 -0700 | [diff] [blame] | 100 | |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 101 | #if STATS |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 102 | struct linker_stats_t { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 103 | int count[kRelocMax]; |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 104 | }; |
| 105 | |
| 106 | static linker_stats_t linker_stats; |
| 107 | |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 108 | void count_relocation(RelocationKind kind) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 109 | ++linker_stats.count[kind]; |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 110 | } |
| 111 | #else |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 112 | void count_relocation(RelocationKind) { |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 113 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 114 | #endif |
| 115 | |
| 116 | #if COUNT_PAGES |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 117 | uint32_t bitmask[4096]; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 118 | #endif |
| 119 | |
Dima Zavin | 2e85579 | 2009-05-20 18:28:09 -0700 | [diff] [blame] | 120 | static char __linker_dl_err_buf[768]; |
Dima Zavin | 2e85579 | 2009-05-20 18:28:09 -0700 | [diff] [blame] | 121 | |
Elliott Hughes | 650be4e | 2013-03-05 18:47:58 -0800 | [diff] [blame] | 122 | char* linker_get_error_buffer() { |
Elliott Hughes | 5419b94 | 2012-10-16 15:54:46 -0700 | [diff] [blame] | 123 | return &__linker_dl_err_buf[0]; |
Dima Zavin | 2e85579 | 2009-05-20 18:28:09 -0700 | [diff] [blame] | 124 | } |
| 125 | |
Elliott Hughes | 650be4e | 2013-03-05 18:47:58 -0800 | [diff] [blame] | 126 | size_t linker_get_error_buffer_size() { |
| 127 | return sizeof(__linker_dl_err_buf); |
| 128 | } |
| 129 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 130 | // This function is an empty stub where GDB locates a breakpoint to get notified |
| 131 | // about linker activity. |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 132 | extern "C" |
| 133 | void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity(); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 134 | |
Elliott Hughes | 1728b23 | 2014-05-14 10:02:03 -0700 | [diff] [blame] | 135 | static pthread_mutex_t g__r_debug_mutex = PTHREAD_MUTEX_INITIALIZER; |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 136 | static r_debug _r_debug = |
| 137 | {1, nullptr, reinterpret_cast<uintptr_t>(&rtld_db_dlactivity), r_debug::RT_CONSISTENT, 0}; |
| 138 | |
Elliott Hughes | 3a9c5d6 | 2014-02-10 13:31:13 -0800 | [diff] [blame] | 139 | static link_map* r_debug_tail = 0; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 140 | |
Elliott Hughes | 3a9c5d6 | 2014-02-10 13:31:13 -0800 | [diff] [blame] | 141 | static void insert_soinfo_into_debug_map(soinfo* info) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 142 | // Copy the necessary fields into the debug structure. |
| 143 | link_map* map = &(info->link_map_head); |
| 144 | map->l_addr = info->load_bias; |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 145 | // link_map l_name field is not const. |
| 146 | map->l_name = const_cast<char*>(info->get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 147 | map->l_ld = info->dynamic; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 148 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 149 | // Stick the new library at the end of the list. |
| 150 | // gdb tends to care more about libc than it does |
| 151 | // about leaf libraries, and ordering it this way |
| 152 | // reduces the back-and-forth over the wire. |
| 153 | if (r_debug_tail) { |
| 154 | r_debug_tail->l_next = map; |
| 155 | map->l_prev = r_debug_tail; |
| 156 | map->l_next = 0; |
| 157 | } else { |
| 158 | _r_debug.r_map = map; |
| 159 | map->l_prev = 0; |
| 160 | map->l_next = 0; |
| 161 | } |
| 162 | r_debug_tail = map; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 163 | } |
| 164 | |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 165 | static void remove_soinfo_from_debug_map(soinfo* info) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 166 | link_map* map = &(info->link_map_head); |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 167 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 168 | if (r_debug_tail == map) { |
| 169 | r_debug_tail = map->l_prev; |
| 170 | } |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 171 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 172 | if (map->l_prev) { |
| 173 | map->l_prev->l_next = map->l_next; |
| 174 | } |
| 175 | if (map->l_next) { |
| 176 | map->l_next->l_prev = map->l_prev; |
| 177 | } |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 178 | } |
| 179 | |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 180 | static void notify_gdb_of_load(soinfo* info) { |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 181 | if (info->is_main_executable()) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 182 | // GDB already knows about the main executable |
| 183 | return; |
| 184 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 185 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 186 | ScopedPthreadMutexLocker locker(&g__r_debug_mutex); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 187 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 188 | _r_debug.r_state = r_debug::RT_ADD; |
| 189 | rtld_db_dlactivity(); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 190 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 191 | insert_soinfo_into_debug_map(info); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 192 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 193 | _r_debug.r_state = r_debug::RT_CONSISTENT; |
| 194 | rtld_db_dlactivity(); |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 195 | } |
| 196 | |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 197 | static void notify_gdb_of_unload(soinfo* info) { |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 198 | if (info->is_main_executable()) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 199 | // GDB already knows about the main executable |
| 200 | return; |
| 201 | } |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 202 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 203 | ScopedPthreadMutexLocker locker(&g__r_debug_mutex); |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 204 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 205 | _r_debug.r_state = r_debug::RT_DELETE; |
| 206 | rtld_db_dlactivity(); |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 207 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 208 | remove_soinfo_from_debug_map(info); |
Iliyan Malchev | 5e12d7e | 2009-03-24 19:02:00 -0700 | [diff] [blame] | 209 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 210 | _r_debug.r_state = r_debug::RT_CONSISTENT; |
| 211 | rtld_db_dlactivity(); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 212 | } |
| 213 | |
Elliott Hughes | 18a206c | 2012-10-29 17:37:13 -0700 | [diff] [blame] | 214 | void notify_gdb_of_libraries() { |
Elliott Hughes | 3a9c5d6 | 2014-02-10 13:31:13 -0800 | [diff] [blame] | 215 | _r_debug.r_state = r_debug::RT_ADD; |
| 216 | rtld_db_dlactivity(); |
| 217 | _r_debug.r_state = r_debug::RT_CONSISTENT; |
| 218 | rtld_db_dlactivity(); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 219 | } |
| 220 | |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 221 | LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() { |
| 222 | return g_soinfo_links_allocator.alloc(); |
| 223 | } |
| 224 | |
| 225 | void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) { |
| 226 | g_soinfo_links_allocator.free(entry); |
| 227 | } |
| 228 | |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 229 | static soinfo* soinfo_alloc(const char* name, struct stat* file_stat, |
| 230 | off64_t file_offset, uint32_t rtld_flags) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 231 | if (strlen(name) >= PATH_MAX) { |
Magnus Malmborn | ba98d92 | 2012-09-12 13:00:55 +0200 | [diff] [blame] | 232 | DL_ERR("library name \"%s\" too long", name); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 233 | return nullptr; |
Magnus Malmborn | ba98d92 | 2012-09-12 13:00:55 +0200 | [diff] [blame] | 234 | } |
| 235 | |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 236 | soinfo* si = new (g_soinfo_allocator.alloc()) soinfo(name, file_stat, file_offset, rtld_flags); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 237 | |
Magnus Malmborn | ba98d92 | 2012-09-12 13:00:55 +0200 | [diff] [blame] | 238 | sonext->next = si; |
| 239 | sonext = si; |
| 240 | |
Elliott Hughes | ca0c11b | 2013-03-12 10:40:45 -0700 | [diff] [blame] | 241 | TRACE("name %s: allocated soinfo @ %p", name, si); |
Magnus Malmborn | ba98d92 | 2012-09-12 13:00:55 +0200 | [diff] [blame] | 242 | return si; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 243 | } |
| 244 | |
Elliott Hughes | faf05ba | 2014-02-11 16:59:37 -0800 | [diff] [blame] | 245 | static void soinfo_free(soinfo* si) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 246 | if (si == nullptr) { |
| 247 | return; |
| 248 | } |
| 249 | |
| 250 | if (si->base != 0 && si->size != 0) { |
| 251 | munmap(reinterpret_cast<void*>(si->base), si->size); |
| 252 | } |
| 253 | |
| 254 | soinfo *prev = nullptr, *trav; |
| 255 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 256 | TRACE("name %s: freeing soinfo @ %p", si->get_realpath(), si); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 257 | |
| 258 | for (trav = solist; trav != nullptr; trav = trav->next) { |
| 259 | if (trav == si) { |
| 260 | break; |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 261 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 262 | prev = trav; |
| 263 | } |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 264 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 265 | if (trav == nullptr) { |
| 266 | // si was not in solist |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 267 | DL_ERR("name \"%s\"@%p is not in solist!", si->get_realpath(), si); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 268 | return; |
| 269 | } |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 270 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 271 | // clear links to/from si |
| 272 | si->remove_all_links(); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 273 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 274 | // prev will never be null, because the first entry in solist is |
| 275 | // always the static libdl_info. |
| 276 | prev->next = si->next; |
| 277 | if (si == sonext) { |
| 278 | sonext = prev; |
| 279 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 280 | |
Dmitriy Ivanov | a5bb841 | 2015-07-08 15:26:46 -0700 | [diff] [blame] | 281 | si->~soinfo(); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 282 | g_soinfo_allocator.free(si); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 283 | } |
| 284 | |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 285 | static void parse_path(const char* path, const char* delimiters, |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 286 | std::vector<std::string>* paths) { |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 287 | if (path == nullptr) { |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 288 | return; |
| 289 | } |
| 290 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 291 | paths->clear(); |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 292 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 293 | for (const char *p = path; ; ++p) { |
| 294 | size_t len = strcspn(p, delimiters); |
| 295 | // skip empty tokens |
| 296 | if (len == 0) { |
| 297 | continue; |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 298 | } |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 299 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 300 | paths->push_back(std::string(p, len)); |
| 301 | p += len; |
| 302 | |
| 303 | if (*p == '\0') { |
| 304 | break; |
| 305 | } |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 306 | } |
| 307 | } |
| 308 | |
| 309 | static void parse_LD_LIBRARY_PATH(const char* path) { |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 310 | parse_path(path, ":", &g_ld_library_paths); |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | static void parse_LD_PRELOAD(const char* path) { |
| 314 | // We have historically supported ':' as well as ' ' in LD_PRELOAD. |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 315 | parse_path(path, " :", &g_ld_preload_names); |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 316 | } |
| 317 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 318 | static bool realpath_fd(int fd, std::string* realpath) { |
| 319 | std::vector<char> buf(PATH_MAX), proc_self_fd(PATH_MAX); |
| 320 | snprintf(&proc_self_fd[0], proc_self_fd.size(), "/proc/self/fd/%d", fd); |
Dmitriy Ivanov | cf92738 | 2015-10-14 11:15:45 -0700 | [diff] [blame] | 321 | // set DUMPABLE to 1 to access /proc/self/fd |
| 322 | int dumpable = prctl(PR_GET_DUMPABLE, 0, 0, 0, 0); |
| 323 | prctl(PR_SET_DUMPABLE, 1, 0, 0, 0); |
| 324 | auto guard = make_scope_guard([&]() { |
| 325 | // restore dumpable |
| 326 | prctl(PR_SET_DUMPABLE, dumpable, 0, 0, 0); |
| 327 | }); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 328 | if (readlink(&proc_self_fd[0], &buf[0], buf.size()) == -1) { |
Dmitriy Ivanov | ca10ac6 | 2015-05-28 11:44:31 -0700 | [diff] [blame] | 329 | PRINT("readlink('%s') failed: %s [fd=%d]", &proc_self_fd[0], strerror(errno), fd); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 330 | return false; |
| 331 | } |
| 332 | |
| 333 | *realpath = std::string(&buf[0]); |
| 334 | return true; |
| 335 | } |
| 336 | |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 337 | #if defined(__arm__) |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 338 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 339 | // For a given PC, find the .so that it belongs to. |
| 340 | // Returns the base address of the .ARM.exidx section |
| 341 | // for that .so, and the number of 8-byte entries |
| 342 | // in that section (via *pcount). |
| 343 | // |
| 344 | // Intended to be called by libc's __gnu_Unwind_Find_exidx(). |
| 345 | // |
| 346 | // This function is exposed via dlfcn.cpp and libdl.so. |
Elliott Hughes | faf05ba | 2014-02-11 16:59:37 -0800 | [diff] [blame] | 347 | _Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) { |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 348 | uintptr_t addr = reinterpret_cast<uintptr_t>(pc); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 349 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 350 | for (soinfo* si = solist; si != 0; si = si->next) { |
| 351 | if ((addr >= si->base) && (addr < (si->base + si->size))) { |
| 352 | *pcount = si->ARM_exidx_count; |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 353 | return reinterpret_cast<_Unwind_Ptr>(si->ARM_exidx); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 354 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 355 | } |
| 356 | *pcount = 0; |
| 357 | return nullptr; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 358 | } |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 359 | |
Christopher Ferris | 24053a4 | 2013-08-19 17:45:09 -0700 | [diff] [blame] | 360 | #endif |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 361 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 362 | // Here, we only have to provide a callback to iterate across all the |
| 363 | // loaded libraries. gcc_eh does the rest. |
Dmitriy Ivanov | f7d5bf3 | 2015-06-29 14:48:25 -0700 | [diff] [blame] | 364 | int do_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 365 | int rv = 0; |
| 366 | for (soinfo* si = solist; si != nullptr; si = si->next) { |
| 367 | dl_phdr_info dl_info; |
| 368 | dl_info.dlpi_addr = si->link_map_head.l_addr; |
| 369 | dl_info.dlpi_name = si->link_map_head.l_name; |
| 370 | dl_info.dlpi_phdr = si->phdr; |
| 371 | dl_info.dlpi_phnum = si->phnum; |
| 372 | rv = cb(&dl_info, sizeof(dl_phdr_info), data); |
| 373 | if (rv != 0) { |
| 374 | break; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 375 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 376 | } |
| 377 | return rv; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 378 | } |
Elliott Hughes | 4688279 | 2012-08-03 16:49:39 -0700 | [diff] [blame] | 379 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 380 | const ElfW(Versym)* soinfo::get_versym(size_t n) const { |
| 381 | if (has_min_version(2) && versym_ != nullptr) { |
| 382 | return versym_ + n; |
| 383 | } |
| 384 | |
| 385 | return nullptr; |
| 386 | } |
| 387 | |
| 388 | ElfW(Addr) soinfo::get_verneed_ptr() const { |
| 389 | if (has_min_version(2)) { |
| 390 | return verneed_ptr_; |
| 391 | } |
| 392 | |
| 393 | return 0; |
| 394 | } |
| 395 | |
| 396 | size_t soinfo::get_verneed_cnt() const { |
| 397 | if (has_min_version(2)) { |
| 398 | return verneed_cnt_; |
| 399 | } |
| 400 | |
| 401 | return 0; |
| 402 | } |
| 403 | |
| 404 | ElfW(Addr) soinfo::get_verdef_ptr() const { |
| 405 | if (has_min_version(2)) { |
| 406 | return verdef_ptr_; |
| 407 | } |
| 408 | |
| 409 | return 0; |
| 410 | } |
| 411 | |
| 412 | size_t soinfo::get_verdef_cnt() const { |
| 413 | if (has_min_version(2)) { |
| 414 | return verdef_cnt_; |
| 415 | } |
| 416 | |
| 417 | return 0; |
| 418 | } |
| 419 | |
| 420 | template<typename F> |
| 421 | static bool for_each_verdef(const soinfo* si, F functor) { |
| 422 | if (!si->has_min_version(2)) { |
| 423 | return true; |
| 424 | } |
| 425 | |
| 426 | uintptr_t verdef_ptr = si->get_verdef_ptr(); |
| 427 | if (verdef_ptr == 0) { |
| 428 | return true; |
| 429 | } |
| 430 | |
| 431 | size_t offset = 0; |
| 432 | |
| 433 | size_t verdef_cnt = si->get_verdef_cnt(); |
| 434 | for (size_t i = 0; i<verdef_cnt; ++i) { |
| 435 | const ElfW(Verdef)* verdef = reinterpret_cast<ElfW(Verdef)*>(verdef_ptr + offset); |
| 436 | size_t verdaux_offset = offset + verdef->vd_aux; |
| 437 | offset += verdef->vd_next; |
| 438 | |
| 439 | if (verdef->vd_version != 1) { |
Dmitriy Ivanov | 3d7bea1 | 2015-04-20 17:40:39 -0700 | [diff] [blame] | 440 | DL_ERR("unsupported verdef[%zd] vd_version: %d (expected 1) library: %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 441 | i, verdef->vd_version, si->get_realpath()); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 442 | return false; |
| 443 | } |
| 444 | |
| 445 | if ((verdef->vd_flags & VER_FLG_BASE) != 0) { |
| 446 | // "this is the version of the file itself. It must not be used for |
| 447 | // matching a symbol. It can be used to match references." |
| 448 | // |
| 449 | // http://www.akkadia.org/drepper/symbol-versioning |
| 450 | continue; |
| 451 | } |
| 452 | |
| 453 | if (verdef->vd_cnt == 0) { |
| 454 | DL_ERR("invalid verdef[%zd] vd_cnt == 0 (version without a name)", i); |
| 455 | return false; |
| 456 | } |
| 457 | |
| 458 | const ElfW(Verdaux)* verdaux = reinterpret_cast<ElfW(Verdaux)*>(verdef_ptr + verdaux_offset); |
| 459 | |
| 460 | if (functor(i, verdef, verdaux) == true) { |
| 461 | break; |
| 462 | } |
| 463 | } |
| 464 | |
| 465 | return true; |
| 466 | } |
| 467 | |
| 468 | bool soinfo::find_verdef_version_index(const version_info* vi, ElfW(Versym)* versym) const { |
| 469 | if (vi == nullptr) { |
| 470 | *versym = kVersymNotNeeded; |
| 471 | return true; |
| 472 | } |
| 473 | |
| 474 | *versym = kVersymGlobal; |
| 475 | |
| 476 | return for_each_verdef(this, |
| 477 | [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) { |
| 478 | if (verdef->vd_hash == vi->elf_hash && |
| 479 | strcmp(vi->name, get_string(verdaux->vda_name)) == 0) { |
| 480 | *versym = verdef->vd_ndx; |
| 481 | return true; |
| 482 | } |
| 483 | |
| 484 | return false; |
| 485 | } |
| 486 | ); |
| 487 | } |
| 488 | |
| 489 | bool soinfo::find_symbol_by_name(SymbolName& symbol_name, |
| 490 | const version_info* vi, |
| 491 | const ElfW(Sym)** symbol) const { |
| 492 | uint32_t symbol_index; |
| 493 | bool success = |
| 494 | is_gnu_hash() ? |
| 495 | gnu_lookup(symbol_name, vi, &symbol_index) : |
| 496 | elf_lookup(symbol_name, vi, &symbol_index); |
| 497 | |
| 498 | if (success) { |
| 499 | *symbol = symbol_index == 0 ? nullptr : symtab_ + symbol_index; |
| 500 | } |
| 501 | |
| 502 | return success; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 503 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 504 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 505 | static bool is_symbol_global_and_defined(const soinfo* si, const ElfW(Sym)* s) { |
| 506 | if (ELF_ST_BIND(s->st_info) == STB_GLOBAL || |
| 507 | ELF_ST_BIND(s->st_info) == STB_WEAK) { |
| 508 | return s->st_shndx != SHN_UNDEF; |
| 509 | } else if (ELF_ST_BIND(s->st_info) != STB_LOCAL) { |
| 510 | DL_WARN("unexpected ST_BIND value: %d for '%s' in '%s'", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 511 | ELF_ST_BIND(s->st_info), si->get_string(s->st_name), si->get_realpath()); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 512 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 513 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 514 | return false; |
| 515 | } |
| 516 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 517 | static const ElfW(Versym) kVersymHiddenBit = 0x8000; |
| 518 | |
| 519 | static inline bool is_versym_hidden(const ElfW(Versym)* versym) { |
| 520 | // the symbol is hidden if bit 15 of versym is set. |
| 521 | return versym != nullptr && (*versym & kVersymHiddenBit) != 0; |
| 522 | } |
| 523 | |
| 524 | static inline bool check_symbol_version(const ElfW(Versym) verneed, |
| 525 | const ElfW(Versym)* verdef) { |
| 526 | return verneed == kVersymNotNeeded || |
| 527 | verdef == nullptr || |
| 528 | verneed == (*verdef & ~kVersymHiddenBit); |
| 529 | } |
| 530 | |
| 531 | bool soinfo::gnu_lookup(SymbolName& symbol_name, |
| 532 | const version_info* vi, |
| 533 | uint32_t* symbol_index) const { |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 534 | uint32_t hash = symbol_name.gnu_hash(); |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 535 | uint32_t h2 = hash >> gnu_shift2_; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 536 | |
| 537 | uint32_t bloom_mask_bits = sizeof(ElfW(Addr))*8; |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 538 | uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_; |
| 539 | ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 540 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 541 | *symbol_index = 0; |
| 542 | |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 543 | TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 544 | symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 545 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 546 | // test against bloom filter |
| 547 | if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) { |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 548 | TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 549 | symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 550 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 551 | return true; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 552 | } |
| 553 | |
| 554 | // bloom test says "probably yes"... |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 555 | uint32_t n = gnu_bucket_[hash % gnu_nbucket_]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 556 | |
| 557 | if (n == 0) { |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 558 | TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 559 | symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 560 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 561 | return true; |
| 562 | } |
| 563 | |
| 564 | // lookup versym for the version definition in this library |
| 565 | // note the difference between "version is not requested" (vi == nullptr) |
| 566 | // and "version not found". In the first case verneed is kVersymNotNeeded |
| 567 | // which implies that the default version can be accepted; the second case results in |
| 568 | // verneed = 1 (kVersymGlobal) and implies that we should ignore versioned symbols |
| 569 | // for this library and consider only *global* ones. |
| 570 | ElfW(Versym) verneed = 0; |
| 571 | if (!find_verdef_version_index(vi, &verneed)) { |
| 572 | return false; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 573 | } |
| 574 | |
| 575 | do { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 576 | ElfW(Sym)* s = symtab_ + n; |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 577 | const ElfW(Versym)* verdef = get_versym(n); |
| 578 | // skip hidden versions when verneed == kVersymNotNeeded (0) |
| 579 | if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) { |
| 580 | continue; |
| 581 | } |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 582 | if (((gnu_chain_[n] ^ hash) >> 1) == 0 && |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 583 | check_symbol_version(verneed, verdef) && |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 584 | strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 && |
| 585 | is_symbol_global_and_defined(this, s)) { |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 586 | TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 587 | symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value), |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 588 | static_cast<size_t>(s->st_size)); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 589 | *symbol_index = n; |
| 590 | return true; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 591 | } |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 592 | } while ((gnu_chain_[n++] & 1) == 0); |
| 593 | |
| 594 | TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 595 | symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base)); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 596 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 597 | return true; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 598 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 599 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 600 | bool soinfo::elf_lookup(SymbolName& symbol_name, |
| 601 | const version_info* vi, |
| 602 | uint32_t* symbol_index) const { |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 603 | uint32_t hash = symbol_name.elf_hash(); |
| 604 | |
| 605 | TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 606 | symbol_name.get_name(), get_realpath(), |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 607 | reinterpret_cast<void*>(base), hash, hash % nbucket_); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 608 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 609 | ElfW(Versym) verneed = 0; |
| 610 | if (!find_verdef_version_index(vi, &verneed)) { |
| 611 | return false; |
| 612 | } |
| 613 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 614 | for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) { |
| 615 | ElfW(Sym)* s = symtab_ + n; |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 616 | const ElfW(Versym)* verdef = get_versym(n); |
| 617 | |
| 618 | // skip hidden versions when verneed == 0 |
| 619 | if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) { |
| 620 | continue; |
| 621 | } |
| 622 | |
| 623 | if (check_symbol_version(verneed, verdef) && |
| 624 | strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 && |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 625 | is_symbol_global_and_defined(this, s)) { |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 626 | TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 627 | symbol_name.get_name(), get_realpath(), |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 628 | reinterpret_cast<void*>(s->st_value), |
| 629 | static_cast<size_t>(s->st_size)); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 630 | *symbol_index = n; |
| 631 | return true; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 632 | } |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 633 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 634 | |
Dmitriy Ivanov | aa0f2bd | 2014-07-28 17:32:20 -0700 | [diff] [blame] | 635 | TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 636 | symbol_name.get_name(), get_realpath(), |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 637 | reinterpret_cast<void*>(base), hash, hash % nbucket_); |
Dmitriy Ivanov | aa0f2bd | 2014-07-28 17:32:20 -0700 | [diff] [blame] | 638 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 639 | *symbol_index = 0; |
| 640 | return true; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 641 | } |
| 642 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 643 | soinfo::soinfo(const char* realpath, const struct stat* file_stat, |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 644 | off64_t file_offset, int rtld_flags) { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 645 | memset(this, 0, sizeof(*this)); |
| 646 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 647 | if (realpath != nullptr) { |
| 648 | realpath_ = realpath; |
| 649 | } |
| 650 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 651 | flags_ = FLAG_NEW_SOINFO; |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 652 | version_ = SOINFO_VERSION; |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 653 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 654 | if (file_stat != nullptr) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 655 | this->st_dev_ = file_stat->st_dev; |
| 656 | this->st_ino_ = file_stat->st_ino; |
| 657 | this->file_offset_ = file_offset; |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 658 | } |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 659 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 660 | this->rtld_flags_ = rtld_flags; |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 661 | } |
| 662 | |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 663 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 664 | uint32_t SymbolName::elf_hash() { |
| 665 | if (!has_elf_hash_) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 666 | const uint8_t* name = reinterpret_cast<const uint8_t*>(name_); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 667 | uint32_t h = 0, g; |
| 668 | |
| 669 | while (*name) { |
| 670 | h = (h << 4) + *name++; |
| 671 | g = h & 0xf0000000; |
| 672 | h ^= g; |
| 673 | h ^= g >> 24; |
| 674 | } |
| 675 | |
| 676 | elf_hash_ = h; |
| 677 | has_elf_hash_ = true; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 678 | } |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 679 | |
| 680 | return elf_hash_; |
| 681 | } |
| 682 | |
| 683 | uint32_t SymbolName::gnu_hash() { |
| 684 | if (!has_gnu_hash_) { |
| 685 | uint32_t h = 5381; |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 686 | const uint8_t* name = reinterpret_cast<const uint8_t*>(name_); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 687 | while (*name != 0) { |
| 688 | h += (h << 5) + *name++; // h*33 + c = h + h * 32 + c = h + h << 5 + c |
| 689 | } |
| 690 | |
| 691 | gnu_hash_ = h; |
| 692 | has_gnu_hash_ = true; |
| 693 | } |
| 694 | |
| 695 | return gnu_hash_; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 696 | } |
| 697 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 698 | bool soinfo_do_lookup(soinfo* si_from, const char* name, const version_info* vi, |
| 699 | soinfo** si_found_in, const soinfo::soinfo_list_t& global_group, |
| 700 | const soinfo::soinfo_list_t& local_group, const ElfW(Sym)** symbol) { |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 701 | SymbolName symbol_name(name); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 702 | const ElfW(Sym)* s = nullptr; |
Iliyan Malchev | 6ed80c8 | 2009-09-28 19:38:04 -0700 | [diff] [blame] | 703 | |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 704 | /* "This element's presence in a shared object library alters the dynamic linker's |
| 705 | * symbol resolution algorithm for references within the library. Instead of starting |
| 706 | * a symbol search with the executable file, the dynamic linker starts from the shared |
| 707 | * object itself. If the shared object fails to supply the referenced symbol, the |
| 708 | * dynamic linker then searches the executable file and other shared objects as usual." |
| 709 | * |
| 710 | * http://www.sco.com/developers/gabi/2012-12-31/ch5.dynamic.html |
| 711 | * |
| 712 | * Note that this is unlikely since static linker avoids generating |
| 713 | * relocations for -Bsymbolic linked dynamic executables. |
| 714 | */ |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 715 | if (si_from->has_DT_SYMBOLIC) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 716 | DEBUG("%s: looking up %s in local scope (DT_SYMBOLIC)", si_from->get_realpath(), name); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 717 | if (!si_from->find_symbol_by_name(symbol_name, vi, &s)) { |
| 718 | return false; |
| 719 | } |
| 720 | |
Dmitriy Ivanov | 8f61d99 | 2014-09-16 14:31:06 -0700 | [diff] [blame] | 721 | if (s != nullptr) { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 722 | *si_found_in = si_from; |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 723 | } |
| 724 | } |
| 725 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 726 | // 1. Look for it in global_group |
| 727 | if (s == nullptr) { |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 728 | bool error = false; |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 729 | global_group.visit([&](soinfo* global_si) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 730 | DEBUG("%s: looking up %s in %s (from global group)", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 731 | si_from->get_realpath(), name, global_si->get_realpath()); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 732 | if (!global_si->find_symbol_by_name(symbol_name, vi, &s)) { |
| 733 | error = true; |
| 734 | return false; |
| 735 | } |
| 736 | |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 737 | if (s != nullptr) { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 738 | *si_found_in = global_si; |
| 739 | return false; |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 740 | } |
Dmitriy Ivanov | c204894 | 2014-08-29 10:15:25 -0700 | [diff] [blame] | 741 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 742 | return true; |
| 743 | }); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 744 | |
| 745 | if (error) { |
| 746 | return false; |
| 747 | } |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 748 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 749 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 750 | // 2. Look for it in the local group |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 751 | if (s == nullptr) { |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 752 | bool error = false; |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 753 | local_group.visit([&](soinfo* local_si) { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 754 | if (local_si == si_from && si_from->has_DT_SYMBOLIC) { |
Dmitriy Ivanov | e47b3f8 | 2014-10-23 14:19:07 -0700 | [diff] [blame] | 755 | // we already did this - skip |
| 756 | return true; |
| 757 | } |
| 758 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 759 | DEBUG("%s: looking up %s in %s (from local group)", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 760 | si_from->get_realpath(), name, local_si->get_realpath()); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 761 | if (!local_si->find_symbol_by_name(symbol_name, vi, &s)) { |
| 762 | error = true; |
| 763 | return false; |
| 764 | } |
| 765 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 766 | if (s != nullptr) { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 767 | *si_found_in = local_si; |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 768 | return false; |
| 769 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 770 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 771 | return true; |
| 772 | }); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 773 | |
| 774 | if (error) { |
| 775 | return false; |
| 776 | } |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 777 | } |
| 778 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 779 | if (s != nullptr) { |
| 780 | TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, " |
| 781 | "found in %s, base = %p, load bias = %p", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 782 | si_from->get_realpath(), name, reinterpret_cast<void*>(s->st_value), |
| 783 | (*si_found_in)->get_realpath(), reinterpret_cast<void*>((*si_found_in)->base), |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 784 | reinterpret_cast<void*>((*si_found_in)->load_bias)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 785 | } |
Iliyan Malchev | 6ed80c8 | 2009-09-28 19:38:04 -0700 | [diff] [blame] | 786 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 787 | *symbol = s; |
| 788 | return true; |
Iliyan Malchev | 6ed80c8 | 2009-09-28 19:38:04 -0700 | [diff] [blame] | 789 | } |
| 790 | |
Dmitriy Ivanov | 279a22f | 2015-01-23 12:03:53 -0800 | [diff] [blame] | 791 | class ProtectedDataGuard { |
| 792 | public: |
| 793 | ProtectedDataGuard() { |
| 794 | if (ref_count_++ == 0) { |
| 795 | protect_data(PROT_READ | PROT_WRITE); |
| 796 | } |
| 797 | } |
| 798 | |
| 799 | ~ProtectedDataGuard() { |
| 800 | if (ref_count_ == 0) { // overflow |
| 801 | __libc_fatal("Too many nested calls to dlopen()"); |
| 802 | } |
| 803 | |
| 804 | if (--ref_count_ == 0) { |
| 805 | protect_data(PROT_READ); |
| 806 | } |
| 807 | } |
| 808 | private: |
| 809 | void protect_data(int protection) { |
| 810 | g_soinfo_allocator.protect_all(protection); |
| 811 | g_soinfo_links_allocator.protect_all(protection); |
| 812 | } |
| 813 | |
| 814 | static size_t ref_count_; |
| 815 | }; |
| 816 | |
| 817 | size_t ProtectedDataGuard::ref_count_ = 0; |
| 818 | |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 819 | // Each size has it's own allocator. |
| 820 | template<size_t size> |
| 821 | class SizeBasedAllocator { |
| 822 | public: |
| 823 | static void* alloc() { |
| 824 | return allocator_.alloc(); |
| 825 | } |
Dmitriy Ivanov | 4bea498 | 2014-08-29 14:01:48 -0700 | [diff] [blame] | 826 | |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 827 | static void free(void* ptr) { |
| 828 | allocator_.free(ptr); |
| 829 | } |
Dmitriy Ivanov | 4bea498 | 2014-08-29 14:01:48 -0700 | [diff] [blame] | 830 | |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 831 | private: |
| 832 | static LinkerBlockAllocator allocator_; |
| 833 | }; |
| 834 | |
| 835 | template<size_t size> |
| 836 | LinkerBlockAllocator SizeBasedAllocator<size>::allocator_(size); |
| 837 | |
| 838 | template<typename T> |
| 839 | class TypeBasedAllocator { |
| 840 | public: |
| 841 | static T* alloc() { |
| 842 | return reinterpret_cast<T*>(SizeBasedAllocator<sizeof(T)>::alloc()); |
| 843 | } |
| 844 | |
| 845 | static void free(T* ptr) { |
| 846 | SizeBasedAllocator<sizeof(T)>::free(ptr); |
| 847 | } |
| 848 | }; |
| 849 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 850 | class LoadTask { |
| 851 | public: |
| 852 | struct deleter_t { |
| 853 | void operator()(LoadTask* t) { |
| 854 | TypeBasedAllocator<LoadTask>::free(t); |
| 855 | } |
| 856 | }; |
| 857 | |
| 858 | typedef UniquePtr<LoadTask, deleter_t> unique_ptr; |
| 859 | |
| 860 | static deleter_t deleter; |
| 861 | |
| 862 | static LoadTask* create(const char* name, soinfo* needed_by) { |
| 863 | LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc(); |
| 864 | return new (ptr) LoadTask(name, needed_by); |
| 865 | } |
| 866 | |
| 867 | const char* get_name() const { |
| 868 | return name_; |
| 869 | } |
| 870 | |
| 871 | soinfo* get_needed_by() const { |
| 872 | return needed_by_; |
| 873 | } |
| 874 | private: |
| 875 | LoadTask(const char* name, soinfo* needed_by) |
| 876 | : name_(name), needed_by_(needed_by) {} |
| 877 | |
| 878 | const char* name_; |
| 879 | soinfo* needed_by_; |
| 880 | |
| 881 | DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask); |
| 882 | }; |
| 883 | |
Ningsheng Jian | e93be99 | 2014-09-16 15:22:10 +0800 | [diff] [blame] | 884 | LoadTask::deleter_t LoadTask::deleter; |
| 885 | |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 886 | template <typename T> |
| 887 | using linked_list_t = LinkedList<T, TypeBasedAllocator<LinkedListEntry<T>>>; |
| 888 | |
| 889 | typedef linked_list_t<soinfo> SoinfoLinkedList; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 890 | typedef linked_list_t<const char> StringLinkedList; |
| 891 | typedef linked_list_t<LoadTask> LoadTaskList; |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 892 | |
Dmitriy Ivanov | aa0f2bd | 2014-07-28 17:32:20 -0700 | [diff] [blame] | 893 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 894 | // This function walks down the tree of soinfo dependencies |
| 895 | // in breadth-first order and |
| 896 | // * calls action(soinfo* si) for each node, and |
| 897 | // * terminates walk if action returns false. |
| 898 | // |
| 899 | // walk_dependencies_tree returns false if walk was terminated |
| 900 | // by the action and true otherwise. |
| 901 | template<typename F> |
| 902 | static bool walk_dependencies_tree(soinfo* root_soinfos[], size_t root_soinfos_size, F action) { |
Dmitriy Ivanov | 0cd83eb | 2014-09-01 16:15:52 -0700 | [diff] [blame] | 903 | SoinfoLinkedList visit_list; |
| 904 | SoinfoLinkedList visited; |
| 905 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 906 | for (size_t i = 0; i < root_soinfos_size; ++i) { |
| 907 | visit_list.push_back(root_soinfos[i]); |
| 908 | } |
| 909 | |
| 910 | soinfo* si; |
| 911 | while ((si = visit_list.pop_front()) != nullptr) { |
| 912 | if (visited.contains(si)) { |
Dmitriy Ivanov | 042426b | 2014-08-12 21:02:13 -0700 | [diff] [blame] | 913 | continue; |
| 914 | } |
| 915 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 916 | if (!action(si)) { |
| 917 | return false; |
Dmitriy Ivanov | aa0f2bd | 2014-07-28 17:32:20 -0700 | [diff] [blame] | 918 | } |
| 919 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 920 | visited.push_back(si); |
| 921 | |
| 922 | si->get_children().for_each([&](soinfo* child) { |
Dmitriy Ivanov | aa0f2bd | 2014-07-28 17:32:20 -0700 | [diff] [blame] | 923 | visit_list.push_back(child); |
| 924 | }); |
| 925 | } |
| 926 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 927 | return true; |
| 928 | } |
| 929 | |
| 930 | |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 931 | static const ElfW(Sym)* dlsym_handle_lookup(soinfo* root, soinfo* skip_until, |
| 932 | soinfo** found, SymbolName& symbol_name) { |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 933 | const ElfW(Sym)* result = nullptr; |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 934 | bool skip_lookup = skip_until != nullptr; |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 935 | |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 936 | walk_dependencies_tree(&root, 1, [&](soinfo* current_soinfo) { |
| 937 | if (skip_lookup) { |
| 938 | skip_lookup = current_soinfo != skip_until; |
| 939 | return true; |
| 940 | } |
| 941 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 942 | if (!current_soinfo->find_symbol_by_name(symbol_name, nullptr, &result)) { |
| 943 | result = nullptr; |
| 944 | return false; |
| 945 | } |
| 946 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 947 | if (result != nullptr) { |
| 948 | *found = current_soinfo; |
| 949 | return false; |
| 950 | } |
| 951 | |
| 952 | return true; |
| 953 | }); |
| 954 | |
| 955 | return result; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 956 | } |
| 957 | |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 958 | // This is used by dlsym(3). It performs symbol lookup only within the |
| 959 | // specified soinfo object and its dependencies in breadth first order. |
| 960 | const ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) { |
Dmitriy Ivanov | c4ebe60 | 2015-05-30 13:04:39 -0700 | [diff] [blame] | 961 | // According to man dlopen(3) and posix docs in the case when si is handle |
| 962 | // of the main executable we need to search not only in the executable and its |
| 963 | // dependencies but also in all libraries loaded with RTLD_GLOBAL. |
| 964 | // |
| 965 | // Since RTLD_GLOBAL is always set for the main executable and all dt_needed shared |
| 966 | // libraries and they are loaded in breath-first (correct) order we can just execute |
| 967 | // dlsym(RTLD_DEFAULT, ...); instead of doing two stage lookup. |
| 968 | if (si == somain) { |
| 969 | return dlsym_linear_lookup(name, found, nullptr, RTLD_DEFAULT); |
| 970 | } |
| 971 | |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 972 | SymbolName symbol_name(name); |
| 973 | return dlsym_handle_lookup(si, nullptr, found, symbol_name); |
| 974 | } |
| 975 | |
Brian Carlstrom | d4ee82d | 2013-02-28 15:58:45 -0800 | [diff] [blame] | 976 | /* This is used by dlsym(3) to performs a global symbol lookup. If the |
| 977 | start value is null (for RTLD_DEFAULT), the search starts at the |
| 978 | beginning of the global solist. Otherwise the search starts at the |
| 979 | specified soinfo (for RTLD_NEXT). |
Iliyan Malchev | 6ed80c8 | 2009-09-28 19:38:04 -0700 | [diff] [blame] | 980 | */ |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 981 | const ElfW(Sym)* dlsym_linear_lookup(const char* name, |
| 982 | soinfo** found, |
| 983 | soinfo* caller, |
| 984 | void* handle) { |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 985 | SymbolName symbol_name(name); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 986 | |
Dmitriy Ivanov | 76ac1ac | 2015-04-01 14:45:10 -0700 | [diff] [blame] | 987 | soinfo* start = solist; |
| 988 | |
| 989 | if (handle == RTLD_NEXT) { |
Dmitriy Ivanov | 15309fd | 2015-05-22 12:34:42 -0700 | [diff] [blame] | 990 | if (caller == nullptr) { |
Dmitriy Ivanov | 76ac1ac | 2015-04-01 14:45:10 -0700 | [diff] [blame] | 991 | return nullptr; |
| 992 | } else { |
| 993 | start = caller->next; |
| 994 | } |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 995 | } |
| 996 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 997 | const ElfW(Sym)* s = nullptr; |
Dmitriy Ivanov | 76ac1ac | 2015-04-01 14:45:10 -0700 | [diff] [blame] | 998 | for (soinfo* si = start; si != nullptr; si = si->next) { |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 999 | // Do not skip RTLD_LOCAL libraries in dlsym(RTLD_DEFAULT, ...) |
| 1000 | // if the library is opened by application with target api level <= 22 |
| 1001 | // See http://b/21565766 |
| 1002 | if ((si->get_rtld_flags() & RTLD_GLOBAL) == 0 && si->get_target_sdk_version() > 22) { |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 1003 | continue; |
| 1004 | } |
| 1005 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1006 | if (!si->find_symbol_by_name(symbol_name, nullptr, &s)) { |
| 1007 | return nullptr; |
| 1008 | } |
| 1009 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1010 | if (s != nullptr) { |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1011 | *found = si; |
| 1012 | break; |
Matt Fischer | 1698d9e | 2009-12-31 12:17:56 -0600 | [diff] [blame] | 1013 | } |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1014 | } |
Matt Fischer | 1698d9e | 2009-12-31 12:17:56 -0600 | [diff] [blame] | 1015 | |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 1016 | // If not found - use dlsym_handle_lookup for caller's |
| 1017 | // local_group unless it is part of the global group in which |
Dmitriy Ivanov | 76ac1ac | 2015-04-01 14:45:10 -0700 | [diff] [blame] | 1018 | // case we already did it. |
| 1019 | if (s == nullptr && caller != nullptr && |
| 1020 | (caller->get_rtld_flags() & RTLD_GLOBAL) == 0) { |
Dmitriy Ivanov | 4bac6ea | 2015-05-12 11:12:27 -0700 | [diff] [blame] | 1021 | return dlsym_handle_lookup(caller->get_local_group_root(), |
| 1022 | (handle == RTLD_NEXT) ? caller : nullptr, found, symbol_name); |
Dmitriy Ivanov | 76ac1ac | 2015-04-01 14:45:10 -0700 | [diff] [blame] | 1023 | } |
| 1024 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1025 | if (s != nullptr) { |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1026 | TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p", |
| 1027 | name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base)); |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1028 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1029 | |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1030 | return s; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1031 | } |
| 1032 | |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1033 | soinfo* find_containing_library(const void* p) { |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 1034 | ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1035 | for (soinfo* si = solist; si != nullptr; si = si->next) { |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1036 | if (address >= si->base && address - si->base < si->size) { |
| 1037 | return si; |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1038 | } |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1039 | } |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1040 | return nullptr; |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1041 | } |
| 1042 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1043 | ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) { |
| 1044 | return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr); |
| 1045 | } |
| 1046 | |
| 1047 | static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) { |
| 1048 | return sym->st_shndx != SHN_UNDEF && |
| 1049 | soaddr >= sym->st_value && |
| 1050 | soaddr < sym->st_value + sym->st_size; |
| 1051 | } |
| 1052 | |
| 1053 | ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) { |
Chris Dearman | 8e55381 | 2013-11-13 17:22:33 -0800 | [diff] [blame] | 1054 | ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1055 | |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 1056 | for (size_t i = 0; i < gnu_nbucket_; ++i) { |
| 1057 | uint32_t n = gnu_bucket_[i]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1058 | |
| 1059 | if (n == 0) { |
| 1060 | continue; |
| 1061 | } |
| 1062 | |
| 1063 | do { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1064 | ElfW(Sym)* sym = symtab_ + n; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1065 | if (symbol_matches_soaddr(sym, soaddr)) { |
| 1066 | return sym; |
| 1067 | } |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 1068 | } while ((gnu_chain_[n++] & 1) == 0); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1069 | } |
| 1070 | |
| 1071 | return nullptr; |
| 1072 | } |
| 1073 | |
| 1074 | ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) { |
Chris Dearman | 8e55381 | 2013-11-13 17:22:33 -0800 | [diff] [blame] | 1075 | ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias; |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1076 | |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1077 | // Search the library's symbol table for any defined symbol which |
| 1078 | // contains this address. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1079 | for (size_t i = 0; i < nchain_; ++i) { |
| 1080 | ElfW(Sym)* sym = symtab_ + i; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 1081 | if (symbol_matches_soaddr(sym, soaddr)) { |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1082 | return sym; |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1083 | } |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 1084 | } |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1085 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1086 | return nullptr; |
Matt Fischer | e2a8b1f | 2009-12-31 12:17:40 -0600 | [diff] [blame] | 1087 | } |
| 1088 | |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1089 | static int open_library_in_zipfile(const char* const path, |
| 1090 | off64_t* file_offset) { |
| 1091 | TRACE("Trying zip file open from path '%s'", path); |
| 1092 | |
Dmitriy Ivanov | 524f1f1 | 2015-06-09 13:46:51 -0700 | [diff] [blame] | 1093 | // Treat an '!/' separator inside a path as the separator between the name |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1094 | // of the zip file on disk and the subdirectory to search within it. |
Dmitriy Ivanov | 524f1f1 | 2015-06-09 13:46:51 -0700 | [diff] [blame] | 1095 | // For example, if path is "foo.zip!/bar/bas/x.so", then we search for |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1096 | // "bar/bas/x.so" within "foo.zip". |
Dmitriy Ivanov | 524f1f1 | 2015-06-09 13:46:51 -0700 | [diff] [blame] | 1097 | const char* separator = strstr(path, "!/"); |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1098 | if (separator == nullptr) { |
| 1099 | return -1; |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1100 | } |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1101 | |
| 1102 | char buf[512]; |
| 1103 | if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf)) { |
| 1104 | PRINT("Warning: ignoring very long library path: %s", path); |
| 1105 | return -1; |
| 1106 | } |
| 1107 | |
| 1108 | buf[separator - path] = '\0'; |
| 1109 | |
| 1110 | const char* zip_path = buf; |
Dmitriy Ivanov | 524f1f1 | 2015-06-09 13:46:51 -0700 | [diff] [blame] | 1111 | const char* file_path = &buf[separator - path + 2]; |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1112 | int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC)); |
| 1113 | if (fd == -1) { |
| 1114 | return -1; |
| 1115 | } |
| 1116 | |
| 1117 | ZipArchiveHandle handle; |
| 1118 | if (OpenArchiveFd(fd, "", &handle, false) != 0) { |
| 1119 | // invalid zip-file (?) |
| 1120 | close(fd); |
| 1121 | return -1; |
| 1122 | } |
| 1123 | |
| 1124 | auto archive_guard = make_scope_guard([&]() { |
| 1125 | CloseArchive(handle); |
| 1126 | }); |
| 1127 | |
| 1128 | ZipEntry entry; |
| 1129 | |
| 1130 | if (FindEntry(handle, ZipEntryName(file_path), &entry) != 0) { |
| 1131 | // Entry was not found. |
| 1132 | close(fd); |
| 1133 | return -1; |
| 1134 | } |
| 1135 | |
| 1136 | // Check if it is properly stored |
| 1137 | if (entry.method != kCompressStored || (entry.offset % PAGE_SIZE) != 0) { |
| 1138 | close(fd); |
| 1139 | return -1; |
| 1140 | } |
| 1141 | |
| 1142 | *file_offset = entry.offset; |
| 1143 | return fd; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1144 | } |
| 1145 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1146 | static bool format_path(char* buf, size_t buf_size, const char* path, const char* name) { |
| 1147 | int n = __libc_format_buffer(buf, buf_size, "%s/%s", path, name); |
| 1148 | if (n < 0 || n >= static_cast<int>(buf_size)) { |
| 1149 | PRINT("Warning: ignoring very long library path: %s/%s", path, name); |
| 1150 | return false; |
| 1151 | } |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1152 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1153 | return true; |
| 1154 | } |
| 1155 | |
| 1156 | static int open_library_on_default_path(const char* name, off64_t* file_offset) { |
| 1157 | for (size_t i = 0; kDefaultLdPaths[i] != nullptr; ++i) { |
| 1158 | char buf[512]; |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1159 | if (!format_path(buf, sizeof(buf), kDefaultLdPaths[i], name)) { |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1160 | continue; |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1161 | } |
| 1162 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1163 | int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC)); |
| 1164 | if (fd != -1) { |
| 1165 | *file_offset = 0; |
| 1166 | return fd; |
| 1167 | } |
| 1168 | } |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1169 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1170 | return -1; |
| 1171 | } |
| 1172 | |
| 1173 | static int open_library_on_ld_library_path(const char* name, off64_t* file_offset) { |
| 1174 | for (const auto& path_str : g_ld_library_paths) { |
| 1175 | char buf[512]; |
| 1176 | const char* const path = path_str.c_str(); |
| 1177 | if (!format_path(buf, sizeof(buf), path, name)) { |
| 1178 | continue; |
| 1179 | } |
| 1180 | |
| 1181 | int fd = -1; |
| 1182 | if (strchr(buf, '!') != nullptr) { |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1183 | fd = open_library_in_zipfile(buf, file_offset); |
| 1184 | } |
| 1185 | |
| 1186 | if (fd == -1) { |
| 1187 | fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC)); |
| 1188 | if (fd != -1) { |
| 1189 | *file_offset = 0; |
| 1190 | } |
| 1191 | } |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1192 | |
| 1193 | if (fd != -1) { |
| 1194 | return fd; |
| 1195 | } |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1196 | } |
| 1197 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1198 | return -1; |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1199 | } |
| 1200 | |
| 1201 | static int open_library(const char* name, off64_t* file_offset) { |
Elliott Hughes | ca0c11b | 2013-03-12 10:40:45 -0700 | [diff] [blame] | 1202 | TRACE("[ opening %s ]", name); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1203 | |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1204 | // If the name contains a slash, we should attempt to open it directly and not search the paths. |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1205 | if (strchr(name, '/') != nullptr) { |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1206 | if (strchr(name, '!') != nullptr) { |
| 1207 | int fd = open_library_in_zipfile(name, file_offset); |
| 1208 | if (fd != -1) { |
| 1209 | return fd; |
| 1210 | } |
| 1211 | } |
| 1212 | |
Elliott Hughes | 6971fe4 | 2012-11-01 22:59:19 -0700 | [diff] [blame] | 1213 | int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC)); |
| 1214 | if (fd != -1) { |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1215 | *file_offset = 0; |
Elliott Hughes | 6971fe4 | 2012-11-01 22:59:19 -0700 | [diff] [blame] | 1216 | } |
Dmitriy Ivanov | e44fffd | 2015-03-17 17:12:18 -0700 | [diff] [blame] | 1217 | return fd; |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1218 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1219 | |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1220 | // Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths. |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1221 | int fd = open_library_on_ld_library_path(name, file_offset); |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1222 | if (fd == -1) { |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1223 | fd = open_library_on_default_path(name, file_offset); |
Elliott Hughes | 124fae9 | 2012-10-31 14:20:03 -0700 | [diff] [blame] | 1224 | } |
| 1225 | return fd; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1226 | } |
| 1227 | |
Dmitriy Ivanov | 4a7c3af | 2015-05-27 18:29:41 -0700 | [diff] [blame] | 1228 | static const char* fix_dt_needed(const char* dt_needed, const char* sopath __unused) { |
| 1229 | #if !defined(__LP64__) |
| 1230 | // Work around incorrect DT_NEEDED entries for old apps: http://b/21364029 |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 1231 | if (get_application_target_sdk_version() <= 22) { |
Dmitriy Ivanov | 4a7c3af | 2015-05-27 18:29:41 -0700 | [diff] [blame] | 1232 | const char* bname = basename(dt_needed); |
| 1233 | if (bname != dt_needed) { |
| 1234 | DL_WARN("'%s' library has invalid DT_NEEDED entry '%s'", sopath, dt_needed); |
| 1235 | } |
| 1236 | |
| 1237 | return bname; |
| 1238 | } |
| 1239 | #endif |
| 1240 | return dt_needed; |
| 1241 | } |
| 1242 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1243 | template<typename F> |
| 1244 | static void for_each_dt_needed(const soinfo* si, F action) { |
| 1245 | for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) { |
| 1246 | if (d->d_tag == DT_NEEDED) { |
Dmitriy Ivanov | 4a7c3af | 2015-05-27 18:29:41 -0700 | [diff] [blame] | 1247 | action(fix_dt_needed(si->get_string(d->d_un.d_val), si->get_realpath())); |
Dima Zavin | 2e85579 | 2009-05-20 18:28:09 -0700 | [diff] [blame] | 1248 | } |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1249 | } |
| 1250 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1251 | |
Spencer Low | 2a44cfb | 2015-04-22 18:06:51 -0700 | [diff] [blame] | 1252 | static soinfo* load_library(int fd, off64_t file_offset, |
| 1253 | LoadTaskList& load_tasks, |
Simon Baldwin | aef7195 | 2015-01-16 13:22:54 +0000 | [diff] [blame] | 1254 | const char* name, int rtld_flags, |
| 1255 | const android_dlextinfo* extinfo) { |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 1256 | if ((file_offset % PAGE_SIZE) != 0) { |
Dmitriy Ivanov | a6c1279 | 2014-10-21 12:09:18 -0700 | [diff] [blame] | 1257 | DL_ERR("file offset for the library \"%s\" is not page-aligned: %" PRId64, name, file_offset); |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 1258 | return nullptr; |
| 1259 | } |
Yabin Cui | 16f7f8d | 2014-11-04 11:08:05 -0800 | [diff] [blame] | 1260 | if (file_offset < 0) { |
| 1261 | DL_ERR("file offset for the library \"%s\" is negative: %" PRId64, name, file_offset); |
| 1262 | return nullptr; |
| 1263 | } |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 1264 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1265 | struct stat file_stat; |
| 1266 | if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) { |
Dmitriy Ivanov | a6c1279 | 2014-10-21 12:09:18 -0700 | [diff] [blame] | 1267 | DL_ERR("unable to stat file for the library \"%s\": %s", name, strerror(errno)); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1268 | return nullptr; |
| 1269 | } |
Yabin Cui | 16f7f8d | 2014-11-04 11:08:05 -0800 | [diff] [blame] | 1270 | if (file_offset >= file_stat.st_size) { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1271 | DL_ERR("file offset for the library \"%s\" >= file size: %" PRId64 " >= %" PRId64, |
| 1272 | name, file_offset, file_stat.st_size); |
Yabin Cui | 16f7f8d | 2014-11-04 11:08:05 -0800 | [diff] [blame] | 1273 | return nullptr; |
| 1274 | } |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1275 | |
| 1276 | // Check for symlink and other situations where |
Dmitriy Ivanov | 9b82136 | 2015-04-02 16:03:56 -0700 | [diff] [blame] | 1277 | // file can have different names, unless ANDROID_DLEXT_FORCE_LOAD is set |
| 1278 | if (extinfo == nullptr || (extinfo->flags & ANDROID_DLEXT_FORCE_LOAD) == 0) { |
| 1279 | for (soinfo* si = solist; si != nullptr; si = si->next) { |
| 1280 | if (si->get_st_dev() != 0 && |
| 1281 | si->get_st_ino() != 0 && |
| 1282 | si->get_st_dev() == file_stat.st_dev && |
| 1283 | si->get_st_ino() == file_stat.st_ino && |
| 1284 | si->get_file_offset() == file_offset) { |
| 1285 | TRACE("library \"%s\" is already loaded under different name/path \"%s\" - " |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1286 | "will return existing soinfo", name, si->get_realpath()); |
Dmitriy Ivanov | 9b82136 | 2015-04-02 16:03:56 -0700 | [diff] [blame] | 1287 | return si; |
| 1288 | } |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1289 | } |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1290 | } |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1291 | |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 1292 | if ((rtld_flags & RTLD_NOLOAD) != 0) { |
Dmitriy Ivanov | a6ac54a | 2014-09-09 10:21:42 -0700 | [diff] [blame] | 1293 | DL_ERR("library \"%s\" wasn't loaded and RTLD_NOLOAD prevented it", name); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1294 | return nullptr; |
| 1295 | } |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1296 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1297 | std::string realpath = name; |
| 1298 | if (!realpath_fd(fd, &realpath)) { |
Dmitriy Ivanov | ca10ac6 | 2015-05-28 11:44:31 -0700 | [diff] [blame] | 1299 | PRINT("warning: unable to get realpath for the library \"%s\". Will use given name.", name); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1300 | realpath = name; |
| 1301 | } |
| 1302 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1303 | // Read the ELF header and load the segments. |
Dmitriy Ivanov | 06700b2 | 2015-06-25 15:51:41 -0700 | [diff] [blame] | 1304 | ElfReader elf_reader(realpath.c_str(), fd, file_offset, file_stat.st_size); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1305 | if (!elf_reader.Load(extinfo)) { |
| 1306 | return nullptr; |
| 1307 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1308 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1309 | soinfo* si = soinfo_alloc(realpath.c_str(), &file_stat, file_offset, rtld_flags); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1310 | if (si == nullptr) { |
| 1311 | return nullptr; |
| 1312 | } |
| 1313 | si->base = elf_reader.load_start(); |
| 1314 | si->size = elf_reader.load_size(); |
| 1315 | si->load_bias = elf_reader.load_bias(); |
| 1316 | si->phnum = elf_reader.phdr_count(); |
| 1317 | si->phdr = elf_reader.loaded_phdr(); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1318 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1319 | if (!si->prelink_image()) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1320 | soinfo_free(si); |
| 1321 | return nullptr; |
| 1322 | } |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1323 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1324 | for_each_dt_needed(si, [&] (const char* name) { |
| 1325 | load_tasks.push_back(LoadTask::create(name, si)); |
| 1326 | }); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1327 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1328 | return si; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1329 | } |
| 1330 | |
Spencer Low | 2a44cfb | 2015-04-22 18:06:51 -0700 | [diff] [blame] | 1331 | static soinfo* load_library(LoadTaskList& load_tasks, |
| 1332 | const char* name, int rtld_flags, |
| 1333 | const android_dlextinfo* extinfo) { |
| 1334 | if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) { |
| 1335 | off64_t file_offset = 0; |
| 1336 | if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) { |
| 1337 | file_offset = extinfo->library_fd_offset; |
| 1338 | } |
| 1339 | return load_library(extinfo->library_fd, file_offset, load_tasks, name, rtld_flags, extinfo); |
| 1340 | } |
| 1341 | |
| 1342 | // Open the file. |
| 1343 | off64_t file_offset; |
| 1344 | int fd = open_library(name, &file_offset); |
| 1345 | if (fd == -1) { |
| 1346 | DL_ERR("library \"%s\" not found", name); |
| 1347 | return nullptr; |
| 1348 | } |
| 1349 | soinfo* result = load_library(fd, file_offset, load_tasks, name, rtld_flags, extinfo); |
| 1350 | close(fd); |
| 1351 | return result; |
| 1352 | } |
| 1353 | |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1354 | // Returns true if library was found and false in 2 cases |
| 1355 | // 1. The library was found but loaded under different target_sdk_version |
| 1356 | // (*candidate != nullptr) |
| 1357 | // 2. The library was not found by soname (*candidate is nullptr) |
| 1358 | static bool find_loaded_library_by_soname(const char* name, soinfo** candidate) { |
| 1359 | *candidate = nullptr; |
| 1360 | |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 1361 | // Ignore filename with path. |
| 1362 | if (strchr(name, '/') != nullptr) { |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1363 | return false; |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 1364 | } |
| 1365 | |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1366 | uint32_t target_sdk_version = get_application_target_sdk_version(); |
| 1367 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1368 | for (soinfo* si = solist; si != nullptr; si = si->next) { |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 1369 | const char* soname = si->get_soname(); |
| 1370 | if (soname != nullptr && (strcmp(name, soname) == 0)) { |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1371 | // If the library was opened under different target sdk version |
| 1372 | // skip this step and try to reopen it. The exceptions are |
| 1373 | // "libdl.so" and global group. There is no point in skipping |
| 1374 | // them because relocation process is going to use them |
| 1375 | // in any case. |
| 1376 | bool is_libdl = si == solist; |
| 1377 | if (is_libdl || (si->get_dt_flags_1() & DF_1_GLOBAL) != 0 || |
| 1378 | !si->is_linked() || si->get_target_sdk_version() == target_sdk_version) { |
| 1379 | *candidate = si; |
| 1380 | return true; |
| 1381 | } else if (*candidate == nullptr) { |
| 1382 | // for the different sdk version - remember the first library. |
| 1383 | *candidate = si; |
| 1384 | } |
Ard Biesheuvel | 12c78bb | 2012-08-14 12:30:09 +0200 | [diff] [blame] | 1385 | } |
Dmitriy Ivanov | 489e498 | 2014-05-19 15:19:52 -0700 | [diff] [blame] | 1386 | } |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1387 | |
| 1388 | return false; |
Ard Biesheuvel | 12c78bb | 2012-08-14 12:30:09 +0200 | [diff] [blame] | 1389 | } |
| 1390 | |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1391 | static soinfo* find_library_internal(LoadTaskList& load_tasks, const char* name, |
| 1392 | int rtld_flags, const android_dlextinfo* extinfo) { |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1393 | soinfo* candidate; |
| 1394 | |
| 1395 | if (find_loaded_library_by_soname(name, &candidate)) { |
| 1396 | return candidate; |
| 1397 | } |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1398 | |
| 1399 | // Library might still be loaded, the accurate detection |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1400 | // of this fact is done by load_library. |
Dmitriy Ivanov | 28154f5 | 2015-06-16 15:38:21 -0700 | [diff] [blame] | 1401 | TRACE("[ '%s' find_loaded_library_by_soname returned false (*candidate=%s@%p). Trying harder...]", |
| 1402 | name, candidate == nullptr ? "n/a" : candidate->get_realpath(), candidate); |
| 1403 | |
| 1404 | soinfo* si = load_library(load_tasks, name, rtld_flags, extinfo); |
| 1405 | |
| 1406 | // In case we were unable to load the library but there |
| 1407 | // is a candidate loaded under the same soname but different |
| 1408 | // sdk level - return it anyways. |
| 1409 | if (si == nullptr && candidate != nullptr) { |
| 1410 | si = candidate; |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1411 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1412 | |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1413 | return si; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1414 | } |
| 1415 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1416 | static void soinfo_unload(soinfo* si); |
| 1417 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 1418 | // TODO: this is slightly unusual way to construct |
| 1419 | // the global group for relocation. Not every RTLD_GLOBAL |
| 1420 | // library is included in this group for backwards-compatibility |
| 1421 | // reasons. |
| 1422 | // |
| 1423 | // This group consists of the main executable, LD_PRELOADs |
| 1424 | // and libraries with the DF_1_GLOBAL flag set. |
| 1425 | static soinfo::soinfo_list_t make_global_group() { |
| 1426 | soinfo::soinfo_list_t global_group; |
| 1427 | for (soinfo* si = somain; si != nullptr; si = si->next) { |
| 1428 | if ((si->get_dt_flags_1() & DF_1_GLOBAL) != 0) { |
| 1429 | global_group.push_back(si); |
| 1430 | } |
| 1431 | } |
| 1432 | |
| 1433 | return global_group; |
| 1434 | } |
| 1435 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1436 | static bool find_libraries(soinfo* start_with, const char* const library_names[], |
| 1437 | size_t library_names_count, soinfo* soinfos[], std::vector<soinfo*>* ld_preloads, |
| 1438 | size_t ld_preloads_count, int rtld_flags, const android_dlextinfo* extinfo) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1439 | // Step 0: prepare. |
| 1440 | LoadTaskList load_tasks; |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1441 | for (size_t i = 0; i < library_names_count; ++i) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1442 | const char* name = library_names[i]; |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1443 | load_tasks.push_back(LoadTask::create(name, start_with)); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1444 | } |
| 1445 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 1446 | // Construct global_group. |
| 1447 | soinfo::soinfo_list_t global_group = make_global_group(); |
| 1448 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1449 | // If soinfos array is null allocate one on stack. |
| 1450 | // The array is needed in case of failure; for example |
| 1451 | // when library_names[] = {libone.so, libtwo.so} and libone.so |
| 1452 | // is loaded correctly but libtwo.so failed for some reason. |
| 1453 | // In this case libone.so should be unloaded on return. |
| 1454 | // See also implementation of failure_guard below. |
| 1455 | |
| 1456 | if (soinfos == nullptr) { |
| 1457 | size_t soinfos_size = sizeof(soinfo*)*library_names_count; |
| 1458 | soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size)); |
| 1459 | memset(soinfos, 0, soinfos_size); |
| 1460 | } |
| 1461 | |
| 1462 | // list of libraries to link - see step 2. |
| 1463 | size_t soinfos_count = 0; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1464 | |
Dmitriy Ivanov | d9ff722 | 2014-09-08 16:22:22 -0700 | [diff] [blame] | 1465 | auto failure_guard = make_scope_guard([&]() { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1466 | // Housekeeping |
| 1467 | load_tasks.for_each([] (LoadTask* t) { |
| 1468 | LoadTask::deleter(t); |
| 1469 | }); |
| 1470 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1471 | for (size_t i = 0; i<soinfos_count; ++i) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1472 | soinfo_unload(soinfos[i]); |
| 1473 | } |
| 1474 | }); |
| 1475 | |
| 1476 | // Step 1: load and pre-link all DT_NEEDED libraries in breadth first order. |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1477 | for (LoadTask::unique_ptr task(load_tasks.pop_front()); |
| 1478 | task.get() != nullptr; task.reset(load_tasks.pop_front())) { |
Torne (Richard Coles) | a828a2f | 2015-09-02 14:14:08 +0100 | [diff] [blame] | 1479 | soinfo* needed_by = task->get_needed_by(); |
| 1480 | |
| 1481 | soinfo* si = find_library_internal(load_tasks, task->get_name(), |
| 1482 | rtld_flags, needed_by == nullptr ? extinfo : nullptr); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1483 | if (si == nullptr) { |
| 1484 | return false; |
| 1485 | } |
| 1486 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1487 | if (needed_by != nullptr) { |
| 1488 | needed_by->add_child(si); |
| 1489 | } |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1490 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1491 | if (si->is_linked()) { |
| 1492 | si->increment_ref_count(); |
| 1493 | } |
| 1494 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1495 | // When ld_preloads is not null, the first |
| 1496 | // ld_preloads_count libs are in fact ld_preloads. |
| 1497 | if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 1498 | // Add LD_PRELOADed libraries to the global group for future runs. |
| 1499 | // There is no need to explicitly add them to the global group |
| 1500 | // for this run because they are going to appear in the local |
| 1501 | // group in the correct order. |
| 1502 | si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL); |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 1503 | ld_preloads->push_back(si); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1504 | } |
| 1505 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1506 | if (soinfos_count < library_names_count) { |
| 1507 | soinfos[soinfos_count++] = si; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1508 | } |
| 1509 | } |
| 1510 | |
| 1511 | // Step 2: link libraries. |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1512 | soinfo::soinfo_list_t local_group; |
| 1513 | walk_dependencies_tree( |
| 1514 | start_with == nullptr ? soinfos : &start_with, |
| 1515 | start_with == nullptr ? soinfos_count : 1, |
| 1516 | [&] (soinfo* si) { |
| 1517 | local_group.push_back(si); |
| 1518 | return true; |
| 1519 | }); |
| 1520 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1521 | // We need to increment ref_count in case |
| 1522 | // the root of the local group was not linked. |
| 1523 | bool was_local_group_root_linked = local_group.front()->is_linked(); |
| 1524 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1525 | bool linked = local_group.visit([&](soinfo* si) { |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1526 | if (!si->is_linked()) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1527 | if (!si->link_image(global_group, local_group, extinfo)) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1528 | return false; |
| 1529 | } |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1530 | si->set_linked(); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1531 | } |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1532 | |
| 1533 | return true; |
| 1534 | }); |
| 1535 | |
| 1536 | if (linked) { |
| 1537 | failure_guard.disable(); |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1538 | } |
| 1539 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1540 | if (!was_local_group_root_linked) { |
| 1541 | local_group.front()->increment_ref_count(); |
| 1542 | } |
| 1543 | |
Dmitriy Ivanov | cfa97f1 | 2014-10-21 09:23:18 -0700 | [diff] [blame] | 1544 | return linked; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1545 | } |
| 1546 | |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 1547 | static soinfo* find_library(const char* name, int rtld_flags, const android_dlextinfo* extinfo) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1548 | soinfo* si; |
| 1549 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1550 | if (name == nullptr) { |
| 1551 | si = somain; |
| 1552 | } else if (!find_libraries(nullptr, &name, 1, &si, nullptr, 0, rtld_flags, extinfo)) { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1553 | return nullptr; |
| 1554 | } |
| 1555 | |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1556 | return si; |
| 1557 | } |
Elliott Hughes | bedfe38 | 2012-08-14 14:07:59 -0700 | [diff] [blame] | 1558 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1559 | static void soinfo_unload(soinfo* root) { |
| 1560 | // Note that the library can be loaded but not linked; |
| 1561 | // in which case there is no root but we still need |
| 1562 | // to walk the tree and unload soinfos involved. |
| 1563 | // |
| 1564 | // This happens on unsuccessful dlopen, when one of |
| 1565 | // the DT_NEEDED libraries could not be linked/found. |
| 1566 | if (root->is_linked()) { |
| 1567 | root = root->get_local_group_root(); |
| 1568 | } |
| 1569 | |
| 1570 | if (!root->can_unload()) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1571 | TRACE("not unloading '%s' - the binary is flagged with NODELETE", root->get_realpath()); |
Dmitriy Ivanov | 1b20daf | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1572 | return; |
| 1573 | } |
| 1574 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1575 | size_t ref_count = root->is_linked() ? root->decrement_ref_count() : 0; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1576 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1577 | if (ref_count == 0) { |
| 1578 | soinfo::soinfo_list_t local_unload_list; |
| 1579 | soinfo::soinfo_list_t external_unload_list; |
| 1580 | soinfo::soinfo_list_t depth_first_list; |
| 1581 | depth_first_list.push_back(root); |
| 1582 | soinfo* si = nullptr; |
| 1583 | |
| 1584 | while ((si = depth_first_list.pop_front()) != nullptr) { |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1585 | if (local_unload_list.contains(si)) { |
| 1586 | continue; |
| 1587 | } |
| 1588 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1589 | local_unload_list.push_back(si); |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1590 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1591 | if (si->has_min_version(0)) { |
| 1592 | soinfo* child = nullptr; |
| 1593 | while ((child = si->get_children().pop_front()) != nullptr) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1594 | TRACE("%s@%p needs to unload %s@%p", si->get_realpath(), si, |
| 1595 | child->get_realpath(), child); |
| 1596 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1597 | if (local_unload_list.contains(child)) { |
| 1598 | continue; |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1599 | } else if (child->is_linked() && child->get_local_group_root() != root) { |
Dimitry Ivanov | 585f2bf | 2017-04-19 11:28:16 -0700 | [diff] [blame^] | 1600 | child->get_parents().remove_if([&] (const soinfo* parent) { |
| 1601 | return parent == si; |
| 1602 | }); |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1603 | external_unload_list.push_back(child); |
| 1604 | } else { |
| 1605 | depth_first_list.push_front(child); |
| 1606 | } |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 1607 | } |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1608 | } else { |
Dmitriy Ivanov | 69a5fb9 | 2015-05-15 17:53:39 -0700 | [diff] [blame] | 1609 | #if !defined(__work_around_b_19059885__) |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1610 | __libc_fatal("soinfo for \"%s\"@%p has no version", si->get_realpath(), si); |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1611 | #else |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1612 | PRINT("warning: soinfo for \"%s\"@%p has no version", si->get_realpath(), si); |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1613 | for_each_dt_needed(si, [&] (const char* library_name) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1614 | TRACE("deprecated (old format of soinfo): %s needs to unload %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1615 | si->get_realpath(), library_name); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1616 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1617 | soinfo* needed = find_library(library_name, RTLD_NOLOAD, nullptr); |
| 1618 | if (needed != nullptr) { |
| 1619 | // Not found: for example if symlink was deleted between dlopen and dlclose |
| 1620 | // Since we cannot really handle errors at this point - print and continue. |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 1621 | PRINT("warning: couldn't find %s needed by %s on unload.", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1622 | library_name, si->get_realpath()); |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1623 | return; |
| 1624 | } else if (local_unload_list.contains(needed)) { |
| 1625 | // already visited |
| 1626 | return; |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1627 | } else if (needed->is_linked() && needed->get_local_group_root() != root) { |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1628 | // external group |
| 1629 | external_unload_list.push_back(needed); |
| 1630 | } else { |
| 1631 | // local group |
| 1632 | depth_first_list.push_front(needed); |
| 1633 | } |
| 1634 | }); |
Dmitriy Ivanov | 5ae82cb | 2014-12-02 17:08:42 -0800 | [diff] [blame] | 1635 | #endif |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1636 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1637 | } |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1638 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 1639 | local_unload_list.for_each([](soinfo* si) { |
| 1640 | si->call_destructors(); |
| 1641 | }); |
| 1642 | |
| 1643 | while ((si = local_unload_list.pop_front()) != nullptr) { |
| 1644 | notify_gdb_of_unload(si); |
| 1645 | soinfo_free(si); |
| 1646 | } |
| 1647 | |
| 1648 | while ((si = external_unload_list.pop_front()) != nullptr) { |
| 1649 | soinfo_unload(si); |
| 1650 | } |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1651 | } else { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1652 | TRACE("not unloading '%s' group, decrementing ref_count to %zd", |
| 1653 | root->get_realpath(), ref_count); |
Dmitriy Ivanov | a254705 | 2014-11-18 12:03:09 -0800 | [diff] [blame] | 1654 | } |
| 1655 | } |
| 1656 | |
Elliott Hughes | a4aafd1 | 2014-01-13 16:37:47 -0800 | [diff] [blame] | 1657 | void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) { |
Christopher Ferris | 052fa3a | 2014-08-26 20:48:11 -0700 | [diff] [blame] | 1658 | // Use basic string manipulation calls to avoid snprintf. |
| 1659 | // snprintf indirectly calls pthread_getspecific to get the size of a buffer. |
| 1660 | // When debug malloc is enabled, this call returns 0. This in turn causes |
| 1661 | // snprintf to do nothing, which causes libraries to fail to load. |
| 1662 | // See b/17302493 for further details. |
| 1663 | // Once the above bug is fixed, this code can be modified to use |
| 1664 | // snprintf again. |
| 1665 | size_t required_len = strlen(kDefaultLdPaths[0]) + strlen(kDefaultLdPaths[1]) + 2; |
| 1666 | if (buffer_size < required_len) { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1667 | __libc_fatal("android_get_LD_LIBRARY_PATH failed, buffer too small: " |
| 1668 | "buffer len %zu, required len %zu", buffer_size, required_len); |
Christopher Ferris | 052fa3a | 2014-08-26 20:48:11 -0700 | [diff] [blame] | 1669 | } |
| 1670 | char* end = stpcpy(buffer, kDefaultLdPaths[0]); |
| 1671 | *end = ':'; |
| 1672 | strcpy(end + 1, kDefaultLdPaths[1]); |
Elliott Hughes | a4aafd1 | 2014-01-13 16:37:47 -0800 | [diff] [blame] | 1673 | } |
| 1674 | |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1675 | void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) { |
Nick Kralevich | 6bb01b6 | 2015-03-07 13:37:05 -0800 | [diff] [blame] | 1676 | parse_LD_LIBRARY_PATH(ld_library_path); |
Elliott Hughes | cade4c3 | 2012-12-20 14:42:14 -0800 | [diff] [blame] | 1677 | } |
| 1678 | |
Elliott Hughes | 1a58629 | 2014-06-03 16:23:08 -0700 | [diff] [blame] | 1679 | soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo) { |
Dmitriy Ivanov | 1b20daf | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1680 | if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) { |
Elliott Hughes | e66190d | 2012-12-18 15:57:55 -0800 | [diff] [blame] | 1681 | DL_ERR("invalid flags to dlopen: %x", flags); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1682 | return nullptr; |
Elliott Hughes | e66190d | 2012-12-18 15:57:55 -0800 | [diff] [blame] | 1683 | } |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 1684 | if (extinfo != nullptr) { |
| 1685 | if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) { |
| 1686 | DL_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags); |
| 1687 | return nullptr; |
| 1688 | } |
| 1689 | if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 && |
Dmitriy Ivanov | a6c1279 | 2014-10-21 12:09:18 -0700 | [diff] [blame] | 1690 | (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1691 | DL_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without " |
| 1692 | "ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags); |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 1693 | return nullptr; |
| 1694 | } |
Torne (Richard Coles) | 012cb45 | 2014-02-06 14:34:21 +0000 | [diff] [blame] | 1695 | } |
Dmitriy Ivanov | 279a22f | 2015-01-23 12:03:53 -0800 | [diff] [blame] | 1696 | |
| 1697 | ProtectedDataGuard guard; |
Dmitriy Ivanov | 9fb216f | 2014-11-01 02:30:38 +0000 | [diff] [blame] | 1698 | soinfo* si = find_library(name, flags, extinfo); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1699 | if (si != nullptr) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1700 | si->call_constructors(); |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1701 | } |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 1702 | return si; |
| 1703 | } |
| 1704 | |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1705 | void do_dlclose(soinfo* si) { |
Dmitriy Ivanov | 279a22f | 2015-01-23 12:03:53 -0800 | [diff] [blame] | 1706 | ProtectedDataGuard guard; |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 1707 | soinfo_unload(si); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 1708 | } |
| 1709 | |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 1710 | static ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) { |
| 1711 | typedef ElfW(Addr) (*ifunc_resolver_t)(void); |
| 1712 | ifunc_resolver_t ifunc_resolver = reinterpret_cast<ifunc_resolver_t>(resolver_addr); |
| 1713 | ElfW(Addr) ifunc_addr = ifunc_resolver(); |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1714 | TRACE_TYPE(RELO, "Called ifunc_resolver@%p. The result is %p", |
| 1715 | ifunc_resolver, reinterpret_cast<void*>(ifunc_addr)); |
Brigid Smith | c5a13ef | 2014-07-23 11:22:25 -0700 | [diff] [blame] | 1716 | |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 1717 | return ifunc_addr; |
Brigid Smith | c5a13ef | 2014-07-23 11:22:25 -0700 | [diff] [blame] | 1718 | } |
Brigid Smith | c5a13ef | 2014-07-23 11:22:25 -0700 | [diff] [blame] | 1719 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1720 | const version_info* VersionTracker::get_version_info(ElfW(Versym) source_symver) const { |
| 1721 | if (source_symver < 2 || |
| 1722 | source_symver >= version_infos.size() || |
| 1723 | version_infos[source_symver].name == nullptr) { |
| 1724 | return nullptr; |
| 1725 | } |
| 1726 | |
| 1727 | return &version_infos[source_symver]; |
| 1728 | } |
| 1729 | |
| 1730 | void VersionTracker::add_version_info(size_t source_index, |
| 1731 | ElfW(Word) elf_hash, |
| 1732 | const char* ver_name, |
| 1733 | const soinfo* target_si) { |
| 1734 | if (source_index >= version_infos.size()) { |
| 1735 | version_infos.resize(source_index+1); |
| 1736 | } |
| 1737 | |
| 1738 | version_infos[source_index].elf_hash = elf_hash; |
| 1739 | version_infos[source_index].name = ver_name; |
| 1740 | version_infos[source_index].target_si = target_si; |
| 1741 | } |
| 1742 | |
| 1743 | bool VersionTracker::init_verneed(const soinfo* si_from) { |
| 1744 | uintptr_t verneed_ptr = si_from->get_verneed_ptr(); |
| 1745 | |
| 1746 | if (verneed_ptr == 0) { |
| 1747 | return true; |
| 1748 | } |
| 1749 | |
| 1750 | size_t verneed_cnt = si_from->get_verneed_cnt(); |
| 1751 | |
| 1752 | for (size_t i = 0, offset = 0; i<verneed_cnt; ++i) { |
| 1753 | const ElfW(Verneed)* verneed = reinterpret_cast<ElfW(Verneed)*>(verneed_ptr + offset); |
| 1754 | size_t vernaux_offset = offset + verneed->vn_aux; |
| 1755 | offset += verneed->vn_next; |
| 1756 | |
| 1757 | if (verneed->vn_version != 1) { |
| 1758 | DL_ERR("unsupported verneed[%zd] vn_version: %d (expected 1)", i, verneed->vn_version); |
| 1759 | return false; |
| 1760 | } |
| 1761 | |
| 1762 | const char* target_soname = si_from->get_string(verneed->vn_file); |
| 1763 | // find it in dependencies |
| 1764 | soinfo* target_si = si_from->get_children().find_if([&](const soinfo* si) { |
Dmitriy Ivanov | 8264afb | 2015-05-06 11:05:27 -0700 | [diff] [blame] | 1765 | return si->get_soname() != nullptr && strcmp(si->get_soname(), target_soname) == 0; |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1766 | }); |
| 1767 | |
| 1768 | if (target_si == nullptr) { |
| 1769 | DL_ERR("cannot find \"%s\" from verneed[%zd] in DT_NEEDED list for \"%s\"", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1770 | target_soname, i, si_from->get_realpath()); |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1771 | return false; |
| 1772 | } |
| 1773 | |
| 1774 | for (size_t j = 0; j<verneed->vn_cnt; ++j) { |
| 1775 | const ElfW(Vernaux)* vernaux = reinterpret_cast<ElfW(Vernaux)*>(verneed_ptr + vernaux_offset); |
| 1776 | vernaux_offset += vernaux->vna_next; |
| 1777 | |
| 1778 | const ElfW(Word) elf_hash = vernaux->vna_hash; |
| 1779 | const char* ver_name = si_from->get_string(vernaux->vna_name); |
| 1780 | ElfW(Half) source_index = vernaux->vna_other; |
| 1781 | |
| 1782 | add_version_info(source_index, elf_hash, ver_name, target_si); |
| 1783 | } |
| 1784 | } |
| 1785 | |
| 1786 | return true; |
| 1787 | } |
| 1788 | |
| 1789 | bool VersionTracker::init_verdef(const soinfo* si_from) { |
| 1790 | return for_each_verdef(si_from, |
| 1791 | [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) { |
| 1792 | add_version_info(verdef->vd_ndx, verdef->vd_hash, |
| 1793 | si_from->get_string(verdaux->vda_name), si_from); |
| 1794 | return false; |
| 1795 | } |
| 1796 | ); |
| 1797 | } |
| 1798 | |
| 1799 | bool VersionTracker::init(const soinfo* si_from) { |
| 1800 | if (!si_from->has_min_version(2)) { |
| 1801 | return true; |
| 1802 | } |
| 1803 | |
| 1804 | return init_verneed(si_from) && init_verdef(si_from); |
| 1805 | } |
| 1806 | |
Dmitriy Ivanov | 114bd83 | 2015-04-30 16:11:48 -0700 | [diff] [blame] | 1807 | bool soinfo::lookup_version_info(const VersionTracker& version_tracker, ElfW(Word) sym, |
| 1808 | const char* sym_name, const version_info** vi) { |
| 1809 | const ElfW(Versym)* sym_ver_ptr = get_versym(sym); |
| 1810 | ElfW(Versym) sym_ver = sym_ver_ptr == nullptr ? 0 : *sym_ver_ptr; |
| 1811 | |
| 1812 | if (sym_ver != VER_NDX_LOCAL && sym_ver != VER_NDX_GLOBAL) { |
| 1813 | *vi = version_tracker.get_version_info(sym_ver); |
| 1814 | |
| 1815 | if (*vi == nullptr) { |
| 1816 | DL_ERR("cannot find verneed/verdef for version index=%d " |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1817 | "referenced by symbol \"%s\" at \"%s\"", sym_ver, sym_name, get_realpath()); |
Dmitriy Ivanov | 114bd83 | 2015-04-30 16:11:48 -0700 | [diff] [blame] | 1818 | return false; |
| 1819 | } |
| 1820 | } else { |
| 1821 | // there is no version info |
| 1822 | *vi = nullptr; |
| 1823 | } |
| 1824 | |
| 1825 | return true; |
| 1826 | } |
| 1827 | |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1828 | #if !defined(__mips__) |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 1829 | #if defined(USE_RELA) |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1830 | static ElfW(Addr) get_addend(ElfW(Rela)* rela, ElfW(Addr) reloc_addr __unused) { |
| 1831 | return rela->r_addend; |
| 1832 | } |
| 1833 | #else |
| 1834 | static ElfW(Addr) get_addend(ElfW(Rel)* rel, ElfW(Addr) reloc_addr) { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 1835 | if (ELFW(R_TYPE)(rel->r_info) == R_GENERIC_RELATIVE || |
| 1836 | ELFW(R_TYPE)(rel->r_info) == R_GENERIC_IRELATIVE) { |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1837 | return *reinterpret_cast<ElfW(Addr)*>(reloc_addr); |
| 1838 | } |
| 1839 | return 0; |
| 1840 | } |
| 1841 | #endif |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1842 | |
Dmitriy Ivanov | fa26eee | 2015-02-03 16:06:47 -0800 | [diff] [blame] | 1843 | template<typename ElfRelIteratorT> |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 1844 | bool soinfo::relocate(const VersionTracker& version_tracker, ElfRelIteratorT&& rel_iterator, |
| 1845 | const soinfo_list_t& global_group, const soinfo_list_t& local_group) { |
Dmitriy Ivanov | fa26eee | 2015-02-03 16:06:47 -0800 | [diff] [blame] | 1846 | for (size_t idx = 0; rel_iterator.has_next(); ++idx) { |
| 1847 | const auto rel = rel_iterator.next(); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 1848 | if (rel == nullptr) { |
| 1849 | return false; |
| 1850 | } |
| 1851 | |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1852 | ElfW(Word) type = ELFW(R_TYPE)(rel->r_info); |
| 1853 | ElfW(Word) sym = ELFW(R_SYM)(rel->r_info); |
| 1854 | |
| 1855 | ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 1856 | ElfW(Addr) sym_addr = 0; |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1857 | const char* sym_name = nullptr; |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1858 | ElfW(Addr) addend = get_addend(rel, reloc); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1859 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1860 | DEBUG("Processing '%s' relocation at index %zd", get_realpath(), idx); |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1861 | if (type == R_GENERIC_NONE) { |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1862 | continue; |
| 1863 | } |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1864 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1865 | const ElfW(Sym)* s = nullptr; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 1866 | soinfo* lsi = nullptr; |
| 1867 | |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1868 | if (sym != 0) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1869 | sym_name = get_string(symtab_[sym].st_name); |
Dmitriy Ivanov | 114bd83 | 2015-04-30 16:11:48 -0700 | [diff] [blame] | 1870 | const version_info* vi = nullptr; |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1871 | |
Dmitriy Ivanov | 114bd83 | 2015-04-30 16:11:48 -0700 | [diff] [blame] | 1872 | if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) { |
| 1873 | return false; |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 1874 | } |
Dmitriy Ivanov | 114bd83 | 2015-04-30 16:11:48 -0700 | [diff] [blame] | 1875 | |
| 1876 | if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) { |
| 1877 | return false; |
| 1878 | } |
| 1879 | |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 1880 | if (s == nullptr) { |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1881 | // We only allow an undefined symbol if this is a weak reference... |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 1882 | s = &symtab_[sym]; |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1883 | if (ELF_ST_BIND(s->st_info) != STB_WEAK) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 1884 | DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, get_realpath()); |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 1885 | return false; |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1886 | } |
| 1887 | |
| 1888 | /* IHI0044C AAELF 4.5.1.1: |
| 1889 | |
| 1890 | Libraries are not searched to resolve weak references. |
| 1891 | It is not an error for a weak reference to remain unsatisfied. |
| 1892 | |
| 1893 | During linking, the value of an undefined weak reference is: |
| 1894 | - Zero if the relocation type is absolute |
| 1895 | - The address of the place if the relocation is pc-relative |
| 1896 | - The address of nominal base address if the relocation |
| 1897 | type is base-relative. |
| 1898 | */ |
| 1899 | |
| 1900 | switch (type) { |
Dmitriy Ivanov | 1b69469 | 2015-01-13 12:17:31 -0800 | [diff] [blame] | 1901 | case R_GENERIC_JUMP_SLOT: |
| 1902 | case R_GENERIC_GLOB_DAT: |
| 1903 | case R_GENERIC_RELATIVE: |
| 1904 | case R_GENERIC_IRELATIVE: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 1905 | #if defined(__aarch64__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 1906 | case R_AARCH64_ABS64: |
| 1907 | case R_AARCH64_ABS32: |
| 1908 | case R_AARCH64_ABS16: |
Dmitriy Ivanov | 1b69469 | 2015-01-13 12:17:31 -0800 | [diff] [blame] | 1909 | #elif defined(__x86_64__) |
| 1910 | case R_X86_64_32: |
| 1911 | case R_X86_64_64: |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1912 | #elif defined(__arm__) |
| 1913 | case R_ARM_ABS32: |
| 1914 | #elif defined(__i386__) |
| 1915 | case R_386_32: |
Dmitriy Ivanov | 1b69469 | 2015-01-13 12:17:31 -0800 | [diff] [blame] | 1916 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 1917 | /* |
| 1918 | * The sym_addr was initialized to be zero above, or the relocation |
| 1919 | * code below does not care about value of sym_addr. |
| 1920 | * No need to do anything. |
| 1921 | */ |
| 1922 | break; |
Dmitriy Ivanov | 1b69469 | 2015-01-13 12:17:31 -0800 | [diff] [blame] | 1923 | #if defined(__x86_64__) |
Dimitry Ivanov | d338aac | 2015-01-13 22:31:54 +0000 | [diff] [blame] | 1924 | case R_X86_64_PC32: |
| 1925 | sym_addr = reloc; |
| 1926 | break; |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1927 | #elif defined(__i386__) |
| 1928 | case R_386_PC32: |
| 1929 | sym_addr = reloc; |
| 1930 | break; |
| 1931 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 1932 | default: |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1933 | DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rel, idx); |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 1934 | return false; |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1935 | } |
Dmitriy Ivanov | de0fb39 | 2015-07-26 07:37:09 -0700 | [diff] [blame] | 1936 | } else { // We got a definition. |
| 1937 | #if !defined(__LP64__) |
| 1938 | // When relocating dso with text_relocation .text segment is |
| 1939 | // not executable. We need to restore elf flags before resolving |
| 1940 | // STT_GNU_IFUNC symbol. |
| 1941 | bool protect_segments = has_text_relocations && |
| 1942 | lsi == this && |
| 1943 | ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC; |
| 1944 | if (protect_segments) { |
| 1945 | if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) { |
| 1946 | DL_ERR("can't protect segments for \"%s\": %s", |
| 1947 | get_realpath(), strerror(errno)); |
| 1948 | return false; |
| 1949 | } |
| 1950 | } |
| 1951 | #endif |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 1952 | sym_addr = lsi->resolve_symbol_address(s); |
Dmitriy Ivanov | de0fb39 | 2015-07-26 07:37:09 -0700 | [diff] [blame] | 1953 | #if !defined(__LP64__) |
| 1954 | if (protect_segments) { |
| 1955 | if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) { |
| 1956 | DL_ERR("can't unprotect loadable segments for \"%s\": %s", |
| 1957 | get_realpath(), strerror(errno)); |
| 1958 | return false; |
| 1959 | } |
| 1960 | } |
| 1961 | #endif |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1962 | } |
| 1963 | count_relocation(kRelocSymbol); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 1964 | } |
| 1965 | |
| 1966 | switch (type) { |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1967 | case R_GENERIC_JUMP_SLOT: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 1968 | count_relocation(kRelocAbsolute); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1969 | MARK(rel->r_offset); |
| 1970 | TRACE_TYPE(RELO, "RELO JMP_SLOT %16p <- %16p %s\n", |
| 1971 | reinterpret_cast<void*>(reloc), |
| 1972 | reinterpret_cast<void*>(sym_addr + addend), sym_name); |
| 1973 | |
| 1974 | *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend); |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 1975 | break; |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1976 | case R_GENERIC_GLOB_DAT: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 1977 | count_relocation(kRelocAbsolute); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1978 | MARK(rel->r_offset); |
| 1979 | TRACE_TYPE(RELO, "RELO GLOB_DAT %16p <- %16p %s\n", |
| 1980 | reinterpret_cast<void*>(reloc), |
| 1981 | reinterpret_cast<void*>(sym_addr + addend), sym_name); |
| 1982 | *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend); |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 1983 | break; |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1984 | case R_GENERIC_RELATIVE: |
| 1985 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1986 | MARK(rel->r_offset); |
| 1987 | TRACE_TYPE(RELO, "RELO RELATIVE %16p <- %16p\n", |
| 1988 | reinterpret_cast<void*>(reloc), |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 1989 | reinterpret_cast<void*>(load_bias + addend)); |
| 1990 | *reinterpret_cast<ElfW(Addr)*>(reloc) = (load_bias + addend); |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1991 | break; |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 1992 | case R_GENERIC_IRELATIVE: |
| 1993 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 1994 | MARK(rel->r_offset); |
| 1995 | TRACE_TYPE(RELO, "RELO IRELATIVE %16p <- %16p\n", |
| 1996 | reinterpret_cast<void*>(reloc), |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 1997 | reinterpret_cast<void*>(load_bias + addend)); |
Dmitriy Ivanov | de0fb39 | 2015-07-26 07:37:09 -0700 | [diff] [blame] | 1998 | { |
| 1999 | #if !defined(__LP64__) |
| 2000 | // When relocating dso with text_relocation .text segment is |
| 2001 | // not executable. We need to restore elf flags for this |
| 2002 | // particular call. |
| 2003 | if (has_text_relocations) { |
| 2004 | if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) { |
| 2005 | DL_ERR("can't protect segments for \"%s\": %s", |
| 2006 | get_realpath(), strerror(errno)); |
| 2007 | return false; |
| 2008 | } |
| 2009 | } |
| 2010 | #endif |
| 2011 | ElfW(Addr) ifunc_addr = call_ifunc_resolver(load_bias + addend); |
| 2012 | #if !defined(__LP64__) |
| 2013 | // Unprotect it afterwards... |
| 2014 | if (has_text_relocations) { |
| 2015 | if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) { |
| 2016 | DL_ERR("can't unprotect loadable segments for \"%s\": %s", |
| 2017 | get_realpath(), strerror(errno)); |
| 2018 | return false; |
| 2019 | } |
| 2020 | } |
| 2021 | #endif |
| 2022 | *reinterpret_cast<ElfW(Addr)*>(reloc) = ifunc_addr; |
| 2023 | } |
Dmitriy Ivanov | cefef7d | 2015-01-08 23:30:15 -0800 | [diff] [blame] | 2024 | break; |
| 2025 | |
| 2026 | #if defined(__aarch64__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2027 | case R_AARCH64_ABS64: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2028 | count_relocation(kRelocAbsolute); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2029 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2030 | TRACE_TYPE(RELO, "RELO ABS64 %16llx <- %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2031 | reloc, (sym_addr + addend), sym_name); |
| 2032 | *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend); |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2033 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2034 | case R_AARCH64_ABS32: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2035 | count_relocation(kRelocAbsolute); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2036 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2037 | TRACE_TYPE(RELO, "RELO ABS32 %16llx <- %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2038 | reloc, (sym_addr + addend), sym_name); |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2039 | { |
| 2040 | const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc); |
| 2041 | const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN); |
| 2042 | const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX); |
| 2043 | if ((min_value <= (reloc_value + (sym_addr + addend))) && |
| 2044 | ((reloc_value + (sym_addr + addend)) <= max_value)) { |
| 2045 | *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend); |
| 2046 | } else { |
| 2047 | DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx", |
| 2048 | (reloc_value + (sym_addr + addend)), min_value, max_value); |
| 2049 | return false; |
| 2050 | } |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2051 | } |
| 2052 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2053 | case R_AARCH64_ABS16: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2054 | count_relocation(kRelocAbsolute); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2055 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2056 | TRACE_TYPE(RELO, "RELO ABS16 %16llx <- %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2057 | reloc, (sym_addr + addend), sym_name); |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2058 | { |
| 2059 | const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc); |
| 2060 | const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN); |
| 2061 | const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX); |
| 2062 | if ((min_value <= (reloc_value + (sym_addr + addend))) && |
| 2063 | ((reloc_value + (sym_addr + addend)) <= max_value)) { |
| 2064 | *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend); |
| 2065 | } else { |
| 2066 | DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx", |
| 2067 | reloc_value + (sym_addr + addend), min_value, max_value); |
| 2068 | return false; |
| 2069 | } |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2070 | } |
| 2071 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2072 | case R_AARCH64_PREL64: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2073 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2074 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2075 | TRACE_TYPE(RELO, "RELO REL64 %16llx <- %16llx - %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2076 | reloc, (sym_addr + addend), rel->r_offset, sym_name); |
| 2077 | *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend) - rel->r_offset; |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2078 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2079 | case R_AARCH64_PREL32: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2080 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2081 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2082 | TRACE_TYPE(RELO, "RELO REL32 %16llx <- %16llx - %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2083 | reloc, (sym_addr + addend), rel->r_offset, sym_name); |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2084 | { |
| 2085 | const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc); |
| 2086 | const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN); |
| 2087 | const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX); |
| 2088 | if ((min_value <= (reloc_value + ((sym_addr + addend) - rel->r_offset))) && |
| 2089 | ((reloc_value + ((sym_addr + addend) - rel->r_offset)) <= max_value)) { |
| 2090 | *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + addend) - rel->r_offset); |
| 2091 | } else { |
| 2092 | DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx", |
| 2093 | reloc_value + ((sym_addr + addend) - rel->r_offset), min_value, max_value); |
| 2094 | return false; |
| 2095 | } |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2096 | } |
| 2097 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2098 | case R_AARCH64_PREL16: |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2099 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2100 | MARK(rel->r_offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2101 | TRACE_TYPE(RELO, "RELO REL16 %16llx <- %16llx - %16llx %s\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2102 | reloc, (sym_addr + addend), rel->r_offset, sym_name); |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2103 | { |
| 2104 | const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc); |
| 2105 | const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN); |
| 2106 | const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX); |
| 2107 | if ((min_value <= (reloc_value + ((sym_addr + addend) - rel->r_offset))) && |
| 2108 | ((reloc_value + ((sym_addr + addend) - rel->r_offset)) <= max_value)) { |
| 2109 | *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + addend) - rel->r_offset); |
| 2110 | } else { |
| 2111 | DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx", |
| 2112 | reloc_value + ((sym_addr + addend) - rel->r_offset), min_value, max_value); |
| 2113 | return false; |
| 2114 | } |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2115 | } |
| 2116 | break; |
| 2117 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2118 | case R_AARCH64_COPY: |
Nick Kralevich | 76e289c | 2014-07-03 12:04:31 -0700 | [diff] [blame] | 2119 | /* |
| 2120 | * ET_EXEC is not supported so this should not happen. |
| 2121 | * |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2122 | * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf |
Nick Kralevich | 76e289c | 2014-07-03 12:04:31 -0700 | [diff] [blame] | 2123 | * |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2124 | * Section 4.6.11 "Dynamic relocations" |
Nick Kralevich | 76e289c | 2014-07-03 12:04:31 -0700 | [diff] [blame] | 2125 | * R_AARCH64_COPY may only appear in executable objects where e_type is |
| 2126 | * set to ET_EXEC. |
| 2127 | */ |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2128 | DL_ERR("%s R_AARCH64_COPY relocations are not supported", get_realpath()); |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 2129 | return false; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2130 | case R_AARCH64_TLS_TPREL64: |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2131 | TRACE_TYPE(RELO, "RELO TLS_TPREL64 *** %16llx <- %16llx - %16llx\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2132 | reloc, (sym_addr + addend), rel->r_offset); |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2133 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2134 | case R_AARCH64_TLS_DTPREL32: |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 2135 | TRACE_TYPE(RELO, "RELO TLS_DTPREL32 *** %16llx <- %16llx - %16llx\n", |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2136 | reloc, (sym_addr + addend), rel->r_offset); |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 2137 | break; |
| 2138 | #elif defined(__x86_64__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2139 | case R_X86_64_32: |
| 2140 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2141 | MARK(rel->r_offset); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2142 | TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc), |
| 2143 | static_cast<size_t>(sym_addr), sym_name); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2144 | *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2145 | break; |
| 2146 | case R_X86_64_64: |
| 2147 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2148 | MARK(rel->r_offset); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2149 | TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc), |
| 2150 | static_cast<size_t>(sym_addr), sym_name); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2151 | *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2152 | break; |
| 2153 | case R_X86_64_PC32: |
| 2154 | count_relocation(kRelocRelative); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2155 | MARK(rel->r_offset); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2156 | TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s", |
| 2157 | static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc), |
| 2158 | static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name); |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2159 | *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend - reloc; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2160 | break; |
Dmitriy Ivanov | bcc04d0 | 2015-01-13 12:12:38 -0800 | [diff] [blame] | 2161 | #elif defined(__arm__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2162 | case R_ARM_ABS32: |
| 2163 | count_relocation(kRelocAbsolute); |
| 2164 | MARK(rel->r_offset); |
| 2165 | TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name); |
| 2166 | *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr; |
| 2167 | break; |
| 2168 | case R_ARM_REL32: |
| 2169 | count_relocation(kRelocRelative); |
| 2170 | MARK(rel->r_offset); |
| 2171 | TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s", |
| 2172 | reloc, sym_addr, rel->r_offset, sym_name); |
| 2173 | *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset; |
| 2174 | break; |
| 2175 | case R_ARM_COPY: |
| 2176 | /* |
| 2177 | * ET_EXEC is not supported so this should not happen. |
| 2178 | * |
| 2179 | * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf |
| 2180 | * |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2181 | * Section 4.6.1.10 "Dynamic relocations" |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2182 | * R_ARM_COPY may only appear in executable objects where e_type is |
| 2183 | * set to ET_EXEC. |
| 2184 | */ |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2185 | DL_ERR("%s R_ARM_COPY relocations are not supported", get_realpath()); |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 2186 | return false; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2187 | #elif defined(__i386__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2188 | case R_386_32: |
| 2189 | count_relocation(kRelocRelative); |
| 2190 | MARK(rel->r_offset); |
| 2191 | TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name); |
| 2192 | *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr; |
| 2193 | break; |
| 2194 | case R_386_PC32: |
| 2195 | count_relocation(kRelocRelative); |
| 2196 | MARK(rel->r_offset); |
| 2197 | TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s", |
| 2198 | reloc, (sym_addr - reloc), sym_addr, reloc, sym_name); |
| 2199 | *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr - reloc); |
| 2200 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2201 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2202 | default: |
| 2203 | DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2204 | return false; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2205 | } |
| 2206 | } |
| 2207 | return true; |
Raghu Gandham | d7daacb | 2012-07-31 12:07:22 -0700 | [diff] [blame] | 2208 | } |
Dmitriy Ivanov | 114ff69 | 2015-01-14 11:36:38 -0800 | [diff] [blame] | 2209 | #endif // !defined(__mips__) |
Raghu Gandham | d7daacb | 2012-07-31 12:07:22 -0700 | [diff] [blame] | 2210 | |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2211 | void soinfo::call_array(const char* array_name __unused, linker_function_t* functions, |
| 2212 | size_t count, bool reverse) { |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 2213 | if (functions == nullptr) { |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2214 | return; |
| 2215 | } |
David 'Digit' Turner | 8215679 | 2009-05-18 14:37:41 +0200 | [diff] [blame] | 2216 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2217 | TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, get_realpath()); |
Elliott Hughes | ca0c11b | 2013-03-12 10:40:45 -0700 | [diff] [blame] | 2218 | |
| 2219 | int begin = reverse ? (count - 1) : 0; |
| 2220 | int end = reverse ? -1 : count; |
| 2221 | int step = reverse ? -1 : 1; |
| 2222 | |
| 2223 | for (int i = begin; i != end; i += step) { |
| 2224 | TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]); |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2225 | call_function("function", functions[i]); |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2226 | } |
David 'Digit' Turner | 8215679 | 2009-05-18 14:37:41 +0200 | [diff] [blame] | 2227 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2228 | TRACE("[ Done calling %s for '%s' ]", array_name, get_realpath()); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2229 | } |
| 2230 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2231 | void soinfo::call_function(const char* function_name __unused, linker_function_t function) { |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 2232 | if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) { |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2233 | return; |
| 2234 | } |
| 2235 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2236 | TRACE("[ Calling %s @ %p for '%s' ]", function_name, function, get_realpath()); |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2237 | function(); |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2238 | TRACE("[ Done calling %s @ %p for '%s' ]", function_name, function, get_realpath()); |
Evgeniy Stepanov | 9181a5d | 2012-08-13 17:58:37 +0400 | [diff] [blame] | 2239 | } |
| 2240 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2241 | void soinfo::call_pre_init_constructors() { |
Elliott Hughes | 8147d3c | 2013-05-09 14:19:58 -0700 | [diff] [blame] | 2242 | // DT_PREINIT_ARRAY functions are called before any other constructors for executables, |
| 2243 | // but ignored in a shared library. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2244 | call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false); |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2245 | } |
Evgeniy Stepanov | e83c56d | 2011-12-21 13:03:54 +0400 | [diff] [blame] | 2246 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2247 | void soinfo::call_constructors() { |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2248 | if (constructors_called) { |
| 2249 | return; |
| 2250 | } |
Jesse Hall | f5d1693 | 2012-01-30 15:39:57 -0800 | [diff] [blame] | 2251 | |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2252 | // We set constructors_called before actually calling the constructors, otherwise it doesn't |
| 2253 | // protect against recursive constructor calls. One simple example of constructor recursion |
| 2254 | // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so: |
| 2255 | // 1. The program depends on libc, so libc's constructor is called here. |
| 2256 | // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so. |
| 2257 | // 3. dlopen() calls the constructors on the newly created |
| 2258 | // soinfo for libc_malloc_debug_leak.so. |
| 2259 | // 4. The debug .so depends on libc, so CallConstructors is |
| 2260 | // called again with the libc soinfo. If it doesn't trigger the early- |
| 2261 | // out above, the libc constructor will be called again (recursively!). |
| 2262 | constructors_called = true; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2263 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2264 | if (!is_main_executable() && preinit_array_ != nullptr) { |
Elliott Hughes | 8147d3c | 2013-05-09 14:19:58 -0700 | [diff] [blame] | 2265 | // The GNU dynamic linker silently ignores these, but we warn the developer. |
Elliott Hughes | c620059 | 2013-09-30 18:43:46 -0700 | [diff] [blame] | 2266 | PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2267 | get_realpath(), preinit_array_count_); |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 2268 | } |
| 2269 | |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2270 | get_children().for_each([] (soinfo* si) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2271 | si->call_constructors(); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2272 | }); |
Evgeniy Stepanov | e83c56d | 2011-12-21 13:03:54 +0400 | [diff] [blame] | 2273 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2274 | TRACE("\"%s\": calling constructors", get_realpath()); |
Elliott Hughes | 8147d3c | 2013-05-09 14:19:58 -0700 | [diff] [blame] | 2275 | |
| 2276 | // DT_INIT should be called before DT_INIT_ARRAY if both are present. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2277 | call_function("DT_INIT", init_func_); |
| 2278 | call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false); |
Evgeniy Stepanov | e83c56d | 2011-12-21 13:03:54 +0400 | [diff] [blame] | 2279 | } |
David 'Digit' Turner | 8215679 | 2009-05-18 14:37:41 +0200 | [diff] [blame] | 2280 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2281 | void soinfo::call_destructors() { |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2282 | if (!constructors_called) { |
| 2283 | return; |
| 2284 | } |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2285 | TRACE("\"%s\": calling destructors", get_realpath()); |
Elliott Hughes | 8147d3c | 2013-05-09 14:19:58 -0700 | [diff] [blame] | 2286 | |
| 2287 | // DT_FINI_ARRAY must be parsed in reverse order. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2288 | call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true); |
Elliott Hughes | 8147d3c | 2013-05-09 14:19:58 -0700 | [diff] [blame] | 2289 | |
| 2290 | // DT_FINI should be called after DT_FINI_ARRAY if both are present. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2291 | call_function("DT_FINI", fini_func_); |
Dmitriy Ivanov | b648a8a | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 2292 | |
| 2293 | // This is needed on second call to dlopen |
| 2294 | // after library has been unloaded with RTLD_NODELETE |
| 2295 | constructors_called = false; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2296 | } |
| 2297 | |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2298 | void soinfo::add_child(soinfo* child) { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2299 | if (has_min_version(0)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2300 | child->parents_.push_back(this); |
| 2301 | this->children_.push_back(child); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2302 | } |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2303 | } |
| 2304 | |
| 2305 | void soinfo::remove_all_links() { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2306 | if (!has_min_version(0)) { |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2307 | return; |
| 2308 | } |
| 2309 | |
| 2310 | // 1. Untie connected soinfos from 'this'. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2311 | children_.for_each([&] (soinfo* child) { |
| 2312 | child->parents_.remove_if([&] (const soinfo* parent) { |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2313 | return parent == this; |
| 2314 | }); |
| 2315 | }); |
| 2316 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2317 | parents_.for_each([&] (soinfo* parent) { |
| 2318 | parent->children_.remove_if([&] (const soinfo* child) { |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2319 | return child == this; |
| 2320 | }); |
| 2321 | }); |
| 2322 | |
| 2323 | // 2. Once everything untied - clear local lists. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2324 | parents_.clear(); |
| 2325 | children_.clear(); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2326 | } |
| 2327 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2328 | dev_t soinfo::get_st_dev() const { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2329 | if (has_min_version(0)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2330 | return st_dev_; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2331 | } |
| 2332 | |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2333 | return 0; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2334 | }; |
| 2335 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2336 | ino_t soinfo::get_st_ino() const { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2337 | if (has_min_version(0)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2338 | return st_ino_; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2339 | } |
| 2340 | |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2341 | return 0; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2342 | } |
| 2343 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2344 | off64_t soinfo::get_file_offset() const { |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 2345 | if (has_min_version(1)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2346 | return file_offset_; |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 2347 | } |
| 2348 | |
| 2349 | return 0; |
| 2350 | } |
| 2351 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2352 | uint32_t soinfo::get_rtld_flags() const { |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 2353 | if (has_min_version(1)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2354 | return rtld_flags_; |
Dmitriy Ivanov | e8ba50f | 2014-09-15 17:00:10 -0700 | [diff] [blame] | 2355 | } |
| 2356 | |
| 2357 | return 0; |
| 2358 | } |
| 2359 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2360 | uint32_t soinfo::get_dt_flags_1() const { |
| 2361 | if (has_min_version(1)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2362 | return dt_flags_1_; |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2363 | } |
| 2364 | |
| 2365 | return 0; |
| 2366 | } |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2367 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2368 | void soinfo::set_dt_flags_1(uint32_t dt_flags_1) { |
| 2369 | if (has_min_version(1)) { |
| 2370 | if ((dt_flags_1 & DF_1_GLOBAL) != 0) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2371 | rtld_flags_ |= RTLD_GLOBAL; |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2372 | } |
| 2373 | |
| 2374 | if ((dt_flags_1 & DF_1_NODELETE) != 0) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2375 | rtld_flags_ |= RTLD_NODELETE; |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2376 | } |
| 2377 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2378 | dt_flags_1_ = dt_flags_1; |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2379 | } |
| 2380 | } |
| 2381 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2382 | const char* soinfo::get_realpath() const { |
Dmitriy Ivanov | 69a5fb9 | 2015-05-15 17:53:39 -0700 | [diff] [blame] | 2383 | #if defined(__work_around_b_19059885__) |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2384 | if (has_min_version(2)) { |
| 2385 | return realpath_.c_str(); |
| 2386 | } else { |
| 2387 | return old_name_; |
| 2388 | } |
| 2389 | #else |
| 2390 | return realpath_.c_str(); |
| 2391 | #endif |
| 2392 | } |
| 2393 | |
| 2394 | const char* soinfo::get_soname() const { |
Dmitriy Ivanov | 69a5fb9 | 2015-05-15 17:53:39 -0700 | [diff] [blame] | 2395 | #if defined(__work_around_b_19059885__) |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2396 | if (has_min_version(2)) { |
| 2397 | return soname_; |
| 2398 | } else { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2399 | return old_name_; |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2400 | } |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2401 | #else |
| 2402 | return soname_; |
| 2403 | #endif |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2404 | } |
| 2405 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2406 | // This is a return on get_children()/get_parents() if |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2407 | // 'this->flags' does not have FLAG_NEW_SOINFO set. |
| 2408 | static soinfo::soinfo_list_t g_empty_list; |
| 2409 | |
| 2410 | soinfo::soinfo_list_t& soinfo::get_children() { |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2411 | if (has_min_version(0)) { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2412 | return children_; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2413 | } |
| 2414 | |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 2415 | return g_empty_list; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 2416 | } |
| 2417 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2418 | const soinfo::soinfo_list_t& soinfo::get_children() const { |
| 2419 | if (has_min_version(0)) { |
| 2420 | return children_; |
| 2421 | } |
| 2422 | |
| 2423 | return g_empty_list; |
| 2424 | } |
| 2425 | |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2426 | soinfo::soinfo_list_t& soinfo::get_parents() { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2427 | if (has_min_version(0)) { |
| 2428 | return parents_; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2429 | } |
| 2430 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2431 | return g_empty_list; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2432 | } |
| 2433 | |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2434 | ElfW(Addr) soinfo::resolve_symbol_address(const ElfW(Sym)* s) const { |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 2435 | if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) { |
| 2436 | return call_ifunc_resolver(s->st_value + load_bias); |
| 2437 | } |
| 2438 | |
| 2439 | return static_cast<ElfW(Addr)>(s->st_value + load_bias); |
| 2440 | } |
| 2441 | |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2442 | const char* soinfo::get_string(ElfW(Word) index) const { |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2443 | if (has_min_version(1) && (index >= strtab_size_)) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2444 | __libc_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2445 | get_realpath(), strtab_size_, index); |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2446 | } |
| 2447 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2448 | return strtab_ + index; |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2449 | } |
| 2450 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2451 | bool soinfo::is_gnu_hash() const { |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2452 | return (flags_ & FLAG_GNU_HASH) != 0; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2453 | } |
| 2454 | |
Dmitriy Ivanov | 1b20daf | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 2455 | bool soinfo::can_unload() const { |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2456 | return (get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0; |
Dmitriy Ivanov | 1b20daf | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 2457 | } |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2458 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2459 | bool soinfo::is_linked() const { |
| 2460 | return (flags_ & FLAG_LINKED) != 0; |
| 2461 | } |
| 2462 | |
| 2463 | bool soinfo::is_main_executable() const { |
| 2464 | return (flags_ & FLAG_EXE) != 0; |
| 2465 | } |
| 2466 | |
| 2467 | void soinfo::set_linked() { |
| 2468 | flags_ |= FLAG_LINKED; |
| 2469 | } |
| 2470 | |
| 2471 | void soinfo::set_linker_flag() { |
| 2472 | flags_ |= FLAG_LINKER; |
| 2473 | } |
| 2474 | |
| 2475 | void soinfo::set_main_executable() { |
| 2476 | flags_ |= FLAG_EXE; |
| 2477 | } |
| 2478 | |
| 2479 | void soinfo::increment_ref_count() { |
| 2480 | local_group_root_->ref_count_++; |
| 2481 | } |
| 2482 | |
| 2483 | size_t soinfo::decrement_ref_count() { |
| 2484 | return --local_group_root_->ref_count_; |
| 2485 | } |
| 2486 | |
| 2487 | soinfo* soinfo::get_local_group_root() const { |
| 2488 | return local_group_root_; |
| 2489 | } |
| 2490 | |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 2491 | // This function returns api-level at the time of |
| 2492 | // dlopen/load. Note that libraries opened by system |
| 2493 | // will always have 'current' api level. |
| 2494 | uint32_t soinfo::get_target_sdk_version() const { |
| 2495 | if (!has_min_version(2)) { |
| 2496 | return __ANDROID_API__; |
| 2497 | } |
| 2498 | |
| 2499 | return local_group_root_->target_sdk_version_; |
| 2500 | } |
| 2501 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2502 | bool soinfo::prelink_image() { |
Ningsheng Jian | e93be99 | 2014-09-16 15:22:10 +0800 | [diff] [blame] | 2503 | /* Extract dynamic section */ |
| 2504 | ElfW(Word) dynamic_flags = 0; |
| 2505 | phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags); |
Dmitriy Ivanov | 498eb18 | 2014-09-05 14:57:59 -0700 | [diff] [blame] | 2506 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2507 | /* We can't log anything until the linker is relocated */ |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2508 | bool relocating_linker = (flags_ & FLAG_LINKER) != 0; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2509 | if (!relocating_linker) { |
Dmitriy Ivanov | 53ba663 | 2015-04-28 18:09:53 -0700 | [diff] [blame] | 2510 | INFO("[ linking %s ]", get_realpath()); |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2511 | DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2512 | } |
| 2513 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2514 | if (dynamic == nullptr) { |
David 'Digit' Turner | b52e438 | 2012-06-19 01:24:17 +0200 | [diff] [blame] | 2515 | if (!relocating_linker) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2516 | DL_ERR("missing PT_DYNAMIC in \"%s\"", get_realpath()); |
David 'Digit' Turner | b52e438 | 2012-06-19 01:24:17 +0200 | [diff] [blame] | 2517 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2518 | return false; |
| 2519 | } else { |
| 2520 | if (!relocating_linker) { |
| 2521 | DEBUG("dynamic = %p", dynamic); |
David 'Digit' Turner | 63f99f4 | 2012-06-19 00:08:39 +0200 | [diff] [blame] | 2522 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2523 | } |
David 'Digit' Turner | 63f99f4 | 2012-06-19 00:08:39 +0200 | [diff] [blame] | 2524 | |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 2525 | #if defined(__arm__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2526 | (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias, |
| 2527 | &ARM_exidx, &ARM_exidx_count); |
David 'Digit' Turner | 63f99f4 | 2012-06-19 00:08:39 +0200 | [diff] [blame] | 2528 | #endif |
| 2529 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2530 | // Extract useful information from dynamic section. |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2531 | // Note that: "Except for the DT_NULL element at the end of the array, |
| 2532 | // and the relative order of DT_NEEDED elements, entries may appear in any order." |
| 2533 | // |
| 2534 | // source: http://www.sco.com/developers/gabi/1998-04-29/ch5.dynamic.html |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2535 | uint32_t needed_count = 0; |
| 2536 | for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) { |
| 2537 | DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p", |
| 2538 | d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val)); |
| 2539 | switch (d->d_tag) { |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2540 | case DT_SONAME: |
Dmitriy Ivanov | 618f1a3 | 2015-03-17 20:06:36 -0700 | [diff] [blame] | 2541 | // this is parsed after we have strtab initialized (see below). |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2542 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2543 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2544 | case DT_HASH: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2545 | nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0]; |
| 2546 | nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1]; |
| 2547 | bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8); |
| 2548 | chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2549 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2550 | |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2551 | case DT_GNU_HASH: |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 2552 | gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2553 | // skip symndx |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2554 | gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2]; |
| 2555 | gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2556 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2557 | gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16); |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 2558 | gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2559 | // amend chain for symndx = header[1] |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2560 | gnu_chain_ = gnu_bucket_ + gnu_nbucket_ - |
| 2561 | reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1]; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2562 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2563 | if (!powerof2(gnu_maskwords_)) { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2564 | DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two", |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2565 | gnu_maskwords_, get_realpath()); |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2566 | return false; |
| 2567 | } |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2568 | --gnu_maskwords_; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2569 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2570 | flags_ |= FLAG_GNU_HASH; |
Dmitriy Ivanov | ec18ce0 | 2014-11-09 19:27:20 -0800 | [diff] [blame] | 2571 | break; |
| 2572 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2573 | case DT_STRTAB: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2574 | strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2575 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2576 | |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2577 | case DT_STRSZ: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2578 | strtab_size_ = d->d_un.d_val; |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2579 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2580 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2581 | case DT_SYMTAB: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2582 | symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2583 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2584 | |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2585 | case DT_SYMENT: |
| 2586 | if (d->d_un.d_val != sizeof(ElfW(Sym))) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2587 | DL_ERR("invalid DT_SYMENT: %zd in \"%s\"", |
| 2588 | static_cast<size_t>(d->d_un.d_val), get_realpath()); |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2589 | return false; |
| 2590 | } |
| 2591 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2592 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2593 | case DT_PLTREL: |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2594 | #if defined(USE_RELA) |
| 2595 | if (d->d_un.d_val != DT_RELA) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2596 | DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_RELA", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2597 | return false; |
| 2598 | } |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2599 | #else |
| 2600 | if (d->d_un.d_val != DT_REL) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2601 | DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_REL", get_realpath()); |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2602 | return false; |
| 2603 | } |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2604 | #endif |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2605 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2606 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2607 | case DT_JMPREL: |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 2608 | #if defined(USE_RELA) |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2609 | plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2610 | #else |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2611 | plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2612 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2613 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2614 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2615 | case DT_PLTRELSZ: |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 2616 | #if defined(USE_RELA) |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2617 | plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela)); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2618 | #else |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2619 | plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel)); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2620 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2621 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2622 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2623 | case DT_PLTGOT: |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2624 | #if defined(__mips__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2625 | // Used by mips and mips64. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2626 | plt_got_ = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr); |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2627 | #endif |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2628 | // Ignore for other platforms... (because RTLD_LAZY is not supported) |
| 2629 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2630 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2631 | case DT_DEBUG: |
| 2632 | // Set the DT_DEBUG entry to the address of _r_debug for GDB |
| 2633 | // if the dynamic table is writable |
Chris Dearman | 9918665 | 2014-02-06 20:36:51 -0800 | [diff] [blame] | 2634 | // FIXME: not working currently for N64 |
| 2635 | // The flags for the LOAD and DYNAMIC program headers do not agree. |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2636 | // The LOAD section containing the dynamic table has been mapped as |
Chris Dearman | 9918665 | 2014-02-06 20:36:51 -0800 | [diff] [blame] | 2637 | // read-only, but the DYNAMIC header claims it is writable. |
| 2638 | #if !(defined(__mips__) && defined(__LP64__)) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2639 | if ((dynamic_flags & PF_W) != 0) { |
| 2640 | d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug); |
| 2641 | } |
Chris Dearman | 9918665 | 2014-02-06 20:36:51 -0800 | [diff] [blame] | 2642 | #endif |
Dmitriy Ivanov | c6292ea | 2015-02-13 16:29:50 -0800 | [diff] [blame] | 2643 | break; |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 2644 | #if defined(USE_RELA) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2645 | case DT_RELA: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2646 | rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2647 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2648 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2649 | case DT_RELASZ: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2650 | rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2651 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2652 | |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2653 | case DT_ANDROID_RELA: |
| 2654 | android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr); |
| 2655 | break; |
| 2656 | |
| 2657 | case DT_ANDROID_RELASZ: |
| 2658 | android_relocs_size_ = d->d_un.d_val; |
| 2659 | break; |
| 2660 | |
| 2661 | case DT_ANDROID_REL: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2662 | DL_ERR("unsupported DT_ANDROID_REL in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2663 | return false; |
| 2664 | |
| 2665 | case DT_ANDROID_RELSZ: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2666 | DL_ERR("unsupported DT_ANDROID_RELSZ in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2667 | return false; |
| 2668 | |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2669 | case DT_RELAENT: |
| 2670 | if (d->d_un.d_val != sizeof(ElfW(Rela))) { |
Dmitriy Ivanov | f240aa8 | 2014-09-16 23:34:20 -0700 | [diff] [blame] | 2671 | DL_ERR("invalid DT_RELAENT: %zd", static_cast<size_t>(d->d_un.d_val)); |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2672 | return false; |
| 2673 | } |
| 2674 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2675 | |
| 2676 | // ignored (see DT_RELCOUNT comments for details) |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2677 | case DT_RELACOUNT: |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2678 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2679 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2680 | case DT_REL: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2681 | DL_ERR("unsupported DT_REL in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2682 | return false; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2683 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2684 | case DT_RELSZ: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2685 | DL_ERR("unsupported DT_RELSZ in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2686 | return false; |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2687 | |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2688 | #else |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2689 | case DT_REL: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2690 | rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2691 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2692 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2693 | case DT_RELSZ: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2694 | rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2695 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2696 | |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2697 | case DT_RELENT: |
| 2698 | if (d->d_un.d_val != sizeof(ElfW(Rel))) { |
Dmitriy Ivanov | f240aa8 | 2014-09-16 23:34:20 -0700 | [diff] [blame] | 2699 | DL_ERR("invalid DT_RELENT: %zd", static_cast<size_t>(d->d_un.d_val)); |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2700 | return false; |
| 2701 | } |
| 2702 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2703 | |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2704 | case DT_ANDROID_REL: |
| 2705 | android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr); |
| 2706 | break; |
| 2707 | |
| 2708 | case DT_ANDROID_RELSZ: |
| 2709 | android_relocs_size_ = d->d_un.d_val; |
| 2710 | break; |
| 2711 | |
| 2712 | case DT_ANDROID_RELA: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2713 | DL_ERR("unsupported DT_ANDROID_RELA in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2714 | return false; |
| 2715 | |
| 2716 | case DT_ANDROID_RELASZ: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2717 | DL_ERR("unsupported DT_ANDROID_RELASZ in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2718 | return false; |
| 2719 | |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2720 | // "Indicates that all RELATIVE relocations have been concatenated together, |
| 2721 | // and specifies the RELATIVE relocation count." |
| 2722 | // |
| 2723 | // TODO: Spec also mentions that this can be used to optimize relocation process; |
| 2724 | // Not currently used by bionic linker - ignored. |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2725 | case DT_RELCOUNT: |
Dmitriy Ivanov | 4a6e9a8 | 2014-09-16 15:51:25 -0700 | [diff] [blame] | 2726 | break; |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2727 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2728 | case DT_RELA: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2729 | DL_ERR("unsupported DT_RELA in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2730 | return false; |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2731 | |
| 2732 | case DT_RELASZ: |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2733 | DL_ERR("unsupported DT_RELASZ in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2734 | return false; |
| 2735 | |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 2736 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2737 | case DT_INIT: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2738 | init_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2739 | DEBUG("%s constructors (DT_INIT) found at %p", get_realpath(), init_func_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2740 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2741 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2742 | case DT_FINI: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2743 | fini_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2744 | DEBUG("%s destructors (DT_FINI) found at %p", get_realpath(), fini_func_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2745 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2746 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2747 | case DT_INIT_ARRAY: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2748 | init_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2749 | DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", get_realpath(), init_array_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2750 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2751 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2752 | case DT_INIT_ARRAYSZ: |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 2753 | init_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2754 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2755 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2756 | case DT_FINI_ARRAY: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2757 | fini_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2758 | DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", get_realpath(), fini_array_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2759 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2760 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2761 | case DT_FINI_ARRAYSZ: |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 2762 | fini_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2763 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2764 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2765 | case DT_PREINIT_ARRAY: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2766 | preinit_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr); |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2767 | DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", get_realpath(), preinit_array_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2768 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2769 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2770 | case DT_PREINIT_ARRAYSZ: |
Dmitriy Ivanov | 1649e7e | 2015-01-22 16:04:25 -0800 | [diff] [blame] | 2771 | preinit_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2772 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2773 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2774 | case DT_TEXTREL: |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2775 | #if defined(__LP64__) |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2776 | DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2777 | return false; |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2778 | #else |
| 2779 | has_text_relocations = true; |
| 2780 | break; |
| 2781 | #endif |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2782 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2783 | case DT_SYMBOLIC: |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 2784 | has_DT_SYMBOLIC = true; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2785 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2786 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2787 | case DT_NEEDED: |
| 2788 | ++needed_count; |
| 2789 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2790 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2791 | case DT_FLAGS: |
| 2792 | if (d->d_un.d_val & DF_TEXTREL) { |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2793 | #if defined(__LP64__) |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2794 | DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2795 | return false; |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2796 | #else |
| 2797 | has_text_relocations = true; |
| 2798 | #endif |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2799 | } |
Dmitriy Ivanov | 96bc37f | 2014-09-29 12:10:36 -0700 | [diff] [blame] | 2800 | if (d->d_un.d_val & DF_SYMBOLIC) { |
| 2801 | has_DT_SYMBOLIC = true; |
| 2802 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2803 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2804 | |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2805 | case DT_FLAGS_1: |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2806 | set_dt_flags_1(d->d_un.d_val); |
Dmitriy Ivanov | 1b20daf | 2014-05-19 15:06:58 -0700 | [diff] [blame] | 2807 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 2808 | if ((d->d_un.d_val & ~SUPPORTED_DT_FLAGS_1) != 0) { |
Dmitriy Ivanov | ca10ac6 | 2015-05-28 11:44:31 -0700 | [diff] [blame] | 2809 | DL_WARN("%s: unsupported flags DT_FLAGS_1=%p", get_realpath(), reinterpret_cast<void*>(d->d_un.d_val)); |
Dmitriy Ivanov | 6cdeb52 | 2014-09-29 19:14:45 -0700 | [diff] [blame] | 2810 | } |
| 2811 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2812 | #if defined(__mips__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2813 | case DT_MIPS_RLD_MAP: |
| 2814 | // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB. |
| 2815 | { |
| 2816 | r_debug** dp = reinterpret_cast<r_debug**>(load_bias + d->d_un.d_ptr); |
| 2817 | *dp = &_r_debug; |
| 2818 | } |
| 2819 | break; |
Raghu Gandham | 6881572 | 2014-12-18 19:12:19 -0800 | [diff] [blame] | 2820 | case DT_MIPS_RLD_MAP2: |
| 2821 | // Set the DT_MIPS_RLD_MAP2 entry to the address of _r_debug for GDB. |
| 2822 | { |
Dmitriy Ivanov | 20d89cb | 2015-03-30 18:43:38 -0700 | [diff] [blame] | 2823 | r_debug** dp = reinterpret_cast<r_debug**>( |
| 2824 | reinterpret_cast<ElfW(Addr)>(d) + d->d_un.d_val); |
Raghu Gandham | 6881572 | 2014-12-18 19:12:19 -0800 | [diff] [blame] | 2825 | *dp = &_r_debug; |
| 2826 | } |
| 2827 | break; |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2828 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2829 | case DT_MIPS_RLD_VERSION: |
| 2830 | case DT_MIPS_FLAGS: |
| 2831 | case DT_MIPS_BASE_ADDRESS: |
| 2832 | case DT_MIPS_UNREFEXTNO: |
| 2833 | break; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2834 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2835 | case DT_MIPS_SYMTABNO: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2836 | mips_symtabno_ = d->d_un.d_val; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2837 | break; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2838 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2839 | case DT_MIPS_LOCAL_GOTNO: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2840 | mips_local_gotno_ = d->d_un.d_val; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2841 | break; |
| 2842 | |
| 2843 | case DT_MIPS_GOTSYM: |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2844 | mips_gotsym_ = d->d_un.d_val; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2845 | break; |
| 2846 | #endif |
Dmitriy Ivanov | ea6eae1 | 2014-10-15 14:59:01 -0700 | [diff] [blame] | 2847 | // Ignored: "Its use has been superseded by the DF_BIND_NOW flag" |
| 2848 | case DT_BIND_NOW: |
| 2849 | break; |
| 2850 | |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2851 | case DT_VERSYM: |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2852 | versym_ = reinterpret_cast<ElfW(Versym)*>(load_bias + d->d_un.d_ptr); |
| 2853 | break; |
| 2854 | |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2855 | case DT_VERDEF: |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2856 | verdef_ptr_ = load_bias + d->d_un.d_ptr; |
| 2857 | break; |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2858 | case DT_VERDEFNUM: |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2859 | verdef_cnt_ = d->d_un.d_val; |
| 2860 | break; |
| 2861 | |
Alexander Ivchenko | e831433 | 2014-12-02 15:32:25 +0300 | [diff] [blame] | 2862 | case DT_VERNEED: |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2863 | verneed_ptr_ = load_bias + d->d_un.d_ptr; |
| 2864 | break; |
| 2865 | |
Alexander Ivchenko | e831433 | 2014-12-02 15:32:25 +0300 | [diff] [blame] | 2866 | case DT_VERNEEDNUM: |
Dmitriy Ivanov | 2a81536 | 2015-04-09 13:42:33 -0700 | [diff] [blame] | 2867 | verneed_cnt_ = d->d_un.d_val; |
Dmitriy Ivanov | 513e29e | 2014-10-06 11:30:43 -0700 | [diff] [blame] | 2868 | break; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2869 | |
| 2870 | default: |
Dmitriy Ivanov | 8f61d99 | 2014-09-16 14:31:06 -0700 | [diff] [blame] | 2871 | if (!relocating_linker) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2872 | DL_WARN("%s: unused DT entry: type %p arg %p", get_realpath(), |
Dmitriy Ivanov | 8f61d99 | 2014-09-16 14:31:06 -0700 | [diff] [blame] | 2873 | reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val)); |
| 2874 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2875 | break; |
Brian Carlstrom | d4ee82d | 2013-02-28 15:58:45 -0800 | [diff] [blame] | 2876 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2877 | } |
| 2878 | |
| 2879 | DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p", |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2880 | reinterpret_cast<void*>(base), strtab_, symtab_); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2881 | |
| 2882 | // Sanity checks. |
| 2883 | if (relocating_linker && needed_count != 0) { |
| 2884 | DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries"); |
| 2885 | return false; |
| 2886 | } |
Dmitriy Ivanov | 3597b80 | 2015-03-09 12:02:02 -0700 | [diff] [blame] | 2887 | if (nbucket_ == 0 && gnu_nbucket_ == 0) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 2888 | DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" " |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2889 | "(new hash type from the future?)", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2890 | return false; |
| 2891 | } |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2892 | if (strtab_ == 0) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2893 | DL_ERR("empty/missing DT_STRTAB in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2894 | return false; |
| 2895 | } |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2896 | if (symtab_ == 0) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2897 | DL_ERR("empty/missing DT_SYMTAB in \"%s\"", get_realpath()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2898 | return false; |
| 2899 | } |
Dmitriy Ivanov | 38c37d6 | 2015-06-02 13:28:06 -0700 | [diff] [blame] | 2900 | |
Dmitriy Ivanov | 07f4f5f | 2015-06-08 10:41:33 -0700 | [diff] [blame] | 2901 | // second pass - parse entries relying on strtab |
| 2902 | for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) { |
| 2903 | if (d->d_tag == DT_SONAME) { |
| 2904 | soname_ = get_string(d->d_un.d_val); |
| 2905 | #if defined(__work_around_b_19059885__) |
| 2906 | strlcpy(old_name_, soname_, sizeof(old_name_)); |
| 2907 | #endif |
| 2908 | break; |
| 2909 | } |
| 2910 | } |
| 2911 | |
Dmitriy Ivanov | 38c37d6 | 2015-06-02 13:28:06 -0700 | [diff] [blame] | 2912 | // Before M release linker was using basename in place of soname. |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 2913 | // In the case when dt_soname is absent some apps stop working |
Dmitriy Ivanov | 38c37d6 | 2015-06-02 13:28:06 -0700 | [diff] [blame] | 2914 | // because they can't find dt_needed library by soname. |
| 2915 | // This workaround should keep them working. (applies only |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 2916 | // for apps targeting sdk version <=22). Make an exception for |
| 2917 | // the main executable and linker; they do not need to have dt_soname |
| 2918 | if (soname_ == nullptr && this != somain && (flags_ & FLAG_LINKER) == 0 && |
| 2919 | get_application_target_sdk_version() <= 22) { |
Dmitriy Ivanov | 38c37d6 | 2015-06-02 13:28:06 -0700 | [diff] [blame] | 2920 | soname_ = basename(realpath_.c_str()); |
| 2921 | DL_WARN("%s: is missing DT_SONAME will use basename as a replacement: \"%s\"", |
| 2922 | get_realpath(), soname_); |
| 2923 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 2924 | return true; |
Dmitriy Ivanov | 14669a9 | 2014-09-05 16:42:53 -0700 | [diff] [blame] | 2925 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2926 | |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2927 | bool soinfo::link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group, |
| 2928 | const android_dlextinfo* extinfo) { |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 2929 | |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 2930 | local_group_root_ = local_group.front(); |
| 2931 | if (local_group_root_ == nullptr) { |
| 2932 | local_group_root_ = this; |
| 2933 | } |
| 2934 | |
Dmitriy Ivanov | 04f7e3e | 2015-06-02 17:36:54 -0700 | [diff] [blame] | 2935 | if ((flags_ & FLAG_LINKER) == 0 && local_group_root_ == this) { |
| 2936 | target_sdk_version_ = get_application_target_sdk_version(); |
| 2937 | } |
| 2938 | |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 2939 | VersionTracker version_tracker; |
| 2940 | |
| 2941 | if (!version_tracker.init(this)) { |
| 2942 | return false; |
| 2943 | } |
| 2944 | |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2945 | #if !defined(__LP64__) |
| 2946 | if (has_text_relocations) { |
Dmitriy Ivanov | 3e6f780 | 2015-06-12 15:00:31 -0700 | [diff] [blame] | 2947 | // Fail if app is targeting sdk version > 22 |
| 2948 | // TODO (dimitry): remove != __ANDROID_API__ check once http://b/20020312 is fixed |
| 2949 | if (get_application_target_sdk_version() != __ANDROID_API__ |
| 2950 | && get_application_target_sdk_version() > 22) { |
Dmitriy Ivanov | f32b689 | 2015-10-13 11:07:56 -0700 | [diff] [blame] | 2951 | PRINT("%s: has text relocations", get_realpath()); |
Dmitriy Ivanov | 3e6f780 | 2015-06-12 15:00:31 -0700 | [diff] [blame] | 2952 | DL_ERR("%s: has text relocations", get_realpath()); |
| 2953 | return false; |
| 2954 | } |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2955 | // Make segments writable to allow text relocations to work properly. We will later call |
| 2956 | // phdr_table_protect_segments() after all of them are applied and all constructors are run. |
| 2957 | DL_WARN("%s has text relocations. This is wasting memory and prevents " |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2958 | "security hardening. Please fix.", get_realpath()); |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2959 | if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) { |
| 2960 | DL_ERR("can't unprotect loadable segments for \"%s\": %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2961 | get_realpath(), strerror(errno)); |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 2962 | return false; |
| 2963 | } |
| 2964 | } |
| 2965 | #endif |
| 2966 | |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2967 | if (android_relocs_ != nullptr) { |
| 2968 | // check signature |
| 2969 | if (android_relocs_size_ > 3 && |
| 2970 | android_relocs_[0] == 'A' && |
| 2971 | android_relocs_[1] == 'P' && |
Dmitriy Ivanov | 18870d3 | 2015-04-22 13:10:04 -0700 | [diff] [blame] | 2972 | android_relocs_[2] == 'S' && |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2973 | android_relocs_[3] == '2') { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2974 | DEBUG("[ android relocating %s ]", get_realpath()); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2975 | |
| 2976 | bool relocated = false; |
| 2977 | const uint8_t* packed_relocs = android_relocs_ + 4; |
| 2978 | const size_t packed_relocs_size = android_relocs_size_ - 4; |
| 2979 | |
Dmitriy Ivanov | 18870d3 | 2015-04-22 13:10:04 -0700 | [diff] [blame] | 2980 | relocated = relocate( |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 2981 | version_tracker, |
Dmitriy Ivanov | 18870d3 | 2015-04-22 13:10:04 -0700 | [diff] [blame] | 2982 | packed_reloc_iterator<sleb128_decoder>( |
| 2983 | sleb128_decoder(packed_relocs, packed_relocs_size)), |
| 2984 | global_group, local_group); |
Dmitriy Ivanov | 18a6956 | 2015-02-04 16:05:30 -0800 | [diff] [blame] | 2985 | |
| 2986 | if (!relocated) { |
| 2987 | return false; |
| 2988 | } |
| 2989 | } else { |
| 2990 | DL_ERR("bad android relocation header."); |
| 2991 | return false; |
| 2992 | } |
| 2993 | } |
| 2994 | |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 2995 | #if defined(USE_RELA) |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 2996 | if (rela_ != nullptr) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 2997 | DEBUG("[ relocating %s ]", get_realpath()); |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 2998 | if (!relocate(version_tracker, |
| 2999 | plain_reloc_iterator(rela_, rela_count_), global_group, local_group)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3000 | return false; |
Elliott Hughes | c00f2cb | 2013-10-04 17:01:33 -0700 | [diff] [blame] | 3001 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3002 | } |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3003 | if (plt_rela_ != nullptr) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3004 | DEBUG("[ relocating %s plt ]", get_realpath()); |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 3005 | if (!relocate(version_tracker, |
| 3006 | plain_reloc_iterator(plt_rela_, plt_rela_count_), global_group, local_group)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3007 | return false; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3008 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3009 | } |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 3010 | #else |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3011 | if (rel_ != nullptr) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3012 | DEBUG("[ relocating %s ]", get_realpath()); |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 3013 | if (!relocate(version_tracker, |
| 3014 | plain_reloc_iterator(rel_, rel_count_), global_group, local_group)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3015 | return false; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3016 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3017 | } |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3018 | if (plt_rel_ != nullptr) { |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3019 | DEBUG("[ relocating %s plt ]", get_realpath()); |
Dmitriy Ivanov | f92a417 | 2015-04-30 19:49:19 -0700 | [diff] [blame] | 3020 | if (!relocate(version_tracker, |
| 3021 | plain_reloc_iterator(plt_rel_, plt_rel_count_), global_group, local_group)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3022 | return false; |
Brigid Smith | c5a13ef | 2014-07-23 11:22:25 -0700 | [diff] [blame] | 3023 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3024 | } |
Dmitriy Ivanov | 9aea164 | 2014-09-11 15:16:03 -0700 | [diff] [blame] | 3025 | #endif |
Brigid Smith | c5a13ef | 2014-07-23 11:22:25 -0700 | [diff] [blame] | 3026 | |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 3027 | #if defined(__mips__) |
Dmitriy Ivanov | dc145b5 | 2015-04-30 20:17:03 -0700 | [diff] [blame] | 3028 | if (!mips_relocate_got(version_tracker, global_group, local_group)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3029 | return false; |
| 3030 | } |
Raghu Gandham | d7daacb | 2012-07-31 12:07:22 -0700 | [diff] [blame] | 3031 | #endif |
| 3032 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3033 | DEBUG("[ finished linking %s ]", get_realpath()); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3034 | |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 3035 | #if !defined(__LP64__) |
| 3036 | if (has_text_relocations) { |
| 3037 | // All relocations are done, we can protect our segments back to read-only. |
| 3038 | if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) { |
| 3039 | DL_ERR("can't protect segments for \"%s\": %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3040 | get_realpath(), strerror(errno)); |
Dimitry Ivanov | 56be6ed | 2015-04-01 21:18:48 +0000 | [diff] [blame] | 3041 | return false; |
| 3042 | } |
| 3043 | } |
| 3044 | #endif |
| 3045 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3046 | /* We can also turn on GNU RELRO protection */ |
| 3047 | if (phdr_table_protect_gnu_relro(phdr, phnum, load_bias) < 0) { |
| 3048 | DL_ERR("can't enable GNU RELRO protection for \"%s\": %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3049 | get_realpath(), strerror(errno)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3050 | return false; |
| 3051 | } |
Nick Kralevich | 9ec0f03 | 2012-02-28 10:40:00 -0800 | [diff] [blame] | 3052 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3053 | /* Handle serializing/sharing the RELRO segment */ |
| 3054 | if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) { |
| 3055 | if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias, |
| 3056 | extinfo->relro_fd) < 0) { |
| 3057 | DL_ERR("failed serializing GNU RELRO section for \"%s\": %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3058 | get_realpath(), strerror(errno)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3059 | return false; |
Torne (Richard Coles) | 183ad9d | 2014-02-27 13:18:00 +0000 | [diff] [blame] | 3060 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3061 | } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) { |
| 3062 | if (phdr_table_map_gnu_relro(phdr, phnum, load_bias, |
| 3063 | extinfo->relro_fd) < 0) { |
| 3064 | DL_ERR("failed mapping GNU RELRO section for \"%s\": %s", |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3065 | get_realpath(), strerror(errno)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3066 | return false; |
| 3067 | } |
| 3068 | } |
Torne (Richard Coles) | 183ad9d | 2014-02-27 13:18:00 +0000 | [diff] [blame] | 3069 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3070 | notify_gdb_of_load(this); |
| 3071 | return true; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3072 | } |
| 3073 | |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3074 | /* |
Sergey Melnikov | c45087b | 2013-01-25 16:40:13 +0400 | [diff] [blame] | 3075 | * This function add vdso to internal dso list. |
| 3076 | * It helps to stack unwinding through signal handlers. |
| 3077 | * Also, it makes bionic more like glibc. |
| 3078 | */ |
Kito Cheng | 812fd42 | 2014-03-25 22:53:56 +0800 | [diff] [blame] | 3079 | static void add_vdso(KernelArgumentBlock& args __unused) { |
Elliott Hughes | 4eeb1f1 | 2013-10-25 17:38:02 -0700 | [diff] [blame] | 3080 | #if defined(AT_SYSINFO_EHDR) |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3081 | ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR)); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 3082 | if (ehdr_vdso == nullptr) { |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3083 | return; |
| 3084 | } |
Sergey Melnikov | c45087b | 2013-01-25 16:40:13 +0400 | [diff] [blame] | 3085 | |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 3086 | soinfo* si = soinfo_alloc("[vdso]", nullptr, 0, 0); |
Sergey Melnikov | ebd506c | 2013-10-31 18:02:12 +0400 | [diff] [blame] | 3087 | |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3088 | si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff); |
| 3089 | si->phnum = ehdr_vdso->e_phnum; |
| 3090 | si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso); |
| 3091 | si->size = phdr_table_get_load_size(si->phdr, si->phnum); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3092 | si->load_bias = get_elf_exec_load_bias(ehdr_vdso); |
Sergey Melnikov | ebd506c | 2013-10-31 18:02:12 +0400 | [diff] [blame] | 3093 | |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3094 | si->prelink_image(); |
| 3095 | si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr); |
Sergey Melnikov | c45087b | 2013-01-25 16:40:13 +0400 | [diff] [blame] | 3096 | #endif |
| 3097 | } |
| 3098 | |
| 3099 | /* |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 3100 | * This is linker soinfo for GDB. See details below. |
| 3101 | */ |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 3102 | #if defined(__LP64__) |
| 3103 | #define LINKER_PATH "/system/bin/linker64" |
| 3104 | #else |
| 3105 | #define LINKER_PATH "/system/bin/linker" |
| 3106 | #endif |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 3107 | |
| 3108 | // This is done to avoid calling c-tor prematurely |
| 3109 | // because soinfo c-tor needs memory allocator |
| 3110 | // which might be initialized after global variables. |
| 3111 | static uint8_t linker_soinfo_for_gdb_buf[sizeof(soinfo)] __attribute__((aligned(8))); |
| 3112 | static soinfo* linker_soinfo_for_gdb = nullptr; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 3113 | |
| 3114 | /* gdb expects the linker to be in the debug shared object list. |
| 3115 | * Without this, gdb has trouble locating the linker's ".text" |
| 3116 | * and ".plt" sections. Gdb could also potentially use this to |
| 3117 | * relocate the offset of our exported 'rtld_db_dlactivity' symbol. |
| 3118 | * Don't use soinfo_alloc(), because the linker shouldn't |
| 3119 | * be on the soinfo list. |
| 3120 | */ |
| 3121 | static void init_linker_info_for_gdb(ElfW(Addr) linker_base) { |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 3122 | linker_soinfo_for_gdb = new (linker_soinfo_for_gdb_buf) soinfo(LINKER_PATH, nullptr, 0, 0); |
| 3123 | |
Dmitriy Ivanov | 38263dd | 2015-06-10 19:46:19 -0700 | [diff] [blame] | 3124 | linker_soinfo_for_gdb->load_bias = linker_base; |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 3125 | |
| 3126 | /* |
| 3127 | * Set the dynamic field in the link map otherwise gdb will complain with |
| 3128 | * the following: |
| 3129 | * warning: .dynamic section for "/system/bin/linker" is not at the |
| 3130 | * expected address (wrong library or version mismatch?) |
| 3131 | */ |
| 3132 | ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base); |
| 3133 | ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff); |
| 3134 | phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base, |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 3135 | &linker_soinfo_for_gdb->dynamic, nullptr); |
| 3136 | insert_soinfo_into_debug_map(linker_soinfo_for_gdb); |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 3137 | } |
| 3138 | |
Dmitriy Ivanov | 0b9e1c6 | 2015-04-28 15:49:26 -0700 | [diff] [blame] | 3139 | extern "C" int __system_properties_init(void); |
| 3140 | |
Dmitriy Ivanov | d59e500 | 2014-05-09 09:10:14 -0700 | [diff] [blame] | 3141 | /* |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3142 | * This code is called after the linker has linked itself and |
| 3143 | * fixed it's own GOT. It is safe to make references to externs |
| 3144 | * and other non-local data at this point. |
| 3145 | */ |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3146 | static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW(Addr) linker_base) { |
Evgeniy Stepanov | 1a78fbb | 2012-03-22 18:01:53 +0400 | [diff] [blame] | 3147 | #if TIMING |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3148 | struct timeval t0, t1; |
| 3149 | gettimeofday(&t0, 0); |
Evgeniy Stepanov | 1a78fbb | 2012-03-22 18:01:53 +0400 | [diff] [blame] | 3150 | #endif |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3151 | |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 3152 | // Sanitize the environment. |
| 3153 | __libc_init_AT_SECURE(args); |
David 'Digit' Turner | be57559 | 2010-12-16 19:52:02 +0100 | [diff] [blame] | 3154 | |
Dmitriy Ivanov | 0b9e1c6 | 2015-04-28 15:49:26 -0700 | [diff] [blame] | 3155 | // Initialize system properties |
| 3156 | __system_properties_init(); // may use 'environ' |
| 3157 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3158 | debuggerd_init(); |
| 3159 | |
| 3160 | // Get a few environment variables. |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 3161 | const char* LD_DEBUG = getenv("LD_DEBUG"); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3162 | if (LD_DEBUG != nullptr) { |
| 3163 | g_ld_debug_verbosity = atoi(LD_DEBUG); |
| 3164 | } |
| 3165 | |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 3166 | // These should have been sanitized by __libc_init_AT_SECURE, but the test |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3167 | // doesn't cost us anything. |
| 3168 | const char* ldpath_env = nullptr; |
| 3169 | const char* ldpreload_env = nullptr; |
Elliott Hughes | 66c3b2d | 2015-06-08 18:04:00 -0700 | [diff] [blame] | 3170 | if (!getauxval(AT_SECURE)) { |
| 3171 | ldpath_env = getenv("LD_LIBRARY_PATH"); |
| 3172 | ldpreload_env = getenv("LD_PRELOAD"); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3173 | } |
| 3174 | |
| 3175 | INFO("[ android linker & debugger ]"); |
| 3176 | |
Dmitriy Ivanov | 07e5bc1 | 2014-10-03 17:52:44 -0700 | [diff] [blame] | 3177 | soinfo* si = soinfo_alloc(args.argv[0], nullptr, 0, RTLD_GLOBAL); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3178 | if (si == nullptr) { |
| 3179 | exit(EXIT_FAILURE); |
| 3180 | } |
| 3181 | |
| 3182 | /* bootstrap the link map, the main exe always needs to be first */ |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 3183 | si->set_main_executable(); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3184 | link_map* map = &(si->link_map_head); |
| 3185 | |
| 3186 | map->l_addr = 0; |
| 3187 | map->l_name = args.argv[0]; |
| 3188 | map->l_prev = nullptr; |
| 3189 | map->l_next = nullptr; |
| 3190 | |
| 3191 | _r_debug.r_map = map; |
| 3192 | r_debug_tail = map; |
| 3193 | |
| 3194 | init_linker_info_for_gdb(linker_base); |
| 3195 | |
| 3196 | // Extract information passed from the kernel. |
| 3197 | si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR)); |
| 3198 | si->phnum = args.getauxval(AT_PHNUM); |
| 3199 | si->entry = args.getauxval(AT_ENTRY); |
| 3200 | |
| 3201 | /* Compute the value of si->base. We can't rely on the fact that |
| 3202 | * the first entry is the PHDR because this will not be true |
| 3203 | * for certain executables (e.g. some in the NDK unit test suite) |
| 3204 | */ |
| 3205 | si->base = 0; |
| 3206 | si->size = phdr_table_get_load_size(si->phdr, si->phnum); |
| 3207 | si->load_bias = 0; |
| 3208 | for (size_t i = 0; i < si->phnum; ++i) { |
| 3209 | if (si->phdr[i].p_type == PT_PHDR) { |
| 3210 | si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr; |
| 3211 | si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset; |
| 3212 | break; |
Nick Kralevich | 8d3e91d | 2013-04-25 13:15:24 -0700 | [diff] [blame] | 3213 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3214 | } |
| 3215 | si->dynamic = nullptr; |
Nick Kralevich | 8d3e91d | 2013-04-25 13:15:24 -0700 | [diff] [blame] | 3216 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3217 | ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base); |
| 3218 | if (elf_hdr->e_type != ET_DYN) { |
| 3219 | __libc_format_fd(2, "error: only position independent executables (PIE) are supported.\n"); |
| 3220 | exit(EXIT_FAILURE); |
| 3221 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3222 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3223 | // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid). |
| 3224 | parse_LD_LIBRARY_PATH(ldpath_env); |
| 3225 | parse_LD_PRELOAD(ldpreload_env); |
David 'Digit' Turner | be57559 | 2010-12-16 19:52:02 +0100 | [diff] [blame] | 3226 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3227 | somain = si; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3228 | |
Dmitriy Ivanov | 6718125 | 2015-01-07 15:48:25 -0800 | [diff] [blame] | 3229 | if (!si->prelink_image()) { |
| 3230 | __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); |
| 3231 | exit(EXIT_FAILURE); |
| 3232 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3233 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 3234 | // add somain to global group |
| 3235 | si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL); |
| 3236 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3237 | // Load ld_preloads and dependencies. |
| 3238 | StringLinkedList needed_library_name_list; |
| 3239 | size_t needed_libraries_count = 0; |
| 3240 | size_t ld_preloads_count = 0; |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 3241 | |
| 3242 | for (const auto& ld_preload_name : g_ld_preload_names) { |
| 3243 | needed_library_name_list.push_back(ld_preload_name.c_str()); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3244 | ++needed_libraries_count; |
Dmitriy Ivanov | 53ba663 | 2015-04-28 18:09:53 -0700 | [diff] [blame] | 3245 | ++ld_preloads_count; |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3246 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3247 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3248 | for_each_dt_needed(si, [&](const char* name) { |
| 3249 | needed_library_name_list.push_back(name); |
| 3250 | ++needed_libraries_count; |
| 3251 | }); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3252 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3253 | const char* needed_library_names[needed_libraries_count]; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3254 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3255 | memset(needed_library_names, 0, sizeof(needed_library_names)); |
| 3256 | needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3257 | |
Dmitriy Ivanov | d165f56 | 2015-03-23 18:43:02 -0700 | [diff] [blame] | 3258 | if (needed_libraries_count > 0 && |
| 3259 | !find_libraries(si, needed_library_names, needed_libraries_count, nullptr, |
| 3260 | &g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr)) { |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3261 | __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); |
| 3262 | exit(EXIT_FAILURE); |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 3263 | } else if (needed_libraries_count == 0) { |
| 3264 | if (!si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr)) { |
| 3265 | __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); |
| 3266 | exit(EXIT_FAILURE); |
| 3267 | } |
| 3268 | si->increment_ref_count(); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3269 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3270 | |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3271 | add_vdso(args); |
Nick Kralevich | 2aebf54 | 2014-05-07 10:32:39 -0700 | [diff] [blame] | 3272 | |
Dmitriy Ivanov | 279a22f | 2015-01-23 12:03:53 -0800 | [diff] [blame] | 3273 | { |
| 3274 | ProtectedDataGuard guard; |
Matt Fischer | 4fd42c1 | 2009-12-31 12:09:10 -0600 | [diff] [blame] | 3275 | |
Dmitriy Ivanov | 279a22f | 2015-01-23 12:03:53 -0800 | [diff] [blame] | 3276 | si->call_pre_init_constructors(); |
| 3277 | |
| 3278 | /* After the prelink_image, the si->load_bias is initialized. |
| 3279 | * For so lib, the map->l_addr will be updated in notify_gdb_of_load. |
| 3280 | * We need to update this value for so exe here. So Unwind_Backtrace |
| 3281 | * for some arch like x86 could work correctly within so exe. |
| 3282 | */ |
| 3283 | map->l_addr = si->load_bias; |
| 3284 | si->call_constructors(); |
| 3285 | } |
Evgeniy Stepanov | e83c56d | 2011-12-21 13:03:54 +0400 | [diff] [blame] | 3286 | |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3287 | #if TIMING |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3288 | gettimeofday(&t1, nullptr); |
| 3289 | PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) ( |
| 3290 | (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) - |
| 3291 | (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec))); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3292 | #endif |
| 3293 | #if STATS |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3294 | PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0], |
| 3295 | linker_stats.count[kRelocAbsolute], |
| 3296 | linker_stats.count[kRelocRelative], |
| 3297 | linker_stats.count[kRelocCopy], |
| 3298 | linker_stats.count[kRelocSymbol]); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3299 | #endif |
| 3300 | #if COUNT_PAGES |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3301 | { |
| 3302 | unsigned n; |
| 3303 | unsigned i; |
| 3304 | unsigned count = 0; |
| 3305 | for (n = 0; n < 4096; n++) { |
| 3306 | if (bitmask[n]) { |
| 3307 | unsigned x = bitmask[n]; |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 3308 | #if defined(__LP64__) |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3309 | for (i = 0; i < 32; i++) { |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 3310 | #else |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3311 | for (i = 0; i < 8; i++) { |
Marcus Oakland | e365f9d | 2013-10-10 15:19:31 +0100 | [diff] [blame] | 3312 | #endif |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3313 | if (x & 1) { |
| 3314 | count++; |
| 3315 | } |
| 3316 | x >>= 1; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3317 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3318 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3319 | } |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3320 | PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4); |
| 3321 | } |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3322 | #endif |
| 3323 | |
| 3324 | #if TIMING || STATS || COUNT_PAGES |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3325 | fflush(stdout); |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3326 | #endif |
| 3327 | |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3328 | TRACE("[ Ready to execute '%s' @ %p ]", si->get_realpath(), reinterpret_cast<void*>(si->entry)); |
Dmitriy Ivanov | 6abf624 | 2014-09-12 09:43:13 -0700 | [diff] [blame] | 3329 | return si->entry; |
The Android Open Source Project | 1dc9e47 | 2009-03-03 19:28:35 -0800 | [diff] [blame] | 3330 | } |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3331 | |
David 'Digit' Turner | bea23e5 | 2012-06-18 23:38:46 +0200 | [diff] [blame] | 3332 | /* Compute the load-bias of an existing executable. This shall only |
| 3333 | * be used to compute the load bias of an executable or shared library |
| 3334 | * that was loaded by the kernel itself. |
| 3335 | * |
| 3336 | * Input: |
| 3337 | * elf -> address of ELF header, assumed to be at the start of the file. |
| 3338 | * Return: |
| 3339 | * load bias, i.e. add the value of any p_vaddr in the file to get |
| 3340 | * the corresponding address in memory. |
| 3341 | */ |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3342 | static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) { |
| 3343 | ElfW(Addr) offset = elf->e_phoff; |
Dmitriy Ivanov | b3c01d0 | 2015-05-07 10:48:00 -0700 | [diff] [blame] | 3344 | const ElfW(Phdr)* phdr_table = |
| 3345 | reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3346 | const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum; |
David 'Digit' Turner | bea23e5 | 2012-06-18 23:38:46 +0200 | [diff] [blame] | 3347 | |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3348 | for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) { |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 3349 | if (phdr->p_type == PT_LOAD) { |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3350 | return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr; |
David 'Digit' Turner | bea23e5 | 2012-06-18 23:38:46 +0200 | [diff] [blame] | 3351 | } |
Kito Cheng | fa8c05d | 2013-03-12 14:58:06 +0800 | [diff] [blame] | 3352 | } |
| 3353 | return 0; |
David 'Digit' Turner | bea23e5 | 2012-06-18 23:38:46 +0200 | [diff] [blame] | 3354 | } |
| 3355 | |
Dmitriy Ivanov | efe1383 | 2014-07-28 15:05:51 -0700 | [diff] [blame] | 3356 | extern "C" void _start(); |
| 3357 | |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3358 | /* |
| 3359 | * This is the entry point for the linker, called from begin.S. This |
| 3360 | * method is responsible for fixing the linker's own relocations, and |
| 3361 | * then calling __linker_init_post_relocation(). |
| 3362 | * |
| 3363 | * Because this method is called before the linker has fixed it's own |
| 3364 | * relocations, any attempt to reference an extern variable, extern |
| 3365 | * function, or other GOT reference will generate a segfault. |
| 3366 | */ |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3367 | extern "C" ElfW(Addr) __linker_init(void* raw_args) { |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3368 | KernelArgumentBlock args(raw_args); |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3369 | |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3370 | ElfW(Addr) linker_addr = args.getauxval(AT_BASE); |
Dmitriy Ivanov | efe1383 | 2014-07-28 15:05:51 -0700 | [diff] [blame] | 3371 | ElfW(Addr) entry_point = args.getauxval(AT_ENTRY); |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3372 | ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr); |
Elliott Hughes | faf05ba | 2014-02-11 16:59:37 -0800 | [diff] [blame] | 3373 | ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff); |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3374 | |
Dmitriy Ivanov | aae859c | 2015-03-31 11:14:03 -0700 | [diff] [blame] | 3375 | soinfo linker_so(nullptr, nullptr, 0, 0); |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3376 | |
Dmitriy Ivanov | efe1383 | 2014-07-28 15:05:51 -0700 | [diff] [blame] | 3377 | // If the linker is not acting as PT_INTERP entry_point is equal to |
| 3378 | // _start. Which means that the linker is running as an executable and |
| 3379 | // already linked by PT_INTERP. |
| 3380 | // |
| 3381 | // This happens when user tries to run 'adb shell /system/bin/linker' |
| 3382 | // see also https://code.google.com/p/android/issues/detail?id=63174 |
| 3383 | if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point) { |
| 3384 | __libc_fatal("This is %s, the helper program for shared library executables.\n", args.argv[0]); |
| 3385 | } |
| 3386 | |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3387 | linker_so.base = linker_addr; |
| 3388 | linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum); |
| 3389 | linker_so.load_bias = get_elf_exec_load_bias(elf_hdr); |
Dmitriy Ivanov | 851135b | 2014-08-29 12:02:36 -0700 | [diff] [blame] | 3390 | linker_so.dynamic = nullptr; |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3391 | linker_so.phdr = phdr; |
| 3392 | linker_so.phnum = elf_hdr->e_phnum; |
Dmitriy Ivanov | ab972b9 | 2014-11-29 13:57:41 -0800 | [diff] [blame] | 3393 | linker_so.set_linker_flag(); |
Elliott Hughes | 5419b94 | 2012-10-16 15:54:46 -0700 | [diff] [blame] | 3394 | |
Dmitriy Ivanov | d225a5e | 2014-08-28 14:12:12 -0700 | [diff] [blame] | 3395 | // This might not be obvious... The reasons why we pass g_empty_list |
| 3396 | // in place of local_group here are (1) we do not really need it, because |
| 3397 | // linker is built with DT_SYMBOLIC and therefore relocates its symbols against |
| 3398 | // itself without having to look into local_group and (2) allocators |
| 3399 | // are not yet initialized, and therefore we cannot use linked_list.push_* |
| 3400 | // functions at this point. |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3401 | if (!(linker_so.prelink_image() && linker_so.link_image(g_empty_list, g_empty_list, nullptr))) { |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3402 | // It would be nice to print an error message, but if the linker |
| 3403 | // can't link itself, there's no guarantee that we'll be able to |
Elliott Hughes | b93702a | 2013-12-21 16:07:45 -0800 | [diff] [blame] | 3404 | // call write() (because it involves a GOT reference). We may as |
| 3405 | // well try though... |
| 3406 | const char* msg = "CANNOT LINK EXECUTABLE: "; |
| 3407 | write(2, msg, strlen(msg)); |
| 3408 | write(2, __linker_dl_err_buf, strlen(__linker_dl_err_buf)); |
| 3409 | write(2, "\n", 1); |
| 3410 | _exit(EXIT_FAILURE); |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3411 | } |
Elliott Hughes | d23736e | 2012-11-01 15:16:56 -0700 | [diff] [blame] | 3412 | |
Dmitriy Ivanov | 1424140 | 2014-08-26 14:16:52 -0700 | [diff] [blame] | 3413 | __libc_init_tls(args); |
| 3414 | |
Dmitriy Ivanov | efe1383 | 2014-07-28 15:05:51 -0700 | [diff] [blame] | 3415 | // Initialize the linker's own global variables |
Dmitriy Ivanov | 047b593 | 2014-11-13 09:39:20 -0800 | [diff] [blame] | 3416 | linker_so.call_constructors(); |
Dmitriy Ivanov | 4151ea7 | 2014-07-24 15:33:25 -0700 | [diff] [blame] | 3417 | |
Dmitriy Ivanov | 0d15094 | 2014-08-22 12:25:04 -0700 | [diff] [blame] | 3418 | // Initialize static variables. Note that in order to |
| 3419 | // get correct libdl_info we need to call constructors |
| 3420 | // before get_libdl_info(). |
| 3421 | solist = get_libdl_info(); |
| 3422 | sonext = get_libdl_info(); |
| 3423 | |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3424 | // We have successfully fixed our own relocations. It's safe to run |
| 3425 | // the main part of the linker now. |
Elliott Hughes | 1728b23 | 2014-05-14 10:02:03 -0700 | [diff] [blame] | 3426 | args.abort_message_ptr = &g_abort_message; |
Elliott Hughes | 0266ae5 | 2014-02-10 17:46:57 -0800 | [diff] [blame] | 3427 | ElfW(Addr) start_address = __linker_init_post_relocation(args, linker_addr); |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3428 | |
Elliott Hughes | 611f956 | 2015-01-23 10:43:58 -0800 | [diff] [blame] | 3429 | INFO("[ jumping to _start ]"); |
| 3430 | |
Elliott Hughes | 42b2c6a | 2013-02-07 10:14:39 -0800 | [diff] [blame] | 3431 | // Return the address that the calling assembly stub should jump to. |
| 3432 | return start_address; |
Nick Kralevich | 468319c | 2011-11-11 15:53:17 -0800 | [diff] [blame] | 3433 | } |