blob: 60f848956a17a57d70f978e7670e6a0a1300011b [file] [log] [blame]
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001/*
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002 * Copyright (C) 2008 The Android Open Source Project
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003 * 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 Ivanov04f7e3e2015-06-02 17:36:54 -070029#include <android/api-level.h>
Elliott Hughes46882792012-08-03 16:49:39 -070030#include <dlfcn.h>
31#include <errno.h>
32#include <fcntl.h>
Elliott Hughes0266ae52014-02-10 17:46:57 -080033#include <inttypes.h>
Elliott Hughes46882792012-08-03 16:49:39 -070034#include <pthread.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080035#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
Elliott Hughes46882792012-08-03 16:49:39 -070038#include <sys/mman.h>
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -080039#include <sys/param.h>
Elliott Hughes46882792012-08-03 16:49:39 -070040#include <unistd.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080041
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070042#include <new>
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070043#include <string>
44#include <vector>
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070045
Elliott Hughes46882792012-08-03 16:49:39 -070046// Private C library headers.
Elliott Hugheseb847bc2013-10-09 15:50:50 -070047#include "private/bionic_tls.h"
48#include "private/KernelArgumentBlock.h"
49#include "private/ScopedPthreadMutexLocker.h"
Dmitriy Ivanov14669a92014-09-05 16:42:53 -070050#include "private/ScopeGuard.h"
51#include "private/UniquePtr.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080052
53#include "linker.h"
Dmitriy Ivanovc9ce70d2015-03-10 15:30:26 -070054#include "linker_block_allocator.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080055#include "linker_debug.h"
Dmitriy Ivanov18870d32015-04-22 13:10:04 -070056#include "linker_sleb128.h"
David 'Digit' Turner23363ed2012-06-18 18:13:49 +020057#include "linker_phdr.h"
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -080058#include "linker_relocs.h"
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -080059#include "linker_reloc_iterators.h"
Simon Baldwinaef71952015-01-16 13:22:54 +000060#include "ziparchive/zip_archive.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080061
Elliott Hughes66c3b2d2015-06-08 18:04:00 -070062extern void __libc_init_AT_SECURE(KernelArgumentBlock&);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080063
Elliott Hughes66c3b2d2015-06-08 18:04:00 -070064// Override macros to use C++ style casts.
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -080065#undef ELF_ST_TYPE
66#define ELF_ST_TYPE(x) (static_cast<uint32_t>(x) & 0xf)
67
Elliott Hughes0266ae52014-02-10 17:46:57 -080068static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080069
Dmitriy Ivanov600bc3c2015-03-10 15:43:50 -070070static LinkerTypeAllocator<soinfo> g_soinfo_allocator;
71static LinkerTypeAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
Magnus Malmbornba98d922012-09-12 13:00:55 +020072
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -070073static soinfo* solist;
74static soinfo* sonext;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -070075static soinfo* somain; // main process, always the one after libdl_info
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080076
Elliott Hughes1728b232014-05-14 10:02:03 -070077static const char* const kDefaultLdPaths[] = {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -070078#if defined(__LP64__)
Elliott Hughes011bc0b2013-10-08 14:27:10 -070079 "/vendor/lib64",
80 "/system/lib64",
81#else
Elliott Hughes124fae92012-10-31 14:20:03 -070082 "/vendor/lib",
83 "/system/lib",
Elliott Hughes011bc0b2013-10-08 14:27:10 -070084#endif
Dmitriy Ivanov851135b2014-08-29 12:02:36 -070085 nullptr
Elliott Hughes124fae92012-10-31 14:20:03 -070086};
David Bartleybc3a5c22009-06-02 18:27:28 -070087
Dmitriy Ivanov2a815362015-04-09 13:42:33 -070088static const ElfW(Versym) kVersymNotNeeded = 0;
89static const ElfW(Versym) kVersymGlobal = 1;
90
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070091static std::vector<std::string> g_ld_library_paths;
92static std::vector<std::string> g_ld_preload_names;
Elliott Hughesa4aafd12014-01-13 16:37:47 -080093
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070094static std::vector<soinfo*> g_ld_preloads;
Matt Fischer4fd42c12009-12-31 12:09:10 -060095
Elliott Hughes1728b232014-05-14 10:02:03 -070096__LIBC_HIDDEN__ int g_ld_debug_verbosity;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080097
Dmitriy Ivanov851135b2014-08-29 12:02:36 -070098__LIBC_HIDDEN__ abort_msg_t* g_abort_message = nullptr; // For debuggerd.
Elliott Hughes0d787c12013-04-04 13:46:46 -070099
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800100#if STATS
Elliott Hughesbedfe382012-08-14 14:07:59 -0700101struct linker_stats_t {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700102 int count[kRelocMax];
Elliott Hughesbedfe382012-08-14 14:07:59 -0700103};
104
105static linker_stats_t linker_stats;
106
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800107void count_relocation(RelocationKind kind) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700108 ++linker_stats.count[kind];
Elliott Hughesbedfe382012-08-14 14:07:59 -0700109}
110#else
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800111void count_relocation(RelocationKind) {
Elliott Hughesbedfe382012-08-14 14:07:59 -0700112}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800113#endif
114
115#if COUNT_PAGES
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800116uint32_t bitmask[4096];
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800117#endif
118
Dima Zavin2e855792009-05-20 18:28:09 -0700119static char __linker_dl_err_buf[768];
Dima Zavin2e855792009-05-20 18:28:09 -0700120
Elliott Hughes650be4e2013-03-05 18:47:58 -0800121char* linker_get_error_buffer() {
Elliott Hughes5419b942012-10-16 15:54:46 -0700122 return &__linker_dl_err_buf[0];
Dima Zavin2e855792009-05-20 18:28:09 -0700123}
124
Elliott Hughes650be4e2013-03-05 18:47:58 -0800125size_t linker_get_error_buffer_size() {
126 return sizeof(__linker_dl_err_buf);
127}
128
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700129// This function is an empty stub where GDB locates a breakpoint to get notified
130// about linker activity.
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700131extern "C"
132void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800133
Elliott Hughes1728b232014-05-14 10:02:03 -0700134static pthread_mutex_t g__r_debug_mutex = PTHREAD_MUTEX_INITIALIZER;
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700135static r_debug _r_debug =
136 {1, nullptr, reinterpret_cast<uintptr_t>(&rtld_db_dlactivity), r_debug::RT_CONSISTENT, 0};
137
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800138static link_map* r_debug_tail = 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800139
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800140static void insert_soinfo_into_debug_map(soinfo* info) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700141 // Copy the necessary fields into the debug structure.
142 link_map* map = &(info->link_map_head);
143 map->l_addr = info->load_bias;
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700144 // link_map l_name field is not const.
145 map->l_name = const_cast<char*>(info->get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700146 map->l_ld = info->dynamic;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800147
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700148 // Stick the new library at the end of the list.
149 // gdb tends to care more about libc than it does
150 // about leaf libraries, and ordering it this way
151 // reduces the back-and-forth over the wire.
152 if (r_debug_tail) {
153 r_debug_tail->l_next = map;
154 map->l_prev = r_debug_tail;
155 map->l_next = 0;
156 } else {
157 _r_debug.r_map = map;
158 map->l_prev = 0;
159 map->l_next = 0;
160 }
161 r_debug_tail = map;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800162}
163
Elliott Hughesbedfe382012-08-14 14:07:59 -0700164static void remove_soinfo_from_debug_map(soinfo* info) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700165 link_map* map = &(info->link_map_head);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700166
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700167 if (r_debug_tail == map) {
168 r_debug_tail = map->l_prev;
169 }
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700170
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700171 if (map->l_prev) {
172 map->l_prev->l_next = map->l_next;
173 }
174 if (map->l_next) {
175 map->l_next->l_prev = map->l_prev;
176 }
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700177}
178
Elliott Hughesbedfe382012-08-14 14:07:59 -0700179static void notify_gdb_of_load(soinfo* info) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -0800180 if (info->is_main_executable()) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700181 // GDB already knows about the main executable
182 return;
183 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800184
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700185 ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800186
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700187 _r_debug.r_state = r_debug::RT_ADD;
188 rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800189
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700190 insert_soinfo_into_debug_map(info);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800191
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700192 _r_debug.r_state = r_debug::RT_CONSISTENT;
193 rtld_db_dlactivity();
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700194}
195
Elliott Hughesbedfe382012-08-14 14:07:59 -0700196static void notify_gdb_of_unload(soinfo* info) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -0800197 if (info->is_main_executable()) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700198 // GDB already knows about the main executable
199 return;
200 }
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700201
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700202 ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700203
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700204 _r_debug.r_state = r_debug::RT_DELETE;
205 rtld_db_dlactivity();
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700206
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700207 remove_soinfo_from_debug_map(info);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700208
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700209 _r_debug.r_state = r_debug::RT_CONSISTENT;
210 rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800211}
212
Elliott Hughes18a206c2012-10-29 17:37:13 -0700213void notify_gdb_of_libraries() {
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800214 _r_debug.r_state = r_debug::RT_ADD;
215 rtld_db_dlactivity();
216 _r_debug.r_state = r_debug::RT_CONSISTENT;
217 rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800218}
219
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700220LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {
221 return g_soinfo_links_allocator.alloc();
222}
223
224void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {
225 g_soinfo_links_allocator.free(entry);
226}
227
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700228static soinfo* soinfo_alloc(const char* name, struct stat* file_stat,
229 off64_t file_offset, uint32_t rtld_flags) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700230 if (strlen(name) >= PATH_MAX) {
Magnus Malmbornba98d922012-09-12 13:00:55 +0200231 DL_ERR("library name \"%s\" too long", name);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700232 return nullptr;
Magnus Malmbornba98d922012-09-12 13:00:55 +0200233 }
234
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -0700235 soinfo* si = new (g_soinfo_allocator.alloc()) soinfo(name, file_stat, file_offset, rtld_flags);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700236
Magnus Malmbornba98d922012-09-12 13:00:55 +0200237 sonext->next = si;
238 sonext = si;
239
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700240 TRACE("name %s: allocated soinfo @ %p", name, si);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200241 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800242}
243
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800244static void soinfo_free(soinfo* si) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700245 if (si == nullptr) {
246 return;
247 }
248
249 if (si->base != 0 && si->size != 0) {
250 munmap(reinterpret_cast<void*>(si->base), si->size);
251 }
252
253 soinfo *prev = nullptr, *trav;
254
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700255 TRACE("name %s: freeing soinfo @ %p", si->get_realpath(), si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700256
257 for (trav = solist; trav != nullptr; trav = trav->next) {
258 if (trav == si) {
259 break;
Elliott Hughes46882792012-08-03 16:49:39 -0700260 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700261 prev = trav;
262 }
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800263
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700264 if (trav == nullptr) {
265 // si was not in solist
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700266 DL_ERR("name \"%s\"@%p is not in solist!", si->get_realpath(), si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700267 return;
268 }
Elliott Hughes46882792012-08-03 16:49:39 -0700269
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700270 // clear links to/from si
271 si->remove_all_links();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700272
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700273 // prev will never be null, because the first entry in solist is
274 // always the static libdl_info.
275 prev->next = si->next;
276 if (si == sonext) {
277 sonext = prev;
278 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800279
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700280 g_soinfo_allocator.free(si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800281}
282
Elliott Hughescade4c32012-12-20 14:42:14 -0800283static void parse_path(const char* path, const char* delimiters,
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700284 std::vector<std::string>* paths) {
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700285 if (path == nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800286 return;
287 }
288
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700289 paths->clear();
Elliott Hughescade4c32012-12-20 14:42:14 -0800290
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700291 for (const char *p = path; ; ++p) {
292 size_t len = strcspn(p, delimiters);
293 // skip empty tokens
294 if (len == 0) {
295 continue;
Elliott Hughescade4c32012-12-20 14:42:14 -0800296 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800297
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700298 paths->push_back(std::string(p, len));
299 p += len;
300
301 if (*p == '\0') {
302 break;
303 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800304 }
305}
306
307static void parse_LD_LIBRARY_PATH(const char* path) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700308 parse_path(path, ":", &g_ld_library_paths);
Elliott Hughescade4c32012-12-20 14:42:14 -0800309}
310
311static void parse_LD_PRELOAD(const char* path) {
312 // We have historically supported ':' as well as ' ' in LD_PRELOAD.
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700313 parse_path(path, " :", &g_ld_preload_names);
Elliott Hughescade4c32012-12-20 14:42:14 -0800314}
315
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700316static bool realpath_fd(int fd, std::string* realpath) {
317 std::vector<char> buf(PATH_MAX), proc_self_fd(PATH_MAX);
318 snprintf(&proc_self_fd[0], proc_self_fd.size(), "/proc/self/fd/%d", fd);
319 if (readlink(&proc_self_fd[0], &buf[0], buf.size()) == -1) {
Dmitriy Ivanovca10ac62015-05-28 11:44:31 -0700320 PRINT("readlink('%s') failed: %s [fd=%d]", &proc_self_fd[0], strerror(errno), fd);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700321 return false;
322 }
323
324 *realpath = std::string(&buf[0]);
325 return true;
326}
327
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700328#if defined(__arm__)
Elliott Hughes46882792012-08-03 16:49:39 -0700329
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700330// For a given PC, find the .so that it belongs to.
331// Returns the base address of the .ARM.exidx section
332// for that .so, and the number of 8-byte entries
333// in that section (via *pcount).
334//
335// Intended to be called by libc's __gnu_Unwind_Find_exidx().
336//
337// This function is exposed via dlfcn.cpp and libdl.so.
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800338_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -0800339 uintptr_t addr = reinterpret_cast<uintptr_t>(pc);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800340
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700341 for (soinfo* si = solist; si != 0; si = si->next) {
342 if ((addr >= si->base) && (addr < (si->base + si->size))) {
343 *pcount = si->ARM_exidx_count;
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -0800344 return reinterpret_cast<_Unwind_Ptr>(si->ARM_exidx);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800345 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700346 }
347 *pcount = 0;
348 return nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800349}
Elliott Hughes46882792012-08-03 16:49:39 -0700350
Christopher Ferris24053a42013-08-19 17:45:09 -0700351#endif
Elliott Hughes46882792012-08-03 16:49:39 -0700352
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700353// Here, we only have to provide a callback to iterate across all the
354// loaded libraries. gcc_eh does the rest.
Dmitriy Ivanovf7d5bf32015-06-29 14:48:25 -0700355int do_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700356 int rv = 0;
357 for (soinfo* si = solist; si != nullptr; si = si->next) {
358 dl_phdr_info dl_info;
359 dl_info.dlpi_addr = si->link_map_head.l_addr;
360 dl_info.dlpi_name = si->link_map_head.l_name;
361 dl_info.dlpi_phdr = si->phdr;
362 dl_info.dlpi_phnum = si->phnum;
363 rv = cb(&dl_info, sizeof(dl_phdr_info), data);
364 if (rv != 0) {
365 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800366 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700367 }
368 return rv;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800369}
Elliott Hughes46882792012-08-03 16:49:39 -0700370
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700371const ElfW(Versym)* soinfo::get_versym(size_t n) const {
372 if (has_min_version(2) && versym_ != nullptr) {
373 return versym_ + n;
374 }
375
376 return nullptr;
377}
378
379ElfW(Addr) soinfo::get_verneed_ptr() const {
380 if (has_min_version(2)) {
381 return verneed_ptr_;
382 }
383
384 return 0;
385}
386
387size_t soinfo::get_verneed_cnt() const {
388 if (has_min_version(2)) {
389 return verneed_cnt_;
390 }
391
392 return 0;
393}
394
395ElfW(Addr) soinfo::get_verdef_ptr() const {
396 if (has_min_version(2)) {
397 return verdef_ptr_;
398 }
399
400 return 0;
401}
402
403size_t soinfo::get_verdef_cnt() const {
404 if (has_min_version(2)) {
405 return verdef_cnt_;
406 }
407
408 return 0;
409}
410
411template<typename F>
412static bool for_each_verdef(const soinfo* si, F functor) {
413 if (!si->has_min_version(2)) {
414 return true;
415 }
416
417 uintptr_t verdef_ptr = si->get_verdef_ptr();
418 if (verdef_ptr == 0) {
419 return true;
420 }
421
422 size_t offset = 0;
423
424 size_t verdef_cnt = si->get_verdef_cnt();
425 for (size_t i = 0; i<verdef_cnt; ++i) {
426 const ElfW(Verdef)* verdef = reinterpret_cast<ElfW(Verdef)*>(verdef_ptr + offset);
427 size_t verdaux_offset = offset + verdef->vd_aux;
428 offset += verdef->vd_next;
429
430 if (verdef->vd_version != 1) {
Dmitriy Ivanov3d7bea12015-04-20 17:40:39 -0700431 DL_ERR("unsupported verdef[%zd] vd_version: %d (expected 1) library: %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700432 i, verdef->vd_version, si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700433 return false;
434 }
435
436 if ((verdef->vd_flags & VER_FLG_BASE) != 0) {
437 // "this is the version of the file itself. It must not be used for
438 // matching a symbol. It can be used to match references."
439 //
440 // http://www.akkadia.org/drepper/symbol-versioning
441 continue;
442 }
443
444 if (verdef->vd_cnt == 0) {
445 DL_ERR("invalid verdef[%zd] vd_cnt == 0 (version without a name)", i);
446 return false;
447 }
448
449 const ElfW(Verdaux)* verdaux = reinterpret_cast<ElfW(Verdaux)*>(verdef_ptr + verdaux_offset);
450
451 if (functor(i, verdef, verdaux) == true) {
452 break;
453 }
454 }
455
456 return true;
457}
458
459bool soinfo::find_verdef_version_index(const version_info* vi, ElfW(Versym)* versym) const {
460 if (vi == nullptr) {
461 *versym = kVersymNotNeeded;
462 return true;
463 }
464
465 *versym = kVersymGlobal;
466
467 return for_each_verdef(this,
468 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
469 if (verdef->vd_hash == vi->elf_hash &&
470 strcmp(vi->name, get_string(verdaux->vda_name)) == 0) {
471 *versym = verdef->vd_ndx;
472 return true;
473 }
474
475 return false;
476 }
477 );
478}
479
480bool soinfo::find_symbol_by_name(SymbolName& symbol_name,
481 const version_info* vi,
482 const ElfW(Sym)** symbol) const {
483 uint32_t symbol_index;
484 bool success =
485 is_gnu_hash() ?
486 gnu_lookup(symbol_name, vi, &symbol_index) :
487 elf_lookup(symbol_name, vi, &symbol_index);
488
489 if (success) {
490 *symbol = symbol_index == 0 ? nullptr : symtab_ + symbol_index;
491 }
492
493 return success;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800494}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800495
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800496static bool is_symbol_global_and_defined(const soinfo* si, const ElfW(Sym)* s) {
497 if (ELF_ST_BIND(s->st_info) == STB_GLOBAL ||
498 ELF_ST_BIND(s->st_info) == STB_WEAK) {
499 return s->st_shndx != SHN_UNDEF;
500 } else if (ELF_ST_BIND(s->st_info) != STB_LOCAL) {
501 DL_WARN("unexpected ST_BIND value: %d for '%s' in '%s'",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700502 ELF_ST_BIND(s->st_info), si->get_string(s->st_name), si->get_realpath());
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800503 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800504
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800505 return false;
506}
507
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700508static const ElfW(Versym) kVersymHiddenBit = 0x8000;
509
510static inline bool is_versym_hidden(const ElfW(Versym)* versym) {
511 // the symbol is hidden if bit 15 of versym is set.
512 return versym != nullptr && (*versym & kVersymHiddenBit) != 0;
513}
514
515static inline bool check_symbol_version(const ElfW(Versym) verneed,
516 const ElfW(Versym)* verdef) {
517 return verneed == kVersymNotNeeded ||
518 verdef == nullptr ||
519 verneed == (*verdef & ~kVersymHiddenBit);
520}
521
522bool soinfo::gnu_lookup(SymbolName& symbol_name,
523 const version_info* vi,
524 uint32_t* symbol_index) const {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800525 uint32_t hash = symbol_name.gnu_hash();
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800526 uint32_t h2 = hash >> gnu_shift2_;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800527
528 uint32_t bloom_mask_bits = sizeof(ElfW(Addr))*8;
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800529 uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_;
530 ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800531
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700532 *symbol_index = 0;
533
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700534 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700535 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700536
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800537 // test against bloom filter
538 if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700539 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700540 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700541
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700542 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800543 }
544
545 // bloom test says "probably yes"...
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700546 uint32_t n = gnu_bucket_[hash % gnu_nbucket_];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800547
548 if (n == 0) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700549 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700550 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700551
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700552 return true;
553 }
554
555 // lookup versym for the version definition in this library
556 // note the difference between "version is not requested" (vi == nullptr)
557 // and "version not found". In the first case verneed is kVersymNotNeeded
558 // which implies that the default version can be accepted; the second case results in
559 // verneed = 1 (kVersymGlobal) and implies that we should ignore versioned symbols
560 // for this library and consider only *global* ones.
561 ElfW(Versym) verneed = 0;
562 if (!find_verdef_version_index(vi, &verneed)) {
563 return false;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800564 }
565
566 do {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800567 ElfW(Sym)* s = symtab_ + n;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700568 const ElfW(Versym)* verdef = get_versym(n);
569 // skip hidden versions when verneed == kVersymNotNeeded (0)
570 if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) {
571 continue;
572 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700573 if (((gnu_chain_[n] ^ hash) >> 1) == 0 &&
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700574 check_symbol_version(verneed, verdef) &&
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800575 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
576 is_symbol_global_and_defined(this, s)) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700577 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700578 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value),
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700579 static_cast<size_t>(s->st_size));
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700580 *symbol_index = n;
581 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800582 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700583 } while ((gnu_chain_[n++] & 1) == 0);
584
585 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700586 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800587
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700588 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800589}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800590
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700591bool soinfo::elf_lookup(SymbolName& symbol_name,
592 const version_info* vi,
593 uint32_t* symbol_index) const {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800594 uint32_t hash = symbol_name.elf_hash();
595
596 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700597 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700598 reinterpret_cast<void*>(base), hash, hash % nbucket_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800599
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700600 ElfW(Versym) verneed = 0;
601 if (!find_verdef_version_index(vi, &verneed)) {
602 return false;
603 }
604
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800605 for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) {
606 ElfW(Sym)* s = symtab_ + n;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700607 const ElfW(Versym)* verdef = get_versym(n);
608
609 // skip hidden versions when verneed == 0
610 if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) {
611 continue;
612 }
613
614 if (check_symbol_version(verneed, verdef) &&
615 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700616 is_symbol_global_and_defined(this, s)) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800617 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700618 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700619 reinterpret_cast<void*>(s->st_value),
620 static_cast<size_t>(s->st_size));
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700621 *symbol_index = n;
622 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800623 }
Elliott Hughes0266ae52014-02-10 17:46:57 -0800624 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800625
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700626 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700627 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700628 reinterpret_cast<void*>(base), hash, hash % nbucket_);
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700629
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700630 *symbol_index = 0;
631 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800632}
633
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700634soinfo::soinfo(const char* realpath, const struct stat* file_stat,
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700635 off64_t file_offset, int rtld_flags) {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700636 memset(this, 0, sizeof(*this));
637
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700638 if (realpath != nullptr) {
639 realpath_ = realpath;
640 }
641
Dmitriy Ivanovab972b92014-11-29 13:57:41 -0800642 flags_ = FLAG_NEW_SOINFO;
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800643 version_ = SOINFO_VERSION;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700644
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700645 if (file_stat != nullptr) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800646 this->st_dev_ = file_stat->st_dev;
647 this->st_ino_ = file_stat->st_ino;
648 this->file_offset_ = file_offset;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700649 }
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -0700650
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800651 this->rtld_flags_ = rtld_flags;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700652}
653
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800654
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800655uint32_t SymbolName::elf_hash() {
656 if (!has_elf_hash_) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700657 const uint8_t* name = reinterpret_cast<const uint8_t*>(name_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800658 uint32_t h = 0, g;
659
660 while (*name) {
661 h = (h << 4) + *name++;
662 g = h & 0xf0000000;
663 h ^= g;
664 h ^= g >> 24;
665 }
666
667 elf_hash_ = h;
668 has_elf_hash_ = true;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700669 }
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800670
671 return elf_hash_;
672}
673
674uint32_t SymbolName::gnu_hash() {
675 if (!has_gnu_hash_) {
676 uint32_t h = 5381;
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700677 const uint8_t* name = reinterpret_cast<const uint8_t*>(name_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800678 while (*name != 0) {
679 h += (h << 5) + *name++; // h*33 + c = h + h * 32 + c = h + h << 5 + c
680 }
681
682 gnu_hash_ = h;
683 has_gnu_hash_ = true;
684 }
685
686 return gnu_hash_;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800687}
688
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700689bool soinfo_do_lookup(soinfo* si_from, const char* name, const version_info* vi,
690 soinfo** si_found_in, const soinfo::soinfo_list_t& global_group,
691 const soinfo::soinfo_list_t& local_group, const ElfW(Sym)** symbol) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800692 SymbolName symbol_name(name);
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700693 const ElfW(Sym)* s = nullptr;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700694
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700695 /* "This element's presence in a shared object library alters the dynamic linker's
696 * symbol resolution algorithm for references within the library. Instead of starting
697 * a symbol search with the executable file, the dynamic linker starts from the shared
698 * object itself. If the shared object fails to supply the referenced symbol, the
699 * dynamic linker then searches the executable file and other shared objects as usual."
700 *
701 * http://www.sco.com/developers/gabi/2012-12-31/ch5.dynamic.html
702 *
703 * Note that this is unlikely since static linker avoids generating
704 * relocations for -Bsymbolic linked dynamic executables.
705 */
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700706 if (si_from->has_DT_SYMBOLIC) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700707 DEBUG("%s: looking up %s in local scope (DT_SYMBOLIC)", si_from->get_realpath(), name);
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700708 if (!si_from->find_symbol_by_name(symbol_name, vi, &s)) {
709 return false;
710 }
711
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -0700712 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700713 *si_found_in = si_from;
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700714 }
715 }
716
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700717 // 1. Look for it in global_group
718 if (s == nullptr) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700719 bool error = false;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700720 global_group.visit([&](soinfo* global_si) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700721 DEBUG("%s: looking up %s in %s (from global group)",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700722 si_from->get_realpath(), name, global_si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700723 if (!global_si->find_symbol_by_name(symbol_name, vi, &s)) {
724 error = true;
725 return false;
726 }
727
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700728 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700729 *si_found_in = global_si;
730 return false;
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700731 }
Dmitriy Ivanovc2048942014-08-29 10:15:25 -0700732
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700733 return true;
734 });
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700735
736 if (error) {
737 return false;
738 }
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700739 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700740
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700741 // 2. Look for it in the local group
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700742 if (s == nullptr) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700743 bool error = false;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700744 local_group.visit([&](soinfo* local_si) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700745 if (local_si == si_from && si_from->has_DT_SYMBOLIC) {
Dmitriy Ivanove47b3f82014-10-23 14:19:07 -0700746 // we already did this - skip
747 return true;
748 }
749
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700750 DEBUG("%s: looking up %s in %s (from local group)",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700751 si_from->get_realpath(), name, local_si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700752 if (!local_si->find_symbol_by_name(symbol_name, vi, &s)) {
753 error = true;
754 return false;
755 }
756
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700757 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700758 *si_found_in = local_si;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700759 return false;
760 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700761
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700762 return true;
763 });
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700764
765 if (error) {
766 return false;
767 }
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700768 }
769
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700770 if (s != nullptr) {
771 TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, "
772 "found in %s, base = %p, load bias = %p",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -0700773 si_from->get_realpath(), name, reinterpret_cast<void*>(s->st_value),
774 (*si_found_in)->get_realpath(), reinterpret_cast<void*>((*si_found_in)->base),
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700775 reinterpret_cast<void*>((*si_found_in)->load_bias));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700776 }
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700777
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700778 *symbol = s;
779 return true;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700780}
781
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800782class ProtectedDataGuard {
783 public:
784 ProtectedDataGuard() {
785 if (ref_count_++ == 0) {
786 protect_data(PROT_READ | PROT_WRITE);
787 }
788 }
789
790 ~ProtectedDataGuard() {
791 if (ref_count_ == 0) { // overflow
792 __libc_fatal("Too many nested calls to dlopen()");
793 }
794
795 if (--ref_count_ == 0) {
796 protect_data(PROT_READ);
797 }
798 }
799 private:
800 void protect_data(int protection) {
801 g_soinfo_allocator.protect_all(protection);
802 g_soinfo_links_allocator.protect_all(protection);
803 }
804
805 static size_t ref_count_;
806};
807
808size_t ProtectedDataGuard::ref_count_ = 0;
809
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700810// Each size has it's own allocator.
811template<size_t size>
812class SizeBasedAllocator {
813 public:
814 static void* alloc() {
815 return allocator_.alloc();
816 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -0700817
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700818 static void free(void* ptr) {
819 allocator_.free(ptr);
820 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -0700821
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700822 private:
823 static LinkerBlockAllocator allocator_;
824};
825
826template<size_t size>
827LinkerBlockAllocator SizeBasedAllocator<size>::allocator_(size);
828
829template<typename T>
830class TypeBasedAllocator {
831 public:
832 static T* alloc() {
833 return reinterpret_cast<T*>(SizeBasedAllocator<sizeof(T)>::alloc());
834 }
835
836 static void free(T* ptr) {
837 SizeBasedAllocator<sizeof(T)>::free(ptr);
838 }
839};
840
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700841class LoadTask {
842 public:
843 struct deleter_t {
844 void operator()(LoadTask* t) {
845 TypeBasedAllocator<LoadTask>::free(t);
846 }
847 };
848
849 typedef UniquePtr<LoadTask, deleter_t> unique_ptr;
850
851 static deleter_t deleter;
852
853 static LoadTask* create(const char* name, soinfo* needed_by) {
854 LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc();
855 return new (ptr) LoadTask(name, needed_by);
856 }
857
858 const char* get_name() const {
859 return name_;
860 }
861
862 soinfo* get_needed_by() const {
863 return needed_by_;
864 }
865 private:
866 LoadTask(const char* name, soinfo* needed_by)
867 : name_(name), needed_by_(needed_by) {}
868
869 const char* name_;
870 soinfo* needed_by_;
871
872 DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask);
873};
874
Ningsheng Jiane93be992014-09-16 15:22:10 +0800875LoadTask::deleter_t LoadTask::deleter;
876
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700877template <typename T>
878using linked_list_t = LinkedList<T, TypeBasedAllocator<LinkedListEntry<T>>>;
879
880typedef linked_list_t<soinfo> SoinfoLinkedList;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700881typedef linked_list_t<const char> StringLinkedList;
882typedef linked_list_t<LoadTask> LoadTaskList;
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700883
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700884
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700885// This function walks down the tree of soinfo dependencies
886// in breadth-first order and
887// * calls action(soinfo* si) for each node, and
888// * terminates walk if action returns false.
889//
890// walk_dependencies_tree returns false if walk was terminated
891// by the action and true otherwise.
892template<typename F>
893static bool walk_dependencies_tree(soinfo* root_soinfos[], size_t root_soinfos_size, F action) {
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700894 SoinfoLinkedList visit_list;
895 SoinfoLinkedList visited;
896
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700897 for (size_t i = 0; i < root_soinfos_size; ++i) {
898 visit_list.push_back(root_soinfos[i]);
899 }
900
901 soinfo* si;
902 while ((si = visit_list.pop_front()) != nullptr) {
903 if (visited.contains(si)) {
Dmitriy Ivanov042426b2014-08-12 21:02:13 -0700904 continue;
905 }
906
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700907 if (!action(si)) {
908 return false;
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700909 }
910
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700911 visited.push_back(si);
912
913 si->get_children().for_each([&](soinfo* child) {
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700914 visit_list.push_back(child);
915 });
916 }
917
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700918 return true;
919}
920
921
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -0700922static const ElfW(Sym)* dlsym_handle_lookup(soinfo* root, soinfo* skip_until,
923 soinfo** found, SymbolName& symbol_name) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700924 const ElfW(Sym)* result = nullptr;
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -0700925 bool skip_lookup = skip_until != nullptr;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700926
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -0700927 walk_dependencies_tree(&root, 1, [&](soinfo* current_soinfo) {
928 if (skip_lookup) {
929 skip_lookup = current_soinfo != skip_until;
930 return true;
931 }
932
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700933 if (!current_soinfo->find_symbol_by_name(symbol_name, nullptr, &result)) {
934 result = nullptr;
935 return false;
936 }
937
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700938 if (result != nullptr) {
939 *found = current_soinfo;
940 return false;
941 }
942
943 return true;
944 });
945
946 return result;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800947}
948
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -0700949// This is used by dlsym(3). It performs symbol lookup only within the
950// specified soinfo object and its dependencies in breadth first order.
951const ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) {
Dmitriy Ivanovc4ebe602015-05-30 13:04:39 -0700952 // According to man dlopen(3) and posix docs in the case when si is handle
953 // of the main executable we need to search not only in the executable and its
954 // dependencies but also in all libraries loaded with RTLD_GLOBAL.
955 //
956 // Since RTLD_GLOBAL is always set for the main executable and all dt_needed shared
957 // libraries and they are loaded in breath-first (correct) order we can just execute
958 // dlsym(RTLD_DEFAULT, ...); instead of doing two stage lookup.
959 if (si == somain) {
960 return dlsym_linear_lookup(name, found, nullptr, RTLD_DEFAULT);
961 }
962
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -0700963 SymbolName symbol_name(name);
964 return dlsym_handle_lookup(si, nullptr, found, symbol_name);
965}
966
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800967/* This is used by dlsym(3) to performs a global symbol lookup. If the
968 start value is null (for RTLD_DEFAULT), the search starts at the
969 beginning of the global solist. Otherwise the search starts at the
970 specified soinfo (for RTLD_NEXT).
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700971 */
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700972const ElfW(Sym)* dlsym_linear_lookup(const char* name,
973 soinfo** found,
974 soinfo* caller,
975 void* handle) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800976 SymbolName symbol_name(name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800977
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700978 soinfo* start = solist;
979
980 if (handle == RTLD_NEXT) {
Dmitriy Ivanov15309fd2015-05-22 12:34:42 -0700981 if (caller == nullptr) {
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700982 return nullptr;
983 } else {
984 start = caller->next;
985 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800986 }
987
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700988 const ElfW(Sym)* s = nullptr;
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700989 for (soinfo* si = start; si != nullptr; si = si->next) {
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -0700990 // Do not skip RTLD_LOCAL libraries in dlsym(RTLD_DEFAULT, ...)
991 // if the library is opened by application with target api level <= 22
992 // See http://b/21565766
993 if ((si->get_rtld_flags() & RTLD_GLOBAL) == 0 && si->get_target_sdk_version() > 22) {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -0700994 continue;
995 }
996
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700997 if (!si->find_symbol_by_name(symbol_name, nullptr, &s)) {
998 return nullptr;
999 }
1000
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001001 if (s != nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -08001002 *found = si;
1003 break;
Matt Fischer1698d9e2009-12-31 12:17:56 -06001004 }
Elliott Hughescade4c32012-12-20 14:42:14 -08001005 }
Matt Fischer1698d9e2009-12-31 12:17:56 -06001006
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -07001007 // If not found - use dlsym_handle_lookup for caller's
1008 // local_group unless it is part of the global group in which
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001009 // case we already did it.
1010 if (s == nullptr && caller != nullptr &&
1011 (caller->get_rtld_flags() & RTLD_GLOBAL) == 0) {
Dmitriy Ivanov4bac6ea2015-05-12 11:12:27 -07001012 return dlsym_handle_lookup(caller->get_local_group_root(),
1013 (handle == RTLD_NEXT) ? caller : nullptr, found, symbol_name);
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001014 }
1015
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001016 if (s != nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001017 TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p",
1018 name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));
Elliott Hughescade4c32012-12-20 14:42:14 -08001019 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001020
Elliott Hughescade4c32012-12-20 14:42:14 -08001021 return s;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001022}
1023
Kito Chengfa8c05d2013-03-12 14:58:06 +08001024soinfo* find_containing_library(const void* p) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001025 ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001026 for (soinfo* si = solist; si != nullptr; si = si->next) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08001027 if (address >= si->base && address - si->base < si->size) {
1028 return si;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001029 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08001030 }
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001031 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001032}
1033
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001034ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) {
1035 return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr);
1036}
1037
1038static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) {
1039 return sym->st_shndx != SHN_UNDEF &&
1040 soaddr >= sym->st_value &&
1041 soaddr < sym->st_value + sym->st_size;
1042}
1043
1044ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
Chris Dearman8e553812013-11-13 17:22:33 -08001045 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001046
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07001047 for (size_t i = 0; i < gnu_nbucket_; ++i) {
1048 uint32_t n = gnu_bucket_[i];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001049
1050 if (n == 0) {
1051 continue;
1052 }
1053
1054 do {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001055 ElfW(Sym)* sym = symtab_ + n;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001056 if (symbol_matches_soaddr(sym, soaddr)) {
1057 return sym;
1058 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07001059 } while ((gnu_chain_[n++] & 1) == 0);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001060 }
1061
1062 return nullptr;
1063}
1064
1065ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) {
Chris Dearman8e553812013-11-13 17:22:33 -08001066 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001067
Kito Chengfa8c05d2013-03-12 14:58:06 +08001068 // Search the library's symbol table for any defined symbol which
1069 // contains this address.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001070 for (size_t i = 0; i < nchain_; ++i) {
1071 ElfW(Sym)* sym = symtab_ + i;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001072 if (symbol_matches_soaddr(sym, soaddr)) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08001073 return sym;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001074 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08001075 }
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001076
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001077 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001078}
1079
Simon Baldwinaef71952015-01-16 13:22:54 +00001080static int open_library_in_zipfile(const char* const path,
1081 off64_t* file_offset) {
1082 TRACE("Trying zip file open from path '%s'", path);
1083
Dmitriy Ivanov524f1f12015-06-09 13:46:51 -07001084 // Treat an '!/' separator inside a path as the separator between the name
Simon Baldwinaef71952015-01-16 13:22:54 +00001085 // of the zip file on disk and the subdirectory to search within it.
Dmitriy Ivanov524f1f12015-06-09 13:46:51 -07001086 // For example, if path is "foo.zip!/bar/bas/x.so", then we search for
Simon Baldwinaef71952015-01-16 13:22:54 +00001087 // "bar/bas/x.so" within "foo.zip".
Dmitriy Ivanov524f1f12015-06-09 13:46:51 -07001088 const char* separator = strstr(path, "!/");
Simon Baldwinaef71952015-01-16 13:22:54 +00001089 if (separator == nullptr) {
1090 return -1;
Elliott Hughes124fae92012-10-31 14:20:03 -07001091 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001092
1093 char buf[512];
1094 if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf)) {
1095 PRINT("Warning: ignoring very long library path: %s", path);
1096 return -1;
1097 }
1098
1099 buf[separator - path] = '\0';
1100
1101 const char* zip_path = buf;
Dmitriy Ivanov524f1f12015-06-09 13:46:51 -07001102 const char* file_path = &buf[separator - path + 2];
Simon Baldwinaef71952015-01-16 13:22:54 +00001103 int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC));
1104 if (fd == -1) {
1105 return -1;
1106 }
1107
1108 ZipArchiveHandle handle;
1109 if (OpenArchiveFd(fd, "", &handle, false) != 0) {
1110 // invalid zip-file (?)
1111 close(fd);
1112 return -1;
1113 }
1114
1115 auto archive_guard = make_scope_guard([&]() {
1116 CloseArchive(handle);
1117 });
1118
1119 ZipEntry entry;
1120
1121 if (FindEntry(handle, ZipEntryName(file_path), &entry) != 0) {
1122 // Entry was not found.
1123 close(fd);
1124 return -1;
1125 }
1126
1127 // Check if it is properly stored
1128 if (entry.method != kCompressStored || (entry.offset % PAGE_SIZE) != 0) {
1129 close(fd);
1130 return -1;
1131 }
1132
1133 *file_offset = entry.offset;
1134 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001135}
1136
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001137static bool format_path(char* buf, size_t buf_size, const char* path, const char* name) {
1138 int n = __libc_format_buffer(buf, buf_size, "%s/%s", path, name);
1139 if (n < 0 || n >= static_cast<int>(buf_size)) {
1140 PRINT("Warning: ignoring very long library path: %s/%s", path, name);
1141 return false;
1142 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001143
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001144 return true;
1145}
1146
1147static int open_library_on_default_path(const char* name, off64_t* file_offset) {
1148 for (size_t i = 0; kDefaultLdPaths[i] != nullptr; ++i) {
1149 char buf[512];
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001150 if (!format_path(buf, sizeof(buf), kDefaultLdPaths[i], name)) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001151 continue;
Simon Baldwinaef71952015-01-16 13:22:54 +00001152 }
1153
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001154 int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
1155 if (fd != -1) {
1156 *file_offset = 0;
1157 return fd;
1158 }
1159 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001160
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001161 return -1;
1162}
1163
1164static int open_library_on_ld_library_path(const char* name, off64_t* file_offset) {
1165 for (const auto& path_str : g_ld_library_paths) {
1166 char buf[512];
1167 const char* const path = path_str.c_str();
1168 if (!format_path(buf, sizeof(buf), path, name)) {
1169 continue;
1170 }
1171
1172 int fd = -1;
1173 if (strchr(buf, '!') != nullptr) {
Simon Baldwinaef71952015-01-16 13:22:54 +00001174 fd = open_library_in_zipfile(buf, file_offset);
1175 }
1176
1177 if (fd == -1) {
1178 fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
1179 if (fd != -1) {
1180 *file_offset = 0;
1181 }
1182 }
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001183
1184 if (fd != -1) {
1185 return fd;
1186 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001187 }
1188
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001189 return -1;
Simon Baldwinaef71952015-01-16 13:22:54 +00001190}
1191
1192static int open_library(const char* name, off64_t* file_offset) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001193 TRACE("[ opening %s ]", name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001194
Elliott Hughes124fae92012-10-31 14:20:03 -07001195 // If the name contains a slash, we should attempt to open it directly and not search the paths.
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001196 if (strchr(name, '/') != nullptr) {
Simon Baldwinaef71952015-01-16 13:22:54 +00001197 if (strchr(name, '!') != nullptr) {
1198 int fd = open_library_in_zipfile(name, file_offset);
1199 if (fd != -1) {
1200 return fd;
1201 }
1202 }
1203
Elliott Hughes6971fe42012-11-01 22:59:19 -07001204 int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC));
1205 if (fd != -1) {
Simon Baldwinaef71952015-01-16 13:22:54 +00001206 *file_offset = 0;
Elliott Hughes6971fe42012-11-01 22:59:19 -07001207 }
Dmitriy Ivanove44fffd2015-03-17 17:12:18 -07001208 return fd;
Elliott Hughes124fae92012-10-31 14:20:03 -07001209 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001210
Elliott Hughes124fae92012-10-31 14:20:03 -07001211 // Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths.
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001212 int fd = open_library_on_ld_library_path(name, file_offset);
Elliott Hughes124fae92012-10-31 14:20:03 -07001213 if (fd == -1) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001214 fd = open_library_on_default_path(name, file_offset);
Elliott Hughes124fae92012-10-31 14:20:03 -07001215 }
1216 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001217}
1218
Dmitriy Ivanov4a7c3af2015-05-27 18:29:41 -07001219static const char* fix_dt_needed(const char* dt_needed, const char* sopath __unused) {
1220#if !defined(__LP64__)
1221 // Work around incorrect DT_NEEDED entries for old apps: http://b/21364029
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -07001222 if (get_application_target_sdk_version() <= 22) {
Dmitriy Ivanov4a7c3af2015-05-27 18:29:41 -07001223 const char* bname = basename(dt_needed);
1224 if (bname != dt_needed) {
1225 DL_WARN("'%s' library has invalid DT_NEEDED entry '%s'", sopath, dt_needed);
1226 }
1227
1228 return bname;
1229 }
1230#endif
1231 return dt_needed;
1232}
1233
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001234template<typename F>
1235static void for_each_dt_needed(const soinfo* si, F action) {
1236 for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
1237 if (d->d_tag == DT_NEEDED) {
Dmitriy Ivanov4a7c3af2015-05-27 18:29:41 -07001238 action(fix_dt_needed(si->get_string(d->d_un.d_val), si->get_realpath()));
Dima Zavin2e855792009-05-20 18:28:09 -07001239 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001240 }
1241}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001242
Spencer Low2a44cfb2015-04-22 18:06:51 -07001243static soinfo* load_library(int fd, off64_t file_offset,
1244 LoadTaskList& load_tasks,
Simon Baldwinaef71952015-01-16 13:22:54 +00001245 const char* name, int rtld_flags,
1246 const android_dlextinfo* extinfo) {
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001247 if ((file_offset % PAGE_SIZE) != 0) {
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07001248 DL_ERR("file offset for the library \"%s\" is not page-aligned: %" PRId64, name, file_offset);
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001249 return nullptr;
1250 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001251 if (file_offset < 0) {
1252 DL_ERR("file offset for the library \"%s\" is negative: %" PRId64, name, file_offset);
1253 return nullptr;
1254 }
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001255
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001256 struct stat file_stat;
1257 if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) {
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07001258 DL_ERR("unable to stat file for the library \"%s\": %s", name, strerror(errno));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001259 return nullptr;
1260 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001261 if (file_offset >= file_stat.st_size) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001262 DL_ERR("file offset for the library \"%s\" >= file size: %" PRId64 " >= %" PRId64,
1263 name, file_offset, file_stat.st_size);
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001264 return nullptr;
1265 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001266
1267 // Check for symlink and other situations where
Dmitriy Ivanov9b821362015-04-02 16:03:56 -07001268 // file can have different names, unless ANDROID_DLEXT_FORCE_LOAD is set
1269 if (extinfo == nullptr || (extinfo->flags & ANDROID_DLEXT_FORCE_LOAD) == 0) {
1270 for (soinfo* si = solist; si != nullptr; si = si->next) {
1271 if (si->get_st_dev() != 0 &&
1272 si->get_st_ino() != 0 &&
1273 si->get_st_dev() == file_stat.st_dev &&
1274 si->get_st_ino() == file_stat.st_ino &&
1275 si->get_file_offset() == file_offset) {
1276 TRACE("library \"%s\" is already loaded under different name/path \"%s\" - "
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001277 "will return existing soinfo", name, si->get_realpath());
Dmitriy Ivanov9b821362015-04-02 16:03:56 -07001278 return si;
1279 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001280 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001281 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001282
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001283 if ((rtld_flags & RTLD_NOLOAD) != 0) {
Dmitriy Ivanova6ac54a2014-09-09 10:21:42 -07001284 DL_ERR("library \"%s\" wasn't loaded and RTLD_NOLOAD prevented it", name);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001285 return nullptr;
1286 }
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001287
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001288 std::string realpath = name;
1289 if (!realpath_fd(fd, &realpath)) {
Dmitriy Ivanovca10ac62015-05-28 11:44:31 -07001290 PRINT("warning: unable to get realpath for the library \"%s\". Will use given name.", name);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001291 realpath = name;
1292 }
1293
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001294 // Read the ELF header and load the segments.
Dmitriy Ivanov06700b22015-06-25 15:51:41 -07001295 ElfReader elf_reader(realpath.c_str(), fd, file_offset, file_stat.st_size);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001296 if (!elf_reader.Load(extinfo)) {
1297 return nullptr;
1298 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001299
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001300 soinfo* si = soinfo_alloc(realpath.c_str(), &file_stat, file_offset, rtld_flags);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001301 if (si == nullptr) {
1302 return nullptr;
1303 }
1304 si->base = elf_reader.load_start();
1305 si->size = elf_reader.load_size();
1306 si->load_bias = elf_reader.load_bias();
1307 si->phnum = elf_reader.phdr_count();
1308 si->phdr = elf_reader.loaded_phdr();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001309
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001310 if (!si->prelink_image()) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001311 soinfo_free(si);
1312 return nullptr;
1313 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001314
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001315 for_each_dt_needed(si, [&] (const char* name) {
1316 load_tasks.push_back(LoadTask::create(name, si));
1317 });
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001318
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001319 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001320}
1321
Spencer Low2a44cfb2015-04-22 18:06:51 -07001322static soinfo* load_library(LoadTaskList& load_tasks,
1323 const char* name, int rtld_flags,
1324 const android_dlextinfo* extinfo) {
1325 if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) {
1326 off64_t file_offset = 0;
1327 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
1328 file_offset = extinfo->library_fd_offset;
1329 }
1330 return load_library(extinfo->library_fd, file_offset, load_tasks, name, rtld_flags, extinfo);
1331 }
1332
1333 // Open the file.
1334 off64_t file_offset;
1335 int fd = open_library(name, &file_offset);
1336 if (fd == -1) {
1337 DL_ERR("library \"%s\" not found", name);
1338 return nullptr;
1339 }
1340 soinfo* result = load_library(fd, file_offset, load_tasks, name, rtld_flags, extinfo);
1341 close(fd);
1342 return result;
1343}
1344
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001345// Returns true if library was found and false in 2 cases
1346// 1. The library was found but loaded under different target_sdk_version
1347// (*candidate != nullptr)
1348// 2. The library was not found by soname (*candidate is nullptr)
1349static bool find_loaded_library_by_soname(const char* name, soinfo** candidate) {
1350 *candidate = nullptr;
1351
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001352 // Ignore filename with path.
1353 if (strchr(name, '/') != nullptr) {
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001354 return false;
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001355 }
1356
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001357 uint32_t target_sdk_version = get_application_target_sdk_version();
1358
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001359 for (soinfo* si = solist; si != nullptr; si = si->next) {
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001360 const char* soname = si->get_soname();
1361 if (soname != nullptr && (strcmp(name, soname) == 0)) {
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001362 // If the library was opened under different target sdk version
1363 // skip this step and try to reopen it. The exceptions are
1364 // "libdl.so" and global group. There is no point in skipping
1365 // them because relocation process is going to use them
1366 // in any case.
1367 bool is_libdl = si == solist;
1368 if (is_libdl || (si->get_dt_flags_1() & DF_1_GLOBAL) != 0 ||
1369 !si->is_linked() || si->get_target_sdk_version() == target_sdk_version) {
1370 *candidate = si;
1371 return true;
1372 } else if (*candidate == nullptr) {
1373 // for the different sdk version - remember the first library.
1374 *candidate = si;
1375 }
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001376 }
Dmitriy Ivanov489e4982014-05-19 15:19:52 -07001377 }
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001378
1379 return false;
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001380}
1381
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001382static soinfo* find_library_internal(LoadTaskList& load_tasks, const char* name,
1383 int rtld_flags, const android_dlextinfo* extinfo) {
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001384 soinfo* candidate;
1385
1386 if (find_loaded_library_by_soname(name, &candidate)) {
1387 return candidate;
1388 }
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001389
1390 // Library might still be loaded, the accurate detection
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001391 // of this fact is done by load_library.
Dmitriy Ivanov28154f52015-06-16 15:38:21 -07001392 TRACE("[ '%s' find_loaded_library_by_soname returned false (*candidate=%s@%p). Trying harder...]",
1393 name, candidate == nullptr ? "n/a" : candidate->get_realpath(), candidate);
1394
1395 soinfo* si = load_library(load_tasks, name, rtld_flags, extinfo);
1396
1397 // In case we were unable to load the library but there
1398 // is a candidate loaded under the same soname but different
1399 // sdk level - return it anyways.
1400 if (si == nullptr && candidate != nullptr) {
1401 si = candidate;
Elliott Hughesd23736e2012-11-01 15:16:56 -07001402 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001403
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001404 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001405}
1406
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001407static void soinfo_unload(soinfo* si);
1408
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07001409// TODO: this is slightly unusual way to construct
1410// the global group for relocation. Not every RTLD_GLOBAL
1411// library is included in this group for backwards-compatibility
1412// reasons.
1413//
1414// This group consists of the main executable, LD_PRELOADs
1415// and libraries with the DF_1_GLOBAL flag set.
1416static soinfo::soinfo_list_t make_global_group() {
1417 soinfo::soinfo_list_t global_group;
1418 for (soinfo* si = somain; si != nullptr; si = si->next) {
1419 if ((si->get_dt_flags_1() & DF_1_GLOBAL) != 0) {
1420 global_group.push_back(si);
1421 }
1422 }
1423
1424 return global_group;
1425}
1426
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001427static bool find_libraries(soinfo* start_with, const char* const library_names[],
1428 size_t library_names_count, soinfo* soinfos[], std::vector<soinfo*>* ld_preloads,
1429 size_t ld_preloads_count, int rtld_flags, const android_dlextinfo* extinfo) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001430 // Step 0: prepare.
1431 LoadTaskList load_tasks;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001432 for (size_t i = 0; i < library_names_count; ++i) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001433 const char* name = library_names[i];
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001434 load_tasks.push_back(LoadTask::create(name, start_with));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001435 }
1436
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07001437 // Construct global_group.
1438 soinfo::soinfo_list_t global_group = make_global_group();
1439
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001440 // If soinfos array is null allocate one on stack.
1441 // The array is needed in case of failure; for example
1442 // when library_names[] = {libone.so, libtwo.so} and libone.so
1443 // is loaded correctly but libtwo.so failed for some reason.
1444 // In this case libone.so should be unloaded on return.
1445 // See also implementation of failure_guard below.
1446
1447 if (soinfos == nullptr) {
1448 size_t soinfos_size = sizeof(soinfo*)*library_names_count;
1449 soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size));
1450 memset(soinfos, 0, soinfos_size);
1451 }
1452
1453 // list of libraries to link - see step 2.
1454 size_t soinfos_count = 0;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001455
Dmitriy Ivanovd9ff7222014-09-08 16:22:22 -07001456 auto failure_guard = make_scope_guard([&]() {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001457 // Housekeeping
1458 load_tasks.for_each([] (LoadTask* t) {
1459 LoadTask::deleter(t);
1460 });
1461
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001462 for (size_t i = 0; i<soinfos_count; ++i) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001463 soinfo_unload(soinfos[i]);
1464 }
1465 });
1466
1467 // Step 1: load and pre-link all DT_NEEDED libraries in breadth first order.
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001468 for (LoadTask::unique_ptr task(load_tasks.pop_front());
1469 task.get() != nullptr; task.reset(load_tasks.pop_front())) {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001470 soinfo* si = find_library_internal(load_tasks, task->get_name(), rtld_flags, extinfo);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001471 if (si == nullptr) {
1472 return false;
1473 }
1474
1475 soinfo* needed_by = task->get_needed_by();
1476
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001477 if (needed_by != nullptr) {
1478 needed_by->add_child(si);
1479 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001480
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001481 if (si->is_linked()) {
1482 si->increment_ref_count();
1483 }
1484
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001485 // When ld_preloads is not null, the first
1486 // ld_preloads_count libs are in fact ld_preloads.
1487 if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07001488 // Add LD_PRELOADed libraries to the global group for future runs.
1489 // There is no need to explicitly add them to the global group
1490 // for this run because they are going to appear in the local
1491 // group in the correct order.
1492 si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001493 ld_preloads->push_back(si);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001494 }
1495
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001496 if (soinfos_count < library_names_count) {
1497 soinfos[soinfos_count++] = si;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001498 }
1499 }
1500
1501 // Step 2: link libraries.
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001502 soinfo::soinfo_list_t local_group;
1503 walk_dependencies_tree(
1504 start_with == nullptr ? soinfos : &start_with,
1505 start_with == nullptr ? soinfos_count : 1,
1506 [&] (soinfo* si) {
1507 local_group.push_back(si);
1508 return true;
1509 });
1510
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001511 // We need to increment ref_count in case
1512 // the root of the local group was not linked.
1513 bool was_local_group_root_linked = local_group.front()->is_linked();
1514
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001515 bool linked = local_group.visit([&](soinfo* si) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001516 if (!si->is_linked()) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001517 if (!si->link_image(global_group, local_group, extinfo)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001518 return false;
1519 }
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001520 si->set_linked();
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001521 }
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001522
1523 return true;
1524 });
1525
1526 if (linked) {
1527 failure_guard.disable();
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001528 }
1529
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001530 if (!was_local_group_root_linked) {
1531 local_group.front()->increment_ref_count();
1532 }
1533
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001534 return linked;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001535}
1536
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001537static soinfo* find_library(const char* name, int rtld_flags, const android_dlextinfo* extinfo) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001538 soinfo* si;
1539
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001540 if (name == nullptr) {
1541 si = somain;
1542 } else if (!find_libraries(nullptr, &name, 1, &si, nullptr, 0, rtld_flags, extinfo)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001543 return nullptr;
1544 }
1545
Elliott Hughesd23736e2012-11-01 15:16:56 -07001546 return si;
1547}
Elliott Hughesbedfe382012-08-14 14:07:59 -07001548
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001549static void soinfo_unload(soinfo* root) {
1550 // Note that the library can be loaded but not linked;
1551 // in which case there is no root but we still need
1552 // to walk the tree and unload soinfos involved.
1553 //
1554 // This happens on unsuccessful dlopen, when one of
1555 // the DT_NEEDED libraries could not be linked/found.
1556 if (root->is_linked()) {
1557 root = root->get_local_group_root();
1558 }
1559
1560 if (!root->can_unload()) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001561 TRACE("not unloading '%s' - the binary is flagged with NODELETE", root->get_realpath());
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07001562 return;
1563 }
1564
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001565 size_t ref_count = root->is_linked() ? root->decrement_ref_count() : 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001566
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001567 if (ref_count == 0) {
1568 soinfo::soinfo_list_t local_unload_list;
1569 soinfo::soinfo_list_t external_unload_list;
1570 soinfo::soinfo_list_t depth_first_list;
1571 depth_first_list.push_back(root);
1572 soinfo* si = nullptr;
1573
1574 while ((si = depth_first_list.pop_front()) != nullptr) {
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001575 if (local_unload_list.contains(si)) {
1576 continue;
1577 }
1578
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001579 local_unload_list.push_back(si);
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001580
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001581 if (si->has_min_version(0)) {
1582 soinfo* child = nullptr;
1583 while ((child = si->get_children().pop_front()) != nullptr) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001584 TRACE("%s@%p needs to unload %s@%p", si->get_realpath(), si,
1585 child->get_realpath(), child);
1586
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001587 if (local_unload_list.contains(child)) {
1588 continue;
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001589 } else if (child->is_linked() && child->get_local_group_root() != root) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001590 external_unload_list.push_back(child);
1591 } else {
1592 depth_first_list.push_front(child);
1593 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001594 }
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001595 } else {
Dmitriy Ivanov69a5fb92015-05-15 17:53:39 -07001596#if !defined(__work_around_b_19059885__)
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001597 __libc_fatal("soinfo for \"%s\"@%p has no version", si->get_realpath(), si);
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001598#else
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001599 PRINT("warning: soinfo for \"%s\"@%p has no version", si->get_realpath(), si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001600 for_each_dt_needed(si, [&] (const char* library_name) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001601 TRACE("deprecated (old format of soinfo): %s needs to unload %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001602 si->get_realpath(), library_name);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001603
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001604 soinfo* needed = find_library(library_name, RTLD_NOLOAD, nullptr);
1605 if (needed != nullptr) {
1606 // Not found: for example if symlink was deleted between dlopen and dlclose
1607 // Since we cannot really handle errors at this point - print and continue.
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07001608 PRINT("warning: couldn't find %s needed by %s on unload.",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001609 library_name, si->get_realpath());
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001610 return;
1611 } else if (local_unload_list.contains(needed)) {
1612 // already visited
1613 return;
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001614 } else if (needed->is_linked() && needed->get_local_group_root() != root) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001615 // external group
1616 external_unload_list.push_back(needed);
1617 } else {
1618 // local group
1619 depth_first_list.push_front(needed);
1620 }
1621 });
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08001622#endif
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001623 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001624 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001625
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001626 local_unload_list.for_each([](soinfo* si) {
1627 si->call_destructors();
1628 });
1629
1630 while ((si = local_unload_list.pop_front()) != nullptr) {
1631 notify_gdb_of_unload(si);
1632 soinfo_free(si);
1633 }
1634
1635 while ((si = external_unload_list.pop_front()) != nullptr) {
1636 soinfo_unload(si);
1637 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001638 } else {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001639 TRACE("not unloading '%s' group, decrementing ref_count to %zd",
1640 root->get_realpath(), ref_count);
Dmitriy Ivanova2547052014-11-18 12:03:09 -08001641 }
1642}
1643
Elliott Hughesa4aafd12014-01-13 16:37:47 -08001644void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
Christopher Ferris052fa3a2014-08-26 20:48:11 -07001645 // Use basic string manipulation calls to avoid snprintf.
1646 // snprintf indirectly calls pthread_getspecific to get the size of a buffer.
1647 // When debug malloc is enabled, this call returns 0. This in turn causes
1648 // snprintf to do nothing, which causes libraries to fail to load.
1649 // See b/17302493 for further details.
1650 // Once the above bug is fixed, this code can be modified to use
1651 // snprintf again.
1652 size_t required_len = strlen(kDefaultLdPaths[0]) + strlen(kDefaultLdPaths[1]) + 2;
1653 if (buffer_size < required_len) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001654 __libc_fatal("android_get_LD_LIBRARY_PATH failed, buffer too small: "
1655 "buffer len %zu, required len %zu", buffer_size, required_len);
Christopher Ferris052fa3a2014-08-26 20:48:11 -07001656 }
1657 char* end = stpcpy(buffer, kDefaultLdPaths[0]);
1658 *end = ':';
1659 strcpy(end + 1, kDefaultLdPaths[1]);
Elliott Hughesa4aafd12014-01-13 16:37:47 -08001660}
1661
Elliott Hughescade4c32012-12-20 14:42:14 -08001662void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
Nick Kralevich6bb01b62015-03-07 13:37:05 -08001663 parse_LD_LIBRARY_PATH(ld_library_path);
Elliott Hughescade4c32012-12-20 14:42:14 -08001664}
1665
Elliott Hughes1a586292014-06-03 16:23:08 -07001666soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo) {
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07001667 if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) {
Elliott Hughese66190d2012-12-18 15:57:55 -08001668 DL_ERR("invalid flags to dlopen: %x", flags);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001669 return nullptr;
Elliott Hughese66190d2012-12-18 15:57:55 -08001670 }
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001671 if (extinfo != nullptr) {
1672 if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) {
1673 DL_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags);
1674 return nullptr;
1675 }
1676 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 &&
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07001677 (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001678 DL_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without "
1679 "ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags);
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001680 return nullptr;
1681 }
Torne (Richard Coles)012cb452014-02-06 14:34:21 +00001682 }
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08001683
1684 ProtectedDataGuard guard;
Dmitriy Ivanov9fb216f2014-11-01 02:30:38 +00001685 soinfo* si = find_library(name, flags, extinfo);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001686 if (si != nullptr) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001687 si->call_constructors();
Elliott Hughesd23736e2012-11-01 15:16:56 -07001688 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001689 return si;
1690}
1691
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001692void do_dlclose(soinfo* si) {
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08001693 ProtectedDataGuard guard;
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001694 soinfo_unload(si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001695}
1696
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07001697static ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) {
1698 typedef ElfW(Addr) (*ifunc_resolver_t)(void);
1699 ifunc_resolver_t ifunc_resolver = reinterpret_cast<ifunc_resolver_t>(resolver_addr);
1700 ElfW(Addr) ifunc_addr = ifunc_resolver();
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001701 TRACE_TYPE(RELO, "Called ifunc_resolver@%p. The result is %p",
1702 ifunc_resolver, reinterpret_cast<void*>(ifunc_addr));
Brigid Smithc5a13ef2014-07-23 11:22:25 -07001703
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07001704 return ifunc_addr;
Brigid Smithc5a13ef2014-07-23 11:22:25 -07001705}
Brigid Smithc5a13ef2014-07-23 11:22:25 -07001706
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001707const version_info* VersionTracker::get_version_info(ElfW(Versym) source_symver) const {
1708 if (source_symver < 2 ||
1709 source_symver >= version_infos.size() ||
1710 version_infos[source_symver].name == nullptr) {
1711 return nullptr;
1712 }
1713
1714 return &version_infos[source_symver];
1715}
1716
1717void VersionTracker::add_version_info(size_t source_index,
1718 ElfW(Word) elf_hash,
1719 const char* ver_name,
1720 const soinfo* target_si) {
1721 if (source_index >= version_infos.size()) {
1722 version_infos.resize(source_index+1);
1723 }
1724
1725 version_infos[source_index].elf_hash = elf_hash;
1726 version_infos[source_index].name = ver_name;
1727 version_infos[source_index].target_si = target_si;
1728}
1729
1730bool VersionTracker::init_verneed(const soinfo* si_from) {
1731 uintptr_t verneed_ptr = si_from->get_verneed_ptr();
1732
1733 if (verneed_ptr == 0) {
1734 return true;
1735 }
1736
1737 size_t verneed_cnt = si_from->get_verneed_cnt();
1738
1739 for (size_t i = 0, offset = 0; i<verneed_cnt; ++i) {
1740 const ElfW(Verneed)* verneed = reinterpret_cast<ElfW(Verneed)*>(verneed_ptr + offset);
1741 size_t vernaux_offset = offset + verneed->vn_aux;
1742 offset += verneed->vn_next;
1743
1744 if (verneed->vn_version != 1) {
1745 DL_ERR("unsupported verneed[%zd] vn_version: %d (expected 1)", i, verneed->vn_version);
1746 return false;
1747 }
1748
1749 const char* target_soname = si_from->get_string(verneed->vn_file);
1750 // find it in dependencies
1751 soinfo* target_si = si_from->get_children().find_if([&](const soinfo* si) {
Dmitriy Ivanov8264afb2015-05-06 11:05:27 -07001752 return si->get_soname() != nullptr && strcmp(si->get_soname(), target_soname) == 0;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001753 });
1754
1755 if (target_si == nullptr) {
1756 DL_ERR("cannot find \"%s\" from verneed[%zd] in DT_NEEDED list for \"%s\"",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001757 target_soname, i, si_from->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001758 return false;
1759 }
1760
1761 for (size_t j = 0; j<verneed->vn_cnt; ++j) {
1762 const ElfW(Vernaux)* vernaux = reinterpret_cast<ElfW(Vernaux)*>(verneed_ptr + vernaux_offset);
1763 vernaux_offset += vernaux->vna_next;
1764
1765 const ElfW(Word) elf_hash = vernaux->vna_hash;
1766 const char* ver_name = si_from->get_string(vernaux->vna_name);
1767 ElfW(Half) source_index = vernaux->vna_other;
1768
1769 add_version_info(source_index, elf_hash, ver_name, target_si);
1770 }
1771 }
1772
1773 return true;
1774}
1775
1776bool VersionTracker::init_verdef(const soinfo* si_from) {
1777 return for_each_verdef(si_from,
1778 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
1779 add_version_info(verdef->vd_ndx, verdef->vd_hash,
1780 si_from->get_string(verdaux->vda_name), si_from);
1781 return false;
1782 }
1783 );
1784}
1785
1786bool VersionTracker::init(const soinfo* si_from) {
1787 if (!si_from->has_min_version(2)) {
1788 return true;
1789 }
1790
1791 return init_verneed(si_from) && init_verdef(si_from);
1792}
1793
Dmitriy Ivanov114bd832015-04-30 16:11:48 -07001794bool soinfo::lookup_version_info(const VersionTracker& version_tracker, ElfW(Word) sym,
1795 const char* sym_name, const version_info** vi) {
1796 const ElfW(Versym)* sym_ver_ptr = get_versym(sym);
1797 ElfW(Versym) sym_ver = sym_ver_ptr == nullptr ? 0 : *sym_ver_ptr;
1798
1799 if (sym_ver != VER_NDX_LOCAL && sym_ver != VER_NDX_GLOBAL) {
1800 *vi = version_tracker.get_version_info(sym_ver);
1801
1802 if (*vi == nullptr) {
1803 DL_ERR("cannot find verneed/verdef for version index=%d "
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001804 "referenced by symbol \"%s\" at \"%s\"", sym_ver, sym_name, get_realpath());
Dmitriy Ivanov114bd832015-04-30 16:11:48 -07001805 return false;
1806 }
1807 } else {
1808 // there is no version info
1809 *vi = nullptr;
1810 }
1811
1812 return true;
1813}
1814
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001815#if !defined(__mips__)
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001816#if defined(USE_RELA)
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001817static ElfW(Addr) get_addend(ElfW(Rela)* rela, ElfW(Addr) reloc_addr __unused) {
1818 return rela->r_addend;
1819}
1820#else
1821static ElfW(Addr) get_addend(ElfW(Rel)* rel, ElfW(Addr) reloc_addr) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001822 if (ELFW(R_TYPE)(rel->r_info) == R_GENERIC_RELATIVE ||
1823 ELFW(R_TYPE)(rel->r_info) == R_GENERIC_IRELATIVE) {
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001824 return *reinterpret_cast<ElfW(Addr)*>(reloc_addr);
1825 }
1826 return 0;
1827}
1828#endif
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001829
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -08001830template<typename ElfRelIteratorT>
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07001831bool soinfo::relocate(const VersionTracker& version_tracker, ElfRelIteratorT&& rel_iterator,
1832 const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -08001833 for (size_t idx = 0; rel_iterator.has_next(); ++idx) {
1834 const auto rel = rel_iterator.next();
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08001835 if (rel == nullptr) {
1836 return false;
1837 }
1838
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001839 ElfW(Word) type = ELFW(R_TYPE)(rel->r_info);
1840 ElfW(Word) sym = ELFW(R_SYM)(rel->r_info);
1841
1842 ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001843 ElfW(Addr) sym_addr = 0;
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001844 const char* sym_name = nullptr;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001845 ElfW(Addr) addend = get_addend(rel, reloc);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001846
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001847 DEBUG("Processing '%s' relocation at index %zd", get_realpath(), idx);
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001848 if (type == R_GENERIC_NONE) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001849 continue;
1850 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001851
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001852 const ElfW(Sym)* s = nullptr;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001853 soinfo* lsi = nullptr;
1854
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001855 if (sym != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001856 sym_name = get_string(symtab_[sym].st_name);
Dmitriy Ivanov114bd832015-04-30 16:11:48 -07001857 const version_info* vi = nullptr;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001858
Dmitriy Ivanov114bd832015-04-30 16:11:48 -07001859 if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) {
1860 return false;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001861 }
Dmitriy Ivanov114bd832015-04-30 16:11:48 -07001862
1863 if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) {
1864 return false;
1865 }
1866
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001867 if (s == nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001868 // We only allow an undefined symbol if this is a weak reference...
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001869 s = &symtab_[sym];
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001870 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07001871 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08001872 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001873 }
1874
1875 /* IHI0044C AAELF 4.5.1.1:
1876
1877 Libraries are not searched to resolve weak references.
1878 It is not an error for a weak reference to remain unsatisfied.
1879
1880 During linking, the value of an undefined weak reference is:
1881 - Zero if the relocation type is absolute
1882 - The address of the place if the relocation is pc-relative
1883 - The address of nominal base address if the relocation
1884 type is base-relative.
1885 */
1886
1887 switch (type) {
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08001888 case R_GENERIC_JUMP_SLOT:
1889 case R_GENERIC_GLOB_DAT:
1890 case R_GENERIC_RELATIVE:
1891 case R_GENERIC_IRELATIVE:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001892#if defined(__aarch64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001893 case R_AARCH64_ABS64:
1894 case R_AARCH64_ABS32:
1895 case R_AARCH64_ABS16:
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08001896#elif defined(__x86_64__)
1897 case R_X86_64_32:
1898 case R_X86_64_64:
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001899#elif defined(__arm__)
1900 case R_ARM_ABS32:
1901#elif defined(__i386__)
1902 case R_386_32:
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08001903#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001904 /*
1905 * The sym_addr was initialized to be zero above, or the relocation
1906 * code below does not care about value of sym_addr.
1907 * No need to do anything.
1908 */
1909 break;
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08001910#if defined(__x86_64__)
Dimitry Ivanovd338aac2015-01-13 22:31:54 +00001911 case R_X86_64_PC32:
1912 sym_addr = reloc;
1913 break;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001914#elif defined(__i386__)
1915 case R_386_PC32:
1916 sym_addr = reloc;
1917 break;
1918#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001919 default:
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001920 DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rel, idx);
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08001921 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001922 }
1923 } else {
1924 // We got a definition.
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07001925 sym_addr = lsi->resolve_symbol_address(s);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001926 }
1927 count_relocation(kRelocSymbol);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001928 }
1929
1930 switch (type) {
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001931 case R_GENERIC_JUMP_SLOT:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001932 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001933 MARK(rel->r_offset);
1934 TRACE_TYPE(RELO, "RELO JMP_SLOT %16p <- %16p %s\n",
1935 reinterpret_cast<void*>(reloc),
1936 reinterpret_cast<void*>(sym_addr + addend), sym_name);
1937
1938 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001939 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001940 case R_GENERIC_GLOB_DAT:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001941 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001942 MARK(rel->r_offset);
1943 TRACE_TYPE(RELO, "RELO GLOB_DAT %16p <- %16p %s\n",
1944 reinterpret_cast<void*>(reloc),
1945 reinterpret_cast<void*>(sym_addr + addend), sym_name);
1946 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001947 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001948 case R_GENERIC_RELATIVE:
1949 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001950 MARK(rel->r_offset);
1951 TRACE_TYPE(RELO, "RELO RELATIVE %16p <- %16p\n",
1952 reinterpret_cast<void*>(reloc),
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08001953 reinterpret_cast<void*>(load_bias + addend));
1954 *reinterpret_cast<ElfW(Addr)*>(reloc) = (load_bias + addend);
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001955 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001956 case R_GENERIC_IRELATIVE:
1957 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001958 MARK(rel->r_offset);
1959 TRACE_TYPE(RELO, "RELO IRELATIVE %16p <- %16p\n",
1960 reinterpret_cast<void*>(reloc),
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08001961 reinterpret_cast<void*>(load_bias + addend));
1962 *reinterpret_cast<ElfW(Addr)*>(reloc) = call_ifunc_resolver(load_bias + addend);
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08001963 break;
1964
1965#if defined(__aarch64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001966 case R_AARCH64_ABS64:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001967 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001968 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001969 TRACE_TYPE(RELO, "RELO ABS64 %16llx <- %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001970 reloc, (sym_addr + addend), sym_name);
1971 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001972 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001973 case R_AARCH64_ABS32:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001974 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001975 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001976 TRACE_TYPE(RELO, "RELO ABS32 %16llx <- %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001977 reloc, (sym_addr + addend), sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001978 {
1979 const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc);
1980 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN);
1981 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX);
1982 if ((min_value <= (reloc_value + (sym_addr + addend))) &&
1983 ((reloc_value + (sym_addr + addend)) <= max_value)) {
1984 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend);
1985 } else {
1986 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1987 (reloc_value + (sym_addr + addend)), min_value, max_value);
1988 return false;
1989 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001990 }
1991 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001992 case R_AARCH64_ABS16:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001993 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001994 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001995 TRACE_TYPE(RELO, "RELO ABS16 %16llx <- %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08001996 reloc, (sym_addr + addend), sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001997 {
1998 const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc);
1999 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN);
2000 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX);
2001 if ((min_value <= (reloc_value + (sym_addr + addend))) &&
2002 ((reloc_value + (sym_addr + addend)) <= max_value)) {
2003 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend);
2004 } else {
2005 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
2006 reloc_value + (sym_addr + addend), min_value, max_value);
2007 return false;
2008 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002009 }
2010 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002011 case R_AARCH64_PREL64:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002012 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002013 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002014 TRACE_TYPE(RELO, "RELO REL64 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002015 reloc, (sym_addr + addend), rel->r_offset, sym_name);
2016 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + addend) - rel->r_offset;
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002017 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002018 case R_AARCH64_PREL32:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002019 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002020 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002021 TRACE_TYPE(RELO, "RELO REL32 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002022 reloc, (sym_addr + addend), rel->r_offset, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002023 {
2024 const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc);
2025 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN);
2026 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX);
2027 if ((min_value <= (reloc_value + ((sym_addr + addend) - rel->r_offset))) &&
2028 ((reloc_value + ((sym_addr + addend) - rel->r_offset)) <= max_value)) {
2029 *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + addend) - rel->r_offset);
2030 } else {
2031 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
2032 reloc_value + ((sym_addr + addend) - rel->r_offset), min_value, max_value);
2033 return false;
2034 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002035 }
2036 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002037 case R_AARCH64_PREL16:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002038 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002039 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002040 TRACE_TYPE(RELO, "RELO REL16 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002041 reloc, (sym_addr + addend), rel->r_offset, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002042 {
2043 const ElfW(Addr) reloc_value = *reinterpret_cast<ElfW(Addr)*>(reloc);
2044 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN);
2045 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX);
2046 if ((min_value <= (reloc_value + ((sym_addr + addend) - rel->r_offset))) &&
2047 ((reloc_value + ((sym_addr + addend) - rel->r_offset)) <= max_value)) {
2048 *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + addend) - rel->r_offset);
2049 } else {
2050 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
2051 reloc_value + ((sym_addr + addend) - rel->r_offset), min_value, max_value);
2052 return false;
2053 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002054 }
2055 break;
2056
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002057 case R_AARCH64_COPY:
Nick Kralevich76e289c2014-07-03 12:04:31 -07002058 /*
2059 * ET_EXEC is not supported so this should not happen.
2060 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002061 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf
Nick Kralevich76e289c2014-07-03 12:04:31 -07002062 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002063 * Section 4.6.11 "Dynamic relocations"
Nick Kralevich76e289c2014-07-03 12:04:31 -07002064 * R_AARCH64_COPY may only appear in executable objects where e_type is
2065 * set to ET_EXEC.
2066 */
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002067 DL_ERR("%s R_AARCH64_COPY relocations are not supported", get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08002068 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002069 case R_AARCH64_TLS_TPREL64:
Elliott Hughes0266ae52014-02-10 17:46:57 -08002070 TRACE_TYPE(RELO, "RELO TLS_TPREL64 *** %16llx <- %16llx - %16llx\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002071 reloc, (sym_addr + addend), rel->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002072 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002073 case R_AARCH64_TLS_DTPREL32:
Elliott Hughes0266ae52014-02-10 17:46:57 -08002074 TRACE_TYPE(RELO, "RELO TLS_DTPREL32 *** %16llx <- %16llx - %16llx\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002075 reloc, (sym_addr + addend), rel->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002076 break;
2077#elif defined(__x86_64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002078 case R_X86_64_32:
2079 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002080 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002081 TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
2082 static_cast<size_t>(sym_addr), sym_name);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002083 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002084 break;
2085 case R_X86_64_64:
2086 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002087 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002088 TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
2089 static_cast<size_t>(sym_addr), sym_name);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002090 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002091 break;
2092 case R_X86_64_PC32:
2093 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002094 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002095 TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s",
2096 static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc),
2097 static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002098 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend - reloc;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002099 break;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002100#elif defined(__arm__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002101 case R_ARM_ABS32:
2102 count_relocation(kRelocAbsolute);
2103 MARK(rel->r_offset);
2104 TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name);
2105 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
2106 break;
2107 case R_ARM_REL32:
2108 count_relocation(kRelocRelative);
2109 MARK(rel->r_offset);
2110 TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s",
2111 reloc, sym_addr, rel->r_offset, sym_name);
2112 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
2113 break;
2114 case R_ARM_COPY:
2115 /*
2116 * ET_EXEC is not supported so this should not happen.
2117 *
2118 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
2119 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002120 * Section 4.6.1.10 "Dynamic relocations"
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002121 * R_ARM_COPY may only appear in executable objects where e_type is
2122 * set to ET_EXEC.
2123 */
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002124 DL_ERR("%s R_ARM_COPY relocations are not supported", get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08002125 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002126#elif defined(__i386__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002127 case R_386_32:
2128 count_relocation(kRelocRelative);
2129 MARK(rel->r_offset);
2130 TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name);
2131 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
2132 break;
2133 case R_386_PC32:
2134 count_relocation(kRelocRelative);
2135 MARK(rel->r_offset);
2136 TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s",
2137 reloc, (sym_addr - reloc), sym_addr, reloc, sym_name);
2138 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr - reloc);
2139 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002140#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002141 default:
2142 DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002143 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002144 }
2145 }
2146 return true;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002147}
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08002148#endif // !defined(__mips__)
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002149
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002150void soinfo::call_array(const char* array_name __unused, linker_function_t* functions,
2151 size_t count, bool reverse) {
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002152 if (functions == nullptr) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07002153 return;
2154 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02002155
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002156 TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, get_realpath());
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002157
2158 int begin = reverse ? (count - 1) : 0;
2159 int end = reverse ? -1 : count;
2160 int step = reverse ? -1 : 1;
2161
2162 for (int i = begin; i != end; i += step) {
2163 TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002164 call_function("function", functions[i]);
Elliott Hughesd23736e2012-11-01 15:16:56 -07002165 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02002166
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002167 TRACE("[ Done calling %s for '%s' ]", array_name, get_realpath());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002168}
2169
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002170void soinfo::call_function(const char* function_name __unused, linker_function_t function) {
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002171 if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07002172 return;
2173 }
2174
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002175 TRACE("[ Calling %s @ %p for '%s' ]", function_name, function, get_realpath());
Elliott Hughesd23736e2012-11-01 15:16:56 -07002176 function();
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002177 TRACE("[ Done calling %s @ %p for '%s' ]", function_name, function, get_realpath());
Evgeniy Stepanov9181a5d2012-08-13 17:58:37 +04002178}
2179
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002180void soinfo::call_pre_init_constructors() {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07002181 // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
2182 // but ignored in a shared library.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002183 call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false);
Elliott Hughesd23736e2012-11-01 15:16:56 -07002184}
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04002185
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002186void soinfo::call_constructors() {
Elliott Hughesd23736e2012-11-01 15:16:56 -07002187 if (constructors_called) {
2188 return;
2189 }
Jesse Hallf5d16932012-01-30 15:39:57 -08002190
Elliott Hughesd23736e2012-11-01 15:16:56 -07002191 // We set constructors_called before actually calling the constructors, otherwise it doesn't
2192 // protect against recursive constructor calls. One simple example of constructor recursion
2193 // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
2194 // 1. The program depends on libc, so libc's constructor is called here.
2195 // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
2196 // 3. dlopen() calls the constructors on the newly created
2197 // soinfo for libc_malloc_debug_leak.so.
2198 // 4. The debug .so depends on libc, so CallConstructors is
2199 // called again with the libc soinfo. If it doesn't trigger the early-
2200 // out above, the libc constructor will be called again (recursively!).
2201 constructors_called = true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002202
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002203 if (!is_main_executable() && preinit_array_ != nullptr) {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07002204 // The GNU dynamic linker silently ignores these, but we warn the developer.
Elliott Hughesc6200592013-09-30 18:43:46 -07002205 PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002206 get_realpath(), preinit_array_count_);
Elliott Hughesd23736e2012-11-01 15:16:56 -07002207 }
2208
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002209 get_children().for_each([] (soinfo* si) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002210 si->call_constructors();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002211 });
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04002212
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002213 TRACE("\"%s\": calling constructors", get_realpath());
Elliott Hughes8147d3c2013-05-09 14:19:58 -07002214
2215 // DT_INIT should be called before DT_INIT_ARRAY if both are present.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002216 call_function("DT_INIT", init_func_);
2217 call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false);
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04002218}
David 'Digit' Turner82156792009-05-18 14:37:41 +02002219
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002220void soinfo::call_destructors() {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002221 if (!constructors_called) {
2222 return;
2223 }
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002224 TRACE("\"%s\": calling destructors", get_realpath());
Elliott Hughes8147d3c2013-05-09 14:19:58 -07002225
2226 // DT_FINI_ARRAY must be parsed in reverse order.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002227 call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true);
Elliott Hughes8147d3c2013-05-09 14:19:58 -07002228
2229 // DT_FINI should be called after DT_FINI_ARRAY if both are present.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002230 call_function("DT_FINI", fini_func_);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07002231
2232 // This is needed on second call to dlopen
2233 // after library has been unloaded with RTLD_NODELETE
2234 constructors_called = false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002235}
2236
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002237void soinfo::add_child(soinfo* child) {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002238 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002239 child->parents_.push_back(this);
2240 this->children_.push_back(child);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002241 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002242}
2243
2244void soinfo::remove_all_links() {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002245 if (!has_min_version(0)) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002246 return;
2247 }
2248
2249 // 1. Untie connected soinfos from 'this'.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002250 children_.for_each([&] (soinfo* child) {
2251 child->parents_.remove_if([&] (const soinfo* parent) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002252 return parent == this;
2253 });
2254 });
2255
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002256 parents_.for_each([&] (soinfo* parent) {
2257 parent->children_.remove_if([&] (const soinfo* child) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002258 return child == this;
2259 });
2260 });
2261
2262 // 2. Once everything untied - clear local lists.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002263 parents_.clear();
2264 children_.clear();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002265}
2266
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002267dev_t soinfo::get_st_dev() const {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002268 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002269 return st_dev_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002270 }
2271
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002272 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002273};
2274
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002275ino_t soinfo::get_st_ino() const {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002276 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002277 return st_ino_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002278 }
2279
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002280 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002281}
2282
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002283off64_t soinfo::get_file_offset() const {
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002284 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002285 return file_offset_;
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002286 }
2287
2288 return 0;
2289}
2290
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002291uint32_t soinfo::get_rtld_flags() const {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07002292 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002293 return rtld_flags_;
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07002294 }
2295
2296 return 0;
2297}
2298
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002299uint32_t soinfo::get_dt_flags_1() const {
2300 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002301 return dt_flags_1_;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002302 }
2303
2304 return 0;
2305}
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002306
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002307void soinfo::set_dt_flags_1(uint32_t dt_flags_1) {
2308 if (has_min_version(1)) {
2309 if ((dt_flags_1 & DF_1_GLOBAL) != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002310 rtld_flags_ |= RTLD_GLOBAL;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002311 }
2312
2313 if ((dt_flags_1 & DF_1_NODELETE) != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002314 rtld_flags_ |= RTLD_NODELETE;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002315 }
2316
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002317 dt_flags_1_ = dt_flags_1;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002318 }
2319}
2320
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002321const char* soinfo::get_realpath() const {
Dmitriy Ivanov69a5fb92015-05-15 17:53:39 -07002322#if defined(__work_around_b_19059885__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002323 if (has_min_version(2)) {
2324 return realpath_.c_str();
2325 } else {
2326 return old_name_;
2327 }
2328#else
2329 return realpath_.c_str();
2330#endif
2331}
2332
2333const char* soinfo::get_soname() const {
Dmitriy Ivanov69a5fb92015-05-15 17:53:39 -07002334#if defined(__work_around_b_19059885__)
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002335 if (has_min_version(2)) {
2336 return soname_;
2337 } else {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002338 return old_name_;
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002339 }
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002340#else
2341 return soname_;
2342#endif
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002343}
2344
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002345// This is a return on get_children()/get_parents() if
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002346// 'this->flags' does not have FLAG_NEW_SOINFO set.
2347static soinfo::soinfo_list_t g_empty_list;
2348
2349soinfo::soinfo_list_t& soinfo::get_children() {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002350 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002351 return children_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002352 }
2353
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07002354 return g_empty_list;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002355}
2356
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002357const soinfo::soinfo_list_t& soinfo::get_children() const {
2358 if (has_min_version(0)) {
2359 return children_;
2360 }
2361
2362 return g_empty_list;
2363}
2364
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002365soinfo::soinfo_list_t& soinfo::get_parents() {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002366 if (has_min_version(0)) {
2367 return parents_;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002368 }
2369
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002370 return g_empty_list;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002371}
2372
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002373ElfW(Addr) soinfo::resolve_symbol_address(const ElfW(Sym)* s) const {
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002374 if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) {
2375 return call_ifunc_resolver(s->st_value + load_bias);
2376 }
2377
2378 return static_cast<ElfW(Addr)>(s->st_value + load_bias);
2379}
2380
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002381const char* soinfo::get_string(ElfW(Word) index) const {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002382 if (has_min_version(1) && (index >= strtab_size_)) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002383 __libc_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002384 get_realpath(), strtab_size_, index);
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002385 }
2386
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002387 return strtab_ + index;
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002388}
2389
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002390bool soinfo::is_gnu_hash() const {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002391 return (flags_ & FLAG_GNU_HASH) != 0;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002392}
2393
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002394bool soinfo::can_unload() const {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002395 return (get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0;
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002396}
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002397
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002398bool soinfo::is_linked() const {
2399 return (flags_ & FLAG_LINKED) != 0;
2400}
2401
2402bool soinfo::is_main_executable() const {
2403 return (flags_ & FLAG_EXE) != 0;
2404}
2405
2406void soinfo::set_linked() {
2407 flags_ |= FLAG_LINKED;
2408}
2409
2410void soinfo::set_linker_flag() {
2411 flags_ |= FLAG_LINKER;
2412}
2413
2414void soinfo::set_main_executable() {
2415 flags_ |= FLAG_EXE;
2416}
2417
2418void soinfo::increment_ref_count() {
2419 local_group_root_->ref_count_++;
2420}
2421
2422size_t soinfo::decrement_ref_count() {
2423 return --local_group_root_->ref_count_;
2424}
2425
2426soinfo* soinfo::get_local_group_root() const {
2427 return local_group_root_;
2428}
2429
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -07002430// This function returns api-level at the time of
2431// dlopen/load. Note that libraries opened by system
2432// will always have 'current' api level.
2433uint32_t soinfo::get_target_sdk_version() const {
2434 if (!has_min_version(2)) {
2435 return __ANDROID_API__;
2436 }
2437
2438 return local_group_root_->target_sdk_version_;
2439}
2440
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002441bool soinfo::prelink_image() {
Ningsheng Jiane93be992014-09-16 15:22:10 +08002442 /* Extract dynamic section */
2443 ElfW(Word) dynamic_flags = 0;
2444 phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);
Dmitriy Ivanov498eb182014-09-05 14:57:59 -07002445
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002446 /* We can't log anything until the linker is relocated */
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002447 bool relocating_linker = (flags_ & FLAG_LINKER) != 0;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002448 if (!relocating_linker) {
Dmitriy Ivanov53ba6632015-04-28 18:09:53 -07002449 INFO("[ linking %s ]", get_realpath());
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002450 DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002451 }
2452
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002453 if (dynamic == nullptr) {
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002454 if (!relocating_linker) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002455 DL_ERR("missing PT_DYNAMIC in \"%s\"", get_realpath());
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002456 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002457 return false;
2458 } else {
2459 if (!relocating_linker) {
2460 DEBUG("dynamic = %p", dynamic);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002461 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002462 }
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002463
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002464#if defined(__arm__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002465 (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias,
2466 &ARM_exidx, &ARM_exidx_count);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002467#endif
2468
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002469 // Extract useful information from dynamic section.
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002470 // Note that: "Except for the DT_NULL element at the end of the array,
2471 // and the relative order of DT_NEEDED elements, entries may appear in any order."
2472 //
2473 // source: http://www.sco.com/developers/gabi/1998-04-29/ch5.dynamic.html
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002474 uint32_t needed_count = 0;
2475 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
2476 DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p",
2477 d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
2478 switch (d->d_tag) {
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002479 case DT_SONAME:
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002480 // this is parsed after we have strtab initialized (see below).
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002481 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002482
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002483 case DT_HASH:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002484 nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
2485 nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
2486 bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
2487 chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002488 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002489
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002490 case DT_GNU_HASH:
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07002491 gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002492 // skip symndx
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002493 gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
2494 gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002495
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002496 gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07002497 gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002498 // amend chain for symndx = header[1]
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002499 gnu_chain_ = gnu_bucket_ + gnu_nbucket_ -
2500 reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002501
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002502 if (!powerof2(gnu_maskwords_)) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002503 DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two",
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002504 gnu_maskwords_, get_realpath());
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002505 return false;
2506 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002507 --gnu_maskwords_;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002508
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002509 flags_ |= FLAG_GNU_HASH;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002510 break;
2511
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002512 case DT_STRTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002513 strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002514 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002515
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002516 case DT_STRSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002517 strtab_size_ = d->d_un.d_val;
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002518 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002519
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002520 case DT_SYMTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002521 symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002522 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002523
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002524 case DT_SYMENT:
2525 if (d->d_un.d_val != sizeof(ElfW(Sym))) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002526 DL_ERR("invalid DT_SYMENT: %zd in \"%s\"",
2527 static_cast<size_t>(d->d_un.d_val), get_realpath());
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002528 return false;
2529 }
2530 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002531
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002532 case DT_PLTREL:
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002533#if defined(USE_RELA)
2534 if (d->d_un.d_val != DT_RELA) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002535 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_RELA", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002536 return false;
2537 }
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002538#else
2539 if (d->d_un.d_val != DT_REL) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002540 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_REL", get_realpath());
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002541 return false;
2542 }
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002543#endif
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002544 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002545
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002546 case DT_JMPREL:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002547#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002548 plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002549#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002550 plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002551#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002552 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002553
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002554 case DT_PLTRELSZ:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002555#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002556 plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002557#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002558 plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002559#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002560 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002561
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002562 case DT_PLTGOT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002563#if defined(__mips__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002564 // Used by mips and mips64.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002565 plt_got_ = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002566#endif
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002567 // Ignore for other platforms... (because RTLD_LAZY is not supported)
2568 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002569
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002570 case DT_DEBUG:
2571 // Set the DT_DEBUG entry to the address of _r_debug for GDB
2572 // if the dynamic table is writable
Chris Dearman99186652014-02-06 20:36:51 -08002573// FIXME: not working currently for N64
2574// The flags for the LOAD and DYNAMIC program headers do not agree.
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002575// The LOAD section containing the dynamic table has been mapped as
Chris Dearman99186652014-02-06 20:36:51 -08002576// read-only, but the DYNAMIC header claims it is writable.
2577#if !(defined(__mips__) && defined(__LP64__))
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002578 if ((dynamic_flags & PF_W) != 0) {
2579 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
2580 }
Chris Dearman99186652014-02-06 20:36:51 -08002581#endif
Dmitriy Ivanovc6292ea2015-02-13 16:29:50 -08002582 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002583#if defined(USE_RELA)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002584 case DT_RELA:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002585 rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002586 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002587
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002588 case DT_RELASZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002589 rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002590 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002591
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002592 case DT_ANDROID_RELA:
2593 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
2594 break;
2595
2596 case DT_ANDROID_RELASZ:
2597 android_relocs_size_ = d->d_un.d_val;
2598 break;
2599
2600 case DT_ANDROID_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002601 DL_ERR("unsupported DT_ANDROID_REL in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002602 return false;
2603
2604 case DT_ANDROID_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002605 DL_ERR("unsupported DT_ANDROID_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002606 return false;
2607
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002608 case DT_RELAENT:
2609 if (d->d_un.d_val != sizeof(ElfW(Rela))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07002610 DL_ERR("invalid DT_RELAENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002611 return false;
2612 }
2613 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002614
2615 // ignored (see DT_RELCOUNT comments for details)
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002616 case DT_RELACOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002617 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002618
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002619 case DT_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002620 DL_ERR("unsupported DT_REL in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002621 return false;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002622
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002623 case DT_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002624 DL_ERR("unsupported DT_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002625 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002626
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002627#else
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002628 case DT_REL:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002629 rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002630 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002631
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002632 case DT_RELSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002633 rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002634 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002635
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002636 case DT_RELENT:
2637 if (d->d_un.d_val != sizeof(ElfW(Rel))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07002638 DL_ERR("invalid DT_RELENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002639 return false;
2640 }
2641 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002642
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002643 case DT_ANDROID_REL:
2644 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
2645 break;
2646
2647 case DT_ANDROID_RELSZ:
2648 android_relocs_size_ = d->d_un.d_val;
2649 break;
2650
2651 case DT_ANDROID_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002652 DL_ERR("unsupported DT_ANDROID_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002653 return false;
2654
2655 case DT_ANDROID_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002656 DL_ERR("unsupported DT_ANDROID_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002657 return false;
2658
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002659 // "Indicates that all RELATIVE relocations have been concatenated together,
2660 // and specifies the RELATIVE relocation count."
2661 //
2662 // TODO: Spec also mentions that this can be used to optimize relocation process;
2663 // Not currently used by bionic linker - ignored.
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002664 case DT_RELCOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002665 break;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002666
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002667 case DT_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002668 DL_ERR("unsupported DT_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002669 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002670
2671 case DT_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002672 DL_ERR("unsupported DT_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002673 return false;
2674
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002675#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002676 case DT_INIT:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002677 init_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002678 DEBUG("%s constructors (DT_INIT) found at %p", get_realpath(), init_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002679 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002680
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002681 case DT_FINI:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002682 fini_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002683 DEBUG("%s destructors (DT_FINI) found at %p", get_realpath(), fini_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002684 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002685
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002686 case DT_INIT_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002687 init_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002688 DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", get_realpath(), init_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002689 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002690
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002691 case DT_INIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08002692 init_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002693 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002694
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002695 case DT_FINI_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002696 fini_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002697 DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", get_realpath(), fini_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002698 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002699
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002700 case DT_FINI_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08002701 fini_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002702 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002703
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002704 case DT_PREINIT_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002705 preinit_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002706 DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", get_realpath(), preinit_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002707 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002708
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002709 case DT_PREINIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08002710 preinit_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002711 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002712
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002713 case DT_TEXTREL:
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002714#if defined(__LP64__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002715 DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002716 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002717#else
2718 has_text_relocations = true;
2719 break;
2720#endif
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002721
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002722 case DT_SYMBOLIC:
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07002723 has_DT_SYMBOLIC = true;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002724 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002725
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002726 case DT_NEEDED:
2727 ++needed_count;
2728 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002729
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002730 case DT_FLAGS:
2731 if (d->d_un.d_val & DF_TEXTREL) {
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002732#if defined(__LP64__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002733 DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002734 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002735#else
2736 has_text_relocations = true;
2737#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002738 }
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07002739 if (d->d_un.d_val & DF_SYMBOLIC) {
2740 has_DT_SYMBOLIC = true;
2741 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002742 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002743
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002744 case DT_FLAGS_1:
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002745 set_dt_flags_1(d->d_un.d_val);
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002746
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002747 if ((d->d_un.d_val & ~SUPPORTED_DT_FLAGS_1) != 0) {
Dmitriy Ivanovca10ac62015-05-28 11:44:31 -07002748 DL_WARN("%s: unsupported flags DT_FLAGS_1=%p", get_realpath(), reinterpret_cast<void*>(d->d_un.d_val));
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002749 }
2750 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002751#if defined(__mips__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002752 case DT_MIPS_RLD_MAP:
2753 // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB.
2754 {
2755 r_debug** dp = reinterpret_cast<r_debug**>(load_bias + d->d_un.d_ptr);
2756 *dp = &_r_debug;
2757 }
2758 break;
Raghu Gandham68815722014-12-18 19:12:19 -08002759 case DT_MIPS_RLD_MAP2:
2760 // Set the DT_MIPS_RLD_MAP2 entry to the address of _r_debug for GDB.
2761 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002762 r_debug** dp = reinterpret_cast<r_debug**>(
2763 reinterpret_cast<ElfW(Addr)>(d) + d->d_un.d_val);
Raghu Gandham68815722014-12-18 19:12:19 -08002764 *dp = &_r_debug;
2765 }
2766 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002767
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002768 case DT_MIPS_RLD_VERSION:
2769 case DT_MIPS_FLAGS:
2770 case DT_MIPS_BASE_ADDRESS:
2771 case DT_MIPS_UNREFEXTNO:
2772 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002773
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002774 case DT_MIPS_SYMTABNO:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002775 mips_symtabno_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002776 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002777
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002778 case DT_MIPS_LOCAL_GOTNO:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002779 mips_local_gotno_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002780 break;
2781
2782 case DT_MIPS_GOTSYM:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002783 mips_gotsym_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002784 break;
2785#endif
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002786 // Ignored: "Its use has been superseded by the DF_BIND_NOW flag"
2787 case DT_BIND_NOW:
2788 break;
2789
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002790 case DT_VERSYM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002791 versym_ = reinterpret_cast<ElfW(Versym)*>(load_bias + d->d_un.d_ptr);
2792 break;
2793
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002794 case DT_VERDEF:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002795 verdef_ptr_ = load_bias + d->d_un.d_ptr;
2796 break;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002797 case DT_VERDEFNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002798 verdef_cnt_ = d->d_un.d_val;
2799 break;
2800
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03002801 case DT_VERNEED:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002802 verneed_ptr_ = load_bias + d->d_un.d_ptr;
2803 break;
2804
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03002805 case DT_VERNEEDNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002806 verneed_cnt_ = d->d_un.d_val;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002807 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002808
2809 default:
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07002810 if (!relocating_linker) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002811 DL_WARN("%s: unused DT entry: type %p arg %p", get_realpath(),
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07002812 reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
2813 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002814 break;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002815 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002816 }
2817
2818 DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p",
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002819 reinterpret_cast<void*>(base), strtab_, symtab_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002820
2821 // Sanity checks.
2822 if (relocating_linker && needed_count != 0) {
2823 DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
2824 return false;
2825 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07002826 if (nbucket_ == 0 && gnu_nbucket_ == 0) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002827 DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" "
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002828 "(new hash type from the future?)", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002829 return false;
2830 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002831 if (strtab_ == 0) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002832 DL_ERR("empty/missing DT_STRTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002833 return false;
2834 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002835 if (symtab_ == 0) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002836 DL_ERR("empty/missing DT_SYMTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002837 return false;
2838 }
Dmitriy Ivanov38c37d62015-06-02 13:28:06 -07002839
Dmitriy Ivanov07f4f5f2015-06-08 10:41:33 -07002840 // second pass - parse entries relying on strtab
2841 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
2842 if (d->d_tag == DT_SONAME) {
2843 soname_ = get_string(d->d_un.d_val);
2844#if defined(__work_around_b_19059885__)
2845 strlcpy(old_name_, soname_, sizeof(old_name_));
2846#endif
2847 break;
2848 }
2849 }
2850
Dmitriy Ivanov38c37d62015-06-02 13:28:06 -07002851 // Before M release linker was using basename in place of soname.
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -07002852 // In the case when dt_soname is absent some apps stop working
Dmitriy Ivanov38c37d62015-06-02 13:28:06 -07002853 // because they can't find dt_needed library by soname.
2854 // This workaround should keep them working. (applies only
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -07002855 // for apps targeting sdk version <=22). Make an exception for
2856 // the main executable and linker; they do not need to have dt_soname
2857 if (soname_ == nullptr && this != somain && (flags_ & FLAG_LINKER) == 0 &&
2858 get_application_target_sdk_version() <= 22) {
Dmitriy Ivanov38c37d62015-06-02 13:28:06 -07002859 soname_ = basename(realpath_.c_str());
2860 DL_WARN("%s: is missing DT_SONAME will use basename as a replacement: \"%s\"",
2861 get_realpath(), soname_);
2862 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002863 return true;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002864}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002865
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002866bool soinfo::link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group,
2867 const android_dlextinfo* extinfo) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002868
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002869 local_group_root_ = local_group.front();
2870 if (local_group_root_ == nullptr) {
2871 local_group_root_ = this;
2872 }
2873
Dmitriy Ivanov04f7e3e2015-06-02 17:36:54 -07002874 if ((flags_ & FLAG_LINKER) == 0 && local_group_root_ == this) {
2875 target_sdk_version_ = get_application_target_sdk_version();
2876 }
2877
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002878 VersionTracker version_tracker;
2879
2880 if (!version_tracker.init(this)) {
2881 return false;
2882 }
2883
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002884#if !defined(__LP64__)
2885 if (has_text_relocations) {
Dmitriy Ivanov3e6f7802015-06-12 15:00:31 -07002886 // Fail if app is targeting sdk version > 22
2887 // TODO (dimitry): remove != __ANDROID_API__ check once http://b/20020312 is fixed
2888 if (get_application_target_sdk_version() != __ANDROID_API__
2889 && get_application_target_sdk_version() > 22) {
2890 DL_ERR("%s: has text relocations", get_realpath());
2891 return false;
2892 }
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002893 // Make segments writable to allow text relocations to work properly. We will later call
2894 // phdr_table_protect_segments() after all of them are applied and all constructors are run.
2895 DL_WARN("%s has text relocations. This is wasting memory and prevents "
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002896 "security hardening. Please fix.", get_realpath());
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002897 if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) {
2898 DL_ERR("can't unprotect loadable segments for \"%s\": %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002899 get_realpath(), strerror(errno));
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002900 return false;
2901 }
2902 }
2903#endif
2904
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002905 if (android_relocs_ != nullptr) {
2906 // check signature
2907 if (android_relocs_size_ > 3 &&
2908 android_relocs_[0] == 'A' &&
2909 android_relocs_[1] == 'P' &&
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07002910 android_relocs_[2] == 'S' &&
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002911 android_relocs_[3] == '2') {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002912 DEBUG("[ android relocating %s ]", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002913
2914 bool relocated = false;
2915 const uint8_t* packed_relocs = android_relocs_ + 4;
2916 const size_t packed_relocs_size = android_relocs_size_ - 4;
2917
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07002918 relocated = relocate(
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002919 version_tracker,
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07002920 packed_reloc_iterator<sleb128_decoder>(
2921 sleb128_decoder(packed_relocs, packed_relocs_size)),
2922 global_group, local_group);
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002923
2924 if (!relocated) {
2925 return false;
2926 }
2927 } else {
2928 DL_ERR("bad android relocation header.");
2929 return false;
2930 }
2931 }
2932
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002933#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002934 if (rela_ != nullptr) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002935 DEBUG("[ relocating %s ]", get_realpath());
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002936 if (!relocate(version_tracker,
2937 plain_reloc_iterator(rela_, rela_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002938 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002939 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002940 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002941 if (plt_rela_ != nullptr) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002942 DEBUG("[ relocating %s plt ]", get_realpath());
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002943 if (!relocate(version_tracker,
2944 plain_reloc_iterator(plt_rela_, plt_rela_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002945 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002946 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002947 }
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002948#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002949 if (rel_ != nullptr) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002950 DEBUG("[ relocating %s ]", get_realpath());
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002951 if (!relocate(version_tracker,
2952 plain_reloc_iterator(rel_, rel_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002953 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002954 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002955 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002956 if (plt_rel_ != nullptr) {
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002957 DEBUG("[ relocating %s plt ]", get_realpath());
Dmitriy Ivanovf92a4172015-04-30 19:49:19 -07002958 if (!relocate(version_tracker,
2959 plain_reloc_iterator(plt_rel_, plt_rel_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002960 return false;
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002961 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002962 }
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002963#endif
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002964
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002965#if defined(__mips__)
Dmitriy Ivanovdc145b52015-04-30 20:17:03 -07002966 if (!mips_relocate_got(version_tracker, global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002967 return false;
2968 }
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002969#endif
2970
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002971 DEBUG("[ finished linking %s ]", get_realpath());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002972
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002973#if !defined(__LP64__)
2974 if (has_text_relocations) {
2975 // All relocations are done, we can protect our segments back to read-only.
2976 if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) {
2977 DL_ERR("can't protect segments for \"%s\": %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002978 get_realpath(), strerror(errno));
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00002979 return false;
2980 }
2981 }
2982#endif
2983
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002984 /* We can also turn on GNU RELRO protection */
2985 if (phdr_table_protect_gnu_relro(phdr, phnum, load_bias) < 0) {
2986 DL_ERR("can't enable GNU RELRO protection for \"%s\": %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002987 get_realpath(), strerror(errno));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002988 return false;
2989 }
Nick Kralevich9ec0f032012-02-28 10:40:00 -08002990
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002991 /* Handle serializing/sharing the RELRO segment */
2992 if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
2993 if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias,
2994 extinfo->relro_fd) < 0) {
2995 DL_ERR("failed serializing GNU RELRO section for \"%s\": %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07002996 get_realpath(), strerror(errno));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002997 return false;
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002998 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002999 } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
3000 if (phdr_table_map_gnu_relro(phdr, phnum, load_bias,
3001 extinfo->relro_fd) < 0) {
3002 DL_ERR("failed mapping GNU RELRO section for \"%s\": %s",
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07003003 get_realpath(), strerror(errno));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003004 return false;
3005 }
3006 }
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00003007
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003008 notify_gdb_of_load(this);
3009 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003010}
3011
Nick Kralevich468319c2011-11-11 15:53:17 -08003012/*
Sergey Melnikovc45087b2013-01-25 16:40:13 +04003013 * This function add vdso to internal dso list.
3014 * It helps to stack unwinding through signal handlers.
3015 * Also, it makes bionic more like glibc.
3016 */
Kito Cheng812fd422014-03-25 22:53:56 +08003017static void add_vdso(KernelArgumentBlock& args __unused) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003018#if defined(AT_SYSINFO_EHDR)
Elliott Hughes0266ae52014-02-10 17:46:57 -08003019 ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR));
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07003020 if (ehdr_vdso == nullptr) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08003021 return;
3022 }
Sergey Melnikovc45087b2013-01-25 16:40:13 +04003023
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07003024 soinfo* si = soinfo_alloc("[vdso]", nullptr, 0, 0);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04003025
Elliott Hughes0266ae52014-02-10 17:46:57 -08003026 si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff);
3027 si->phnum = ehdr_vdso->e_phnum;
3028 si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso);
3029 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003030 si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04003031
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003032 si->prelink_image();
3033 si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr);
Sergey Melnikovc45087b2013-01-25 16:40:13 +04003034#endif
3035}
3036
3037/*
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003038 * This is linker soinfo for GDB. See details below.
3039 */
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003040#if defined(__LP64__)
3041#define LINKER_PATH "/system/bin/linker64"
3042#else
3043#define LINKER_PATH "/system/bin/linker"
3044#endif
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003045
3046// This is done to avoid calling c-tor prematurely
3047// because soinfo c-tor needs memory allocator
3048// which might be initialized after global variables.
3049static uint8_t linker_soinfo_for_gdb_buf[sizeof(soinfo)] __attribute__((aligned(8)));
3050static soinfo* linker_soinfo_for_gdb = nullptr;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003051
3052/* gdb expects the linker to be in the debug shared object list.
3053 * Without this, gdb has trouble locating the linker's ".text"
3054 * and ".plt" sections. Gdb could also potentially use this to
3055 * relocate the offset of our exported 'rtld_db_dlactivity' symbol.
3056 * Don't use soinfo_alloc(), because the linker shouldn't
3057 * be on the soinfo list.
3058 */
3059static void init_linker_info_for_gdb(ElfW(Addr) linker_base) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003060 linker_soinfo_for_gdb = new (linker_soinfo_for_gdb_buf) soinfo(LINKER_PATH, nullptr, 0, 0);
3061
Dmitriy Ivanov38263dd2015-06-10 19:46:19 -07003062 linker_soinfo_for_gdb->load_bias = linker_base;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003063
3064 /*
3065 * Set the dynamic field in the link map otherwise gdb will complain with
3066 * the following:
3067 * warning: .dynamic section for "/system/bin/linker" is not at the
3068 * expected address (wrong library or version mismatch?)
3069 */
3070 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base);
3071 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff);
3072 phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003073 &linker_soinfo_for_gdb->dynamic, nullptr);
3074 insert_soinfo_into_debug_map(linker_soinfo_for_gdb);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003075}
3076
Dmitriy Ivanov0b9e1c62015-04-28 15:49:26 -07003077extern "C" int __system_properties_init(void);
3078
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003079/*
Nick Kralevich468319c2011-11-11 15:53:17 -08003080 * This code is called after the linker has linked itself and
3081 * fixed it's own GOT. It is safe to make references to externs
3082 * and other non-local data at this point.
3083 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08003084static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW(Addr) linker_base) {
Evgeniy Stepanov1a78fbb2012-03-22 18:01:53 +04003085#if TIMING
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003086 struct timeval t0, t1;
3087 gettimeofday(&t0, 0);
Evgeniy Stepanov1a78fbb2012-03-22 18:01:53 +04003088#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003089
Elliott Hughes66c3b2d2015-06-08 18:04:00 -07003090 // Sanitize the environment.
3091 __libc_init_AT_SECURE(args);
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01003092
Dmitriy Ivanov0b9e1c62015-04-28 15:49:26 -07003093 // Initialize system properties
3094 __system_properties_init(); // may use 'environ'
3095
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003096 debuggerd_init();
3097
3098 // Get a few environment variables.
Elliott Hughes66c3b2d2015-06-08 18:04:00 -07003099 const char* LD_DEBUG = getenv("LD_DEBUG");
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003100 if (LD_DEBUG != nullptr) {
3101 g_ld_debug_verbosity = atoi(LD_DEBUG);
3102 }
3103
Elliott Hughes66c3b2d2015-06-08 18:04:00 -07003104 // These should have been sanitized by __libc_init_AT_SECURE, but the test
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003105 // doesn't cost us anything.
3106 const char* ldpath_env = nullptr;
3107 const char* ldpreload_env = nullptr;
Elliott Hughes66c3b2d2015-06-08 18:04:00 -07003108 if (!getauxval(AT_SECURE)) {
3109 ldpath_env = getenv("LD_LIBRARY_PATH");
3110 ldpreload_env = getenv("LD_PRELOAD");
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003111 }
3112
3113 INFO("[ android linker & debugger ]");
3114
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07003115 soinfo* si = soinfo_alloc(args.argv[0], nullptr, 0, RTLD_GLOBAL);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003116 if (si == nullptr) {
3117 exit(EXIT_FAILURE);
3118 }
3119
3120 /* bootstrap the link map, the main exe always needs to be first */
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003121 si->set_main_executable();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003122 link_map* map = &(si->link_map_head);
3123
3124 map->l_addr = 0;
3125 map->l_name = args.argv[0];
3126 map->l_prev = nullptr;
3127 map->l_next = nullptr;
3128
3129 _r_debug.r_map = map;
3130 r_debug_tail = map;
3131
3132 init_linker_info_for_gdb(linker_base);
3133
3134 // Extract information passed from the kernel.
3135 si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
3136 si->phnum = args.getauxval(AT_PHNUM);
3137 si->entry = args.getauxval(AT_ENTRY);
3138
3139 /* Compute the value of si->base. We can't rely on the fact that
3140 * the first entry is the PHDR because this will not be true
3141 * for certain executables (e.g. some in the NDK unit test suite)
3142 */
3143 si->base = 0;
3144 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
3145 si->load_bias = 0;
3146 for (size_t i = 0; i < si->phnum; ++i) {
3147 if (si->phdr[i].p_type == PT_PHDR) {
3148 si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
3149 si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
3150 break;
Nick Kralevich8d3e91d2013-04-25 13:15:24 -07003151 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003152 }
3153 si->dynamic = nullptr;
Nick Kralevich8d3e91d2013-04-25 13:15:24 -07003154
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003155 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);
3156 if (elf_hdr->e_type != ET_DYN) {
3157 __libc_format_fd(2, "error: only position independent executables (PIE) are supported.\n");
3158 exit(EXIT_FAILURE);
3159 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003160
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003161 // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
3162 parse_LD_LIBRARY_PATH(ldpath_env);
3163 parse_LD_PRELOAD(ldpreload_env);
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01003164
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003165 somain = si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003166
Dmitriy Ivanov67181252015-01-07 15:48:25 -08003167 if (!si->prelink_image()) {
3168 __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
3169 exit(EXIT_FAILURE);
3170 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003171
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003172 // add somain to global group
3173 si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
3174
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003175 // Load ld_preloads and dependencies.
3176 StringLinkedList needed_library_name_list;
3177 size_t needed_libraries_count = 0;
3178 size_t ld_preloads_count = 0;
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07003179
3180 for (const auto& ld_preload_name : g_ld_preload_names) {
3181 needed_library_name_list.push_back(ld_preload_name.c_str());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003182 ++needed_libraries_count;
Dmitriy Ivanov53ba6632015-04-28 18:09:53 -07003183 ++ld_preloads_count;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003184 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003185
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003186 for_each_dt_needed(si, [&](const char* name) {
3187 needed_library_name_list.push_back(name);
3188 ++needed_libraries_count;
3189 });
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003190
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003191 const char* needed_library_names[needed_libraries_count];
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003192
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003193 memset(needed_library_names, 0, sizeof(needed_library_names));
3194 needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003195
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07003196 if (needed_libraries_count > 0 &&
3197 !find_libraries(si, needed_library_names, needed_libraries_count, nullptr,
3198 &g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003199 __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
3200 exit(EXIT_FAILURE);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003201 } else if (needed_libraries_count == 0) {
3202 if (!si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr)) {
3203 __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
3204 exit(EXIT_FAILURE);
3205 }
3206 si->increment_ref_count();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003207 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003208
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003209 add_vdso(args);
Nick Kralevich2aebf542014-05-07 10:32:39 -07003210
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08003211 {
3212 ProtectedDataGuard guard;
Matt Fischer4fd42c12009-12-31 12:09:10 -06003213
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08003214 si->call_pre_init_constructors();
3215
3216 /* After the prelink_image, the si->load_bias is initialized.
3217 * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
3218 * We need to update this value for so exe here. So Unwind_Backtrace
3219 * for some arch like x86 could work correctly within so exe.
3220 */
3221 map->l_addr = si->load_bias;
3222 si->call_constructors();
3223 }
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04003224
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003225#if TIMING
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003226 gettimeofday(&t1, nullptr);
3227 PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) (
3228 (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
3229 (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003230#endif
3231#if STATS
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003232 PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0],
3233 linker_stats.count[kRelocAbsolute],
3234 linker_stats.count[kRelocRelative],
3235 linker_stats.count[kRelocCopy],
3236 linker_stats.count[kRelocSymbol]);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003237#endif
3238#if COUNT_PAGES
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003239 {
3240 unsigned n;
3241 unsigned i;
3242 unsigned count = 0;
3243 for (n = 0; n < 4096; n++) {
3244 if (bitmask[n]) {
3245 unsigned x = bitmask[n];
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003246#if defined(__LP64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003247 for (i = 0; i < 32; i++) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003248#else
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003249 for (i = 0; i < 8; i++) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003250#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003251 if (x & 1) {
3252 count++;
3253 }
3254 x >>= 1;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003255 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003256 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003257 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003258 PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4);
3259 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003260#endif
3261
3262#if TIMING || STATS || COUNT_PAGES
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003263 fflush(stdout);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003264#endif
3265
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07003266 TRACE("[ Ready to execute '%s' @ %p ]", si->get_realpath(), reinterpret_cast<void*>(si->entry));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003267 return si->entry;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003268}
Nick Kralevich468319c2011-11-11 15:53:17 -08003269
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02003270/* Compute the load-bias of an existing executable. This shall only
3271 * be used to compute the load bias of an executable or shared library
3272 * that was loaded by the kernel itself.
3273 *
3274 * Input:
3275 * elf -> address of ELF header, assumed to be at the start of the file.
3276 * Return:
3277 * load bias, i.e. add the value of any p_vaddr in the file to get
3278 * the corresponding address in memory.
3279 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08003280static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) {
3281 ElfW(Addr) offset = elf->e_phoff;
Dmitriy Ivanovb3c01d02015-05-07 10:48:00 -07003282 const ElfW(Phdr)* phdr_table =
3283 reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003284 const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02003285
Elliott Hughes0266ae52014-02-10 17:46:57 -08003286 for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08003287 if (phdr->p_type == PT_LOAD) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08003288 return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02003289 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08003290 }
3291 return 0;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02003292}
3293
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07003294extern "C" void _start();
3295
Nick Kralevich468319c2011-11-11 15:53:17 -08003296/*
3297 * This is the entry point for the linker, called from begin.S. This
3298 * method is responsible for fixing the linker's own relocations, and
3299 * then calling __linker_init_post_relocation().
3300 *
3301 * Because this method is called before the linker has fixed it's own
3302 * relocations, any attempt to reference an extern variable, extern
3303 * function, or other GOT reference will generate a segfault.
3304 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08003305extern "C" ElfW(Addr) __linker_init(void* raw_args) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003306 KernelArgumentBlock args(raw_args);
Nick Kralevich468319c2011-11-11 15:53:17 -08003307
Elliott Hughes0266ae52014-02-10 17:46:57 -08003308 ElfW(Addr) linker_addr = args.getauxval(AT_BASE);
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07003309 ElfW(Addr) entry_point = args.getauxval(AT_ENTRY);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003310 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08003311 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);
Nick Kralevich468319c2011-11-11 15:53:17 -08003312
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003313 soinfo linker_so(nullptr, nullptr, 0, 0);
Nick Kralevich468319c2011-11-11 15:53:17 -08003314
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07003315 // If the linker is not acting as PT_INTERP entry_point is equal to
3316 // _start. Which means that the linker is running as an executable and
3317 // already linked by PT_INTERP.
3318 //
3319 // This happens when user tries to run 'adb shell /system/bin/linker'
3320 // see also https://code.google.com/p/android/issues/detail?id=63174
3321 if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point) {
3322 __libc_fatal("This is %s, the helper program for shared library executables.\n", args.argv[0]);
3323 }
3324
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003325 linker_so.base = linker_addr;
3326 linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
3327 linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07003328 linker_so.dynamic = nullptr;
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003329 linker_so.phdr = phdr;
3330 linker_so.phnum = elf_hdr->e_phnum;
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003331 linker_so.set_linker_flag();
Elliott Hughes5419b942012-10-16 15:54:46 -07003332
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003333 // This might not be obvious... The reasons why we pass g_empty_list
3334 // in place of local_group here are (1) we do not really need it, because
3335 // linker is built with DT_SYMBOLIC and therefore relocates its symbols against
3336 // itself without having to look into local_group and (2) allocators
3337 // are not yet initialized, and therefore we cannot use linked_list.push_*
3338 // functions at this point.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003339 if (!(linker_so.prelink_image() && linker_so.link_image(g_empty_list, g_empty_list, nullptr))) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003340 // It would be nice to print an error message, but if the linker
3341 // can't link itself, there's no guarantee that we'll be able to
Elliott Hughesb93702a2013-12-21 16:07:45 -08003342 // call write() (because it involves a GOT reference). We may as
3343 // well try though...
3344 const char* msg = "CANNOT LINK EXECUTABLE: ";
3345 write(2, msg, strlen(msg));
3346 write(2, __linker_dl_err_buf, strlen(__linker_dl_err_buf));
3347 write(2, "\n", 1);
3348 _exit(EXIT_FAILURE);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003349 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07003350
Dmitriy Ivanov14241402014-08-26 14:16:52 -07003351 __libc_init_tls(args);
3352
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07003353 // Initialize the linker's own global variables
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003354 linker_so.call_constructors();
Dmitriy Ivanov4151ea72014-07-24 15:33:25 -07003355
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003356 // Initialize static variables. Note that in order to
3357 // get correct libdl_info we need to call constructors
3358 // before get_libdl_info().
3359 solist = get_libdl_info();
3360 sonext = get_libdl_info();
3361
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003362 // We have successfully fixed our own relocations. It's safe to run
3363 // the main part of the linker now.
Elliott Hughes1728b232014-05-14 10:02:03 -07003364 args.abort_message_ptr = &g_abort_message;
Elliott Hughes0266ae52014-02-10 17:46:57 -08003365 ElfW(Addr) start_address = __linker_init_post_relocation(args, linker_addr);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003366
Elliott Hughes611f9562015-01-23 10:43:58 -08003367 INFO("[ jumping to _start ]");
3368
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08003369 // Return the address that the calling assembly stub should jump to.
3370 return start_address;
Nick Kralevich468319c2011-11-11 15:53:17 -08003371}