blob: 1befaa6a94cfad6bd740c5477e2e067f27934635 [file] [log] [blame]
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001/*
Doug Kwan94304352009-10-23 18:11:40 -07002 * Copyright (C) 2008, 2009 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
Elliott Hughes46882792012-08-03 16:49:39 -070029#include <dlfcn.h>
30#include <errno.h>
31#include <fcntl.h>
Elliott Hughes0266ae52014-02-10 17:46:57 -080032#include <inttypes.h>
Elliott Hughes46882792012-08-03 16:49:39 -070033#include <pthread.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080034#include <stdio.h>
35#include <stdlib.h>
36#include <string.h>
Elliott Hughes46882792012-08-03 16:49:39 -070037#include <sys/mman.h>
Elliott Hughes46882792012-08-03 16:49:39 -070038#include <unistd.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080039
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -070040#include <new>
41
Elliott Hughes46882792012-08-03 16:49:39 -070042// Private C library headers.
Elliott Hugheseb847bc2013-10-09 15:50:50 -070043#include "private/bionic_tls.h"
44#include "private/KernelArgumentBlock.h"
45#include "private/ScopedPthreadMutexLocker.h"
Dmitriy Ivanov04dc91a2014-07-01 14:10:16 -070046#include "private/ScopedFd.h"
Dmitriy Ivanovae69a952014-09-05 16:42:53 -070047#include "private/ScopeGuard.h"
48#include "private/UniquePtr.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080049
50#include "linker.h"
51#include "linker_debug.h"
David 'Digit' Turnerbe575592010-12-16 19:52:02 +010052#include "linker_environ.h"
David 'Digit' Turner23363ed2012-06-18 18:13:49 +020053#include "linker_phdr.h"
Dmitriy Ivanovd597d262014-05-05 16:49:04 -070054#include "linker_allocator.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080055
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080056/* >>> IMPORTANT NOTE - READ ME BEFORE MODIFYING <<<
57 *
58 * Do NOT use malloc() and friends or pthread_*() code here.
59 * Don't use printf() either; it's caused mysterious memory
60 * corruption in the past.
61 * The linker runs before we bring up libc and it's easiest
62 * to make sure it does not depend on any complex libc features
63 *
64 * open issues / todo:
65 *
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080066 * - cleaner error reporting
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080067 * - after linking, set as much stuff as possible to READONLY
68 * and NOEXEC
Elliott Hughes46882792012-08-03 16:49:39 -070069 */
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080070
Dmitriy Ivanov489e4982014-05-19 15:19:52 -070071#if defined(__LP64__)
72#define SEARCH_NAME(x) x
73#else
74// Nvidia drivers are relying on the bug:
75// http://code.google.com/p/android/issues/detail?id=6670
76// so we continue to use base-name lookup for lp32
77static const char* get_base_name(const char* name) {
78 const char* bname = strrchr(name, '/');
79 return bname ? bname + 1 : name;
80}
81#define SEARCH_NAME(x) get_base_name(x)
82#endif
83
Elliott Hughes0266ae52014-02-10 17:46:57 -080084static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080085
Elliott Hughes1728b232014-05-14 10:02:03 -070086static LinkerAllocator<soinfo> g_soinfo_allocator;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -070087static LinkerAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
Magnus Malmbornba98d922012-09-12 13:00:55 +020088
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -070089static soinfo* solist;
90static soinfo* sonext;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -080091static soinfo* somain; /* main process, always the one after libdl_info */
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080092
Elliott Hughes1728b232014-05-14 10:02:03 -070093static const char* const kDefaultLdPaths[] = {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -070094#if defined(__LP64__)
Elliott Hughes011bc0b2013-10-08 14:27:10 -070095 "/vendor/lib64",
96 "/system/lib64",
97#else
Elliott Hughes124fae92012-10-31 14:20:03 -070098 "/vendor/lib",
99 "/system/lib",
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700100#endif
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700101 nullptr
Elliott Hughes124fae92012-10-31 14:20:03 -0700102};
David Bartleybc3a5c22009-06-02 18:27:28 -0700103
Elliott Hughesa4aafd12014-01-13 16:37:47 -0800104#define LDPATH_BUFSIZE (LDPATH_MAX*64)
105#define LDPATH_MAX 8
106
107#define LDPRELOAD_BUFSIZE (LDPRELOAD_MAX*64)
108#define LDPRELOAD_MAX 8
109
Elliott Hughes1728b232014-05-14 10:02:03 -0700110static char g_ld_library_paths_buffer[LDPATH_BUFSIZE];
111static const char* g_ld_library_paths[LDPATH_MAX + 1];
Elliott Hughes124fae92012-10-31 14:20:03 -0700112
Elliott Hughes1728b232014-05-14 10:02:03 -0700113static char g_ld_preloads_buffer[LDPRELOAD_BUFSIZE];
114static const char* g_ld_preload_names[LDPRELOAD_MAX + 1];
Matt Fischer4fd42c12009-12-31 12:09:10 -0600115
Elliott Hughes1728b232014-05-14 10:02:03 -0700116static soinfo* g_ld_preloads[LDPRELOAD_MAX + 1];
Matt Fischer4fd42c12009-12-31 12:09:10 -0600117
Elliott Hughes1728b232014-05-14 10:02:03 -0700118__LIBC_HIDDEN__ int g_ld_debug_verbosity;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800119
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700120__LIBC_HIDDEN__ abort_msg_t* g_abort_message = nullptr; // For debuggerd.
Elliott Hughes0d787c12013-04-04 13:46:46 -0700121
Elliott Hughesbedfe382012-08-14 14:07:59 -0700122enum RelocationKind {
123 kRelocAbsolute = 0,
124 kRelocRelative,
125 kRelocCopy,
126 kRelocSymbol,
127 kRelocMax
128};
David 'Digit' Turnerbe575592010-12-16 19:52:02 +0100129
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800130#if STATS
Elliott Hughesbedfe382012-08-14 14:07:59 -0700131struct linker_stats_t {
132 int count[kRelocMax];
133};
134
135static linker_stats_t linker_stats;
136
137static void count_relocation(RelocationKind kind) {
138 ++linker_stats.count[kind];
139}
140#else
141static void count_relocation(RelocationKind) {
142}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800143#endif
144
145#if COUNT_PAGES
Elliott Hughesbedfe382012-08-14 14:07:59 -0700146static unsigned bitmask[4096];
Marcus Oaklande365f9d2013-10-10 15:19:31 +0100147#if defined(__LP64__)
148#define MARK(offset) \
149 do { \
150 if ((((offset) >> 12) >> 5) < 4096) \
151 bitmask[((offset) >> 12) >> 5] |= (1 << (((offset) >> 12) & 31)); \
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800152 } while (0)
Marcus Oaklande365f9d2013-10-10 15:19:31 +0100153#else
Elliott Hughesbedfe382012-08-14 14:07:59 -0700154#define MARK(offset) \
155 do { \
156 bitmask[((offset) >> 12) >> 3] |= (1 << (((offset) >> 12) & 7)); \
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800157 } while (0)
Marcus Oaklande365f9d2013-10-10 15:19:31 +0100158#endif
Elliott Hughesbedfe382012-08-14 14:07:59 -0700159#else
160#define MARK(x) do {} while (0)
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800161#endif
162
Elliott Hughes46882792012-08-03 16:49:39 -0700163// You shouldn't try to call memory-allocating functions in the dynamic linker.
164// Guard against the most obvious ones.
Elliott Hughes8f2a5a02013-03-15 15:30:25 -0700165#define DISALLOW_ALLOCATION(return_type, name, ...) \
166 return_type name __VA_ARGS__ \
167 { \
Dmitriy Ivanov12bf3bc2014-07-01 14:24:45 -0700168 __libc_fatal("ERROR: " #name " called from the dynamic linker!\n"); \
Dima Zavin2e855792009-05-20 18:28:09 -0700169 }
Kito Cheng812fd422014-03-25 22:53:56 +0800170DISALLOW_ALLOCATION(void*, malloc, (size_t u __unused));
171DISALLOW_ALLOCATION(void, free, (void* u __unused));
172DISALLOW_ALLOCATION(void*, realloc, (void* u1 __unused, size_t u2 __unused));
173DISALLOW_ALLOCATION(void*, calloc, (size_t u1 __unused, size_t u2 __unused));
Dima Zavin2e855792009-05-20 18:28:09 -0700174
175static char __linker_dl_err_buf[768];
Dima Zavin2e855792009-05-20 18:28:09 -0700176
Elliott Hughes650be4e2013-03-05 18:47:58 -0800177char* linker_get_error_buffer() {
Elliott Hughes5419b942012-10-16 15:54:46 -0700178 return &__linker_dl_err_buf[0];
Dima Zavin2e855792009-05-20 18:28:09 -0700179}
180
Elliott Hughes650be4e2013-03-05 18:47:58 -0800181size_t linker_get_error_buffer_size() {
182 return sizeof(__linker_dl_err_buf);
183}
184
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800185/*
186 * This function is an empty stub where GDB locates a breakpoint to get notified
187 * about linker activity.
188 */
Elliott Hughes5419b942012-10-16 15:54:46 -0700189extern "C" void __attribute__((noinline)) __attribute__((visibility("default"))) rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800190
Elliott Hughes1728b232014-05-14 10:02:03 -0700191static pthread_mutex_t g__r_debug_mutex = PTHREAD_MUTEX_INITIALIZER;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700192static r_debug _r_debug = {1, nullptr, reinterpret_cast<uintptr_t>(&rtld_db_dlactivity), r_debug::RT_CONSISTENT, 0};
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800193static link_map* r_debug_tail = 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800194
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800195static void insert_soinfo_into_debug_map(soinfo* info) {
Elliott Hughesbedfe382012-08-14 14:07:59 -0700196 // Copy the necessary fields into the debug structure.
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800197 link_map* map = &(info->link_map_head);
Sergey Melnikovebd506c2013-10-31 18:02:12 +0400198 map->l_addr = info->load_bias;
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800199 map->l_name = reinterpret_cast<char*>(info->name);
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800200 map->l_ld = info->dynamic;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800201
202 /* Stick the new library at the end of the list.
203 * gdb tends to care more about libc than it does
204 * about leaf libraries, and ordering it this way
205 * reduces the back-and-forth over the wire.
206 */
207 if (r_debug_tail) {
208 r_debug_tail->l_next = map;
209 map->l_prev = r_debug_tail;
210 map->l_next = 0;
211 } else {
212 _r_debug.r_map = map;
213 map->l_prev = 0;
214 map->l_next = 0;
215 }
216 r_debug_tail = map;
217}
218
Elliott Hughesbedfe382012-08-14 14:07:59 -0700219static void remove_soinfo_from_debug_map(soinfo* info) {
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800220 link_map* map = &(info->link_map_head);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700221
Elliott Hughesbedfe382012-08-14 14:07:59 -0700222 if (r_debug_tail == map) {
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700223 r_debug_tail = map->l_prev;
Elliott Hughesbedfe382012-08-14 14:07:59 -0700224 }
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700225
Elliott Hughesbedfe382012-08-14 14:07:59 -0700226 if (map->l_prev) {
227 map->l_prev->l_next = map->l_next;
228 }
229 if (map->l_next) {
230 map->l_next->l_prev = map->l_prev;
231 }
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700232}
233
Elliott Hughesbedfe382012-08-14 14:07:59 -0700234static void notify_gdb_of_load(soinfo* info) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800235 if (info->flags & FLAG_EXE) {
236 // GDB already knows about the main executable
237 return;
238 }
239
Elliott Hughes1728b232014-05-14 10:02:03 -0700240 ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800241
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800242 _r_debug.r_state = r_debug::RT_ADD;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800243 rtld_db_dlactivity();
244
245 insert_soinfo_into_debug_map(info);
246
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800247 _r_debug.r_state = r_debug::RT_CONSISTENT;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800248 rtld_db_dlactivity();
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700249}
250
Elliott Hughesbedfe382012-08-14 14:07:59 -0700251static void notify_gdb_of_unload(soinfo* info) {
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700252 if (info->flags & FLAG_EXE) {
253 // GDB already knows about the main executable
254 return;
255 }
256
Elliott Hughes1728b232014-05-14 10:02:03 -0700257 ScopedPthreadMutexLocker locker(&g__r_debug_mutex);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700258
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800259 _r_debug.r_state = r_debug::RT_DELETE;
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700260 rtld_db_dlactivity();
261
262 remove_soinfo_from_debug_map(info);
263
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800264 _r_debug.r_state = r_debug::RT_CONSISTENT;
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700265 rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800266}
267
Elliott Hughes18a206c2012-10-29 17:37:13 -0700268void notify_gdb_of_libraries() {
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800269 _r_debug.r_state = r_debug::RT_ADD;
270 rtld_db_dlactivity();
271 _r_debug.r_state = r_debug::RT_CONSISTENT;
272 rtld_db_dlactivity();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800273}
274
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700275LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {
276 return g_soinfo_links_allocator.alloc();
277}
278
279void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {
280 g_soinfo_links_allocator.free(entry);
281}
282
283static void protect_data(int protection) {
284 g_soinfo_allocator.protect_all(protection);
285 g_soinfo_links_allocator.protect_all(protection);
286}
287
288static soinfo* soinfo_alloc(const char* name, struct stat* file_stat) {
Magnus Malmbornba98d922012-09-12 13:00:55 +0200289 if (strlen(name) >= SOINFO_NAME_LEN) {
290 DL_ERR("library name \"%s\" too long", name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700291 return nullptr;
Magnus Malmbornba98d922012-09-12 13:00:55 +0200292 }
293
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -0700294 soinfo* si = new (g_soinfo_allocator.alloc()) soinfo(name, file_stat);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700295
Magnus Malmbornba98d922012-09-12 13:00:55 +0200296 sonext->next = si;
297 sonext = si;
298
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700299 TRACE("name %s: allocated soinfo @ %p", name, si);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200300 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800301}
302
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800303static void soinfo_free(soinfo* si) {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700304 if (si == nullptr) {
Elliott Hughes46882792012-08-03 16:49:39 -0700305 return;
306 }
307
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700308 if (si->base != 0 && si->size != 0) {
309 munmap(reinterpret_cast<void*>(si->base), si->size);
310 }
311
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700312 soinfo *prev = nullptr, *trav;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800313
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700314 TRACE("name %s: freeing soinfo @ %p", si->name, si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800315
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700316 for (trav = solist; trav != nullptr; trav = trav->next) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800317 if (trav == si)
318 break;
319 prev = trav;
320 }
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700321 if (trav == nullptr) {
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800322 /* si was not in solist */
Elliott Hughes46882792012-08-03 16:49:39 -0700323 DL_ERR("name \"%s\" is not in solist!", si->name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800324 return;
325 }
326
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700327 // clear links to/from si
328 si->remove_all_links();
329
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700330 /* prev will never be null, because the first entry in solist is
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800331 always the static libdl_info.
332 */
333 prev->next = si->next;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800334 if (si == sonext) {
335 sonext = prev;
336 }
Dmitriy Ivanovd597d262014-05-05 16:49:04 -0700337
Elliott Hughes1728b232014-05-14 10:02:03 -0700338 g_soinfo_allocator.free(si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800339}
340
Elliott Hughescade4c32012-12-20 14:42:14 -0800341
342static void parse_path(const char* path, const char* delimiters,
343 const char** array, char* buf, size_t buf_size, size_t max_count) {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700344 if (path == nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800345 return;
346 }
347
348 size_t len = strlcpy(buf, path, buf_size);
349
350 size_t i = 0;
351 char* buf_p = buf;
352 while (i < max_count && (array[i] = strsep(&buf_p, delimiters))) {
353 if (*array[i] != '\0') {
354 ++i;
355 }
356 }
357
358 // Forget the last path if we had to truncate; this occurs if the 2nd to
359 // last char isn't '\0' (i.e. wasn't originally a delimiter).
360 if (i > 0 && len >= buf_size && buf[buf_size - 2] != '\0') {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700361 array[i - 1] = nullptr;
Elliott Hughescade4c32012-12-20 14:42:14 -0800362 } else {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700363 array[i] = nullptr;
Elliott Hughescade4c32012-12-20 14:42:14 -0800364 }
365}
366
367static void parse_LD_LIBRARY_PATH(const char* path) {
Elliott Hughes1728b232014-05-14 10:02:03 -0700368 parse_path(path, ":", g_ld_library_paths,
369 g_ld_library_paths_buffer, sizeof(g_ld_library_paths_buffer), LDPATH_MAX);
Elliott Hughescade4c32012-12-20 14:42:14 -0800370}
371
372static void parse_LD_PRELOAD(const char* path) {
373 // We have historically supported ':' as well as ' ' in LD_PRELOAD.
Elliott Hughes1728b232014-05-14 10:02:03 -0700374 parse_path(path, " :", g_ld_preload_names,
375 g_ld_preloads_buffer, sizeof(g_ld_preloads_buffer), LDPRELOAD_MAX);
Elliott Hughescade4c32012-12-20 14:42:14 -0800376}
377
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700378#if defined(__arm__)
Elliott Hughes46882792012-08-03 16:49:39 -0700379
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800380/* For a given PC, find the .so that it belongs to.
381 * Returns the base address of the .ARM.exidx section
382 * for that .so, and the number of 8-byte entries
383 * in that section (via *pcount).
384 *
385 * Intended to be called by libc's __gnu_Unwind_Find_exidx().
386 *
Elliott Hughes3b297c42012-10-11 16:08:51 -0700387 * This function is exposed via dlfcn.cpp and libdl.so.
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800388 */
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800389_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800390 unsigned addr = (unsigned)pc;
391
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800392 for (soinfo* si = solist; si != 0; si = si->next) {
Nick Kralevich468319c2011-11-11 15:53:17 -0800393 if ((addr >= si->base) && (addr < (si->base + si->size))) {
394 *pcount = si->ARM_exidx_count;
Ji-Hwan Leef186a182012-05-31 20:20:36 +0900395 return (_Unwind_Ptr)si->ARM_exidx;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800396 }
397 }
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800398 *pcount = 0;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700399 return nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800400}
Elliott Hughes46882792012-08-03 16:49:39 -0700401
Christopher Ferris24053a42013-08-19 17:45:09 -0700402#endif
Elliott Hughes46882792012-08-03 16:49:39 -0700403
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800404/* Here, we only have to provide a callback to iterate across all the
405 * loaded libraries. gcc_eh does the rest. */
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800406int dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800407 int rv = 0;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700408 for (soinfo* si = solist; si != nullptr; si = si->next) {
Elliott Hughesbedfe382012-08-14 14:07:59 -0700409 dl_phdr_info dl_info;
Elliott Hughes3a9c5d62014-02-10 13:31:13 -0800410 dl_info.dlpi_addr = si->link_map_head.l_addr;
411 dl_info.dlpi_name = si->link_map_head.l_name;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800412 dl_info.dlpi_phdr = si->phdr;
413 dl_info.dlpi_phnum = si->phnum;
Elliott Hughesbedfe382012-08-14 14:07:59 -0700414 rv = cb(&dl_info, sizeof(dl_phdr_info), data);
415 if (rv != 0) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800416 break;
Elliott Hughesbedfe382012-08-14 14:07:59 -0700417 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800418 }
419 return rv;
420}
Elliott Hughes46882792012-08-03 16:49:39 -0700421
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700422static ElfW(Sym)* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) {
Elliott Hughes0266ae52014-02-10 17:46:57 -0800423 ElfW(Sym)* symtab = si->symtab;
424 const char* strtab = si->strtab;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800425
Elliott Hughes0266ae52014-02-10 17:46:57 -0800426 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p %x %zd",
427 name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800428
Elliott Hughes0266ae52014-02-10 17:46:57 -0800429 for (unsigned n = si->bucket[hash % si->nbucket]; n != 0; n = si->chain[n]) {
430 ElfW(Sym)* s = symtab + n;
431 if (strcmp(strtab + s->st_name, name)) continue;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800432
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700433 /* only concern ourselves with global and weak symbol definitions */
Elliott Hughes0266ae52014-02-10 17:46:57 -0800434 switch (ELF_ST_BIND(s->st_info)) {
435 case STB_GLOBAL:
436 case STB_WEAK:
437 if (s->st_shndx == SHN_UNDEF) {
Dmitriy Ivanovd97e9f52014-06-29 12:28:37 -0700438 continue;
439 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800440
Dmitriy Ivanovd97e9f52014-06-29 12:28:37 -0700441 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
Elliott Hughes0266ae52014-02-10 17:46:57 -0800442 name, si->name, reinterpret_cast<void*>(s->st_value),
443 static_cast<size_t>(s->st_size));
Dmitriy Ivanovd97e9f52014-06-29 12:28:37 -0700444 return s;
445 case STB_LOCAL:
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700446 continue;
Dmitriy Ivanovd97e9f52014-06-29 12:28:37 -0700447 default:
Dmitriy Ivanov12bf3bc2014-07-01 14:24:45 -0700448 __libc_fatal("ERROR: Unexpected ST_BIND value: %d for '%s' in '%s'",
449 ELF_ST_BIND(s->st_info), name, si->name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800450 }
Elliott Hughes0266ae52014-02-10 17:46:57 -0800451 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800452
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000453 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
454 name, si->name, reinterpret_cast<void*>(si->base), hash, hash % si->nbucket);
455
456
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700457 return nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800458}
459
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -0700460soinfo::soinfo(const char* name, const struct stat* file_stat) {
461 memset(this, 0, sizeof(*this));
462
463 strlcpy(this->name, name, sizeof(this->name));
464 flags = FLAG_NEW_SOINFO;
465 version = SOINFO_VERSION;
466
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700467 if (file_stat != nullptr) {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -0700468 set_st_dev(file_stat->st_dev);
469 set_st_ino(file_stat->st_ino);
470 }
471}
472
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800473static unsigned elfhash(const char* _name) {
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800474 const unsigned char* name = reinterpret_cast<const unsigned char*>(_name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800475 unsigned h = 0, g;
476
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800477 while (*name) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800478 h = (h << 4) + *name++;
479 g = h & 0xf0000000;
480 h ^= g;
481 h ^= g >> 24;
482 }
483 return h;
484}
485
Dmitriy Ivanov7210c412014-09-02 11:47:23 -0700486static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi) {
Doug Kwan94304352009-10-23 18:11:40 -0700487 unsigned elf_hash = elfhash(name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700488 ElfW(Sym)* s = nullptr;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700489
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700490 if (somain != nullptr) {
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200491 /*
Pavel Chupinc77c4342012-10-31 13:55:51 +0400492 * Local scope is executable scope. Just start looking into it right away
493 * for the shortcut.
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200494 */
495
Pavel Chupinc77c4342012-10-31 13:55:51 +0400496 if (si == somain) {
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700497 s = soinfo_elf_lookup(si, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700498 if (s != nullptr) {
Pavel Chupinc77c4342012-10-31 13:55:51 +0400499 *lsi = si;
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200500 goto done;
501 }
Dmitriy Ivanov05e190c2014-08-29 10:15:25 -0700502
503 /* Next, look for it in the preloads list */
504 for (int i = 0; g_ld_preloads[i] != NULL; i++) {
505 s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);
506 if (s != NULL) {
507 *lsi = g_ld_preloads[i];
508 goto done;
509 }
510 }
Pavel Chupinc77c4342012-10-31 13:55:51 +0400511 } else {
512 /* Order of symbol lookup is controlled by DT_SYMBOLIC flag */
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200513
Pavel Chupinc77c4342012-10-31 13:55:51 +0400514 /*
515 * If this object was built with symbolic relocations disabled, the
516 * first place to look to resolve external references is the main
517 * executable.
518 */
Nick Kralevich468319c2011-11-11 15:53:17 -0800519
Pavel Chupinc77c4342012-10-31 13:55:51 +0400520 if (!si->has_DT_SYMBOLIC) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700521 DEBUG("%s: looking up %s in executable %s",
Elliott Hughes61a9ccb2012-11-02 12:37:13 -0700522 si->name, name, somain->name);
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700523 s = soinfo_elf_lookup(somain, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700524 if (s != nullptr) {
Pavel Chupinc77c4342012-10-31 13:55:51 +0400525 *lsi = somain;
526 goto done;
527 }
Dmitriy Ivanov05e190c2014-08-29 10:15:25 -0700528
529 /* Next, look for it in the preloads list */
530 for (int i = 0; g_ld_preloads[i] != NULL; i++) {
531 s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);
532 if (s != NULL) {
533 *lsi = g_ld_preloads[i];
534 goto done;
535 }
536 }
Pavel Chupinc77c4342012-10-31 13:55:51 +0400537 }
538
539 /* Look for symbols in the local scope (the object who is
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700540 * searching). This happens with C++ templates on x86 for some
Pavel Chupinc77c4342012-10-31 13:55:51 +0400541 * reason.
542 *
543 * Notes on weak symbols:
544 * The ELF specs are ambiguous about treatment of weak definitions in
545 * dynamic linking. Some systems return the first definition found
546 * and some the first non-weak definition. This is system dependent.
547 * Here we return the first definition found for simplicity. */
548
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700549 s = soinfo_elf_lookup(si, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700550 if (s != nullptr) {
Pavel Chupinc77c4342012-10-31 13:55:51 +0400551 *lsi = si;
552 goto done;
553 }
554
555 /*
556 * If this object was built with -Bsymbolic and symbol is not found
557 * in the local scope, try to find the symbol in the main executable.
558 */
559
560 if (si->has_DT_SYMBOLIC) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700561 DEBUG("%s: looking up %s in executable %s after local scope",
Elliott Hughes61a9ccb2012-11-02 12:37:13 -0700562 si->name, name, somain->name);
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700563 s = soinfo_elf_lookup(somain, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700564 if (s != nullptr) {
Pavel Chupinc77c4342012-10-31 13:55:51 +0400565 *lsi = somain;
566 goto done;
567 }
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700568
Dmitriy Ivanov05e190c2014-08-29 10:15:25 -0700569 /* Next, look for it in the preloads list */
570 for (int i = 0; g_ld_preloads[i] != NULL; i++) {
571 s = soinfo_elf_lookup(g_ld_preloads[i], elf_hash, name);
572 if (s != NULL) {
573 *lsi = g_ld_preloads[i];
574 goto done;
575 }
576 }
577 }
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200578 }
Matt Fischer4fd42c12009-12-31 12:09:10 -0600579 }
580
Dmitriy Ivanov7210c412014-09-02 11:47:23 -0700581 si->get_children().visit([&](soinfo* child) {
582 DEBUG("%s: looking up %s in %s", si->name, name, child->name);
583 s = soinfo_elf_lookup(child, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700584 if (s != nullptr) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -0700585 *lsi = child;
586 return false;
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +0200587 }
Dmitriy Ivanov7210c412014-09-02 11:47:23 -0700588 return true;
589 });
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700590
591done:
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700592 if (s != nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -0700593 TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, "
594 "found in %s, base = %p, load bias = %p",
595 si->name, name, reinterpret_cast<void*>(s->st_value),
596 (*lsi)->name, reinterpret_cast<void*>((*lsi)->base),
597 reinterpret_cast<void*>((*lsi)->load_bias));
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700598 return s;
599 }
600
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700601 return nullptr;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700602}
603
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700604// Each size has it's own allocator.
605template<size_t size>
606class SizeBasedAllocator {
607 public:
608 static void* alloc() {
609 return allocator_.alloc();
610 }
Dmitriy Ivanov4d01d082014-08-29 14:01:48 -0700611
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700612 static void free(void* ptr) {
613 allocator_.free(ptr);
614 }
Dmitriy Ivanov4d01d082014-08-29 14:01:48 -0700615
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700616 private:
617 static LinkerBlockAllocator allocator_;
618};
619
620template<size_t size>
621LinkerBlockAllocator SizeBasedAllocator<size>::allocator_(size);
622
623template<typename T>
624class TypeBasedAllocator {
625 public:
626 static T* alloc() {
627 return reinterpret_cast<T*>(SizeBasedAllocator<sizeof(T)>::alloc());
628 }
629
630 static void free(T* ptr) {
631 SizeBasedAllocator<sizeof(T)>::free(ptr);
632 }
633};
634
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700635class LoadTask {
636 public:
637 struct deleter_t {
638 void operator()(LoadTask* t) {
639 TypeBasedAllocator<LoadTask>::free(t);
640 }
641 };
642
643 typedef UniquePtr<LoadTask, deleter_t> unique_ptr;
644
645 static deleter_t deleter;
646
647 static LoadTask* create(const char* name, soinfo* needed_by) {
648 LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc();
649 return new (ptr) LoadTask(name, needed_by);
650 }
651
652 const char* get_name() const {
653 return name_;
654 }
655
656 soinfo* get_needed_by() const {
657 return needed_by_;
658 }
659 private:
660 LoadTask(const char* name, soinfo* needed_by)
661 : name_(name), needed_by_(needed_by) {}
662
663 const char* name_;
664 soinfo* needed_by_;
665
666 DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask);
667};
668
Ningsheng Jian04f5f412014-09-16 15:22:10 +0800669LoadTask::deleter_t LoadTask::deleter;
670
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700671template <typename T>
672using linked_list_t = LinkedList<T, TypeBasedAllocator<LinkedListEntry<T>>>;
673
674typedef linked_list_t<soinfo> SoinfoLinkedList;
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700675typedef linked_list_t<const char> StringLinkedList;
676typedef linked_list_t<LoadTask> LoadTaskList;
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700677
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000678
679// This is used by dlsym(3). It performs symbol lookup only within the
680// specified soinfo object and its dependencies in breadth first order.
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700681ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) {
Dmitriy Ivanovff01f6f2014-09-01 16:15:52 -0700682 SoinfoLinkedList visit_list;
683 SoinfoLinkedList visited;
684
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000685 visit_list.push_back(si);
686 soinfo* current_soinfo;
687 while ((current_soinfo = visit_list.pop_front()) != nullptr) {
Dmitriy Ivanov8a84d382014-08-12 21:02:13 -0700688 if (visited.contains(current_soinfo)) {
689 continue;
690 }
691
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700692 ElfW(Sym)* result = soinfo_elf_lookup(current_soinfo, elfhash(name), name);
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000693
694 if (result != nullptr) {
695 *found = current_soinfo;
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000696 return result;
697 }
Dmitriy Ivanov8a84d382014-08-12 21:02:13 -0700698 visited.push_back(current_soinfo);
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000699
700 current_soinfo->get_children().for_each([&](soinfo* child) {
701 visit_list.push_back(child);
702 });
703 }
704
Dmitriy Ivanovdb7a17d2014-08-04 23:39:22 +0000705 return nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800706}
707
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800708/* This is used by dlsym(3) to performs a global symbol lookup. If the
709 start value is null (for RTLD_DEFAULT), the search starts at the
710 beginning of the global solist. Otherwise the search starts at the
711 specified soinfo (for RTLD_NEXT).
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700712 */
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700713ElfW(Sym)* dlsym_linear_lookup(const char* name, soinfo** found, soinfo* start) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800714 unsigned elf_hash = elfhash(name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800715
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700716 if (start == nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800717 start = solist;
718 }
719
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700720 ElfW(Sym)* s = nullptr;
721 for (soinfo* si = start; (s == nullptr) && (si != nullptr); si = si->next) {
Dmitriy Ivanov94194202014-08-18 15:08:51 -0700722 s = soinfo_elf_lookup(si, elf_hash, name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700723 if (s != nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800724 *found = si;
725 break;
Matt Fischer1698d9e2009-12-31 12:17:56 -0600726 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800727 }
Matt Fischer1698d9e2009-12-31 12:17:56 -0600728
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700729 if (s != nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -0700730 TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p",
731 name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));
Elliott Hughescade4c32012-12-20 14:42:14 -0800732 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800733
Elliott Hughescade4c32012-12-20 14:42:14 -0800734 return s;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800735}
736
Kito Chengfa8c05d2013-03-12 14:58:06 +0800737soinfo* find_containing_library(const void* p) {
Elliott Hughes0266ae52014-02-10 17:46:57 -0800738 ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700739 for (soinfo* si = solist; si != nullptr; si = si->next) {
Kito Chengfa8c05d2013-03-12 14:58:06 +0800740 if (address >= si->base && address - si->base < si->size) {
741 return si;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600742 }
Kito Chengfa8c05d2013-03-12 14:58:06 +0800743 }
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700744 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600745}
746
Elliott Hughes0266ae52014-02-10 17:46:57 -0800747ElfW(Sym)* dladdr_find_symbol(soinfo* si, const void* addr) {
748 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - si->base;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600749
Kito Chengfa8c05d2013-03-12 14:58:06 +0800750 // Search the library's symbol table for any defined symbol which
751 // contains this address.
752 for (size_t i = 0; i < si->nchain; ++i) {
Elliott Hughes0266ae52014-02-10 17:46:57 -0800753 ElfW(Sym)* sym = &si->symtab[i];
Kito Chengfa8c05d2013-03-12 14:58:06 +0800754 if (sym->st_shndx != SHN_UNDEF &&
755 soaddr >= sym->st_value &&
756 soaddr < sym->st_value + sym->st_size) {
757 return sym;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600758 }
Kito Chengfa8c05d2013-03-12 14:58:06 +0800759 }
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600760
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700761 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600762}
763
Elliott Hughes124fae92012-10-31 14:20:03 -0700764static int open_library_on_path(const char* name, const char* const paths[]) {
765 char buf[512];
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700766 for (size_t i = 0; paths[i] != nullptr; ++i) {
Elliott Hughes1e980b62013-01-17 18:36:06 -0800767 int n = __libc_format_buffer(buf, sizeof(buf), "%s/%s", paths[i], name);
Elliott Hughes124fae92012-10-31 14:20:03 -0700768 if (n < 0 || n >= static_cast<int>(sizeof(buf))) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700769 PRINT("Warning: ignoring very long library path: %s/%s", paths[i], name);
Elliott Hughes124fae92012-10-31 14:20:03 -0700770 continue;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800771 }
Elliott Hughes124fae92012-10-31 14:20:03 -0700772 int fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
773 if (fd != -1) {
774 return fd;
775 }
776 }
777 return -1;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800778}
779
Elliott Hughes124fae92012-10-31 14:20:03 -0700780static int open_library(const char* name) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700781 TRACE("[ opening %s ]", name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800782
Elliott Hughes124fae92012-10-31 14:20:03 -0700783 // If the name contains a slash, we should attempt to open it directly and not search the paths.
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700784 if (strchr(name, '/') != nullptr) {
Elliott Hughes6971fe42012-11-01 22:59:19 -0700785 int fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC));
786 if (fd != -1) {
787 return fd;
788 }
789 // ...but nvidia binary blobs (at least) rely on this behavior, so fall through for now.
Dmitriy Ivanov5ca7ed92014-05-02 18:18:50 -0700790#if defined(__LP64__)
Dmitriy Ivanove43c4a72014-06-29 13:00:23 -0700791 return -1;
Dmitriy Ivanov5ca7ed92014-05-02 18:18:50 -0700792#endif
Elliott Hughes124fae92012-10-31 14:20:03 -0700793 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800794
Elliott Hughes124fae92012-10-31 14:20:03 -0700795 // Otherwise we try LD_LIBRARY_PATH first, and fall back to the built-in well known paths.
Elliott Hughes1728b232014-05-14 10:02:03 -0700796 int fd = open_library_on_path(name, g_ld_library_paths);
Elliott Hughes124fae92012-10-31 14:20:03 -0700797 if (fd == -1) {
Elliott Hughes1728b232014-05-14 10:02:03 -0700798 fd = open_library_on_path(name, kDefaultLdPaths);
Elliott Hughes124fae92012-10-31 14:20:03 -0700799 }
800 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800801}
802
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700803template<typename F>
804static void for_each_dt_needed(const soinfo* si, F action) {
805 for (ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
806 if (d->d_tag == DT_NEEDED) {
807 action(si->strtab + d->d_un.d_val);
Dima Zavin2e855792009-05-20 18:28:09 -0700808 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700809 }
810}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800811
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700812static soinfo* load_library(LoadTaskList& load_tasks, const char* name, int dlflags, const android_dlextinfo* extinfo) {
813 int fd = -1;
814 ScopedFd file_guard(-1);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700815
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700816 if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) {
817 fd = extinfo->library_fd;
818 } else {
819 // Open the file.
820 fd = open_library(name);
821 if (fd == -1) {
822 DL_ERR("library \"%s\" not found", name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700823 return nullptr;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700824 }
825
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700826 file_guard.reset(fd);
827 }
828
829 struct stat file_stat;
830 if (TEMP_FAILURE_RETRY(fstat(fd, &file_stat)) != 0) {
831 DL_ERR("unable to stat file for the library %s: %s", name, strerror(errno));
832 return nullptr;
833 }
834
835 // Check for symlink and other situations where
836 // file can have different names.
837 for (soinfo* si = solist; si != nullptr; si = si->next) {
838 if (si->get_st_dev() != 0 &&
839 si->get_st_ino() != 0 &&
840 si->get_st_dev() == file_stat.st_dev &&
841 si->get_st_ino() == file_stat.st_ino) {
842 TRACE("library \"%s\" is already loaded under different name/path \"%s\" - will return existing soinfo", name, si->name);
843 return si;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700844 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700845 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700846
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700847 if ((dlflags & RTLD_NOLOAD) != 0) {
Dmitriy Ivanov7d971ec2014-09-09 10:21:42 -0700848 DL_ERR("library \"%s\" wasn't loaded and RTLD_NOLOAD prevented it", name);
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700849 return nullptr;
850 }
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -0700851
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700852 // Read the ELF header and load the segments.
853 ElfReader elf_reader(name, fd);
854 if (!elf_reader.Load(extinfo)) {
855 return nullptr;
856 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800857
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700858 soinfo* si = soinfo_alloc(SEARCH_NAME(name), &file_stat);
859 if (si == nullptr) {
860 return nullptr;
861 }
862 si->base = elf_reader.load_start();
863 si->size = elf_reader.load_size();
864 si->load_bias = elf_reader.load_bias();
865 si->phnum = elf_reader.phdr_count();
866 si->phdr = elf_reader.loaded_phdr();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700867
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700868 if (!si->PrelinkImage()) {
869 soinfo_free(si);
870 return nullptr;
871 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700872
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700873 for_each_dt_needed(si, [&] (const char* name) {
874 load_tasks.push_back(LoadTask::create(name, si));
875 });
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700876
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700877 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800878}
879
Dmitriy Ivanov489e4982014-05-19 15:19:52 -0700880static soinfo *find_loaded_library_by_name(const char* name) {
881 const char* search_name = SEARCH_NAME(name);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700882 for (soinfo* si = solist; si != nullptr; si = si->next) {
Dmitriy Ivanov489e4982014-05-19 15:19:52 -0700883 if (!strcmp(search_name, si->name)) {
884 return si;
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +0200885 }
Dmitriy Ivanov489e4982014-05-19 15:19:52 -0700886 }
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700887 return nullptr;
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +0200888}
889
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700890static soinfo* find_library_internal(LoadTaskList& load_tasks, const char* name, int dlflags, const android_dlextinfo* extinfo) {
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +0200891
Dmitriy Ivanov489e4982014-05-19 15:19:52 -0700892 soinfo* si = find_loaded_library_by_name(name);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -0700893
894 // Library might still be loaded, the accurate detection
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700895 // of this fact is done by load_library.
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -0700896 if (si == nullptr) {
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -0700897 TRACE("[ '%s' has not been found by name. Trying harder...]", name);
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700898 si = load_library(load_tasks, name, dlflags, extinfo);
Elliott Hughesd23736e2012-11-01 15:16:56 -0700899 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800900
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -0700901 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800902}
903
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700904static void soinfo_unload(soinfo* si);
905
906static bool is_recursive(soinfo* si, soinfo* parent) {
907 if (parent == nullptr) {
908 return false;
Dmitriy Ivanov59c12a62014-07-29 14:21:45 -0700909 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700910
911 if (si == parent) {
912 DL_ERR("recursive link to \"%s\"", si->name);
913 return true;
914 }
915
916 return !parent->get_parents().visit([&](soinfo* grandparent) {
917 return !is_recursive(si, grandparent);
918 });
919}
920
921static bool find_libraries(const char* const library_names[], size_t library_names_size, soinfo* soinfos[],
922 soinfo* ld_preloads[], size_t ld_preloads_size, int dlflags, const android_dlextinfo* extinfo) {
923 // Step 0: prepare.
924 LoadTaskList load_tasks;
925 for (size_t i = 0; i < library_names_size; ++i) {
926 const char* name = library_names[i];
927 load_tasks.push_back(LoadTask::create(name, nullptr));
928 }
929
930 // Libraries added to this list in reverse order so that we can
931 // start linking from bottom-up - see step 2.
932 SoinfoLinkedList found_libs;
933 size_t soinfos_size = 0;
934
Dmitriy Ivanovef1306d2014-09-08 16:22:22 -0700935 auto failure_guard = make_scope_guard([&]() {
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700936 // Housekeeping
937 load_tasks.for_each([] (LoadTask* t) {
938 LoadTask::deleter(t);
939 });
940
941 for (size_t i = 0; i<soinfos_size; ++i) {
942 soinfo_unload(soinfos[i]);
943 }
944 });
945
946 // Step 1: load and pre-link all DT_NEEDED libraries in breadth first order.
947 for (LoadTask::unique_ptr task(load_tasks.pop_front()); task.get() != nullptr; task.reset(load_tasks.pop_front())) {
948 soinfo* si = find_library_internal(load_tasks, task->get_name(), dlflags, extinfo);
949 if (si == nullptr) {
950 return false;
951 }
952
953 soinfo* needed_by = task->get_needed_by();
954
955 if (is_recursive(si, needed_by)) {
Dmitriy Ivanovae69a952014-09-05 16:42:53 -0700956 return false;
957 }
958
959 si->ref_count++;
960 if (needed_by != nullptr) {
961 needed_by->add_child(si);
962 }
963 found_libs.push_front(si);
964
965 // When ld_preloads is not null first
966 // ld_preloads_size libs are in fact ld_preloads.
967 if (ld_preloads != nullptr && soinfos_size < ld_preloads_size) {
968 ld_preloads[soinfos_size] = si;
969 }
970
971 if (soinfos_size<library_names_size) {
972 soinfos[soinfos_size++] = si;
973 }
974 }
975
976 // Step 2: link libraries.
977 soinfo* si;
978 while ((si = found_libs.pop_front()) != nullptr) {
979 if ((si->flags & FLAG_LINKED) == 0) {
980 if (!si->LinkImage(extinfo)) {
981 return false;
982 }
983 si->flags |= FLAG_LINKED;
984 }
985 }
986
987 // All is well - found_libs and load_tasks are empty at this point
988 // and all libs are successfully linked.
989 failure_guard.disable();
990 return true;
991}
992
993static soinfo* find_library(const char* name, int dlflags, const android_dlextinfo* extinfo) {
994 if (name == nullptr) {
995 somain->ref_count++;
996 return somain;
997 }
998
999 soinfo* si;
1000
1001 if (!find_libraries(&name, 1, &si, nullptr, 0, dlflags, extinfo)) {
1002 return nullptr;
1003 }
1004
Elliott Hughesd23736e2012-11-01 15:16:56 -07001005 return si;
1006}
Elliott Hughesbedfe382012-08-14 14:07:59 -07001007
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001008static void soinfo_unload(soinfo* si) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001009 if (si->ref_count == 1) {
1010 TRACE("unloading '%s'", si->name);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001011 si->CallDestructors();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001012
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001013 if (si->has_min_version(0)) {
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001014 soinfo* child = nullptr;
1015 while ((child = si->get_children().pop_front()) != nullptr) {
1016 TRACE("%s needs to unload %s", si->name, child->name);
1017 soinfo_unload(child);
Dmitriy Ivanov4d01d082014-08-29 14:01:48 -07001018 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001019 } else {
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001020 for_each_dt_needed(si, [&] (const char* library_name) {
1021 TRACE("deprecated (old format of soinfo): %s needs to unload %s", si->name, library_name);
1022 soinfo* needed = find_library(library_name, RTLD_NOLOAD, nullptr);
1023 if (needed != nullptr) {
1024 soinfo_unload(needed);
1025 } else {
1026 // Not found: for example if symlink was deleted between dlopen and dlclose
1027 // Since we cannot really handle errors at this point - print and continue.
1028 PRINT("warning: couldn't find %s needed by %s on unload.", library_name, si->name);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001029 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001030 });
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001031 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001032
Elliott Hughesd23736e2012-11-01 15:16:56 -07001033 notify_gdb_of_unload(si);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001034 si->ref_count = 0;
Dmitriy Ivanovd597d262014-05-05 16:49:04 -07001035 soinfo_free(si);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001036 } else {
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001037 si->ref_count--;
Elliott Hughesc6200592013-09-30 18:43:46 -07001038 TRACE("not unloading '%s', decrementing ref_count to %zd", si->name, si->ref_count);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001039 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001040}
1041
Elliott Hughesa4aafd12014-01-13 16:37:47 -08001042void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
Christopher Ferris172955a2014-08-26 20:48:11 -07001043 // Use basic string manipulation calls to avoid snprintf.
1044 // snprintf indirectly calls pthread_getspecific to get the size of a buffer.
1045 // When debug malloc is enabled, this call returns 0. This in turn causes
1046 // snprintf to do nothing, which causes libraries to fail to load.
1047 // See b/17302493 for further details.
1048 // Once the above bug is fixed, this code can be modified to use
1049 // snprintf again.
1050 size_t required_len = strlen(kDefaultLdPaths[0]) + strlen(kDefaultLdPaths[1]) + 2;
1051 if (buffer_size < required_len) {
1052 __libc_fatal("android_get_LD_LIBRARY_PATH failed, buffer too small: buffer len %zu, required len %zu",
1053 buffer_size, required_len);
1054 }
1055 char* end = stpcpy(buffer, kDefaultLdPaths[0]);
1056 *end = ':';
1057 strcpy(end + 1, kDefaultLdPaths[1]);
Elliott Hughesa4aafd12014-01-13 16:37:47 -08001058}
1059
Elliott Hughescade4c32012-12-20 14:42:14 -08001060void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
1061 if (!get_AT_SECURE()) {
1062 parse_LD_LIBRARY_PATH(ld_library_path);
1063 }
1064}
1065
Elliott Hughes1a586292014-06-03 16:23:08 -07001066soinfo* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo) {
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001067 if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NOLOAD)) != 0) {
Elliott Hughese66190d2012-12-18 15:57:55 -08001068 DL_ERR("invalid flags to dlopen: %x", flags);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001069 return nullptr;
Elliott Hughese66190d2012-12-18 15:57:55 -08001070 }
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001071 if (extinfo != nullptr && ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0)) {
Dmitriy Ivanov3a8646f2014-07-08 11:21:56 -07001072 DL_ERR("invalid extended flags to android_dlopen_ext: %" PRIx64, extinfo->flags);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001073 return nullptr;
Torne (Richard Coles)012cb452014-02-06 14:34:21 +00001074 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001075 protect_data(PROT_READ | PROT_WRITE);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001076 soinfo* si = find_library(name, flags, extinfo);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001077 if (si != nullptr) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07001078 si->CallConstructors();
1079 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001080 protect_data(PROT_READ);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001081 return si;
1082}
1083
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001084void do_dlclose(soinfo* si) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001085 protect_data(PROT_READ | PROT_WRITE);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001086 soinfo_unload(si);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001087 protect_data(PROT_READ);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001088}
1089
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001090static ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) {
1091 typedef ElfW(Addr) (*ifunc_resolver_t)(void);
1092 ifunc_resolver_t ifunc_resolver = reinterpret_cast<ifunc_resolver_t>(resolver_addr);
1093 ElfW(Addr) ifunc_addr = ifunc_resolver();
1094 TRACE_TYPE(RELO, "Called ifunc_resolver@%p. The result is %p", ifunc_resolver, reinterpret_cast<void*>(ifunc_addr));
Brigid Smith31b88da2014-07-23 11:22:25 -07001095
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001096 return ifunc_addr;
Brigid Smith31b88da2014-07-23 11:22:25 -07001097}
Brigid Smith31b88da2014-07-23 11:22:25 -07001098
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001099#if defined(USE_RELA)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001100int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001101 for (size_t idx = 0; idx < count; ++idx, ++rela) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001102 unsigned type = ELFW(R_TYPE)(rela->r_info);
1103 unsigned sym = ELFW(R_SYM)(rela->r_info);
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001104 ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rela->r_offset + load_bias);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001105 ElfW(Addr) sym_addr = 0;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001106 const char* sym_name = nullptr;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001107
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001108 DEBUG("Processing '%s' relocation at index %zd", name, idx);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001109 if (type == 0) { // R_*_NONE
1110 continue;
1111 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001112
1113 ElfW(Sym)* s = nullptr;
1114 soinfo* lsi = nullptr;
1115
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001116 if (sym != 0) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001117 sym_name = reinterpret_cast<const char*>(strtab + symtab[sym].st_name);
1118 s = soinfo_do_lookup(this, sym_name, &lsi);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001119 if (s == nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001120 // We only allow an undefined symbol if this is a weak reference...
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001121 s = &symtab[sym];
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001122 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001123 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, name);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001124 return -1;
1125 }
1126
1127 /* IHI0044C AAELF 4.5.1.1:
1128
1129 Libraries are not searched to resolve weak references.
1130 It is not an error for a weak reference to remain unsatisfied.
1131
1132 During linking, the value of an undefined weak reference is:
1133 - Zero if the relocation type is absolute
1134 - The address of the place if the relocation is pc-relative
1135 - The address of nominal base address if the relocation
1136 type is base-relative.
1137 */
1138
1139 switch (type) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001140#if defined(__aarch64__)
1141 case R_AARCH64_JUMP_SLOT:
1142 case R_AARCH64_GLOB_DAT:
1143 case R_AARCH64_ABS64:
1144 case R_AARCH64_ABS32:
1145 case R_AARCH64_ABS16:
1146 case R_AARCH64_RELATIVE:
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001147 case R_AARCH64_IRELATIVE:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001148 /*
1149 * The sym_addr was initialized to be zero above, or the relocation
1150 * code below does not care about value of sym_addr.
1151 * No need to do anything.
1152 */
1153 break;
1154#elif defined(__x86_64__)
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001155 case R_X86_64_JUMP_SLOT:
1156 case R_X86_64_GLOB_DAT:
1157 case R_X86_64_32:
Pavel Chupinbb5bb202014-05-16 13:49:24 +04001158 case R_X86_64_64:
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001159 case R_X86_64_RELATIVE:
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001160 case R_X86_64_IRELATIVE:
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001161 // No need to do anything.
1162 break;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001163 case R_X86_64_PC32:
1164 sym_addr = reloc;
1165 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001166#endif
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001167 default:
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001168 DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rela, idx);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001169 return -1;
1170 }
1171 } else {
1172 // We got a definition.
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001173 sym_addr = lsi->resolve_symbol_address(s);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001174 }
1175 count_relocation(kRelocSymbol);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001176 }
1177
1178 switch (type) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001179#if defined(__aarch64__)
1180 case R_AARCH64_JUMP_SLOT:
1181 count_relocation(kRelocAbsolute);
1182 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001183 TRACE_TYPE(RELO, "RELO JMP_SLOT %16llx <- %16llx %s\n",
1184 reloc, (sym_addr + rela->r_addend), sym_name);
1185 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001186 break;
1187 case R_AARCH64_GLOB_DAT:
1188 count_relocation(kRelocAbsolute);
1189 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001190 TRACE_TYPE(RELO, "RELO GLOB_DAT %16llx <- %16llx %s\n",
1191 reloc, (sym_addr + rela->r_addend), sym_name);
1192 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001193 break;
1194 case R_AARCH64_ABS64:
1195 count_relocation(kRelocAbsolute);
1196 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001197 TRACE_TYPE(RELO, "RELO ABS64 %16llx <- %16llx %s\n",
1198 reloc, (sym_addr + rela->r_addend), sym_name);
1199 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001200 break;
1201 case R_AARCH64_ABS32:
1202 count_relocation(kRelocAbsolute);
1203 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001204 TRACE_TYPE(RELO, "RELO ABS32 %16llx <- %16llx %s\n",
1205 reloc, (sym_addr + rela->r_addend), sym_name);
1206 if ((static_cast<ElfW(Addr)>(INT32_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend))) &&
1207 ((*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)) <= static_cast<ElfW(Addr)>(UINT32_MAX))) {
1208 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001209 } else {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001210 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1211 (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)),
1212 static_cast<ElfW(Addr)>(INT32_MIN),
1213 static_cast<ElfW(Addr)>(UINT32_MAX));
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001214 return -1;
1215 }
1216 break;
1217 case R_AARCH64_ABS16:
1218 count_relocation(kRelocAbsolute);
1219 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001220 TRACE_TYPE(RELO, "RELO ABS16 %16llx <- %16llx %s\n",
1221 reloc, (sym_addr + rela->r_addend), sym_name);
1222 if ((static_cast<ElfW(Addr)>(INT16_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend))) &&
1223 ((*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)) <= static_cast<ElfW(Addr)>(UINT16_MAX))) {
1224 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001225 } else {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001226 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1227 (*reinterpret_cast<ElfW(Addr)*>(reloc) + (sym_addr + rela->r_addend)),
1228 static_cast<ElfW(Addr)>(INT16_MIN),
1229 static_cast<ElfW(Addr)>(UINT16_MAX));
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001230 return -1;
1231 }
1232 break;
1233 case R_AARCH64_PREL64:
1234 count_relocation(kRelocRelative);
1235 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001236 TRACE_TYPE(RELO, "RELO REL64 %16llx <- %16llx - %16llx %s\n",
1237 reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
1238 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr + rela->r_addend) - rela->r_offset;
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001239 break;
1240 case R_AARCH64_PREL32:
1241 count_relocation(kRelocRelative);
1242 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001243 TRACE_TYPE(RELO, "RELO REL32 %16llx <- %16llx - %16llx %s\n",
1244 reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
1245 if ((static_cast<ElfW(Addr)>(INT32_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset))) &&
1246 ((*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)) <= static_cast<ElfW(Addr)>(UINT32_MAX))) {
1247 *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + rela->r_addend) - rela->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001248 } else {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001249 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1250 (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)),
1251 static_cast<ElfW(Addr)>(INT32_MIN),
1252 static_cast<ElfW(Addr)>(UINT32_MAX));
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001253 return -1;
1254 }
1255 break;
1256 case R_AARCH64_PREL16:
1257 count_relocation(kRelocRelative);
1258 MARK(rela->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001259 TRACE_TYPE(RELO, "RELO REL16 %16llx <- %16llx - %16llx %s\n",
1260 reloc, (sym_addr + rela->r_addend), rela->r_offset, sym_name);
1261 if ((static_cast<ElfW(Addr)>(INT16_MIN) <= (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset))) &&
1262 ((*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)) <= static_cast<ElfW(Addr)>(UINT16_MAX))) {
1263 *reinterpret_cast<ElfW(Addr)*>(reloc) += ((sym_addr + rela->r_addend) - rela->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001264 } else {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001265 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
1266 (*reinterpret_cast<ElfW(Addr)*>(reloc) + ((sym_addr + rela->r_addend) - rela->r_offset)),
1267 static_cast<ElfW(Addr)>(INT16_MIN),
1268 static_cast<ElfW(Addr)>(UINT16_MAX));
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001269 return -1;
1270 }
1271 break;
1272
1273 case R_AARCH64_RELATIVE:
1274 count_relocation(kRelocRelative);
1275 MARK(rela->r_offset);
1276 if (sym) {
1277 DL_ERR("odd RELATIVE form...");
1278 return -1;
1279 }
Elliott Hughes0266ae52014-02-10 17:46:57 -08001280 TRACE_TYPE(RELO, "RELO RELATIVE %16llx <- %16llx\n",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001281 reloc, (base + rela->r_addend));
1282 *reinterpret_cast<ElfW(Addr)*>(reloc) = (base + rela->r_addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001283 break;
1284
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001285 case R_AARCH64_IRELATIVE:
1286 count_relocation(kRelocRelative);
1287 MARK(rela->r_offset);
1288 TRACE_TYPE(RELO, "RELO IRELATIVE %16llx <- %16llx\n", reloc, (base + rela->r_addend));
1289 *reinterpret_cast<ElfW(Addr)*>(reloc) = call_ifunc_resolver(base + rela->r_addend);
1290 break;
1291
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001292 case R_AARCH64_COPY:
Nick Kralevich76e289c2014-07-03 12:04:31 -07001293 /*
1294 * ET_EXEC is not supported so this should not happen.
1295 *
1296 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
1297 *
1298 * Section 4.7.1.10 "Dynamic relocations"
1299 * R_AARCH64_COPY may only appear in executable objects where e_type is
1300 * set to ET_EXEC.
1301 */
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001302 DL_ERR("%s R_AARCH64_COPY relocations are not supported", name);
Nick Kralevich76e289c2014-07-03 12:04:31 -07001303 return -1;
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001304 case R_AARCH64_TLS_TPREL64:
Elliott Hughes0266ae52014-02-10 17:46:57 -08001305 TRACE_TYPE(RELO, "RELO TLS_TPREL64 *** %16llx <- %16llx - %16llx\n",
1306 reloc, (sym_addr + rela->r_addend), rela->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001307 break;
1308 case R_AARCH64_TLS_DTPREL32:
Elliott Hughes0266ae52014-02-10 17:46:57 -08001309 TRACE_TYPE(RELO, "RELO TLS_DTPREL32 *** %16llx <- %16llx - %16llx\n",
1310 reloc, (sym_addr + rela->r_addend), rela->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001311 break;
1312#elif defined(__x86_64__)
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001313 case R_X86_64_JUMP_SLOT:
1314 count_relocation(kRelocAbsolute);
1315 MARK(rela->r_offset);
1316 TRACE_TYPE(RELO, "RELO JMP_SLOT %08zx <- %08zx %s", static_cast<size_t>(reloc),
1317 static_cast<size_t>(sym_addr + rela->r_addend), sym_name);
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001318 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001319 break;
1320 case R_X86_64_GLOB_DAT:
1321 count_relocation(kRelocAbsolute);
1322 MARK(rela->r_offset);
1323 TRACE_TYPE(RELO, "RELO GLOB_DAT %08zx <- %08zx %s", static_cast<size_t>(reloc),
1324 static_cast<size_t>(sym_addr + rela->r_addend), sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001325 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001326 break;
1327 case R_X86_64_RELATIVE:
1328 count_relocation(kRelocRelative);
1329 MARK(rela->r_offset);
1330 if (sym) {
1331 DL_ERR("odd RELATIVE form...");
1332 return -1;
1333 }
1334 TRACE_TYPE(RELO, "RELO RELATIVE %08zx <- +%08zx", static_cast<size_t>(reloc),
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001335 static_cast<size_t>(base));
1336 *reinterpret_cast<ElfW(Addr)*>(reloc) = base + rela->r_addend;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001337 break;
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001338 case R_X86_64_IRELATIVE:
1339 count_relocation(kRelocRelative);
1340 MARK(rela->r_offset);
1341 TRACE_TYPE(RELO, "RELO IRELATIVE %16llx <- %16llx\n", reloc, (base + rela->r_addend));
1342 *reinterpret_cast<ElfW(Addr)*>(reloc) = call_ifunc_resolver(base + rela->r_addend);
1343 break;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001344 case R_X86_64_32:
1345 count_relocation(kRelocRelative);
1346 MARK(rela->r_offset);
1347 TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
1348 static_cast<size_t>(sym_addr), sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001349 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001350 break;
Pavel Chupinc075c182013-10-16 19:13:58 +04001351 case R_X86_64_64:
1352 count_relocation(kRelocRelative);
1353 MARK(rela->r_offset);
1354 TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
1355 static_cast<size_t>(sym_addr), sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001356 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend;
Pavel Chupinc075c182013-10-16 19:13:58 +04001357 break;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001358 case R_X86_64_PC32:
1359 count_relocation(kRelocRelative);
1360 MARK(rela->r_offset);
1361 TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s",
1362 static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc),
1363 static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001364 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + rela->r_addend - reloc;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001365 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001366#endif
Marcus Oaklande365f9d2013-10-10 15:19:31 +01001367
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001368 default:
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001369 DL_ERR("unknown reloc type %d @ %p (%zu)", type, rela, idx);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001370 return -1;
1371 }
1372 }
1373 return 0;
1374}
Chris Dearman99186652014-02-06 20:36:51 -08001375
1376#else // REL, not RELA.
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001377int soinfo::Relocate(ElfW(Rel)* rel, unsigned count) {
Elliott Hughes46882792012-08-03 16:49:39 -07001378 for (size_t idx = 0; idx < count; ++idx, ++rel) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001379 unsigned type = ELFW(R_TYPE)(rel->r_info);
1380 // TODO: don't use unsigned for 'sym'. Use uint32_t or ElfW(Addr) instead.
1381 unsigned sym = ELFW(R_SYM)(rel->r_info);
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001382 ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001383 ElfW(Addr) sym_addr = 0;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001384 const char* sym_name = nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001385
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001386 DEBUG("Processing '%s' relocation at index %zd", name, idx);
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001387 if (type == 0) { // R_*_NONE
1388 continue;
1389 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001390
1391 ElfW(Sym)* s = nullptr;
1392 soinfo* lsi = nullptr;
1393
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08001394 if (sym != 0) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001395 sym_name = reinterpret_cast<const char*>(strtab + symtab[sym].st_name);
1396 s = soinfo_do_lookup(this, sym_name, &lsi);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001397 if (s == nullptr) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001398 // We only allow an undefined symbol if this is a weak reference...
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001399 s = &symtab[sym];
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001400 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001401 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, name);
Doug Kwane8238072009-10-26 12:05:23 -07001402 return -1;
1403 }
1404
1405 /* IHI0044C AAELF 4.5.1.1:
1406
1407 Libraries are not searched to resolve weak references.
1408 It is not an error for a weak reference to remain
1409 unsatisfied.
1410
1411 During linking, the value of an undefined weak reference is:
1412 - Zero if the relocation type is absolute
1413 - The address of the place if the relocation is pc-relative
Elliott Hughesbedfe382012-08-14 14:07:59 -07001414 - The address of nominal base address if the relocation
Doug Kwane8238072009-10-26 12:05:23 -07001415 type is base-relative.
1416 */
1417
1418 switch (type) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001419#if defined(__arm__)
Doug Kwane8238072009-10-26 12:05:23 -07001420 case R_ARM_JUMP_SLOT:
1421 case R_ARM_GLOB_DAT:
1422 case R_ARM_ABS32:
1423 case R_ARM_RELATIVE: /* Don't care. */
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001424 // sym_addr was initialized to be zero above or relocation
1425 // code below does not care about value of sym_addr.
1426 // No need to do anything.
1427 break;
1428#elif defined(__i386__)
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001429 case R_386_JMP_SLOT:
Doug Kwane8238072009-10-26 12:05:23 -07001430 case R_386_GLOB_DAT:
1431 case R_386_32:
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001432 case R_386_RELATIVE: /* Don't care. */
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001433 case R_386_IRELATIVE:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001434 // sym_addr was initialized to be zero above or relocation
1435 // code below does not care about value of sym_addr.
1436 // No need to do anything.
Doug Kwane8238072009-10-26 12:05:23 -07001437 break;
Doug Kwane8238072009-10-26 12:05:23 -07001438 case R_386_PC32:
1439 sym_addr = reloc;
1440 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001441#endif
Doug Kwane8238072009-10-26 12:05:23 -07001442
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001443#if defined(__arm__)
Doug Kwane8238072009-10-26 12:05:23 -07001444 case R_ARM_COPY:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001445 // Fall through. Can't really copy if weak symbol is not found at run-time.
1446#endif
Doug Kwane8238072009-10-26 12:05:23 -07001447 default:
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001448 DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rel, idx);
Doug Kwane8238072009-10-26 12:05:23 -07001449 return -1;
1450 }
1451 } else {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001452 // We got a definition.
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001453 sym_addr = lsi->resolve_symbol_address(s);
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001454 }
Elliott Hughesbedfe382012-08-14 14:07:59 -07001455 count_relocation(kRelocSymbol);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001456 }
1457
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001458 switch (type) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001459#if defined(__arm__)
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001460 case R_ARM_JUMP_SLOT:
Elliott Hughesbedfe382012-08-14 14:07:59 -07001461 count_relocation(kRelocAbsolute);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001462 MARK(rel->r_offset);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001463 TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001464 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001465 break;
1466 case R_ARM_GLOB_DAT:
Elliott Hughesbedfe382012-08-14 14:07:59 -07001467 count_relocation(kRelocAbsolute);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001468 MARK(rel->r_offset);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001469 TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001470 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001471 break;
1472 case R_ARM_ABS32:
Elliott Hughesbedfe382012-08-14 14:07:59 -07001473 count_relocation(kRelocAbsolute);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001474 MARK(rel->r_offset);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001475 TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001476 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001477 break;
David 'Digit' Turner34ea5112009-11-17 14:56:26 -08001478 case R_ARM_REL32:
Elliott Hughesbedfe382012-08-14 14:07:59 -07001479 count_relocation(kRelocRelative);
David 'Digit' Turner34ea5112009-11-17 14:56:26 -08001480 MARK(rel->r_offset);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001481 TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s",
David 'Digit' Turner34ea5112009-11-17 14:56:26 -08001482 reloc, sym_addr, rel->r_offset, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001483 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
David 'Digit' Turner34ea5112009-11-17 14:56:26 -08001484 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001485 case R_ARM_COPY:
Nick Kralevich76e289c2014-07-03 12:04:31 -07001486 /*
1487 * ET_EXEC is not supported so this should not happen.
1488 *
1489 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
1490 *
1491 * Section 4.7.1.10 "Dynamic relocations"
1492 * R_ARM_COPY may only appear in executable objects where e_type is
1493 * set to ET_EXEC.
1494 */
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001495 DL_ERR("%s R_ARM_COPY relocations are not supported", name);
Nick Kralevich76e289c2014-07-03 12:04:31 -07001496 return -1;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001497#elif defined(__i386__)
1498 case R_386_JMP_SLOT:
1499 count_relocation(kRelocAbsolute);
1500 MARK(rel->r_offset);
1501 TRACE_TYPE(RELO, "RELO JMP_SLOT %08x <- %08x %s", reloc, sym_addr, sym_name);
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001502 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001503 break;
1504 case R_386_GLOB_DAT:
1505 count_relocation(kRelocAbsolute);
1506 MARK(rel->r_offset);
1507 TRACE_TYPE(RELO, "RELO GLOB_DAT %08x <- %08x %s", reloc, sym_addr, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001508 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001509 break;
1510 case R_386_32:
1511 count_relocation(kRelocRelative);
1512 MARK(rel->r_offset);
1513 TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001514 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001515 break;
1516 case R_386_PC32:
1517 count_relocation(kRelocRelative);
1518 MARK(rel->r_offset);
1519 TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s",
1520 reloc, (sym_addr - reloc), sym_addr, reloc, sym_name);
Elliott Hughes0266ae52014-02-10 17:46:57 -08001521 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr - reloc);
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001522 break;
1523#elif defined(__mips__)
1524 case R_MIPS_REL32:
Chris Dearman99186652014-02-06 20:36:51 -08001525#if defined(__LP64__)
1526 // MIPS Elf64_Rel entries contain compound relocations
1527 // We only handle the R_MIPS_NONE|R_MIPS_64|R_MIPS_REL32 case
1528 if (ELF64_R_TYPE2(rel->r_info) != R_MIPS_64 ||
1529 ELF64_R_TYPE3(rel->r_info) != R_MIPS_NONE) {
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001530 DL_ERR("Unexpected compound relocation type:%d type2:%d type3:%d @ %p (%zu)",
Chris Dearman99186652014-02-06 20:36:51 -08001531 type, (unsigned)ELF64_R_TYPE2(rel->r_info),
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001532 (unsigned)ELF64_R_TYPE3(rel->r_info), rel, idx);
Chris Dearman99186652014-02-06 20:36:51 -08001533 return -1;
1534 }
1535#endif
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001536 count_relocation(kRelocAbsolute);
1537 MARK(rel->r_offset);
Chris Dearman99186652014-02-06 20:36:51 -08001538 TRACE_TYPE(RELO, "RELO REL32 %08zx <- %08zx %s", static_cast<size_t>(reloc),
1539 static_cast<size_t>(sym_addr), sym_name ? sym_name : "*SECTIONHDR*");
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001540 if (s) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001541 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001542 } else {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001543 *reinterpret_cast<ElfW(Addr)*>(reloc) += base;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001544 }
1545 break;
1546#endif
1547
1548#if defined(__arm__)
1549 case R_ARM_RELATIVE:
1550#elif defined(__i386__)
1551 case R_386_RELATIVE:
1552#endif
1553 count_relocation(kRelocRelative);
1554 MARK(rel->r_offset);
1555 if (sym) {
1556 DL_ERR("odd RELATIVE form...");
1557 return -1;
1558 }
1559 TRACE_TYPE(RELO, "RELO RELATIVE %p <- +%p",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001560 reinterpret_cast<void*>(reloc), reinterpret_cast<void*>(base));
1561 *reinterpret_cast<ElfW(Addr)*>(reloc) += base;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001562 break;
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001563#if defined(__i386__)
1564 case R_386_IRELATIVE:
1565 count_relocation(kRelocRelative);
1566 MARK(rel->r_offset);
1567 TRACE_TYPE(RELO, "RELO IRELATIVE %p <- %p", reinterpret_cast<void*>(reloc), reinterpret_cast<void*>(base));
1568 *reinterpret_cast<ElfW(Addr)*>(reloc) = call_ifunc_resolver(base + *reinterpret_cast<ElfW(Addr)*>(reloc));
1569 break;
1570#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001571
1572 default:
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08001573 DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001574 return -1;
1575 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001576 }
1577 return 0;
1578}
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001579#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001580
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001581#if defined(__mips__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001582static bool mips_relocate_got(soinfo* si) {
Chris Dearman99186652014-02-06 20:36:51 -08001583 ElfW(Addr)** got = si->plt_got;
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001584 if (got == nullptr) {
Brian Carlstrom87c35852013-08-20 21:05:44 -07001585 return true;
1586 }
1587 unsigned local_gotno = si->mips_local_gotno;
1588 unsigned gotsym = si->mips_gotsym;
1589 unsigned symtabno = si->mips_symtabno;
Elliott Hughes0266ae52014-02-10 17:46:57 -08001590 ElfW(Sym)* symtab = si->symtab;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001591
Chris Dearman99186652014-02-06 20:36:51 -08001592 // got[0] is the address of the lazy resolver function.
1593 // got[1] may be used for a GNU extension.
1594 // Set it to a recognizable address in case someone calls it (should be _rtld_bind_start).
1595 // FIXME: maybe this should be in a separate routine?
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001596 if ((si->flags & FLAG_LINKER) == 0) {
Brian Carlstrom87c35852013-08-20 21:05:44 -07001597 size_t g = 0;
Chris Dearman99186652014-02-06 20:36:51 -08001598 got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadbeef);
1599 if (reinterpret_cast<intptr_t>(got[g]) < 0) {
1600 got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadfeed);
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001601 }
Chris Dearman99186652014-02-06 20:36:51 -08001602 // Relocate the local GOT entries.
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001603 for (; g < local_gotno; g++) {
Chris Dearman99186652014-02-06 20:36:51 -08001604 got[g] = reinterpret_cast<ElfW(Addr)*>(reinterpret_cast<uintptr_t>(got[g]) + si->load_bias);
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001605 }
1606 }
1607
Chris Dearman99186652014-02-06 20:36:51 -08001608 // Now for the global GOT entries...
Elliott Hughes0266ae52014-02-10 17:46:57 -08001609 ElfW(Sym)* sym = symtab + gotsym;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001610 got = si->plt_got + local_gotno;
Brian Carlstrom87c35852013-08-20 21:05:44 -07001611 for (size_t g = gotsym; g < symtabno; g++, sym++, got++) {
Chris Dearman99186652014-02-06 20:36:51 -08001612 // This is an undefined reference... try to locate it.
1613 const char* sym_name = si->strtab + sym->st_name;
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001614 soinfo* lsi = nullptr;
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001615 ElfW(Sym)* s = soinfo_do_lookup(si, sym_name, &lsi);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001616 if (s == nullptr) {
Chris Dearman99186652014-02-06 20:36:51 -08001617 // We only allow an undefined symbol if this is a weak reference.
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001618 s = &symtab[g];
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001619 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
Elliott Hughes46882792012-08-03 16:49:39 -07001620 DL_ERR("cannot locate \"%s\"...", sym_name);
Brian Carlstrom87c35852013-08-20 21:05:44 -07001621 return false;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001622 }
1623 *got = 0;
Chris Dearman99186652014-02-06 20:36:51 -08001624 } else {
1625 // FIXME: is this sufficient?
1626 // For reference see NetBSD link loader
1627 // http://cvsweb.netbsd.org/bsdweb.cgi/src/libexec/ld.elf_so/arch/mips/mips_reloc.c?rev=1.53&content-type=text/x-cvsweb-markup
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001628 *got = reinterpret_cast<ElfW(Addr)*>(lsi->resolve_symbol_address(s));
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001629 }
1630 }
Brian Carlstrom87c35852013-08-20 21:05:44 -07001631 return true;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07001632}
1633#endif
1634
Kito Cheng812fd422014-03-25 22:53:56 +08001635void soinfo::CallArray(const char* array_name __unused, linker_function_t* functions, size_t count, bool reverse) {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001636 if (functions == nullptr) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07001637 return;
1638 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02001639
Elliott Hughesc6200592013-09-30 18:43:46 -07001640 TRACE("[ Calling %s (size %zd) @ %p for '%s' ]", array_name, count, functions, name);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001641
1642 int begin = reverse ? (count - 1) : 0;
1643 int end = reverse ? -1 : count;
1644 int step = reverse ? -1 : 1;
1645
1646 for (int i = begin; i != end; i += step) {
1647 TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
1648 CallFunction("function", functions[i]);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001649 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02001650
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001651 TRACE("[ Done calling %s for '%s' ]", array_name, name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001652}
1653
Kito Cheng812fd422014-03-25 22:53:56 +08001654void soinfo::CallFunction(const char* function_name __unused, linker_function_t function) {
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001655 if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07001656 return;
1657 }
1658
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001659 TRACE("[ Calling %s @ %p for '%s' ]", function_name, function, name);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001660 function();
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001661 TRACE("[ Done calling %s @ %p for '%s' ]", function_name, function, name);
Elliott Hughesdb492b32013-01-03 15:44:03 -08001662
1663 // The function may have called dlopen(3) or dlclose(3), so we need to ensure our data structures
1664 // are still writable. This happens with our debug malloc (see http://b/7941716).
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001665 protect_data(PROT_READ | PROT_WRITE);
Evgeniy Stepanov9181a5d2012-08-13 17:58:37 +04001666}
1667
Elliott Hughesd23736e2012-11-01 15:16:56 -07001668void soinfo::CallPreInitConstructors() {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001669 // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
1670 // but ignored in a shared library.
Elliott Hughesd23736e2012-11-01 15:16:56 -07001671 CallArray("DT_PREINIT_ARRAY", preinit_array, preinit_array_count, false);
1672}
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04001673
Elliott Hughesd23736e2012-11-01 15:16:56 -07001674void soinfo::CallConstructors() {
1675 if (constructors_called) {
1676 return;
1677 }
Jesse Hallf5d16932012-01-30 15:39:57 -08001678
Elliott Hughesd23736e2012-11-01 15:16:56 -07001679 // We set constructors_called before actually calling the constructors, otherwise it doesn't
1680 // protect against recursive constructor calls. One simple example of constructor recursion
1681 // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
1682 // 1. The program depends on libc, so libc's constructor is called here.
1683 // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
1684 // 3. dlopen() calls the constructors on the newly created
1685 // soinfo for libc_malloc_debug_leak.so.
1686 // 4. The debug .so depends on libc, so CallConstructors is
1687 // called again with the libc soinfo. If it doesn't trigger the early-
1688 // out above, the libc constructor will be called again (recursively!).
1689 constructors_called = true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001690
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07001691 if ((flags & FLAG_EXE) == 0 && preinit_array != nullptr) {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001692 // The GNU dynamic linker silently ignores these, but we warn the developer.
Elliott Hughesc6200592013-09-30 18:43:46 -07001693 PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!",
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001694 name, preinit_array_count);
Elliott Hughesd23736e2012-11-01 15:16:56 -07001695 }
1696
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001697 get_children().for_each([] (soinfo* si) {
1698 si->CallConstructors();
1699 });
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04001700
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001701 TRACE("\"%s\": calling constructors", name);
1702
1703 // DT_INIT should be called before DT_INIT_ARRAY if both are present.
Elliott Hughesd23736e2012-11-01 15:16:56 -07001704 CallFunction("DT_INIT", init_func);
1705 CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04001706}
David 'Digit' Turner82156792009-05-18 14:37:41 +02001707
Elliott Hughesd23736e2012-11-01 15:16:56 -07001708void soinfo::CallDestructors() {
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001709 if (!constructors_called) {
1710 return;
1711 }
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001712 TRACE("\"%s\": calling destructors", name);
1713
1714 // DT_FINI_ARRAY must be parsed in reverse order.
Elliott Hughesd23736e2012-11-01 15:16:56 -07001715 CallArray("DT_FINI_ARRAY", fini_array, fini_array_count, true);
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001716
1717 // DT_FINI should be called after DT_FINI_ARRAY if both are present.
Elliott Hughesd23736e2012-11-01 15:16:56 -07001718 CallFunction("DT_FINI", fini_func);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001719
1720 // This is needed on second call to dlopen
1721 // after library has been unloaded with RTLD_NODELETE
1722 constructors_called = false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001723}
1724
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001725void soinfo::add_child(soinfo* child) {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001726 if (has_min_version(0)) {
Dmitriy Ivanov8de1dde2014-09-04 18:23:00 -07001727 child->parents.push_back(this);
1728 this->children.push_back(child);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001729 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001730}
1731
1732void soinfo::remove_all_links() {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001733 if (!has_min_version(0)) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001734 return;
1735 }
1736
1737 // 1. Untie connected soinfos from 'this'.
1738 children.for_each([&] (soinfo* child) {
1739 child->parents.remove_if([&] (const soinfo* parent) {
1740 return parent == this;
1741 });
1742 });
1743
1744 parents.for_each([&] (soinfo* parent) {
Dmitriy Ivanov4d01d082014-08-29 14:01:48 -07001745 parent->children.remove_if([&] (const soinfo* child) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001746 return child == this;
1747 });
1748 });
1749
1750 // 2. Once everything untied - clear local lists.
1751 parents.clear();
1752 children.clear();
1753}
1754
1755void soinfo::set_st_dev(dev_t dev) {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001756 if (has_min_version(0)) {
1757 st_dev = dev;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001758 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001759}
1760
1761void soinfo::set_st_ino(ino_t ino) {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001762 if (has_min_version(0)) {
1763 st_ino = ino;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001764 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001765}
1766
1767dev_t soinfo::get_st_dev() {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001768 if (has_min_version(0)) {
1769 return st_dev;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001770 }
1771
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001772 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001773};
1774
1775ino_t soinfo::get_st_ino() {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001776 if (has_min_version(0)) {
1777 return st_ino;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001778 }
1779
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001780 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001781}
1782
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001783// This is a return on get_children()/get_parents() if
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001784// 'this->flags' does not have FLAG_NEW_SOINFO set.
1785static soinfo::soinfo_list_t g_empty_list;
1786
1787soinfo::soinfo_list_t& soinfo::get_children() {
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001788 if (has_min_version(0)) {
1789 return this->children;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001790 }
1791
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07001792 return g_empty_list;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001793}
1794
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001795soinfo::soinfo_list_t& soinfo::get_parents() {
1796 if ((this->flags & FLAG_NEW_SOINFO) == 0) {
1797 return g_empty_list;
1798 }
1799
1800 return this->parents;
1801}
1802
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07001803ElfW(Addr) soinfo::resolve_symbol_address(ElfW(Sym)* s) {
1804 if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) {
1805 return call_ifunc_resolver(s->st_value + load_bias);
1806 }
1807
1808 return static_cast<ElfW(Addr)>(s->st_value + load_bias);
1809}
1810
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001811/* Force any of the closed stdin, stdout and stderr to be associated with
1812 /dev/null. */
Elliott Hughes5419b942012-10-16 15:54:46 -07001813static int nullify_closed_stdio() {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001814 int dev_null, i, status;
1815 int return_value = 0;
1816
David 'Digit' Turner16084162012-06-12 16:25:37 +02001817 dev_null = TEMP_FAILURE_RETRY(open("/dev/null", O_RDWR));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001818 if (dev_null < 0) {
Elliott Hughes46882792012-08-03 16:49:39 -07001819 DL_ERR("cannot open /dev/null: %s", strerror(errno));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001820 return -1;
1821 }
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001822 TRACE("[ Opened /dev/null file-descriptor=%d]", dev_null);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001823
1824 /* If any of the stdio file descriptors is valid and not associated
1825 with /dev/null, dup /dev/null to it. */
1826 for (i = 0; i < 3; i++) {
1827 /* If it is /dev/null already, we are done. */
Elliott Hughes46882792012-08-03 16:49:39 -07001828 if (i == dev_null) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001829 continue;
Elliott Hughes46882792012-08-03 16:49:39 -07001830 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001831
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001832 TRACE("[ Nullifying stdio file descriptor %d]", i);
Elliott Hughes46882792012-08-03 16:49:39 -07001833 status = TEMP_FAILURE_RETRY(fcntl(i, F_GETFL));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001834
Elliott Hughes46882792012-08-03 16:49:39 -07001835 /* If file is opened, we are good. */
1836 if (status != -1) {
1837 continue;
1838 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001839
1840 /* The only error we allow is that the file descriptor does not
1841 exist, in which case we dup /dev/null to it. */
1842 if (errno != EBADF) {
Elliott Hughes46882792012-08-03 16:49:39 -07001843 DL_ERR("fcntl failed: %s", strerror(errno));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001844 return_value = -1;
1845 continue;
1846 }
1847
1848 /* Try dupping /dev/null to this stdio file descriptor and
1849 repeat if there is a signal. Note that any errors in closing
1850 the stdio descriptor are lost. */
Elliott Hughes46882792012-08-03 16:49:39 -07001851 status = TEMP_FAILURE_RETRY(dup2(dev_null, i));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001852 if (status < 0) {
Elliott Hughes46882792012-08-03 16:49:39 -07001853 DL_ERR("dup2 failed: %s", strerror(errno));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001854 return_value = -1;
1855 continue;
1856 }
1857 }
1858
1859 /* If /dev/null is not one of the stdio file descriptors, close it. */
1860 if (dev_null > 2) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001861 TRACE("[ Closing /dev/null file-descriptor=%d]", dev_null);
Elliott Hughes46882792012-08-03 16:49:39 -07001862 status = TEMP_FAILURE_RETRY(close(dev_null));
1863 if (status == -1) {
1864 DL_ERR("close failed: %s", strerror(errno));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001865 return_value = -1;
1866 }
1867 }
1868
1869 return return_value;
1870}
1871
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001872bool soinfo::PrelinkImage() {
Ningsheng Jian04f5f412014-09-16 15:22:10 +08001873 /* Extract dynamic section */
1874 ElfW(Word) dynamic_flags = 0;
1875 phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);
Dmitriy Ivanovc0133a72014-09-05 14:57:59 -07001876
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001877 /* We can't log anything until the linker is relocated */
1878 bool relocating_linker = (flags & FLAG_LINKER) != 0;
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001879 if (!relocating_linker) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001880 INFO("[ linking %s ]", name);
1881 DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags);
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001882 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001883
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001884 if (dynamic == nullptr) {
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001885 if (!relocating_linker) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001886 DL_ERR("missing PT_DYNAMIC in \"%s\"", name);
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001887 }
Elliott Hughes124fae92012-10-31 14:20:03 -07001888 return false;
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02001889 } else {
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001890 if (!relocating_linker) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001891 DEBUG("dynamic = %p", dynamic);
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02001892 }
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02001893 }
1894
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001895#if defined(__arm__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001896 (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias,
1897 &ARM_exidx, &ARM_exidx_count);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02001898#endif
1899
Elliott Hughes8147d3c2013-05-09 14:19:58 -07001900 // Extract useful information from dynamic section.
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08001901 uint32_t needed_count = 0;
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001902 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001903 DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p",
1904 d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
1905 switch (d->d_tag) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001906 case DT_HASH:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001907 nbucket = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
1908 nchain = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
1909 bucket = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
1910 chain = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket * 4);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001911 break;
1912 case DT_STRTAB:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001913 strtab = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001914 break;
1915 case DT_SYMTAB:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001916 symtab = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001917 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001918#if !defined(__LP64__)
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001919 case DT_PLTREL:
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08001920 if (d->d_un.d_val != DT_REL) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001921 DL_ERR("unsupported DT_RELA in \"%s\"", name);
Elliott Hughes124fae92012-10-31 14:20:03 -07001922 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001923 }
1924 break;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001925#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001926 case DT_JMPREL:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001927#if defined(USE_RELA)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001928 plt_rela = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001929#else
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001930 plt_rel = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001931#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001932 break;
1933 case DT_PLTRELSZ:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001934#if defined(USE_RELA)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001935 plt_rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001936#else
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001937 plt_rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001938#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001939 break;
Chris Dearman99186652014-02-06 20:36:51 -08001940#if defined(__mips__)
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001941 case DT_PLTGOT:
Chris Dearman99186652014-02-06 20:36:51 -08001942 // Used by mips and mips64.
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001943 plt_got = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001944 break;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001945#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001946 case DT_DEBUG:
Elliott Hughesbedfe382012-08-14 14:07:59 -07001947 // Set the DT_DEBUG entry to the address of _r_debug for GDB
Chris Dearmancf239052013-01-11 15:32:20 -08001948 // if the dynamic table is writable
Chris Dearman99186652014-02-06 20:36:51 -08001949// FIXME: not working currently for N64
1950// The flags for the LOAD and DYNAMIC program headers do not agree.
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07001951// The LOAD section containing the dynamic table has been mapped as
Chris Dearman99186652014-02-06 20:36:51 -08001952// read-only, but the DYNAMIC header claims it is writable.
1953#if !(defined(__mips__) && defined(__LP64__))
Elliott Hughes99c32052013-01-14 09:56:21 -08001954 if ((dynamic_flags & PF_W) != 0) {
Elliott Hughesc6200592013-09-30 18:43:46 -07001955 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
Elliott Hughes99c32052013-01-14 09:56:21 -08001956 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001957 break;
Chris Dearman99186652014-02-06 20:36:51 -08001958#endif
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07001959#if defined(USE_RELA)
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001960 case DT_RELA:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001961 rela = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001962 break;
1963 case DT_RELASZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001964 rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001965 break;
1966 case DT_REL:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001967 DL_ERR("unsupported DT_REL in \"%s\"", name);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001968 return false;
1969 case DT_RELSZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001970 DL_ERR("unsupported DT_RELSZ in \"%s\"", name);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001971 return false;
1972#else
1973 case DT_REL:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001974 rel = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001975 break;
1976 case DT_RELSZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001977 rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001978 break;
Shin-ichiro KAWASAKIad13c572009-11-06 10:36:37 +09001979 case DT_RELA:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001980 DL_ERR("unsupported DT_RELA in \"%s\"", name);
Elliott Hughes124fae92012-10-31 14:20:03 -07001981 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001982#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001983 case DT_INIT:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001984 init_func = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
1985 DEBUG("%s constructors (DT_INIT) found at %p", name, init_func);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001986 break;
1987 case DT_FINI:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001988 fini_func = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
1989 DEBUG("%s destructors (DT_FINI) found at %p", name, fini_func);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001990 break;
1991 case DT_INIT_ARRAY:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001992 init_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
1993 DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", name, init_array);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001994 break;
1995 case DT_INIT_ARRAYSZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001996 init_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001997 break;
1998 case DT_FINI_ARRAY:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07001999 fini_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
2000 DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", name, fini_array);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002001 break;
2002 case DT_FINI_ARRAYSZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002003 fini_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002004 break;
2005 case DT_PREINIT_ARRAY:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002006 preinit_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
2007 DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", name, preinit_array);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002008 break;
2009 case DT_PREINIT_ARRAYSZ:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002010 preinit_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002011 break;
2012 case DT_TEXTREL:
Elliott Hughese4d792a2013-10-28 14:19:05 -07002013#if defined(__LP64__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002014 DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", name);
Elliott Hughese4d792a2013-10-28 14:19:05 -07002015 return false;
2016#else
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002017 has_text_relocations = true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002018 break;
Elliott Hughese4d792a2013-10-28 14:19:05 -07002019#endif
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002020 case DT_SYMBOLIC:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002021 has_DT_SYMBOLIC = true;
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002022 break;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002023 case DT_NEEDED:
2024 ++needed_count;
2025 break;
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002026 case DT_FLAGS:
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002027 if (d->d_un.d_val & DF_TEXTREL) {
Elliott Hughese4d792a2013-10-28 14:19:05 -07002028#if defined(__LP64__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002029 DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", name);
Elliott Hughese4d792a2013-10-28 14:19:05 -07002030 return false;
2031#else
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002032 has_text_relocations = true;
Elliott Hughese4d792a2013-10-28 14:19:05 -07002033#endif
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002034 }
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002035 if (d->d_un.d_val & DF_SYMBOLIC) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002036 has_DT_SYMBOLIC = true;
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002037 }
2038 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002039#if defined(__mips__)
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002040 case DT_STRSZ:
2041 case DT_SYMENT:
2042 case DT_RELENT:
2043 break;
2044 case DT_MIPS_RLD_MAP:
Elliott Hughesbedfe382012-08-14 14:07:59 -07002045 // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB.
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002046 {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002047 r_debug** dp = reinterpret_cast<r_debug**>(load_bias + d->d_un.d_ptr);
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002048 *dp = &_r_debug;
2049 }
2050 break;
2051 case DT_MIPS_RLD_VERSION:
2052 case DT_MIPS_FLAGS:
2053 case DT_MIPS_BASE_ADDRESS:
2054 case DT_MIPS_UNREFEXTNO:
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002055 break;
2056
2057 case DT_MIPS_SYMTABNO:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002058 mips_symtabno = d->d_un.d_val;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002059 break;
2060
2061 case DT_MIPS_LOCAL_GOTNO:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002062 mips_local_gotno = d->d_un.d_val;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002063 break;
2064
2065 case DT_MIPS_GOTSYM:
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002066 mips_gotsym = d->d_un.d_val;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002067 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002068#endif
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002069
2070 default:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002071 DEBUG("Unused DT entry: type %p arg %p",
2072 reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002073 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002074 }
2075 }
2076
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002077 DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002078 reinterpret_cast<void*>(base), strtab, symtab);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002079
Elliott Hughes124fae92012-10-31 14:20:03 -07002080 // Sanity checks.
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002081 if (relocating_linker && needed_count != 0) {
2082 DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
2083 return false;
2084 }
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002085 if (nbucket == 0) {
2086 DL_ERR("empty/missing DT_HASH in \"%s\" (built with --hash-style=gnu?)", name);
Elliott Hughes124fae92012-10-31 14:20:03 -07002087 return false;
2088 }
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002089 if (strtab == 0) {
2090 DL_ERR("empty/missing DT_STRTAB in \"%s\"", name);
Elliott Hughes124fae92012-10-31 14:20:03 -07002091 return false;
2092 }
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002093 if (symtab == 0) {
2094 DL_ERR("empty/missing DT_SYMTAB in \"%s\"", name);
Elliott Hughes124fae92012-10-31 14:20:03 -07002095 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002096 }
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002097 return true;
2098}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002099
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002100bool soinfo::LinkImage(const android_dlextinfo* extinfo) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002101
Elliott Hughese4d792a2013-10-28 14:19:05 -07002102#if !defined(__LP64__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002103 if (has_text_relocations) {
Elliott Hughese4d792a2013-10-28 14:19:05 -07002104 // Make segments writable to allow text relocations to work properly. We will later call
2105 // phdr_table_protect_segments() after all of them are applied and all constructors are run.
Nick Kralevich3d4470c2013-10-22 12:06:36 -07002106 DL_WARN("%s has text relocations. This is wasting memory and prevents "
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002107 "security hardening. Please fix.", name);
2108 if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) {
Nick Kralevich5135b3a2012-08-10 21:08:42 -07002109 DL_ERR("can't unprotect loadable segments for \"%s\": %s",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002110 name, strerror(errno));
Elliott Hughes124fae92012-10-31 14:20:03 -07002111 return false;
Nick Kralevich5135b3a2012-08-10 21:08:42 -07002112 }
2113 }
Elliott Hughese4d792a2013-10-28 14:19:05 -07002114#endif
Nick Kralevich5135b3a2012-08-10 21:08:42 -07002115
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002116#if defined(USE_RELA)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002117 if (rela != nullptr) {
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002118 DEBUG("[ relocating %s ]", name);
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002119 if (Relocate(rela, rela_count)) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002120 return false;
2121 }
2122 }
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002123 if (plt_rela != nullptr) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002124 DEBUG("[ relocating %s plt ]", name);
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002125 if (Relocate(plt_rela, plt_rela_count)) {
Elliott Hughes124fae92012-10-31 14:20:03 -07002126 return false;
2127 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002128 }
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002129#else
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002130 if (rel != nullptr) {
2131 DEBUG("[ relocating %s ]", name);
2132 if (Relocate(rel, rel_count)) {
Elliott Hughes124fae92012-10-31 14:20:03 -07002133 return false;
2134 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002135 }
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002136 if (plt_rel != nullptr) {
2137 DEBUG("[ relocating %s plt ]", name);
2138 if (Relocate(plt_rel, plt_rel_count)) {
2139 return false;
2140 }
Brigid Smith31b88da2014-07-23 11:22:25 -07002141 }
Dmitriy Ivanovf4cb6312014-09-11 15:16:03 -07002142#endif
Brigid Smith31b88da2014-07-23 11:22:25 -07002143
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002144#if defined(__mips__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002145 if (!mips_relocate_got(this)) {
Elliott Hughes124fae92012-10-31 14:20:03 -07002146 return false;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07002147 }
2148#endif
2149
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002150 DEBUG("[ finished linking %s ]", name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002151
Elliott Hughese4d792a2013-10-28 14:19:05 -07002152#if !defined(__LP64__)
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002153 if (has_text_relocations) {
Elliott Hughese4d792a2013-10-28 14:19:05 -07002154 // All relocations are done, we can protect our segments back to read-only.
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002155 if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) {
Nick Kralevich5135b3a2012-08-10 21:08:42 -07002156 DL_ERR("can't protect segments for \"%s\": %s",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002157 name, strerror(errno));
Elliott Hughes124fae92012-10-31 14:20:03 -07002158 return false;
Nick Kralevich5135b3a2012-08-10 21:08:42 -07002159 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002160 }
Elliott Hughese4d792a2013-10-28 14:19:05 -07002161#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002162
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002163 /* We can also turn on GNU RELRO protection */
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002164 if (phdr_table_protect_gnu_relro(phdr, phnum, load_bias) < 0) {
Elliott Hughes46882792012-08-03 16:49:39 -07002165 DL_ERR("can't enable GNU RELRO protection for \"%s\": %s",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002166 name, strerror(errno));
Elliott Hughes124fae92012-10-31 14:20:03 -07002167 return false;
Nick Kralevich9ec0f032012-02-28 10:40:00 -08002168 }
2169
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002170 /* Handle serializing/sharing the RELRO segment */
2171 if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002172 if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias,
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002173 extinfo->relro_fd) < 0) {
2174 DL_ERR("failed serializing GNU RELRO section for \"%s\": %s",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002175 name, strerror(errno));
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002176 return false;
2177 }
2178 } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002179 if (phdr_table_map_gnu_relro(phdr, phnum, load_bias,
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002180 extinfo->relro_fd) < 0) {
2181 DL_ERR("failed mapping GNU RELRO section for \"%s\": %s",
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002182 name, strerror(errno));
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00002183 return false;
2184 }
2185 }
2186
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002187 notify_gdb_of_load(this);
Elliott Hughes124fae92012-10-31 14:20:03 -07002188 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002189}
2190
Nick Kralevich468319c2011-11-11 15:53:17 -08002191/*
Sergey Melnikovc45087b2013-01-25 16:40:13 +04002192 * This function add vdso to internal dso list.
2193 * It helps to stack unwinding through signal handlers.
2194 * Also, it makes bionic more like glibc.
2195 */
Kito Cheng812fd422014-03-25 22:53:56 +08002196static void add_vdso(KernelArgumentBlock& args __unused) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002197#if defined(AT_SYSINFO_EHDR)
Elliott Hughes0266ae52014-02-10 17:46:57 -08002198 ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR));
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002199 if (ehdr_vdso == nullptr) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08002200 return;
2201 }
Sergey Melnikovc45087b2013-01-25 16:40:13 +04002202
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002203 soinfo* si = soinfo_alloc("[vdso]", nullptr);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04002204
Elliott Hughes0266ae52014-02-10 17:46:57 -08002205 si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff);
2206 si->phnum = ehdr_vdso->e_phnum;
2207 si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso);
2208 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002209 si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04002210
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002211 si->PrelinkImage();
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002212 si->LinkImage(nullptr);
Sergey Melnikovc45087b2013-01-25 16:40:13 +04002213#endif
2214}
2215
2216/*
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002217 * This is linker soinfo for GDB. See details below.
2218 */
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07002219#if defined(__LP64__)
2220#define LINKER_PATH "/system/bin/linker64"
2221#else
2222#define LINKER_PATH "/system/bin/linker"
2223#endif
2224static soinfo linker_soinfo_for_gdb(LINKER_PATH, nullptr);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002225
2226/* gdb expects the linker to be in the debug shared object list.
2227 * Without this, gdb has trouble locating the linker's ".text"
2228 * and ".plt" sections. Gdb could also potentially use this to
2229 * relocate the offset of our exported 'rtld_db_dlactivity' symbol.
2230 * Don't use soinfo_alloc(), because the linker shouldn't
2231 * be on the soinfo list.
2232 */
2233static void init_linker_info_for_gdb(ElfW(Addr) linker_base) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002234 linker_soinfo_for_gdb.base = linker_base;
2235
2236 /*
2237 * Set the dynamic field in the link map otherwise gdb will complain with
2238 * the following:
2239 * warning: .dynamic section for "/system/bin/linker" is not at the
2240 * expected address (wrong library or version mismatch?)
2241 */
2242 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base);
2243 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff);
2244 phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
Ningsheng Jian04f5f412014-09-16 15:22:10 +08002245 &linker_soinfo_for_gdb.dynamic, nullptr);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002246 insert_soinfo_into_debug_map(&linker_soinfo_for_gdb);
2247}
2248
2249/*
Nick Kralevich468319c2011-11-11 15:53:17 -08002250 * This code is called after the linker has linked itself and
2251 * fixed it's own GOT. It is safe to make references to externs
2252 * and other non-local data at this point.
2253 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08002254static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW(Addr) linker_base) {
Evgeniy Stepanov1a78fbb2012-03-22 18:01:53 +04002255#if TIMING
2256 struct timeval t0, t1;
2257 gettimeofday(&t0, 0);
2258#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002259
Elliott Hughes18a206c2012-10-29 17:37:13 -07002260 // Initialize environment functions, and get to the ELF aux vectors table.
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002261 linker_env_init(args);
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01002262
Nick Kralevich8d3e91d2013-04-25 13:15:24 -07002263 // If this is a setuid/setgid program, close the security hole described in
2264 // ftp://ftp.freebsd.org/pub/FreeBSD/CERT/advisories/FreeBSD-SA-02:23.stdio.asc
2265 if (get_AT_SECURE()) {
2266 nullify_closed_stdio();
2267 }
2268
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002269 debuggerd_init();
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002270
Elliott Hughes18a206c2012-10-29 17:37:13 -07002271 // Get a few environment variables.
Elliott Hughes61a9ccb2012-11-02 12:37:13 -07002272 const char* LD_DEBUG = linker_env_get("LD_DEBUG");
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002273 if (LD_DEBUG != nullptr) {
Elliott Hughes1728b232014-05-14 10:02:03 -07002274 g_ld_debug_verbosity = atoi(LD_DEBUG);
Elliott Hughes18a206c2012-10-29 17:37:13 -07002275 }
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01002276
Elliott Hughes18a206c2012-10-29 17:37:13 -07002277 // Normally, these are cleaned by linker_env_init, but the test
2278 // doesn't cost us anything.
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002279 const char* ldpath_env = nullptr;
2280 const char* ldpreload_env = nullptr;
Elliott Hughes18a206c2012-10-29 17:37:13 -07002281 if (!get_AT_SECURE()) {
2282 ldpath_env = linker_env_get("LD_LIBRARY_PATH");
2283 ldpreload_env = linker_env_get("LD_PRELOAD");
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002284 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002285
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002286 INFO("[ android linker & debugger ]");
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002287
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002288 soinfo* si = soinfo_alloc(args.argv[0], nullptr);
2289 if (si == nullptr) {
Elliott Hughes18a206c2012-10-29 17:37:13 -07002290 exit(EXIT_FAILURE);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002291 }
2292
Nick Kralevichd39c3ab2012-08-24 13:25:51 -07002293 /* bootstrap the link map, the main exe always needs to be first */
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002294 si->flags |= FLAG_EXE;
Elliott Hughes3a9c5d62014-02-10 13:31:13 -08002295 link_map* map = &(si->link_map_head);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002296
2297 map->l_addr = 0;
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002298 map->l_name = args.argv[0];
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002299 map->l_prev = nullptr;
2300 map->l_next = nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002301
2302 _r_debug.r_map = map;
2303 r_debug_tail = map;
2304
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002305 init_linker_info_for_gdb(linker_base);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002306
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002307 // Extract information passed from the kernel.
Elliott Hughes0266ae52014-02-10 17:46:57 -08002308 si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002309 si->phnum = args.getauxval(AT_PHNUM);
2310 si->entry = args.getauxval(AT_ENTRY);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002311
David 'Digit' Turner8180b082011-11-15 17:17:28 +01002312 /* Compute the value of si->base. We can't rely on the fact that
2313 * the first entry is the PHDR because this will not be true
2314 * for certain executables (e.g. some in the NDK unit test suite)
2315 */
David 'Digit' Turner8180b082011-11-15 17:17:28 +01002316 si->base = 0;
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002317 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02002318 si->load_bias = 0;
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002319 for (size_t i = 0; i < si->phnum; ++i) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002320 if (si->phdr[i].p_type == PT_PHDR) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08002321 si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
2322 si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002323 break;
2324 }
David 'Digit' Turner8180b082011-11-15 17:17:28 +01002325 }
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002326 si->dynamic = nullptr;
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002327 si->ref_count = 1;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002328
Nick Kralevich2aebf542014-05-07 10:32:39 -07002329 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);
2330 if (elf_hdr->e_type != ET_DYN) {
2331 __libc_format_fd(2, "error: only position independent executables (PIE) are supported.\n");
2332 exit(EXIT_FAILURE);
2333 }
2334
Elliott Hughes46882792012-08-03 16:49:39 -07002335 // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
2336 parse_LD_LIBRARY_PATH(ldpath_env);
2337 parse_LD_PRELOAD(ldpreload_env);
Matt Fischer4fd42c12009-12-31 12:09:10 -06002338
Ard Biesheuvel5ae44f32012-08-30 12:48:32 +02002339 somain = si;
2340
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002341 si->PrelinkImage();
2342
2343 // Load ld_preloads and dependencies.
2344 StringLinkedList needed_library_name_list;
2345 size_t needed_libraries_count = 0;
2346 size_t ld_preloads_count = 0;
2347 while (g_ld_preload_names[ld_preloads_count] != nullptr) {
2348 needed_library_name_list.push_back(g_ld_preload_names[ld_preloads_count++]);
2349 ++needed_libraries_count;
2350 }
2351
2352 for_each_dt_needed(si, [&](const char* name) {
2353 needed_library_name_list.push_back(name);
2354 ++needed_libraries_count;
2355 });
2356
2357 const char* needed_library_names[needed_libraries_count];
2358 soinfo* needed_library_si[needed_libraries_count];
2359
2360 memset(needed_library_names, 0, sizeof(needed_library_names));
2361 needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count);
2362
2363 if (needed_libraries_count > 0 && !find_libraries(needed_library_names, needed_libraries_count, needed_library_si, g_ld_preloads, ld_preloads_count, 0, nullptr)) {
2364 __libc_format_fd(2, "CANNOT LINK EXECUTABLE DEPENDENCIES: %s\n", linker_get_error_buffer());
2365 exit(EXIT_FAILURE);
2366 }
2367
2368 for (size_t i = 0; i<needed_libraries_count; ++i) {
2369 si->add_child(needed_library_si[i]);
2370 }
2371
Dmitriy Ivanov7210c412014-09-02 11:47:23 -07002372 if (!si->LinkImage(nullptr)) {
Elliott Hughes650be4e2013-03-05 18:47:58 -08002373 __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer());
Elliott Hughes18a206c2012-10-29 17:37:13 -07002374 exit(EXIT_FAILURE);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002375 }
2376
Sergey Melnikovc45087b2013-01-25 16:40:13 +04002377 add_vdso(args);
2378
Elliott Hughesd23736e2012-11-01 15:16:56 -07002379 si->CallPreInitConstructors();
Evgeniy Stepanov9181a5d2012-08-13 17:58:37 +04002380
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002381 /* After the PrelinkImage, the si->load_bias is initialized.
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002382 * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
2383 * We need to update this value for so exe here. So Unwind_Backtrace
2384 * for some arch like x86 could work correctly within so exe.
Xiaokang Qin9c3449e2012-09-13 18:07:24 +08002385 */
Chao-Ying Fuc5db9692012-11-15 02:00:17 -08002386 map->l_addr = si->load_bias;
Elliott Hughesd23736e2012-11-01 15:16:56 -07002387 si->CallConstructors();
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04002388
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002389#if TIMING
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002390 gettimeofday(&t1, nullptr);
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002391 PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) (
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002392 (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08002393 (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002394#endif
2395#if STATS
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002396 PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0],
Elliott Hughesbedfe382012-08-14 14:07:59 -07002397 linker_stats.count[kRelocAbsolute],
2398 linker_stats.count[kRelocRelative],
2399 linker_stats.count[kRelocCopy],
2400 linker_stats.count[kRelocSymbol]);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002401#endif
2402#if COUNT_PAGES
2403 {
2404 unsigned n;
2405 unsigned i;
2406 unsigned count = 0;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002407 for (n = 0; n < 4096; n++) {
2408 if (bitmask[n]) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002409 unsigned x = bitmask[n];
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002410#if defined(__LP64__)
2411 for (i = 0; i < 32; i++) {
2412#else
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002413 for (i = 0; i < 8; i++) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002414#endif
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08002415 if (x & 1) {
2416 count++;
2417 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002418 x >>= 1;
2419 }
2420 }
2421 }
Elliott Hughesca0c11b2013-03-12 10:40:45 -07002422 PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002423 }
2424#endif
2425
2426#if TIMING || STATS || COUNT_PAGES
2427 fflush(stdout);
2428#endif
2429
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002430 TRACE("[ Ready to execute '%s' @ %p ]", si->name, reinterpret_cast<void*>(si->entry));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002431 return si->entry;
2432}
Nick Kralevich468319c2011-11-11 15:53:17 -08002433
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02002434/* Compute the load-bias of an existing executable. This shall only
2435 * be used to compute the load bias of an executable or shared library
2436 * that was loaded by the kernel itself.
2437 *
2438 * Input:
2439 * elf -> address of ELF header, assumed to be at the start of the file.
2440 * Return:
2441 * load bias, i.e. add the value of any p_vaddr in the file to get
2442 * the corresponding address in memory.
2443 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08002444static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) {
2445 ElfW(Addr) offset = elf->e_phoff;
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08002446 const ElfW(Phdr)* phdr_table = reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002447 const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02002448
Elliott Hughes0266ae52014-02-10 17:46:57 -08002449 for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08002450 if (phdr->p_type == PT_LOAD) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08002451 return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02002452 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08002453 }
2454 return 0;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02002455}
2456
Dmitriy Ivanov5febb0d2014-07-28 15:05:51 -07002457extern "C" void _start();
2458
Nick Kralevich468319c2011-11-11 15:53:17 -08002459/*
2460 * This is the entry point for the linker, called from begin.S. This
2461 * method is responsible for fixing the linker's own relocations, and
2462 * then calling __linker_init_post_relocation().
2463 *
2464 * Because this method is called before the linker has fixed it's own
2465 * relocations, any attempt to reference an extern variable, extern
2466 * function, or other GOT reference will generate a segfault.
2467 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08002468extern "C" ElfW(Addr) __linker_init(void* raw_args) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002469 KernelArgumentBlock args(raw_args);
Nick Kralevich468319c2011-11-11 15:53:17 -08002470
Elliott Hughes0266ae52014-02-10 17:46:57 -08002471 ElfW(Addr) linker_addr = args.getauxval(AT_BASE);
Dmitriy Ivanov5febb0d2014-07-28 15:05:51 -07002472 ElfW(Addr) entry_point = args.getauxval(AT_ENTRY);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002473 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08002474 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);
Nick Kralevich468319c2011-11-11 15:53:17 -08002475
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07002476 soinfo linker_so("[dynamic linker]", nullptr);
Nick Kralevich468319c2011-11-11 15:53:17 -08002477
Dmitriy Ivanov5febb0d2014-07-28 15:05:51 -07002478 // If the linker is not acting as PT_INTERP entry_point is equal to
2479 // _start. Which means that the linker is running as an executable and
2480 // already linked by PT_INTERP.
2481 //
2482 // This happens when user tries to run 'adb shell /system/bin/linker'
2483 // see also https://code.google.com/p/android/issues/detail?id=63174
2484 if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point) {
2485 __libc_fatal("This is %s, the helper program for shared library executables.\n", args.argv[0]);
2486 }
2487
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002488 linker_so.base = linker_addr;
2489 linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
2490 linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
Dmitriy Ivanovcfad7ae2014-08-29 12:02:36 -07002491 linker_so.dynamic = nullptr;
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002492 linker_so.phdr = phdr;
2493 linker_so.phnum = elf_hdr->e_phnum;
2494 linker_so.flags |= FLAG_LINKER;
Elliott Hughes5419b942012-10-16 15:54:46 -07002495
Dmitriy Ivanovae69a952014-09-05 16:42:53 -07002496 if (!(linker_so.PrelinkImage() && linker_so.LinkImage(nullptr))) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002497 // It would be nice to print an error message, but if the linker
2498 // can't link itself, there's no guarantee that we'll be able to
Elliott Hughesb93702a2013-12-21 16:07:45 -08002499 // call write() (because it involves a GOT reference). We may as
2500 // well try though...
2501 const char* msg = "CANNOT LINK EXECUTABLE: ";
2502 write(2, msg, strlen(msg));
2503 write(2, __linker_dl_err_buf, strlen(__linker_dl_err_buf));
2504 write(2, "\n", 1);
2505 _exit(EXIT_FAILURE);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002506 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07002507
Dmitriy Ivanov93c3f422014-08-26 14:16:52 -07002508 __libc_init_tls(args);
2509
Dmitriy Ivanov5febb0d2014-07-28 15:05:51 -07002510 // Initialize the linker's own global variables
Dmitriy Ivanov65549962014-07-24 15:33:25 -07002511 linker_so.CallConstructors();
2512
Dmitriy Ivanov3bbd2182014-08-22 12:25:04 -07002513 // Initialize static variables. Note that in order to
2514 // get correct libdl_info we need to call constructors
2515 // before get_libdl_info().
2516 solist = get_libdl_info();
2517 sonext = get_libdl_info();
2518
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002519 // We have successfully fixed our own relocations. It's safe to run
2520 // the main part of the linker now.
Elliott Hughes1728b232014-05-14 10:02:03 -07002521 args.abort_message_ptr = &g_abort_message;
Elliott Hughes0266ae52014-02-10 17:46:57 -08002522 ElfW(Addr) start_address = __linker_init_post_relocation(args, linker_addr);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002523
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002524 protect_data(PROT_READ);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08002525
2526 // Return the address that the calling assembly stub should jump to.
2527 return start_address;
Nick Kralevich468319c2011-11-11 15:53:17 -08002528}