blob: 9b1f97b3f3c45a50a25e4ad602b578f922da7b0c [file] [log] [blame]
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001/*
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002 * Copyright (C) 2008 The Android Open Source Project
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 * * Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * * Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in
12 * the documentation and/or other materials provided with the
13 * distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * SUCH DAMAGE.
27 */
28
Dmitriy Ivanov19133522015-06-02 17:36:54 -070029#include <android/api-level.h>
Elliott Hughes46882792012-08-03 16:49:39 -070030#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>
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -080038#include <sys/param.h>
Elliott Hughes46882792012-08-03 16:49:39 -070039#include <unistd.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080040
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070041#include <new>
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070042#include <string>
Dmitriy Ivanovb4827502015-09-28 16:38:31 -070043#include <unordered_map>
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070044#include <vector>
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070045
Elliott Hughes46882792012-08-03 16:49:39 -070046// Private C library headers.
Mingwei Shi9ce09e42015-11-12 07:02:14 +000047#include "private/bionic_globals.h"
Elliott Hugheseb847bc2013-10-09 15:50:50 -070048#include "private/bionic_tls.h"
49#include "private/KernelArgumentBlock.h"
50#include "private/ScopedPthreadMutexLocker.h"
Dmitriy Ivanov14669a92014-09-05 16:42:53 -070051#include "private/ScopeGuard.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080052
53#include "linker.h"
Dmitriy Ivanovc9ce70d2015-03-10 15:30:26 -070054#include "linker_block_allocator.h"
Dimitry Ivanoved70f6a2016-02-17 16:08:03 -080055#include "linker_gdb_support.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080056#include "linker_debug.h"
Dimitry Ivanovdf91dc22016-02-25 15:22:04 -080057#include "linker_dlwarning.h"
Dmitriy Ivanov18870d32015-04-22 13:10:04 -070058#include "linker_sleb128.h"
David 'Digit' Turner23363ed2012-06-18 18:13:49 +020059#include "linker_phdr.h"
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -080060#include "linker_relocs.h"
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -080061#include "linker_reloc_iterators.h"
Dmitriy Ivanova1feb112015-10-01 18:41:57 -070062#include "linker_utils.h"
tony.ys_liub4474402015-07-29 18:00:22 +080063
Elliott Hughes939a7e02015-12-04 15:27:46 -080064#include "android-base/strings.h"
Simon Baldwinaef71952015-01-16 13:22:54 +000065#include "ziparchive/zip_archive.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080066
Josh Gao93c0f5e2015-10-06 11:08:13 -070067extern void __libc_init_globals(KernelArgumentBlock&);
Elliott Hughes1801db32015-06-08 18:04:00 -070068extern void __libc_init_AT_SECURE(KernelArgumentBlock&);
69
Mingwei Shi9ce09e42015-11-12 07:02:14 +000070extern "C" void _start();
71
Elliott Hughes1801db32015-06-08 18:04:00 -070072// Override macros to use C++ style casts.
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -080073#undef ELF_ST_TYPE
74#define ELF_ST_TYPE(x) (static_cast<uint32_t>(x) & 0xf)
75
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -070076struct android_namespace_t {
77 public:
78 android_namespace_t() : name_(nullptr), is_isolated_(false) {}
79
80 const char* get_name() const { return name_; }
81 void set_name(const char* name) { name_ = name; }
82
83 bool is_isolated() const { return is_isolated_; }
84 void set_isolated(bool isolated) { is_isolated_ = isolated; }
85
86 const std::vector<std::string>& get_ld_library_paths() const {
87 return ld_library_paths_;
88 }
89 void set_ld_library_paths(std::vector<std::string>&& library_paths) {
90 ld_library_paths_ = library_paths;
91 }
92
93 const std::vector<std::string>& get_default_library_paths() const {
94 return default_library_paths_;
95 }
96 void set_default_library_paths(std::vector<std::string>&& library_paths) {
97 default_library_paths_ = library_paths;
98 }
99
Dimitry Ivanov350bdad2016-03-01 13:11:28 -0800100 const std::vector<std::string>& get_permitted_paths() const {
101 return permitted_paths_;
102 }
Dimitry Ivanov284ae352015-12-08 10:47:13 -0800103 void set_permitted_paths(std::vector<std::string>&& permitted_paths) {
104 permitted_paths_ = permitted_paths;
105 }
106
Dimitry Ivanovae74e872016-03-24 15:30:30 -0700107 void add_soinfo(soinfo* si) {
108 soinfo_list_.push_back(si);
109 }
110
111 void add_soinfos(const soinfo::soinfo_list_t& soinfos) {
112 for (auto si : soinfos) {
113 add_soinfo(si);
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -0700114 si->add_secondary_namespace(this);
Dimitry Ivanovae74e872016-03-24 15:30:30 -0700115 }
116 }
117
118 void remove_soinfo(soinfo* si) {
119 soinfo_list_.remove_if([&](soinfo* candidate) {
120 return si == candidate;
121 });
122 }
123
124 const soinfo::soinfo_list_t& soinfo_list() const { return soinfo_list_; }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700125
126 // For isolated namespaces - checks if the file is on the search path;
127 // always returns true for not isolated namespace.
128 bool is_accessible(const std::string& path);
129
130 private:
131 const char* name_;
132 bool is_isolated_;
133 std::vector<std::string> ld_library_paths_;
134 std::vector<std::string> default_library_paths_;
Dimitry Ivanov284ae352015-12-08 10:47:13 -0800135 std::vector<std::string> permitted_paths_;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700136 soinfo::soinfo_list_t soinfo_list_;
137
138 DISALLOW_COPY_AND_ASSIGN(android_namespace_t);
139};
140
141android_namespace_t g_default_namespace;
Dimitry Ivanov49cfc892016-05-12 15:20:21 -0700142
Dimitry Ivanovae74e872016-03-24 15:30:30 -0700143static std::unordered_map<uintptr_t, soinfo*> g_soinfo_handles_map;
144static android_namespace_t* g_anonymous_namespace = &g_default_namespace;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700145
Elliott Hughes0266ae52014-02-10 17:46:57 -0800146static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800147
Dmitriy Ivanov600bc3c2015-03-10 15:43:50 -0700148static LinkerTypeAllocator<soinfo> g_soinfo_allocator;
149static LinkerTypeAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
Magnus Malmbornba98d922012-09-12 13:00:55 +0200150
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700151static LinkerTypeAllocator<android_namespace_t> g_namespace_allocator;
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -0700152static LinkerTypeAllocator<LinkedListEntry<android_namespace_t>> g_namespace_list_allocator;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700153
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700154static soinfo* solist;
155static soinfo* sonext;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700156static soinfo* somain; // main process, always the one after libdl_info
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800157
Elliott Hughes1728b232014-05-14 10:02:03 -0700158static const char* const kDefaultLdPaths[] = {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700159#if defined(__LP64__)
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700160 "/system/lib64",
Dimitry Ivanov88f51112016-02-01 23:00:55 -0800161 "/vendor/lib64",
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700162#else
Elliott Hughes124fae92012-10-31 14:20:03 -0700163 "/system/lib",
Dimitry Ivanov88f51112016-02-01 23:00:55 -0800164 "/vendor/lib",
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700165#endif
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700166 nullptr
Elliott Hughes124fae92012-10-31 14:20:03 -0700167};
David Bartleybc3a5c22009-06-02 18:27:28 -0700168
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700169static const char* const kAsanDefaultLdPaths[] = {
170#if defined(__LP64__)
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700171 "/data/lib64",
172 "/system/lib64",
Dimitry Ivanov88f51112016-02-01 23:00:55 -0800173 "/data/vendor/lib64",
174 "/vendor/lib64",
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700175#else
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700176 "/data/lib",
177 "/system/lib",
Dimitry Ivanov88f51112016-02-01 23:00:55 -0800178 "/data/vendor/lib",
179 "/vendor/lib",
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700180#endif
181 nullptr
182};
183
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -0800184static bool is_system_library(const std::string& realpath) {
185 for (const auto& dir : g_default_namespace.get_default_library_paths()) {
186 if (file_is_in_dir(realpath, dir)) {
187 return true;
188 }
189 }
190 return false;
191}
192
Dimitry Ivanovb8e37692016-02-12 13:33:19 -0800193#if defined(__LP64__)
194static const char* const kSystemLibDir = "/system/lib64";
195#else
196static const char* const kSystemLibDir = "/system/lib";
197#endif
198
199static std::string dirname(const char *path);
200
Dimitry Ivanovf1d4a492016-05-23 17:33:27 -0700201// TODO(dimitry): The grey-list is a workaround for http://b/26394120 ---
202// gradually remove libraries from this list until it is gone.
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -0800203static bool is_greylisted(const char* name, const soinfo* needed_by) {
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800204 static const char* const kLibraryGreyList[] = {
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -0800205 "libandroid_runtime.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800206 "libbinder.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800207 "libcrypto.so",
208 "libcutils.so",
Dimitry Ivanov5981d5b2016-04-08 09:49:07 -0700209 "libexpat.so",
Dimitry Ivanov8e3a3fb2016-04-12 14:53:06 -0700210 "libgui.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800211 "libmedia.so",
212 "libnativehelper.so",
Dimitry Ivanova2a05012016-01-25 15:48:44 -0800213 "libskia.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800214 "libssl.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800215 "libstagefright.so",
Dimitry Ivanov31e910c2016-03-03 18:13:18 -0800216 "libsqlite.so",
Dimitry Ivanov78dfc402016-01-12 10:37:38 -0800217 "libui.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800218 "libutils.so",
Dimitry Ivanov19b5e8c2016-04-27 16:55:45 -0700219 "libvorbisidec.so",
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800220 nullptr
221 };
222
Dimitry Ivanovf1db47a2016-01-11 10:20:15 -0800223 // limit greylisting to apps targeting sdk version 23 and below
224 if (get_application_target_sdk_version() > 23) {
225 return false;
226 }
227
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -0800228 // if the library needed by a system library - implicitly assume it
229 // is greylisted
230
231 if (needed_by != nullptr && is_system_library(needed_by->get_realpath())) {
232 return true;
233 }
234
Dimitry Ivanovb8e37692016-02-12 13:33:19 -0800235 // if this is an absolute path - make sure it points to /system/lib(64)
236 if (name[0] == '/' && dirname(name) == kSystemLibDir) {
237 // and reduce the path to basename
238 name = basename(name);
239 }
240
Dimitry Ivanova8bda262016-01-07 11:16:43 -0800241 for (size_t i = 0; kLibraryGreyList[i] != nullptr; ++i) {
242 if (strcmp(name, kLibraryGreyList[i]) == 0) {
243 return true;
244 }
245 }
246
247 return false;
248}
249// END OF WORKAROUND
250
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700251static const ElfW(Versym) kVersymNotNeeded = 0;
252static const ElfW(Versym) kVersymGlobal = 1;
253
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700254static const char* const* g_default_ld_paths;
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700255static std::vector<std::string> g_ld_preload_names;
Elliott Hughesa4aafd12014-01-13 16:37:47 -0800256
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700257static std::vector<soinfo*> g_ld_preloads;
Matt Fischer4fd42c12009-12-31 12:09:10 -0600258
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700259static bool g_public_namespace_initialized;
260static soinfo::soinfo_list_t g_public_namespace;
261
Elliott Hughes1728b232014-05-14 10:02:03 -0700262__LIBC_HIDDEN__ int g_ld_debug_verbosity;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800263
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700264__LIBC_HIDDEN__ abort_msg_t* g_abort_message = nullptr; // For debuggerd.
Elliott Hughes0d787c12013-04-04 13:46:46 -0700265
Evgenii Stepanov68650822015-06-10 13:38:39 -0700266static std::string dirname(const char *path) {
267 const char* last_slash = strrchr(path, '/');
268 if (last_slash == path) return "/";
269 else if (last_slash == nullptr) return ".";
270 else
271 return std::string(path, last_slash - path);
272}
273
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800274#if STATS
Elliott Hughesbedfe382012-08-14 14:07:59 -0700275struct linker_stats_t {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700276 int count[kRelocMax];
Elliott Hughesbedfe382012-08-14 14:07:59 -0700277};
278
279static linker_stats_t linker_stats;
280
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800281void count_relocation(RelocationKind kind) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700282 ++linker_stats.count[kind];
Elliott Hughesbedfe382012-08-14 14:07:59 -0700283}
284#else
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800285void count_relocation(RelocationKind) {
Elliott Hughesbedfe382012-08-14 14:07:59 -0700286}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800287#endif
288
289#if COUNT_PAGES
Dmitriy Ivanov114ff692015-01-14 11:36:38 -0800290uint32_t bitmask[4096];
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800291#endif
292
Dima Zavin2e855792009-05-20 18:28:09 -0700293static char __linker_dl_err_buf[768];
Dima Zavin2e855792009-05-20 18:28:09 -0700294
Elliott Hughes650be4e2013-03-05 18:47:58 -0800295char* linker_get_error_buffer() {
Elliott Hughes5419b942012-10-16 15:54:46 -0700296 return &__linker_dl_err_buf[0];
Dima Zavin2e855792009-05-20 18:28:09 -0700297}
298
Elliott Hughes650be4e2013-03-05 18:47:58 -0800299size_t linker_get_error_buffer_size() {
300 return sizeof(__linker_dl_err_buf);
301}
302
Elliott Hughesbedfe382012-08-14 14:07:59 -0700303static void notify_gdb_of_load(soinfo* info) {
Dimitry Ivanov9acb3b72016-03-01 15:55:56 -0800304 if (info->is_linker() || info->is_main_executable()) {
305 // gdb already knows about the linker and the main executable.
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700306 return;
307 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800308
Dimitry Ivanoved70f6a2016-02-17 16:08:03 -0800309 link_map* map = &(info->link_map_head);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800310
Dimitry Ivanoved70f6a2016-02-17 16:08:03 -0800311 map->l_addr = info->load_bias;
312 // link_map l_name field is not const.
313 map->l_name = const_cast<char*>(info->get_realpath());
314 map->l_ld = info->dynamic;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800315
Dimitry Ivanov9acb3b72016-03-01 15:55:56 -0800316 CHECK(map->l_name != nullptr);
317 CHECK(map->l_name[0] != '\0');
318
Dimitry Ivanoved70f6a2016-02-17 16:08:03 -0800319 notify_gdb_of_load(map);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700320}
321
Elliott Hughesbedfe382012-08-14 14:07:59 -0700322static void notify_gdb_of_unload(soinfo* info) {
Dimitry Ivanoved70f6a2016-02-17 16:08:03 -0800323 notify_gdb_of_unload(&(info->link_map_head));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800324}
325
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700326bool android_namespace_t::is_accessible(const std::string& file) {
327 if (!is_isolated_) {
328 return true;
329 }
330
331 for (const auto& dir : ld_library_paths_) {
332 if (file_is_in_dir(file, dir)) {
333 return true;
334 }
335 }
336
337 for (const auto& dir : default_library_paths_) {
338 if (file_is_in_dir(file, dir)) {
339 return true;
340 }
341 }
342
Dimitry Ivanov284ae352015-12-08 10:47:13 -0800343 for (const auto& dir : permitted_paths_) {
344 if (file_is_under_dir(file, dir)) {
345 return true;
346 }
347 }
348
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700349 return false;
350}
351
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700352LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {
353 return g_soinfo_links_allocator.alloc();
354}
355
356void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {
357 g_soinfo_links_allocator.free(entry);
358}
359
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -0700360LinkedListEntry<android_namespace_t>* NamespaceListAllocator::alloc() {
361 return g_namespace_list_allocator.alloc();
362}
363
364void NamespaceListAllocator::free(LinkedListEntry<android_namespace_t>* entry) {
365 g_namespace_list_allocator.free(entry);
366}
367
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700368static soinfo* soinfo_alloc(android_namespace_t* ns, const char* name,
369 struct stat* file_stat, off64_t file_offset,
370 uint32_t rtld_flags) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700371 if (strlen(name) >= PATH_MAX) {
Magnus Malmbornba98d922012-09-12 13:00:55 +0200372 DL_ERR("library name \"%s\" too long", name);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700373 return nullptr;
Magnus Malmbornba98d922012-09-12 13:00:55 +0200374 }
375
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700376 soinfo* si = new (g_soinfo_allocator.alloc()) soinfo(ns, name, file_stat,
377 file_offset, rtld_flags);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700378
Magnus Malmbornba98d922012-09-12 13:00:55 +0200379 sonext->next = si;
380 sonext = si;
381
Dimitry Ivanovae74e872016-03-24 15:30:30 -0700382 si->generate_handle();
383 ns->add_soinfo(si);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700384
Elliott Hughesca0c11b2013-03-12 10:40:45 -0700385 TRACE("name %s: allocated soinfo @ %p", name, si);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200386 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800387}
388
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800389static void soinfo_free(soinfo* si) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700390 if (si == nullptr) {
391 return;
392 }
393
394 if (si->base != 0 && si->size != 0) {
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -0800395 if (!si->is_mapped_by_caller()) {
396 munmap(reinterpret_cast<void*>(si->base), si->size);
397 } else {
398 // remap the region as PROT_NONE, MAP_ANONYMOUS | MAP_NORESERVE
399 mmap(reinterpret_cast<void*>(si->base), si->size, PROT_NONE,
400 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
401 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700402 }
403
404 soinfo *prev = nullptr, *trav;
405
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700406 TRACE("name %s: freeing soinfo @ %p", si->get_realpath(), si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700407
408 for (trav = solist; trav != nullptr; trav = trav->next) {
409 if (trav == si) {
410 break;
Elliott Hughes46882792012-08-03 16:49:39 -0700411 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700412 prev = trav;
413 }
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800414
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700415 if (trav == nullptr) {
416 // si was not in solist
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700417 DL_ERR("name \"%s\"@%p is not in solist!", si->get_realpath(), si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700418 return;
419 }
Elliott Hughes46882792012-08-03 16:49:39 -0700420
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700421 // clear links to/from si
422 si->remove_all_links();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700423
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700424 // prev will never be null, because the first entry in solist is
425 // always the static libdl_info.
426 prev->next = si->next;
427 if (si == sonext) {
428 sonext = prev;
429 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800430
Dmitriy Ivanov609f11b2015-07-08 15:26:46 -0700431 si->~soinfo();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700432 g_soinfo_allocator.free(si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800433}
434
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700435// For every path element this function checks of it exists, and is a directory,
436// and normalizes it:
437// 1. For regular path it converts it to realpath()
438// 2. For path in a zip file it uses realpath on the zipfile
439// normalizes entry name by calling normalize_path function.
440static void resolve_paths(std::vector<std::string>& paths,
441 std::vector<std::string>* resolved_paths) {
442 resolved_paths->clear();
443 for (const auto& path : paths) {
444 char resolved_path[PATH_MAX];
445 const char* original_path = path.c_str();
446 if (realpath(original_path, resolved_path) != nullptr) {
447 struct stat s;
448 if (stat(resolved_path, &s) == 0) {
449 if (S_ISDIR(s.st_mode)) {
450 resolved_paths->push_back(resolved_path);
451 } else {
452 DL_WARN("Warning: \"%s\" is not a directory (excluding from path)", resolved_path);
453 continue;
454 }
455 } else {
456 DL_WARN("Warning: cannot stat file \"%s\": %s", resolved_path, strerror(errno));
457 continue;
458 }
459 } else {
460 std::string zip_path;
461 std::string entry_path;
462
463 std::string normalized_path;
464
465 if (!normalize_path(original_path, &normalized_path)) {
466 DL_WARN("Warning: unable to normalize \"%s\"", original_path);
467 continue;
468 }
469
470 if (parse_zip_path(normalized_path.c_str(), &zip_path, &entry_path)) {
471 if (realpath(zip_path.c_str(), resolved_path) == nullptr) {
472 DL_WARN("Warning: unable to resolve \"%s\": %s", zip_path.c_str(), strerror(errno));
473 continue;
474 }
475
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700476 resolved_paths->push_back(std::string(resolved_path) + kZipFileSeparator + entry_path);
477 }
478 }
479 }
480}
481
482static void split_path(const char* path, const char* delimiters,
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700483 std::vector<std::string>* paths) {
Dmitriy Ivanovfbfba642015-11-16 14:23:37 -0800484 if (path != nullptr && path[0] != 0) {
tony.ys_liub4474402015-07-29 18:00:22 +0800485 *paths = android::base::Split(path, delimiters);
Elliott Hughescade4c32012-12-20 14:42:14 -0800486 }
487}
488
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700489static void parse_path(const char* path, const char* delimiters,
490 std::vector<std::string>* resolved_paths) {
491 std::vector<std::string> paths;
492 split_path(path, delimiters, &paths);
493 resolve_paths(paths, resolved_paths);
494}
495
Elliott Hughescade4c32012-12-20 14:42:14 -0800496static void parse_LD_LIBRARY_PATH(const char* path) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700497 std::vector<std::string> ld_libary_paths;
498 parse_path(path, ":", &ld_libary_paths);
499 g_default_namespace.set_ld_library_paths(std::move(ld_libary_paths));
Elliott Hughescade4c32012-12-20 14:42:14 -0800500}
501
Evgenii Stepanov68650822015-06-10 13:38:39 -0700502void soinfo::set_dt_runpath(const char* path) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700503 if (!has_min_version(3)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700504 return;
505 }
506
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700507 std::vector<std::string> runpaths;
508
509 split_path(path, ":", &runpaths);
Evgenii Stepanov68650822015-06-10 13:38:39 -0700510
511 std::string origin = dirname(get_realpath());
512 // FIXME: add $LIB and $PLATFORM.
513 std::pair<std::string, std::string> substs[] = {{"ORIGIN", origin}};
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700514 for (auto&& s : runpaths) {
Evgenii Stepanov68650822015-06-10 13:38:39 -0700515 size_t pos = 0;
516 while (pos < s.size()) {
517 pos = s.find("$", pos);
518 if (pos == std::string::npos) break;
519 for (const auto& subst : substs) {
520 const std::string& token = subst.first;
521 const std::string& replacement = subst.second;
522 if (s.substr(pos + 1, token.size()) == token) {
523 s.replace(pos, token.size() + 1, replacement);
524 // -1 to compensate for the ++pos below.
525 pos += replacement.size() - 1;
526 break;
527 } else if (s.substr(pos + 1, token.size() + 2) == "{" + token + "}") {
528 s.replace(pos, token.size() + 3, replacement);
529 pos += replacement.size() - 1;
530 break;
531 }
532 }
533 // Skip $ in case it did not match any of the known substitutions.
534 ++pos;
535 }
536 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700537
538 resolve_paths(runpaths, &dt_runpath_);
Evgenii Stepanov68650822015-06-10 13:38:39 -0700539}
540
Elliott Hughescade4c32012-12-20 14:42:14 -0800541static void parse_LD_PRELOAD(const char* path) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700542 g_ld_preload_names.clear();
543 if (path != nullptr) {
544 // We have historically supported ':' as well as ' ' in LD_PRELOAD.
545 g_ld_preload_names = android::base::Split(path, " :");
Dimitry Ivanovbda20e72016-05-24 14:29:56 -0700546 std::remove_if(g_ld_preload_names.begin(),
547 g_ld_preload_names.end(),
548 [] (const std::string& s) { return s.empty(); });
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700549 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800550}
551
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700552static bool realpath_fd(int fd, std::string* realpath) {
553 std::vector<char> buf(PATH_MAX), proc_self_fd(PATH_MAX);
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700554 __libc_format_buffer(&proc_self_fd[0], proc_self_fd.size(), "/proc/self/fd/%d", fd);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700555 if (readlink(&proc_self_fd[0], &buf[0], buf.size()) == -1) {
Elliott Hughes38b88a42016-04-01 10:10:54 -0700556 PRINT("readlink(\"%s\") failed: %s [fd=%d]", &proc_self_fd[0], strerror(errno), fd);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700557 return false;
558 }
559
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700560 *realpath = &buf[0];
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700561 return true;
562}
563
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700564#if defined(__arm__)
Elliott Hughes46882792012-08-03 16:49:39 -0700565
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700566// For a given PC, find the .so that it belongs to.
567// Returns the base address of the .ARM.exidx section
568// for that .so, and the number of 8-byte entries
569// in that section (via *pcount).
570//
571// Intended to be called by libc's __gnu_Unwind_Find_exidx().
572//
573// This function is exposed via dlfcn.cpp and libdl.so.
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800574_Unwind_Ptr dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -0800575 uintptr_t addr = reinterpret_cast<uintptr_t>(pc);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800576
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700577 for (soinfo* si = solist; si != 0; si = si->next) {
578 if ((addr >= si->base) && (addr < (si->base + si->size))) {
579 *pcount = si->ARM_exidx_count;
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -0800580 return reinterpret_cast<_Unwind_Ptr>(si->ARM_exidx);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800581 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700582 }
583 *pcount = 0;
584 return nullptr;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800585}
Elliott Hughes46882792012-08-03 16:49:39 -0700586
Christopher Ferris24053a42013-08-19 17:45:09 -0700587#endif
Elliott Hughes46882792012-08-03 16:49:39 -0700588
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700589// Here, we only have to provide a callback to iterate across all the
590// loaded libraries. gcc_eh does the rest.
Dmitriy Ivanov7271caf2015-06-29 14:48:25 -0700591int do_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700592 int rv = 0;
593 for (soinfo* si = solist; si != nullptr; si = si->next) {
594 dl_phdr_info dl_info;
595 dl_info.dlpi_addr = si->link_map_head.l_addr;
596 dl_info.dlpi_name = si->link_map_head.l_name;
597 dl_info.dlpi_phdr = si->phdr;
598 dl_info.dlpi_phnum = si->phnum;
599 rv = cb(&dl_info, sizeof(dl_phdr_info), data);
600 if (rv != 0) {
601 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800602 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700603 }
604 return rv;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800605}
Elliott Hughes46882792012-08-03 16:49:39 -0700606
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700607const ElfW(Versym)* soinfo::get_versym(size_t n) const {
608 if (has_min_version(2) && versym_ != nullptr) {
609 return versym_ + n;
610 }
611
612 return nullptr;
613}
614
615ElfW(Addr) soinfo::get_verneed_ptr() const {
616 if (has_min_version(2)) {
617 return verneed_ptr_;
618 }
619
620 return 0;
621}
622
623size_t soinfo::get_verneed_cnt() const {
624 if (has_min_version(2)) {
625 return verneed_cnt_;
626 }
627
628 return 0;
629}
630
631ElfW(Addr) soinfo::get_verdef_ptr() const {
632 if (has_min_version(2)) {
633 return verdef_ptr_;
634 }
635
636 return 0;
637}
638
639size_t soinfo::get_verdef_cnt() const {
640 if (has_min_version(2)) {
641 return verdef_cnt_;
642 }
643
644 return 0;
645}
646
647template<typename F>
648static bool for_each_verdef(const soinfo* si, F functor) {
649 if (!si->has_min_version(2)) {
650 return true;
651 }
652
653 uintptr_t verdef_ptr = si->get_verdef_ptr();
654 if (verdef_ptr == 0) {
655 return true;
656 }
657
658 size_t offset = 0;
659
660 size_t verdef_cnt = si->get_verdef_cnt();
661 for (size_t i = 0; i<verdef_cnt; ++i) {
662 const ElfW(Verdef)* verdef = reinterpret_cast<ElfW(Verdef)*>(verdef_ptr + offset);
663 size_t verdaux_offset = offset + verdef->vd_aux;
664 offset += verdef->vd_next;
665
666 if (verdef->vd_version != 1) {
Dmitriy Ivanov3d7bea12015-04-20 17:40:39 -0700667 DL_ERR("unsupported verdef[%zd] vd_version: %d (expected 1) library: %s",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700668 i, verdef->vd_version, si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700669 return false;
670 }
671
672 if ((verdef->vd_flags & VER_FLG_BASE) != 0) {
673 // "this is the version of the file itself. It must not be used for
674 // matching a symbol. It can be used to match references."
675 //
676 // http://www.akkadia.org/drepper/symbol-versioning
677 continue;
678 }
679
680 if (verdef->vd_cnt == 0) {
681 DL_ERR("invalid verdef[%zd] vd_cnt == 0 (version without a name)", i);
682 return false;
683 }
684
685 const ElfW(Verdaux)* verdaux = reinterpret_cast<ElfW(Verdaux)*>(verdef_ptr + verdaux_offset);
686
687 if (functor(i, verdef, verdaux) == true) {
688 break;
689 }
690 }
691
692 return true;
693}
694
695bool soinfo::find_verdef_version_index(const version_info* vi, ElfW(Versym)* versym) const {
696 if (vi == nullptr) {
697 *versym = kVersymNotNeeded;
698 return true;
699 }
700
701 *versym = kVersymGlobal;
702
703 return for_each_verdef(this,
704 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
705 if (verdef->vd_hash == vi->elf_hash &&
706 strcmp(vi->name, get_string(verdaux->vda_name)) == 0) {
707 *versym = verdef->vd_ndx;
708 return true;
709 }
710
711 return false;
712 }
713 );
714}
715
716bool soinfo::find_symbol_by_name(SymbolName& symbol_name,
717 const version_info* vi,
718 const ElfW(Sym)** symbol) const {
719 uint32_t symbol_index;
720 bool success =
721 is_gnu_hash() ?
722 gnu_lookup(symbol_name, vi, &symbol_index) :
723 elf_lookup(symbol_name, vi, &symbol_index);
724
725 if (success) {
726 *symbol = symbol_index == 0 ? nullptr : symtab_ + symbol_index;
727 }
728
729 return success;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800730}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800731
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800732static bool is_symbol_global_and_defined(const soinfo* si, const ElfW(Sym)* s) {
733 if (ELF_ST_BIND(s->st_info) == STB_GLOBAL ||
734 ELF_ST_BIND(s->st_info) == STB_WEAK) {
735 return s->st_shndx != SHN_UNDEF;
736 } else if (ELF_ST_BIND(s->st_info) != STB_LOCAL) {
Elliott Hughes38b88a42016-04-01 10:10:54 -0700737 DL_WARN("unexpected ST_BIND value: %d for \"%s\" in \"%s\"",
738 ELF_ST_BIND(s->st_info), si->get_string(s->st_name), si->get_realpath());
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800739 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800740
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800741 return false;
742}
743
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700744static const ElfW(Versym) kVersymHiddenBit = 0x8000;
745
746static inline bool is_versym_hidden(const ElfW(Versym)* versym) {
747 // the symbol is hidden if bit 15 of versym is set.
748 return versym != nullptr && (*versym & kVersymHiddenBit) != 0;
749}
750
751static inline bool check_symbol_version(const ElfW(Versym) verneed,
752 const ElfW(Versym)* verdef) {
753 return verneed == kVersymNotNeeded ||
754 verdef == nullptr ||
755 verneed == (*verdef & ~kVersymHiddenBit);
756}
757
758bool soinfo::gnu_lookup(SymbolName& symbol_name,
759 const version_info* vi,
760 uint32_t* symbol_index) const {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800761 uint32_t hash = symbol_name.gnu_hash();
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800762 uint32_t h2 = hash >> gnu_shift2_;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800763
764 uint32_t bloom_mask_bits = sizeof(ElfW(Addr))*8;
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800765 uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_;
766 ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800767
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700768 *symbol_index = 0;
769
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700770 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p (gnu)",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700771 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700772
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800773 // test against bloom filter
774 if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700775 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700776 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700777
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700778 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800779 }
780
781 // bloom test says "probably yes"...
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700782 uint32_t n = gnu_bucket_[hash % gnu_nbucket_];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800783
784 if (n == 0) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700785 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700786 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700787
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700788 return true;
789 }
790
791 // lookup versym for the version definition in this library
792 // note the difference between "version is not requested" (vi == nullptr)
793 // and "version not found". In the first case verneed is kVersymNotNeeded
794 // which implies that the default version can be accepted; the second case results in
795 // verneed = 1 (kVersymGlobal) and implies that we should ignore versioned symbols
796 // for this library and consider only *global* ones.
797 ElfW(Versym) verneed = 0;
798 if (!find_verdef_version_index(vi, &verneed)) {
799 return false;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800800 }
801
802 do {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800803 ElfW(Sym)* s = symtab_ + n;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700804 const ElfW(Versym)* verdef = get_versym(n);
805 // skip hidden versions when verneed == kVersymNotNeeded (0)
806 if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) {
807 continue;
808 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700809 if (((gnu_chain_[n] ^ hash) >> 1) == 0 &&
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700810 check_symbol_version(verneed, verdef) &&
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800811 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
812 is_symbol_global_and_defined(this, s)) {
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700813 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700814 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(s->st_value),
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700815 static_cast<size_t>(s->st_size));
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700816 *symbol_index = n;
817 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800818 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -0700819 } while ((gnu_chain_[n++] & 1) == 0);
820
821 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700822 symbol_name.get_name(), get_realpath(), reinterpret_cast<void*>(base));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800823
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700824 return true;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800825}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800826
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700827bool soinfo::elf_lookup(SymbolName& symbol_name,
828 const version_info* vi,
829 uint32_t* symbol_index) const {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800830 uint32_t hash = symbol_name.elf_hash();
831
832 TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700833 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700834 reinterpret_cast<void*>(base), hash, hash % nbucket_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800835
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700836 ElfW(Versym) verneed = 0;
837 if (!find_verdef_version_index(vi, &verneed)) {
838 return false;
839 }
840
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800841 for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) {
842 ElfW(Sym)* s = symtab_ + n;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700843 const ElfW(Versym)* verdef = get_versym(n);
844
845 // skip hidden versions when verneed == 0
846 if (verneed == kVersymNotNeeded && is_versym_hidden(verdef)) {
847 continue;
848 }
849
850 if (check_symbol_version(verneed, verdef) &&
851 strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -0700852 is_symbol_global_and_defined(this, s)) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800853 TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700854 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700855 reinterpret_cast<void*>(s->st_value),
856 static_cast<size_t>(s->st_size));
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700857 *symbol_index = n;
858 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800859 }
Elliott Hughes0266ae52014-02-10 17:46:57 -0800860 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800861
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700862 TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700863 symbol_name.get_name(), get_realpath(),
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700864 reinterpret_cast<void*>(base), hash, hash % nbucket_);
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700865
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700866 *symbol_index = 0;
867 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800868}
869
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700870soinfo::soinfo(android_namespace_t* ns, const char* realpath,
871 const struct stat* file_stat, off64_t file_offset,
872 int rtld_flags) {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700873 memset(this, 0, sizeof(*this));
874
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700875 if (realpath != nullptr) {
876 realpath_ = realpath;
877 }
878
Dmitriy Ivanovab972b92014-11-29 13:57:41 -0800879 flags_ = FLAG_NEW_SOINFO;
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800880 version_ = SOINFO_VERSION;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700881
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700882 if (file_stat != nullptr) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800883 this->st_dev_ = file_stat->st_dev;
884 this->st_ino_ = file_stat->st_ino;
885 this->file_offset_ = file_offset;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700886 }
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -0700887
Dmitriy Ivanov047b5932014-11-13 09:39:20 -0800888 this->rtld_flags_ = rtld_flags;
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -0700889 this->primary_namespace_ = ns;
Dmitriy Ivanov0d150942014-08-22 12:25:04 -0700890}
891
Dimitry Ivanovae74e872016-03-24 15:30:30 -0700892soinfo::~soinfo() {
893 g_soinfo_handles_map.erase(handle_);
894}
895
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -0800896static uint32_t calculate_elf_hash(const char* name) {
897 const uint8_t* name_bytes = reinterpret_cast<const uint8_t*>(name);
898 uint32_t h = 0, g;
899
900 while (*name_bytes) {
901 h = (h << 4) + *name_bytes++;
902 g = h & 0xf0000000;
903 h ^= g;
904 h ^= g >> 24;
905 }
906
907 return h;
908}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800909
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800910uint32_t SymbolName::elf_hash() {
911 if (!has_elf_hash_) {
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -0800912 elf_hash_ = calculate_elf_hash(name_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800913 has_elf_hash_ = true;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700914 }
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800915
916 return elf_hash_;
917}
918
919uint32_t SymbolName::gnu_hash() {
920 if (!has_gnu_hash_) {
921 uint32_t h = 5381;
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700922 const uint8_t* name = reinterpret_cast<const uint8_t*>(name_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800923 while (*name != 0) {
924 h += (h << 5) + *name++; // h*33 + c = h + h * 32 + c = h + h << 5 + c
925 }
926
927 gnu_hash_ = h;
928 has_gnu_hash_ = true;
929 }
930
931 return gnu_hash_;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800932}
933
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700934bool soinfo_do_lookup(soinfo* si_from, const char* name, const version_info* vi,
935 soinfo** si_found_in, const soinfo::soinfo_list_t& global_group,
936 const soinfo::soinfo_list_t& local_group, const ElfW(Sym)** symbol) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800937 SymbolName symbol_name(name);
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700938 const ElfW(Sym)* s = nullptr;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700939
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700940 /* "This element's presence in a shared object library alters the dynamic linker's
941 * symbol resolution algorithm for references within the library. Instead of starting
942 * a symbol search with the executable file, the dynamic linker starts from the shared
943 * object itself. If the shared object fails to supply the referenced symbol, the
944 * dynamic linker then searches the executable file and other shared objects as usual."
945 *
946 * http://www.sco.com/developers/gabi/2012-12-31/ch5.dynamic.html
947 *
948 * Note that this is unlikely since static linker avoids generating
949 * relocations for -Bsymbolic linked dynamic executables.
950 */
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700951 if (si_from->has_DT_SYMBOLIC) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700952 DEBUG("%s: looking up %s in local scope (DT_SYMBOLIC)", si_from->get_realpath(), name);
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700953 if (!si_from->find_symbol_by_name(symbol_name, vi, &s)) {
954 return false;
955 }
956
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -0700957 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700958 *si_found_in = si_from;
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700959 }
960 }
961
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700962 // 1. Look for it in global_group
963 if (s == nullptr) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700964 bool error = false;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700965 global_group.visit([&](soinfo* global_si) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700966 DEBUG("%s: looking up %s in %s (from global group)",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700967 si_from->get_realpath(), name, global_si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700968 if (!global_si->find_symbol_by_name(symbol_name, vi, &s)) {
969 error = true;
970 return false;
971 }
972
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700973 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700974 *si_found_in = global_si;
975 return false;
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700976 }
Dmitriy Ivanovc2048942014-08-29 10:15:25 -0700977
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700978 return true;
979 });
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700980
981 if (error) {
982 return false;
983 }
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -0700984 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700985
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700986 // 2. Look for it in the local group
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700987 if (s == nullptr) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700988 bool error = false;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700989 local_group.visit([&](soinfo* local_si) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -0700990 if (local_si == si_from && si_from->has_DT_SYMBOLIC) {
Dmitriy Ivanove47b3f82014-10-23 14:19:07 -0700991 // we already did this - skip
992 return true;
993 }
994
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700995 DEBUG("%s: looking up %s in %s (from local group)",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -0700996 si_from->get_realpath(), name, local_si->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700997 if (!local_si->find_symbol_by_name(symbol_name, vi, &s)) {
998 error = true;
999 return false;
1000 }
1001
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001002 if (s != nullptr) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07001003 *si_found_in = local_si;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001004 return false;
1005 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001006
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001007 return true;
1008 });
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001009
1010 if (error) {
1011 return false;
1012 }
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001013 }
1014
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001015 if (s != nullptr) {
1016 TRACE_TYPE(LOOKUP, "si %s sym %s s->st_value = %p, "
1017 "found in %s, base = %p, load bias = %p",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07001018 si_from->get_realpath(), name, reinterpret_cast<void*>(s->st_value),
1019 (*si_found_in)->get_realpath(), reinterpret_cast<void*>((*si_found_in)->base),
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07001020 reinterpret_cast<void*>((*si_found_in)->load_bias));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07001021 }
Iliyan Malchev6ed80c82009-09-28 19:38:04 -07001022
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001023 *symbol = s;
1024 return true;
Iliyan Malchev6ed80c82009-09-28 19:38:04 -07001025}
1026
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08001027class ProtectedDataGuard {
1028 public:
1029 ProtectedDataGuard() {
1030 if (ref_count_++ == 0) {
1031 protect_data(PROT_READ | PROT_WRITE);
1032 }
1033 }
1034
1035 ~ProtectedDataGuard() {
1036 if (ref_count_ == 0) { // overflow
1037 __libc_fatal("Too many nested calls to dlopen()");
1038 }
1039
1040 if (--ref_count_ == 0) {
1041 protect_data(PROT_READ);
1042 }
1043 }
1044 private:
1045 void protect_data(int protection) {
1046 g_soinfo_allocator.protect_all(protection);
1047 g_soinfo_links_allocator.protect_all(protection);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001048 g_namespace_allocator.protect_all(protection);
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07001049 g_namespace_list_allocator.protect_all(protection);
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08001050 }
1051
1052 static size_t ref_count_;
1053};
1054
1055size_t ProtectedDataGuard::ref_count_ = 0;
1056
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001057// Each size has it's own allocator.
1058template<size_t size>
1059class SizeBasedAllocator {
1060 public:
1061 static void* alloc() {
1062 return allocator_.alloc();
1063 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -07001064
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001065 static void free(void* ptr) {
1066 allocator_.free(ptr);
1067 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -07001068
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001069 private:
1070 static LinkerBlockAllocator allocator_;
1071};
1072
1073template<size_t size>
1074LinkerBlockAllocator SizeBasedAllocator<size>::allocator_(size);
1075
1076template<typename T>
1077class TypeBasedAllocator {
1078 public:
1079 static T* alloc() {
1080 return reinterpret_cast<T*>(SizeBasedAllocator<sizeof(T)>::alloc());
1081 }
1082
1083 static void free(T* ptr) {
1084 SizeBasedAllocator<sizeof(T)>::free(ptr);
1085 }
1086};
1087
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001088class LoadTask {
1089 public:
1090 struct deleter_t {
1091 void operator()(LoadTask* t) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001092 t->~LoadTask();
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001093 TypeBasedAllocator<LoadTask>::free(t);
1094 }
1095 };
1096
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001097 static deleter_t deleter;
1098
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001099 static LoadTask* create(const char* name, soinfo* needed_by,
1100 std::unordered_map<const soinfo*, ElfReader>* readers_map) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001101 LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc();
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001102 return new (ptr) LoadTask(name, needed_by, readers_map);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001103 }
1104
1105 const char* get_name() const {
1106 return name_;
1107 }
1108
1109 soinfo* get_needed_by() const {
1110 return needed_by_;
1111 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001112
1113 soinfo* get_soinfo() const {
1114 return si_;
1115 }
1116
1117 void set_soinfo(soinfo* si) {
1118 si_ = si;
1119 }
1120
1121 off64_t get_file_offset() const {
1122 return file_offset_;
1123 }
1124
1125 void set_file_offset(off64_t offset) {
1126 file_offset_ = offset;
1127 }
1128
1129 int get_fd() const {
1130 return fd_;
1131 }
1132
1133 void set_fd(int fd, bool assume_ownership) {
1134 fd_ = fd;
1135 close_fd_ = assume_ownership;
1136 }
1137
1138 const android_dlextinfo* get_extinfo() const {
1139 return extinfo_;
1140 }
1141
1142 void set_extinfo(const android_dlextinfo* extinfo) {
1143 extinfo_ = extinfo;
1144 }
1145
Dimitry Ivanov10057482016-01-28 17:24:20 -08001146 bool is_dt_needed() const {
1147 return is_dt_needed_;
1148 }
1149
1150 void set_dt_needed(bool is_dt_needed) {
1151 is_dt_needed_ = is_dt_needed;
1152 }
1153
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001154 const ElfReader& get_elf_reader() const {
1155 CHECK(si_ != nullptr);
1156 return (*elf_readers_map_)[si_];
1157 }
1158
1159 ElfReader& get_elf_reader() {
1160 CHECK(si_ != nullptr);
1161 return (*elf_readers_map_)[si_];
1162 }
1163
1164 std::unordered_map<const soinfo*, ElfReader>* get_readers_map() {
1165 return elf_readers_map_;
1166 }
1167
1168 bool read(const char* realpath, off64_t file_size) {
1169 ElfReader& elf_reader = get_elf_reader();
1170 return elf_reader.Read(realpath, fd_, file_offset_, file_size);
1171 }
1172
1173 bool load() {
1174 ElfReader& elf_reader = get_elf_reader();
1175 if (!elf_reader.Load(extinfo_)) {
1176 return false;
1177 }
1178
1179 si_->base = elf_reader.load_start();
1180 si_->size = elf_reader.load_size();
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -08001181 si_->set_mapped_by_caller(elf_reader.is_mapped_by_caller());
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001182 si_->load_bias = elf_reader.load_bias();
1183 si_->phnum = elf_reader.phdr_count();
1184 si_->phdr = elf_reader.loaded_phdr();
1185
1186 return true;
1187 }
1188
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001189 private:
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001190 LoadTask(const char* name, soinfo* needed_by,
1191 std::unordered_map<const soinfo*, ElfReader>* readers_map)
1192 : name_(name), needed_by_(needed_by), si_(nullptr),
Dimitry Ivanov10057482016-01-28 17:24:20 -08001193 fd_(-1), close_fd_(false), file_offset_(0), elf_readers_map_(readers_map),
1194 is_dt_needed_(false) {}
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001195
1196 ~LoadTask() {
1197 if (fd_ != -1 && close_fd_) {
1198 close(fd_);
1199 }
1200 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001201
1202 const char* name_;
1203 soinfo* needed_by_;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001204 soinfo* si_;
1205 const android_dlextinfo* extinfo_;
1206 int fd_;
1207 bool close_fd_;
1208 off64_t file_offset_;
1209 std::unordered_map<const soinfo*, ElfReader>* elf_readers_map_;
Dimitry Ivanovf1d4a492016-05-23 17:33:27 -07001210 // TODO(dimitry): needed by workaround for http://b/26394120 (the grey-list)
Dimitry Ivanov10057482016-01-28 17:24:20 -08001211 bool is_dt_needed_;
1212 // END OF WORKAROUND
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001213
1214 DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask);
1215};
1216
Ningsheng Jiane93be992014-09-16 15:22:10 +08001217LoadTask::deleter_t LoadTask::deleter;
1218
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001219template <typename T>
1220using linked_list_t = LinkedList<T, TypeBasedAllocator<LinkedListEntry<T>>>;
1221
1222typedef linked_list_t<soinfo> SoinfoLinkedList;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001223typedef linked_list_t<const char> StringLinkedList;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001224typedef std::vector<LoadTask*> LoadTaskList;
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001225
Chirayu Desai6ef70452016-08-25 19:02:41 +05301226static soinfo* find_library(android_namespace_t* ns,
1227 const char* name, int rtld_flags,
1228 const android_dlextinfo* extinfo,
1229 soinfo* needed_by);
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001230
1231// g_ld_all_shim_libs maintains the references to memory as it used
1232// in the soinfo structures and in the g_active_shim_libs list.
1233
Danny Baumannc0975512016-09-07 16:54:06 +02001234typedef std::pair<std::string, std::string> ShimDescriptor;
1235static std::vector<ShimDescriptor> g_ld_all_shim_libs;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001236
1237// g_active_shim_libs are all shim libs that are still eligible
1238// to be loaded. We must remove a shim lib from the list before
1239// we load the library to avoid recursive loops (load shim libA
1240// for libB where libA also links against libB).
1241
Danny Baumannc0975512016-09-07 16:54:06 +02001242static linked_list_t<const ShimDescriptor> g_active_shim_libs;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001243
1244static void reset_g_active_shim_libs(void) {
1245 g_active_shim_libs.clear();
1246 for (const auto& pair : g_ld_all_shim_libs) {
1247 g_active_shim_libs.push_back(&pair);
1248 }
1249}
1250
1251static void parse_LD_SHIM_LIBS(const char* path) {
Chippa-a248de712016-08-27 14:56:30 +02001252 g_ld_all_shim_libs.clear();
1253 if (path != nullptr) {
1254 // We have historically supported ':' as well as ' ' in LD_SHIM_LIBS.
Danny Baumannc0975512016-09-07 16:54:06 +02001255 for (const auto& pair : android::base::Split(path, " :")) {
1256 size_t pos = pair.find('|');
1257 if (pos > 0 && pos < pair.length() - 1) {
1258 auto desc = std::pair<std::string, std::string>(pair.substr(0, pos), pair.substr(pos + 1));
1259 g_ld_all_shim_libs.push_back(desc);
1260 }
1261 }
Chippa-a248de712016-08-27 14:56:30 +02001262 }
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001263 reset_g_active_shim_libs();
1264}
1265
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001266template<typename F>
Danny Baumannc0975512016-09-07 16:54:06 +02001267static void for_each_matching_shim(const char *const path, F action) {
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001268 if (path == nullptr) return;
1269 INFO("Finding shim libs for \"%s\"\n", path);
Danny Baumannc0975512016-09-07 16:54:06 +02001270 std::vector<const ShimDescriptor *> matched;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001271
Danny Baumannc0975512016-09-07 16:54:06 +02001272 g_active_shim_libs.for_each([&](const ShimDescriptor *a_pair) {
1273 if (a_pair->first == path) {
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001274 matched.push_back(a_pair);
1275 }
1276 });
1277
Danny Baumannc0975512016-09-07 16:54:06 +02001278 g_active_shim_libs.remove_if([&](const ShimDescriptor *a_pair) {
1279 return a_pair->first == path;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001280 });
1281
1282 for (const auto& one_pair : matched) {
Danny Baumannc0975512016-09-07 16:54:06 +02001283 INFO("Injecting shim lib \"%s\" as needed for %s", one_pair->second.c_str(), path);
1284 action(one_pair->second.c_str());
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05001285 }
1286}
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -07001287
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001288// This function walks down the tree of soinfo dependencies
1289// in breadth-first order and
1290// * calls action(soinfo* si) for each node, and
1291// * terminates walk if action returns false.
1292//
1293// walk_dependencies_tree returns false if walk was terminated
1294// by the action and true otherwise.
1295template<typename F>
Danny Baumannc0975512016-09-07 16:54:06 +02001296static bool walk_dependencies_tree(soinfo* root_soinfos[], size_t root_soinfos_size, F action) {
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -07001297 SoinfoLinkedList visit_list;
1298 SoinfoLinkedList visited;
1299
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001300 for (size_t i = 0; i < root_soinfos_size; ++i) {
1301 visit_list.push_back(root_soinfos[i]);
1302 }
1303
1304 soinfo* si;
1305 while ((si = visit_list.pop_front()) != nullptr) {
1306 if (visited.contains(si)) {
Dmitriy Ivanov042426b2014-08-12 21:02:13 -07001307 continue;
1308 }
1309
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001310 if (!action(si)) {
1311 return false;
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -07001312 }
1313
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001314 visited.push_back(si);
1315
1316 si->get_children().for_each([&](soinfo* child) {
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -07001317 visit_list.push_back(child);
1318 });
1319 }
1320
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001321 return true;
1322}
1323
1324
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001325static const ElfW(Sym)* dlsym_handle_lookup(soinfo* root, soinfo* skip_until,
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001326 soinfo** found, SymbolName& symbol_name,
1327 const version_info* vi) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001328 const ElfW(Sym)* result = nullptr;
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001329 bool skip_lookup = skip_until != nullptr;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001330
Danny Baumannc0975512016-09-07 16:54:06 +02001331 walk_dependencies_tree(&root, 1, [&](soinfo* current_soinfo) {
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001332 if (skip_lookup) {
1333 skip_lookup = current_soinfo != skip_until;
1334 return true;
1335 }
1336
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001337 if (!current_soinfo->find_symbol_by_name(symbol_name, vi, &result)) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001338 result = nullptr;
1339 return false;
1340 }
1341
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001342 if (result != nullptr) {
1343 *found = current_soinfo;
1344 return false;
1345 }
1346
1347 return true;
1348 });
1349
1350 return result;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001351}
1352
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001353static const ElfW(Sym)* dlsym_linear_lookup(android_namespace_t* ns,
1354 const char* name,
1355 const version_info* vi,
1356 soinfo** found,
1357 soinfo* caller,
1358 void* handle);
1359
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001360// This is used by dlsym(3). It performs symbol lookup only within the
1361// specified soinfo object and its dependencies in breadth first order.
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001362static const ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found,
1363 const char* name, const version_info* vi) {
Dmitriy Ivanovf439b5a2015-05-30 13:04:39 -07001364 // According to man dlopen(3) and posix docs in the case when si is handle
1365 // of the main executable we need to search not only in the executable and its
1366 // dependencies but also in all libraries loaded with RTLD_GLOBAL.
1367 //
1368 // Since RTLD_GLOBAL is always set for the main executable and all dt_needed shared
1369 // libraries and they are loaded in breath-first (correct) order we can just execute
1370 // dlsym(RTLD_DEFAULT, ...); instead of doing two stage lookup.
1371 if (si == somain) {
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001372 return dlsym_linear_lookup(&g_default_namespace, name, vi, found, nullptr, RTLD_DEFAULT);
Dmitriy Ivanovf439b5a2015-05-30 13:04:39 -07001373 }
1374
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001375 SymbolName symbol_name(name);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001376 return dlsym_handle_lookup(si, nullptr, found, symbol_name, vi);
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001377}
1378
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08001379/* This is used by dlsym(3) to performs a global symbol lookup. If the
1380 start value is null (for RTLD_DEFAULT), the search starts at the
1381 beginning of the global solist. Otherwise the search starts at the
1382 specified soinfo (for RTLD_NEXT).
Iliyan Malchev6ed80c82009-09-28 19:38:04 -07001383 */
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001384static const ElfW(Sym)* dlsym_linear_lookup(android_namespace_t* ns,
1385 const char* name,
1386 const version_info* vi,
1387 soinfo** found,
1388 soinfo* caller,
1389 void* handle) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001390 SymbolName symbol_name(name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001391
Dimitry Ivanovae74e872016-03-24 15:30:30 -07001392 auto& soinfo_list = ns->soinfo_list();
1393 auto start = soinfo_list.begin();
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001394
1395 if (handle == RTLD_NEXT) {
Dmitriy Ivanovb96ac412015-05-22 12:34:42 -07001396 if (caller == nullptr) {
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001397 return nullptr;
1398 } else {
Dimitry Ivanovae74e872016-03-24 15:30:30 -07001399 auto it = soinfo_list.find(caller);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001400 CHECK (it != soinfo_list.end());
1401 start = ++it;
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001402 }
Elliott Hughescade4c32012-12-20 14:42:14 -08001403 }
1404
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001405 const ElfW(Sym)* s = nullptr;
Dimitry Ivanovae74e872016-03-24 15:30:30 -07001406 for (auto it = start, end = soinfo_list.end(); it != end; ++it) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001407 soinfo* si = *it;
Dmitriy Ivanov19133522015-06-02 17:36:54 -07001408 // Do not skip RTLD_LOCAL libraries in dlsym(RTLD_DEFAULT, ...)
1409 // if the library is opened by application with target api level <= 22
1410 // See http://b/21565766
1411 if ((si->get_rtld_flags() & RTLD_GLOBAL) == 0 && si->get_target_sdk_version() > 22) {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001412 continue;
1413 }
1414
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001415 if (!si->find_symbol_by_name(symbol_name, vi, &s)) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07001416 return nullptr;
1417 }
1418
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001419 if (s != nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -08001420 *found = si;
1421 break;
Matt Fischer1698d9e2009-12-31 12:17:56 -06001422 }
Elliott Hughescade4c32012-12-20 14:42:14 -08001423 }
Matt Fischer1698d9e2009-12-31 12:17:56 -06001424
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001425 // If not found - use dlsym_handle_lookup for caller's
1426 // local_group unless it is part of the global group in which
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001427 // case we already did it.
1428 if (s == nullptr && caller != nullptr &&
1429 (caller->get_rtld_flags() & RTLD_GLOBAL) == 0) {
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -07001430 return dlsym_handle_lookup(caller->get_local_group_root(),
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08001431 (handle == RTLD_NEXT) ? caller : nullptr, found, symbol_name, vi);
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -07001432 }
1433
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001434 if (s != nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07001435 TRACE_TYPE(LOOKUP, "%s s->st_value = %p, found->base = %p",
1436 name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));
Elliott Hughescade4c32012-12-20 14:42:14 -08001437 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001438
Elliott Hughescade4c32012-12-20 14:42:14 -08001439 return s;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001440}
1441
Kito Chengfa8c05d2013-03-12 14:58:06 +08001442soinfo* find_containing_library(const void* p) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08001443 ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(p);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001444 for (soinfo* si = solist; si != nullptr; si = si->next) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08001445 if (address >= si->base && address - si->base < si->size) {
1446 return si;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001447 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08001448 }
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001449 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001450}
1451
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001452ElfW(Sym)* soinfo::find_symbol_by_address(const void* addr) {
1453 return is_gnu_hash() ? gnu_addr_lookup(addr) : elf_addr_lookup(addr);
1454}
1455
1456static bool symbol_matches_soaddr(const ElfW(Sym)* sym, ElfW(Addr) soaddr) {
1457 return sym->st_shndx != SHN_UNDEF &&
1458 soaddr >= sym->st_value &&
1459 soaddr < sym->st_value + sym->st_size;
1460}
1461
1462ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
Chris Dearman8e553812013-11-13 17:22:33 -08001463 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001464
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07001465 for (size_t i = 0; i < gnu_nbucket_; ++i) {
1466 uint32_t n = gnu_bucket_[i];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001467
1468 if (n == 0) {
1469 continue;
1470 }
1471
1472 do {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001473 ElfW(Sym)* sym = symtab_ + n;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001474 if (symbol_matches_soaddr(sym, soaddr)) {
1475 return sym;
1476 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07001477 } while ((gnu_chain_[n++] & 1) == 0);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001478 }
1479
1480 return nullptr;
1481}
1482
1483ElfW(Sym)* soinfo::elf_addr_lookup(const void* addr) {
Chris Dearman8e553812013-11-13 17:22:33 -08001484 ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - load_bias;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001485
Kito Chengfa8c05d2013-03-12 14:58:06 +08001486 // Search the library's symbol table for any defined symbol which
1487 // contains this address.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08001488 for (size_t i = 0; i < nchain_; ++i) {
1489 ElfW(Sym)* sym = symtab_ + i;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08001490 if (symbol_matches_soaddr(sym, soaddr)) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08001491 return sym;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001492 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08001493 }
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001494
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001495 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -06001496}
1497
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001498class ZipArchiveCache {
1499 public:
1500 ZipArchiveCache() {}
1501 ~ZipArchiveCache();
1502
1503 bool get_or_open(const char* zip_path, ZipArchiveHandle* handle);
1504 private:
1505 DISALLOW_COPY_AND_ASSIGN(ZipArchiveCache);
1506
1507 std::unordered_map<std::string, ZipArchiveHandle> cache_;
1508};
1509
1510bool ZipArchiveCache::get_or_open(const char* zip_path, ZipArchiveHandle* handle) {
1511 std::string key(zip_path);
1512
1513 auto it = cache_.find(key);
1514 if (it != cache_.end()) {
1515 *handle = it->second;
1516 return true;
1517 }
1518
1519 int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC));
1520 if (fd == -1) {
1521 return false;
1522 }
1523
1524 if (OpenArchiveFd(fd, "", handle) != 0) {
1525 // invalid zip-file (?)
Yabin Cuib3ee8592016-03-21 17:10:12 -07001526 CloseArchive(handle);
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001527 close(fd);
1528 return false;
1529 }
1530
1531 cache_[key] = *handle;
1532 return true;
1533}
1534
1535ZipArchiveCache::~ZipArchiveCache() {
Dmitriy Ivanov5dce8942015-10-13 12:14:16 -07001536 for (const auto& it : cache_) {
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001537 CloseArchive(it.second);
1538 }
1539}
1540
1541static int open_library_in_zipfile(ZipArchiveCache* zip_archive_cache,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001542 const char* const input_path,
1543 off64_t* file_offset, std::string* realpath) {
1544 std::string normalized_path;
1545 if (!normalize_path(input_path, &normalized_path)) {
1546 return -1;
1547 }
1548
1549 const char* const path = normalized_path.c_str();
Elliott Hughes38b88a42016-04-01 10:10:54 -07001550 TRACE("Trying zip file open from path \"%s\" -> normalized \"%s\"", input_path, path);
Simon Baldwinaef71952015-01-16 13:22:54 +00001551
Dmitriy Ivanov402a7502015-06-09 13:46:51 -07001552 // Treat an '!/' separator inside a path as the separator between the name
Simon Baldwinaef71952015-01-16 13:22:54 +00001553 // of the zip file on disk and the subdirectory to search within it.
Dmitriy Ivanov402a7502015-06-09 13:46:51 -07001554 // For example, if path is "foo.zip!/bar/bas/x.so", then we search for
Simon Baldwinaef71952015-01-16 13:22:54 +00001555 // "bar/bas/x.so" within "foo.zip".
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001556 const char* const separator = strstr(path, kZipFileSeparator);
Simon Baldwinaef71952015-01-16 13:22:54 +00001557 if (separator == nullptr) {
1558 return -1;
Elliott Hughes124fae92012-10-31 14:20:03 -07001559 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001560
1561 char buf[512];
1562 if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf)) {
1563 PRINT("Warning: ignoring very long library path: %s", path);
1564 return -1;
1565 }
1566
1567 buf[separator - path] = '\0';
1568
1569 const char* zip_path = buf;
Dmitriy Ivanov402a7502015-06-09 13:46:51 -07001570 const char* file_path = &buf[separator - path + 2];
Simon Baldwinaef71952015-01-16 13:22:54 +00001571 int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC));
1572 if (fd == -1) {
1573 return -1;
1574 }
1575
1576 ZipArchiveHandle handle;
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001577 if (!zip_archive_cache->get_or_open(zip_path, &handle)) {
Simon Baldwinaef71952015-01-16 13:22:54 +00001578 // invalid zip-file (?)
1579 close(fd);
1580 return -1;
1581 }
1582
Simon Baldwinaef71952015-01-16 13:22:54 +00001583 ZipEntry entry;
1584
Yusuke Sato56f40fb2015-06-25 14:56:07 -07001585 if (FindEntry(handle, ZipString(file_path), &entry) != 0) {
Simon Baldwinaef71952015-01-16 13:22:54 +00001586 // Entry was not found.
1587 close(fd);
1588 return -1;
1589 }
1590
1591 // Check if it is properly stored
1592 if (entry.method != kCompressStored || (entry.offset % PAGE_SIZE) != 0) {
1593 close(fd);
1594 return -1;
1595 }
1596
1597 *file_offset = entry.offset;
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001598
1599 if (realpath_fd(fd, realpath)) {
1600 *realpath += separator;
1601 } else {
1602 PRINT("warning: unable to get realpath for the library \"%s\". Will use given path.",
1603 normalized_path.c_str());
1604 *realpath = normalized_path;
1605 }
1606
Simon Baldwinaef71952015-01-16 13:22:54 +00001607 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001608}
1609
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001610static bool format_path(char* buf, size_t buf_size, const char* path, const char* name) {
1611 int n = __libc_format_buffer(buf, buf_size, "%s/%s", path, name);
1612 if (n < 0 || n >= static_cast<int>(buf_size)) {
1613 PRINT("Warning: ignoring very long library path: %s/%s", path, name);
1614 return false;
1615 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001616
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001617 return true;
1618}
1619
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001620static int open_library_on_paths(ZipArchiveCache* zip_archive_cache,
1621 const char* name, off64_t* file_offset,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001622 const std::vector<std::string>& paths,
1623 std::string* realpath) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001624 for (const auto& path : paths) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001625 char buf[512];
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001626 if (!format_path(buf, sizeof(buf), path.c_str(), name)) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001627 continue;
1628 }
1629
1630 int fd = -1;
Dmitriy Ivanov730ed9d2015-07-16 04:52:06 -07001631 if (strstr(buf, kZipFileSeparator) != nullptr) {
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001632 fd = open_library_in_zipfile(zip_archive_cache, buf, file_offset, realpath);
Simon Baldwinaef71952015-01-16 13:22:54 +00001633 }
1634
1635 if (fd == -1) {
1636 fd = TEMP_FAILURE_RETRY(open(buf, O_RDONLY | O_CLOEXEC));
1637 if (fd != -1) {
1638 *file_offset = 0;
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001639 if (!realpath_fd(fd, realpath)) {
1640 PRINT("warning: unable to get realpath for the library \"%s\". Will use given path.", buf);
1641 *realpath = buf;
1642 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001643 }
1644 }
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001645
1646 if (fd != -1) {
1647 return fd;
1648 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001649 }
1650
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001651 return -1;
Simon Baldwinaef71952015-01-16 13:22:54 +00001652}
1653
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001654static int open_library(android_namespace_t* ns,
1655 ZipArchiveCache* zip_archive_cache,
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001656 const char* name, soinfo *needed_by,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001657 off64_t* file_offset, std::string* realpath) {
Elliott Hughesca0c11b2013-03-12 10:40:45 -07001658 TRACE("[ opening %s ]", name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001659
Elliott Hughes124fae92012-10-31 14:20:03 -07001660 // If the name contains a slash, we should attempt to open it directly and not search the paths.
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07001661 if (strchr(name, '/') != nullptr) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001662 int fd = -1;
1663
Dmitriy Ivanov730ed9d2015-07-16 04:52:06 -07001664 if (strstr(name, kZipFileSeparator) != nullptr) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001665 fd = open_library_in_zipfile(zip_archive_cache, name, file_offset, realpath);
1666 }
1667
1668 if (fd == -1) {
1669 fd = TEMP_FAILURE_RETRY(open(name, O_RDONLY | O_CLOEXEC));
Simon Baldwinaef71952015-01-16 13:22:54 +00001670 if (fd != -1) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001671 *file_offset = 0;
1672 if (!realpath_fd(fd, realpath)) {
1673 PRINT("warning: unable to get realpath for the library \"%s\". Will use given path.", name);
1674 *realpath = name;
1675 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001676 }
1677 }
1678
Dmitriy Ivanove44fffd2015-03-17 17:12:18 -07001679 return fd;
Elliott Hughes124fae92012-10-31 14:20:03 -07001680 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001681
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001682 // Otherwise we try LD_LIBRARY_PATH first, and fall back to the default library path
1683 int fd = open_library_on_paths(zip_archive_cache, name, file_offset, ns->get_ld_library_paths(), realpath);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001684 if (fd == -1 && needed_by != nullptr) {
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001685 fd = open_library_on_paths(zip_archive_cache, name, file_offset, needed_by->get_dt_runpath(), realpath);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001686 // Check if the library is accessible
1687 if (fd != -1 && !ns->is_accessible(*realpath)) {
1688 fd = -1;
1689 }
Evgenii Stepanov68650822015-06-10 13:38:39 -07001690 }
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001691
Elliott Hughes124fae92012-10-31 14:20:03 -07001692 if (fd == -1) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001693 fd = open_library_on_paths(zip_archive_cache, name, file_offset, ns->get_default_library_paths(), realpath);
Elliott Hughes124fae92012-10-31 14:20:03 -07001694 }
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001695
Dimitry Ivanovf1d4a492016-05-23 17:33:27 -07001696 // TODO(dimitry): workaround for http://b/26394120 (the grey-list)
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -08001697 if (fd == -1 && ns != &g_default_namespace && is_greylisted(name, needed_by)) {
Dimitry Ivanova8bda262016-01-07 11:16:43 -08001698 // try searching for it on default_namespace default_library_path
1699 fd = open_library_on_paths(zip_archive_cache, name, file_offset,
1700 g_default_namespace.get_default_library_paths(), realpath);
1701 }
1702 // END OF WORKAROUND
1703
Elliott Hughes124fae92012-10-31 14:20:03 -07001704 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001705}
1706
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001707static const char* fix_dt_needed(const char* dt_needed, const char* sopath __unused) {
1708#if !defined(__LP64__)
1709 // Work around incorrect DT_NEEDED entries for old apps: http://b/21364029
Dmitriy Ivanov19133522015-06-02 17:36:54 -07001710 if (get_application_target_sdk_version() <= 22) {
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001711 const char* bname = basename(dt_needed);
1712 if (bname != dt_needed) {
Elliott Hughes38b88a42016-04-01 10:10:54 -07001713 DL_WARN("library \"%s\" has invalid DT_NEEDED entry \"%s\"", sopath, dt_needed);
Dimitry Ivanovdf91dc22016-02-25 15:22:04 -08001714 add_dlwarning(sopath, "invalid DT_NEEDED entry", dt_needed);
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001715 }
1716
1717 return bname;
1718 }
1719#endif
1720 return dt_needed;
1721}
1722
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001723template<typename F>
1724static void for_each_dt_needed(const soinfo* si, F action) {
jrior001105d8f92016-10-07 19:36:51 -04001725 for_each_matching_shim(si->get_realpath(), action);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001726 for (const ElfW(Dyn)* d = si->dynamic; d->d_tag != DT_NULL; ++d) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001727 if (d->d_tag == DT_NEEDED) {
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001728 action(fix_dt_needed(si->get_string(d->d_un.d_val), si->get_realpath()));
Dima Zavin2e855792009-05-20 18:28:09 -07001729 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001730 }
1731}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001732
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001733template<typename F>
1734static void for_each_dt_needed(const ElfReader& elf_reader, F action) {
jrior001105d8f92016-10-07 19:36:51 -04001735 for_each_matching_shim(elf_reader.name(), action);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001736 for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
1737 if (d->d_tag == DT_NEEDED) {
1738 action(fix_dt_needed(elf_reader.get_string(d->d_un.d_val), elf_reader.name()));
1739 }
1740 }
1741}
1742
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001743static bool load_library(android_namespace_t* ns,
1744 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001745 LoadTaskList* load_tasks,
1746 int rtld_flags,
1747 const std::string& realpath) {
1748 off64_t file_offset = task->get_file_offset();
1749 const char* name = task->get_name();
1750 const android_dlextinfo* extinfo = task->get_extinfo();
1751
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001752 if ((file_offset % PAGE_SIZE) != 0) {
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07001753 DL_ERR("file offset for the library \"%s\" is not page-aligned: %" PRId64, name, file_offset);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001754 return false;
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001755 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001756 if (file_offset < 0) {
1757 DL_ERR("file offset for the library \"%s\" is negative: %" PRId64, name, file_offset);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001758 return false;
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001759 }
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001760
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001761 struct stat file_stat;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001762 if (TEMP_FAILURE_RETRY(fstat(task->get_fd(), &file_stat)) != 0) {
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07001763 DL_ERR("unable to stat file for the library \"%s\": %s", name, strerror(errno));
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001764 return false;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001765 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001766 if (file_offset >= file_stat.st_size) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001767 DL_ERR("file offset for the library \"%s\" >= file size: %" PRId64 " >= %" PRId64,
1768 name, file_offset, file_stat.st_size);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001769 return false;
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001770 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001771
1772 // Check for symlink and other situations where
Dmitriy Ivanov9b821362015-04-02 16:03:56 -07001773 // file can have different names, unless ANDROID_DLEXT_FORCE_LOAD is set
1774 if (extinfo == nullptr || (extinfo->flags & ANDROID_DLEXT_FORCE_LOAD) == 0) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001775 auto predicate = [&](soinfo* si) {
1776 return si->get_st_dev() != 0 &&
1777 si->get_st_ino() != 0 &&
1778 si->get_st_dev() == file_stat.st_dev &&
1779 si->get_st_ino() == file_stat.st_ino &&
1780 si->get_file_offset() == file_offset;
1781 };
1782
1783 soinfo* si = ns->soinfo_list().find_if(predicate);
1784
1785 // check public namespace
1786 if (si == nullptr) {
1787 si = g_public_namespace.find_if(predicate);
1788 if (si != nullptr) {
Dimitry Ivanovae74e872016-03-24 15:30:30 -07001789 ns->add_soinfo(si);
Dmitriy Ivanov9b821362015-04-02 16:03:56 -07001790 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001791 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001792
1793 if (si != nullptr) {
1794 TRACE("library \"%s\" is already loaded under different name/path \"%s\" - "
1795 "will return existing soinfo", name, si->get_realpath());
1796 task->set_soinfo(si);
1797 return true;
1798 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001799 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001800
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001801 if ((rtld_flags & RTLD_NOLOAD) != 0) {
Dmitriy Ivanova6ac54a2014-09-09 10:21:42 -07001802 DL_ERR("library \"%s\" wasn't loaded and RTLD_NOLOAD prevented it", name);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001803 return false;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001804 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001805
Dimitry Ivanov22840aa2015-12-04 18:28:49 -08001806 if (!ns->is_accessible(realpath)) {
Dimitry Ivanovf1d4a492016-05-23 17:33:27 -07001807 // TODO(dimitry): workaround for http://b/26394120 - the grey-list
Dimitry Ivanov10057482016-01-28 17:24:20 -08001808 const soinfo* needed_by = task->is_dt_needed() ? task->get_needed_by() : nullptr;
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -08001809 if (is_greylisted(name, needed_by)) {
1810 // print warning only if needed by non-system library
1811 if (needed_by == nullptr || !is_system_library(needed_by->get_realpath())) {
Dimitry Ivanovf53e7de2016-02-01 12:32:22 -08001812 const soinfo* needed_or_dlopened_by = task->get_needed_by();
Dimitry Ivanovdf91dc22016-02-25 15:22:04 -08001813 const char* sopath = needed_or_dlopened_by == nullptr ? "(unknown)" :
1814 needed_or_dlopened_by->get_realpath();
Dimitry Ivanovf53e7de2016-02-01 12:32:22 -08001815 DL_WARN("library \"%s\" (\"%s\") needed or dlopened by \"%s\" is not accessible for the namespace \"%s\""
Dimitry Ivanovf1d4a492016-05-23 17:33:27 -07001816 " - the access is temporarily granted as a workaround for http://b/26394120, note that the access"
1817 " will be removed in future releases of Android.",
Dimitry Ivanovdf91dc22016-02-25 15:22:04 -08001818 name, realpath.c_str(), sopath, ns->get_name());
1819 add_dlwarning(sopath, "unauthorized access to", name);
Dimitry Ivanov36ac45f2016-01-07 18:43:20 -08001820 }
Dimitry Ivanova8bda262016-01-07 11:16:43 -08001821 } else {
1822 // do not load libraries if they are not accessible for the specified namespace.
Dimitry Ivanov350bdad2016-03-01 13:11:28 -08001823 const char* needed_or_dlopened_by = task->get_needed_by() == nullptr ?
1824 "(unknown)" :
1825 task->get_needed_by()->get_realpath();
1826
1827 DL_ERR("library \"%s\" needed or dlopened by \"%s\" is not accessible for the namespace \"%s\"",
1828 name, needed_or_dlopened_by, ns->get_name());
1829
1830 PRINT("library \"%s\" (\"%s\") needed or dlopened by \"%s\" is not accessible for the"
1831 " namespace: [name=\"%s\", ld_library_paths=\"%s\", default_library_paths=\"%s\","
1832 " permitted_paths=\"%s\"]",
1833 name, realpath.c_str(),
1834 needed_or_dlopened_by,
1835 ns->get_name(),
1836 android::base::Join(ns->get_ld_library_paths(), ':').c_str(),
1837 android::base::Join(ns->get_default_library_paths(), ':').c_str(),
1838 android::base::Join(ns->get_permitted_paths(), ':').c_str());
Dimitry Ivanova8bda262016-01-07 11:16:43 -08001839 return false;
1840 }
Dimitry Ivanov22840aa2015-12-04 18:28:49 -08001841 }
1842
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001843 soinfo* si = soinfo_alloc(ns, realpath.c_str(), &file_stat, file_offset, rtld_flags);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001844 if (si == nullptr) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001845 return false;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001846 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001847
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001848 task->set_soinfo(si);
1849
1850 // Read the ELF header and some of the segments.
1851 if (!task->read(realpath.c_str(), file_stat.st_size)) {
Dmitriy Ivanovfd7a91e2015-11-06 10:44:37 -08001852 soinfo_free(si);
1853 task->set_soinfo(nullptr);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001854 return false;
1855 }
1856
1857 // find and set DT_RUNPATH and dt_soname
1858 // Note that these field values are temporary and are
1859 // going to be overwritten on soinfo::prelink_image
1860 // with values from PT_LOAD segments.
1861 const ElfReader& elf_reader = task->get_elf_reader();
1862 for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
1863 if (d->d_tag == DT_RUNPATH) {
1864 si->set_dt_runpath(elf_reader.get_string(d->d_un.d_val));
1865 }
1866 if (d->d_tag == DT_SONAME) {
1867 si->set_soname(elf_reader.get_string(d->d_un.d_val));
1868 }
1869 }
1870
1871 for_each_dt_needed(task->get_elf_reader(), [&](const char* name) {
1872 load_tasks->push_back(LoadTask::create(name, si, task->get_readers_map()));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001873 });
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001874
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001875 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001876}
1877
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001878static bool load_library(android_namespace_t* ns,
1879 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001880 ZipArchiveCache* zip_archive_cache,
1881 LoadTaskList* load_tasks,
1882 int rtld_flags) {
1883 const char* name = task->get_name();
1884 soinfo* needed_by = task->get_needed_by();
1885 const android_dlextinfo* extinfo = task->get_extinfo();
1886
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001887 off64_t file_offset;
1888 std::string realpath;
Spencer Low0346ad72015-04-22 18:06:51 -07001889 if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) {
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001890 file_offset = 0;
Spencer Low0346ad72015-04-22 18:06:51 -07001891 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
1892 file_offset = extinfo->library_fd_offset;
1893 }
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001894
1895 if (!realpath_fd(extinfo->library_fd, &realpath)) {
1896 PRINT("warning: unable to get realpath for the library \"%s\" by extinfo->library_fd. "
1897 "Will use given name.", name);
1898 realpath = name;
1899 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001900
1901 task->set_fd(extinfo->library_fd, false);
1902 task->set_file_offset(file_offset);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001903 return load_library(ns, task, load_tasks, rtld_flags, realpath);
Spencer Low0346ad72015-04-22 18:06:51 -07001904 }
1905
1906 // Open the file.
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001907 int fd = open_library(ns, zip_archive_cache, name, needed_by, &file_offset, &realpath);
Spencer Low0346ad72015-04-22 18:06:51 -07001908 if (fd == -1) {
1909 DL_ERR("library \"%s\" not found", name);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001910 return false;
Spencer Low0346ad72015-04-22 18:06:51 -07001911 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001912
1913 task->set_fd(fd, true);
1914 task->set_file_offset(file_offset);
1915
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001916 return load_library(ns, task, load_tasks, rtld_flags, realpath);
Spencer Low0346ad72015-04-22 18:06:51 -07001917}
1918
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001919// Returns true if library was found and false in 2 cases
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001920// 1. (for default namespace only) The library was found but loaded under different
1921// target_sdk_version (*candidate != nullptr)
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001922// 2. The library was not found by soname (*candidate is nullptr)
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001923static bool find_loaded_library_by_soname(android_namespace_t* ns,
1924 const char* name, soinfo** candidate) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001925 *candidate = nullptr;
1926
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001927 // Ignore filename with path.
1928 if (strchr(name, '/') != nullptr) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001929 return false;
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001930 }
1931
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001932 uint32_t target_sdk_version = get_application_target_sdk_version();
1933
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001934 return !ns->soinfo_list().visit([&](soinfo* si) {
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07001935 const char* soname = si->get_soname();
1936 if (soname != nullptr && (strcmp(name, soname) == 0)) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001937 // If the library was opened under different target sdk version
1938 // skip this step and try to reopen it. The exceptions are
1939 // "libdl.so" and global group. There is no point in skipping
1940 // them because relocation process is going to use them
1941 // in any case.
1942 bool is_libdl = si == solist;
1943 if (is_libdl || (si->get_dt_flags_1() & DF_1_GLOBAL) != 0 ||
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001944 !si->is_linked() || si->get_target_sdk_version() == target_sdk_version ||
1945 ns != &g_default_namespace) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001946 *candidate = si;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001947 return false;
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001948 } else if (*candidate == nullptr) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001949 // for the different sdk version in the default namespace
1950 // remember the first library.
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001951 *candidate = si;
1952 }
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001953 }
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001954
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001955 return true;
1956 });
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001957}
1958
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001959static bool find_library_internal(android_namespace_t* ns,
1960 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001961 ZipArchiveCache* zip_archive_cache,
1962 LoadTaskList* load_tasks,
1963 int rtld_flags) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001964 soinfo* candidate;
1965
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001966 if (find_loaded_library_by_soname(ns, task->get_name(), &candidate)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001967 task->set_soinfo(candidate);
1968 return true;
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001969 }
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001970
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001971 if (ns != &g_default_namespace) {
1972 // check public namespace
1973 candidate = g_public_namespace.find_if([&](soinfo* si) {
1974 return strcmp(task->get_name(), si->get_soname()) == 0;
1975 });
1976
1977 if (candidate != nullptr) {
Dimitry Ivanovae74e872016-03-24 15:30:30 -07001978 ns->add_soinfo(candidate);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001979 task->set_soinfo(candidate);
1980 return true;
1981 }
1982 }
1983
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001984 // Library might still be loaded, the accurate detection
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001985 // of this fact is done by load_library.
Elliott Hughes38b88a42016-04-01 10:10:54 -07001986 TRACE("[ \"%s\" find_loaded_library_by_soname failed (*candidate=%s@%p). Trying harder...]",
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001987 task->get_name(), candidate == nullptr ? "n/a" : candidate->get_realpath(), candidate);
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001988
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001989 if (load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001990 return true;
1991 } else {
1992 // In case we were unable to load the library but there
1993 // is a candidate loaded under the same soname but different
1994 // sdk level - return it anyways.
1995 if (candidate != nullptr) {
1996 task->set_soinfo(candidate);
1997 return true;
1998 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001999 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002000
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002001 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002002}
2003
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002004static void soinfo_unload(soinfo* si);
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002005static void soinfo_unload(soinfo* soinfos[], size_t count);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002006
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002007// TODO: this is slightly unusual way to construct
2008// the global group for relocation. Not every RTLD_GLOBAL
2009// library is included in this group for backwards-compatibility
2010// reasons.
2011//
2012// This group consists of the main executable, LD_PRELOADs
2013// and libraries with the DF_1_GLOBAL flag set.
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002014static soinfo::soinfo_list_t make_global_group(android_namespace_t* ns) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002015 soinfo::soinfo_list_t global_group;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002016 ns->soinfo_list().for_each([&](soinfo* si) {
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002017 if ((si->get_dt_flags_1() & DF_1_GLOBAL) != 0) {
2018 global_group.push_back(si);
2019 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002020 });
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002021
2022 return global_group;
2023}
2024
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002025// This function provides a list of libraries to be shared
2026// by the namespace. For the default namespace this is the global
2027// group (see make_global_group). For all others this is a group
2028// of RTLD_GLOBAL libraries (which includes the global group from
2029// the default namespace).
2030static soinfo::soinfo_list_t get_shared_group(android_namespace_t* ns) {
2031 if (ns == &g_default_namespace) {
2032 return make_global_group(ns);
2033 }
2034
2035 soinfo::soinfo_list_t shared_group;
2036 ns->soinfo_list().for_each([&](soinfo* si) {
2037 if ((si->get_rtld_flags() & RTLD_GLOBAL) != 0) {
2038 shared_group.push_back(si);
2039 }
2040 });
2041
2042 return shared_group;
2043}
2044
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002045static void shuffle(std::vector<LoadTask*>* v) {
2046 for (size_t i = 0, size = v->size(); i < size; ++i) {
2047 size_t n = size - i;
2048 size_t r = arc4random_uniform(n);
2049 std::swap((*v)[n-1], (*v)[r]);
2050 }
2051}
2052
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07002053// add_as_children - add first-level loaded libraries (i.e. library_names[], but
2054// not their transitive dependencies) as children of the start_with library.
2055// This is false when find_libraries is called for dlopen(), when newly loaded
2056// libraries must form a disjoint tree.
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002057static bool find_libraries(android_namespace_t* ns,
2058 soinfo* start_with,
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07002059 const char* const library_names[],
2060 size_t library_names_count, soinfo* soinfos[],
2061 std::vector<soinfo*>* ld_preloads,
2062 size_t ld_preloads_count, int rtld_flags,
2063 const android_dlextinfo* extinfo,
2064 bool add_as_children) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002065 // Step 0: prepare.
2066 LoadTaskList load_tasks;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002067 std::unordered_map<const soinfo*, ElfReader> readers_map;
2068
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002069 for (size_t i = 0; i < library_names_count; ++i) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002070 const char* name = library_names[i];
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002071 load_tasks.push_back(LoadTask::create(name, start_with, &readers_map));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002072 }
2073
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002074 // Construct global_group.
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002075 soinfo::soinfo_list_t global_group = make_global_group(ns);
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07002076
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002077 // If soinfos array is null allocate one on stack.
2078 // The array is needed in case of failure; for example
2079 // when library_names[] = {libone.so, libtwo.so} and libone.so
2080 // is loaded correctly but libtwo.so failed for some reason.
2081 // In this case libone.so should be unloaded on return.
2082 // See also implementation of failure_guard below.
2083
2084 if (soinfos == nullptr) {
2085 size_t soinfos_size = sizeof(soinfo*)*library_names_count;
2086 soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size));
2087 memset(soinfos, 0, soinfos_size);
2088 }
2089
2090 // list of libraries to link - see step 2.
2091 size_t soinfos_count = 0;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002092
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002093 auto scope_guard = make_scope_guard([&]() {
2094 for (LoadTask* t : load_tasks) {
2095 LoadTask::deleter(t);
2096 }
2097 });
2098
Dmitriy Ivanovd9ff7222014-09-08 16:22:22 -07002099 auto failure_guard = make_scope_guard([&]() {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002100 // Housekeeping
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002101 soinfo_unload(soinfos, soinfos_count);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002102 });
2103
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07002104 ZipArchiveCache zip_archive_cache;
2105
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002106 // Step 1: expand the list of load_tasks to include
2107 // all DT_NEEDED libraries (do not load them just yet)
2108 for (size_t i = 0; i<load_tasks.size(); ++i) {
2109 LoadTask* task = load_tasks[i];
Evgenii Stepanov68650822015-06-10 13:38:39 -07002110 soinfo* needed_by = task->get_needed_by();
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002111
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07002112 bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002113 task->set_extinfo(is_dt_needed ? nullptr : extinfo);
Dimitry Ivanov10057482016-01-28 17:24:20 -08002114 task->set_dt_needed(is_dt_needed);
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07002115
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002116 if(!find_library_internal(ns, task, &zip_archive_cache, &load_tasks, rtld_flags)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002117 return false;
2118 }
2119
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002120 soinfo* si = task->get_soinfo();
2121
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07002122 if (is_dt_needed) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002123 needed_by->add_child(si);
2124 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002125
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002126 if (si->is_linked()) {
2127 si->increment_ref_count();
2128 }
2129
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002130 // When ld_preloads is not null, the first
2131 // ld_preloads_count libs are in fact ld_preloads.
2132 if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07002133 ld_preloads->push_back(si);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002134 }
2135
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002136 if (soinfos_count < library_names_count) {
2137 soinfos[soinfos_count++] = si;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002138 }
2139 }
2140
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07002141 // Step 2: Load libraries in random order (see b/24047022)
2142 LoadTaskList load_list;
2143 for (auto&& task : load_tasks) {
2144 soinfo* si = task->get_soinfo();
2145 auto pred = [&](const LoadTask* t) {
2146 return t->get_soinfo() == si;
2147 };
2148
2149 if (!si->is_linked() &&
2150 std::find_if(load_list.begin(), load_list.end(), pred) == load_list.end() ) {
2151 load_list.push_back(task);
2152 }
2153 }
2154 shuffle(&load_list);
2155
2156 for (auto&& task : load_list) {
2157 if (!task->load()) {
2158 return false;
2159 }
2160 }
2161
2162 // Step 3: pre-link all DT_NEEDED libraries in breadth first order.
2163 for (auto&& task : load_tasks) {
2164 soinfo* si = task->get_soinfo();
2165 if (!si->is_linked() && !si->prelink_image()) {
2166 return false;
2167 }
2168 }
2169
2170 // Step 4: Add LD_PRELOADed libraries to the global group for
2171 // future runs. There is no need to explicitly add them to
2172 // the global group for this run because they are going to
2173 // appear in the local group in the correct order.
2174 if (ld_preloads != nullptr) {
2175 for (auto&& si : *ld_preloads) {
2176 si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
2177 }
2178 }
2179
2180
2181 // Step 5: link libraries.
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002182 soinfo::soinfo_list_t local_group;
2183 walk_dependencies_tree(
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07002184 (start_with != nullptr && add_as_children) ? &start_with : soinfos,
2185 (start_with != nullptr && add_as_children) ? 1 : soinfos_count,
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002186 [&] (soinfo* si) {
2187 local_group.push_back(si);
2188 return true;
2189 });
2190
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002191 // We need to increment ref_count in case
2192 // the root of the local group was not linked.
2193 bool was_local_group_root_linked = local_group.front()->is_linked();
2194
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002195 bool linked = local_group.visit([&](soinfo* si) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002196 if (!si->is_linked()) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002197 if (!si->link_image(global_group, local_group, extinfo)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002198 return false;
2199 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002200 }
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002201
2202 return true;
2203 });
2204
2205 if (linked) {
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002206 local_group.for_each([](soinfo* si) {
2207 if (!si->is_linked()) {
2208 si->set_linked();
2209 }
2210 });
2211
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002212 failure_guard.disable();
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002213 }
2214
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002215 if (!was_local_group_root_linked) {
2216 local_group.front()->increment_ref_count();
2217 }
2218
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07002219 return linked;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002220}
2221
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002222static soinfo* find_library(android_namespace_t* ns,
2223 const char* name, int rtld_flags,
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07002224 const android_dlextinfo* extinfo,
2225 soinfo* needed_by) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002226 soinfo* si;
2227
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002228 if (name == nullptr) {
2229 si = somain;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002230 } else if (!find_libraries(ns, needed_by, &name, 1, &si, nullptr, 0, rtld_flags,
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07002231 extinfo, /* add_as_children */ false)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002232 return nullptr;
2233 }
2234
Elliott Hughesd23736e2012-11-01 15:16:56 -07002235 return si;
2236}
Elliott Hughesbedfe382012-08-14 14:07:59 -07002237
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002238static void soinfo_unload(soinfo* root) {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002239 if (root->is_linked()) {
2240 root = root->get_local_group_root();
2241 }
2242
2243 if (!root->can_unload()) {
Elliott Hughes38b88a42016-04-01 10:10:54 -07002244 TRACE("not unloading \"%s\" - the binary is flagged with NODELETE", root->get_realpath());
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002245 return;
2246 }
2247
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002248 soinfo_unload(&root, 1);
2249}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002250
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002251static void soinfo_unload(soinfo* soinfos[], size_t count) {
2252 // Note that the library can be loaded but not linked;
2253 // in which case there is no root but we still need
2254 // to walk the tree and unload soinfos involved.
2255 //
2256 // This happens on unsuccessful dlopen, when one of
2257 // the DT_NEEDED libraries could not be linked/found.
2258 if (count == 0) {
2259 return;
2260 }
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002261
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002262 soinfo::soinfo_list_t unload_list;
2263 for (size_t i = 0; i < count; ++i) {
2264 soinfo* si = soinfos[i];
Dmitriy Ivanov5ae82cb2014-12-02 17:08:42 -08002265
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002266 if (si->can_unload()) {
2267 size_t ref_count = si->is_linked() ? si->decrement_ref_count() : 0;
2268 if (ref_count == 0) {
2269 unload_list.push_back(si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002270 } else {
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002271 TRACE("not unloading '%s' group, decrementing ref_count to %zd",
2272 si->get_realpath(), ref_count);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002273 }
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002274 } else {
2275 TRACE("not unloading '%s' - the binary is flagged with NODELETE", si->get_realpath());
2276 return;
2277 }
2278 }
2279
2280 // This is used to identify soinfos outside of the load-group
2281 // note that we cannot have > 1 in the array and have any of them
2282 // linked. This is why we can safely use the first one.
2283 soinfo* root = soinfos[0];
2284
2285 soinfo::soinfo_list_t local_unload_list;
2286 soinfo::soinfo_list_t external_unload_list;
2287 soinfo* si = nullptr;
2288
2289 while ((si = unload_list.pop_front()) != nullptr) {
2290 if (local_unload_list.contains(si)) {
2291 continue;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002292 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07002293
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002294 local_unload_list.push_back(si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002295
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002296 if (si->has_min_version(0)) {
2297 soinfo* child = nullptr;
2298 while ((child = si->get_children().pop_front()) != nullptr) {
2299 TRACE("%s@%p needs to unload %s@%p", si->get_realpath(), si,
2300 child->get_realpath(), child);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002301
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002302 if (local_unload_list.contains(child)) {
2303 continue;
2304 } else if (child->is_linked() && child->get_local_group_root() != root) {
2305 external_unload_list.push_back(child);
2306 } else {
2307 unload_list.push_front(child);
2308 }
2309 }
2310 } else {
2311#if !defined(__work_around_b_24465209__)
2312 __libc_fatal("soinfo for \"%s\"@%p has no version", si->get_realpath(), si);
2313#else
2314 PRINT("warning: soinfo for \"%s\"@%p has no version", si->get_realpath(), si);
2315 for_each_dt_needed(si, [&] (const char* library_name) {
2316 TRACE("deprecated (old format of soinfo): %s needs to unload %s",
2317 si->get_realpath(), library_name);
2318
2319 soinfo* needed = find_library(si->get_primary_namespace(),
2320 library_name, RTLD_NOLOAD, nullptr, nullptr);
2321
2322 if (needed != nullptr) {
2323 // Not found: for example if symlink was deleted between dlopen and dlclose
2324 // Since we cannot really handle errors at this point - print and continue.
2325 PRINT("warning: couldn't find %s needed by %s on unload.",
2326 library_name, si->get_realpath());
2327 return;
2328 } else if (local_unload_list.contains(needed)) {
2329 // already visited
2330 return;
2331 } else if (needed->is_linked() && needed->get_local_group_root() != root) {
2332 // external group
2333 external_unload_list.push_back(needed);
2334 } else {
2335 // local group
2336 unload_list.push_front(needed);
2337 }
2338 });
2339#endif
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002340 }
Dimitry Ivanovbee85722016-05-04 17:19:14 -07002341 }
2342
2343 local_unload_list.for_each([](soinfo* si) {
2344 si->call_destructors();
2345 });
2346
2347 while ((si = local_unload_list.pop_front()) != nullptr) {
2348 notify_gdb_of_unload(si);
2349 soinfo_free(si);
2350 }
2351
2352 while ((si = external_unload_list.pop_front()) != nullptr) {
2353 soinfo_unload(si);
Dmitriy Ivanova2547052014-11-18 12:03:09 -08002354 }
2355}
2356
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002357static std::string symbol_display_name(const char* sym_name, const char* sym_ver) {
2358 if (sym_ver == nullptr) {
2359 return sym_name;
2360 }
2361
Dimitry Ivanov9cf99cb2015-12-11 14:22:24 -08002362 return std::string(sym_name) + ", version " + sym_ver;
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002363}
2364
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07002365static android_namespace_t* get_caller_namespace(soinfo* caller) {
2366 return caller != nullptr ? caller->get_primary_namespace() : g_anonymous_namespace;
2367}
2368
Elliott Hughesa4aafd12014-01-13 16:37:47 -08002369void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
Christopher Ferris052fa3a2014-08-26 20:48:11 -07002370 // Use basic string manipulation calls to avoid snprintf.
2371 // snprintf indirectly calls pthread_getspecific to get the size of a buffer.
2372 // When debug malloc is enabled, this call returns 0. This in turn causes
2373 // snprintf to do nothing, which causes libraries to fail to load.
2374 // See b/17302493 for further details.
2375 // Once the above bug is fixed, this code can be modified to use
2376 // snprintf again.
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002377 size_t required_len = 0;
2378 for (size_t i = 0; g_default_ld_paths[i] != nullptr; ++i) {
2379 required_len += strlen(g_default_ld_paths[i]) + 1;
2380 }
Christopher Ferris052fa3a2014-08-26 20:48:11 -07002381 if (buffer_size < required_len) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002382 __libc_fatal("android_get_LD_LIBRARY_PATH failed, buffer too small: "
2383 "buffer len %zu, required len %zu", buffer_size, required_len);
Christopher Ferris052fa3a2014-08-26 20:48:11 -07002384 }
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002385 char* end = buffer;
2386 for (size_t i = 0; g_default_ld_paths[i] != nullptr; ++i) {
2387 if (i > 0) *end++ = ':';
2388 end = stpcpy(end, g_default_ld_paths[i]);
2389 }
Elliott Hughesa4aafd12014-01-13 16:37:47 -08002390}
2391
Elliott Hughescade4c32012-12-20 14:42:14 -08002392void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
Nick Kralevich6bb01b62015-03-07 13:37:05 -08002393 parse_LD_LIBRARY_PATH(ld_library_path);
Elliott Hughescade4c32012-12-20 14:42:14 -08002394}
2395
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002396void* do_dlopen(const char* name, int flags, const android_dlextinfo* extinfo,
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002397 void* caller_addr) {
2398 soinfo* const caller = find_containing_library(caller_addr);
2399
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002400 if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) {
Elliott Hughese66190d2012-12-18 15:57:55 -08002401 DL_ERR("invalid flags to dlopen: %x", flags);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002402 return nullptr;
Elliott Hughese66190d2012-12-18 15:57:55 -08002403 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002404
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07002405 android_namespace_t* ns = get_caller_namespace(caller);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002406
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002407 if (extinfo != nullptr) {
2408 if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) {
2409 DL_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags);
2410 return nullptr;
2411 }
Dmitriy Ivanov126af752015-10-07 16:34:20 -07002412
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002413 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 &&
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07002414 (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002415 DL_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without "
2416 "ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags);
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002417 return nullptr;
2418 }
Dmitriy Ivanov126af752015-10-07 16:34:20 -07002419
2420 if ((extinfo->flags & ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS) != 0 &&
2421 (extinfo->flags & (ANDROID_DLEXT_RESERVED_ADDRESS | ANDROID_DLEXT_RESERVED_ADDRESS_HINT)) != 0) {
2422 DL_ERR("invalid extended flag combination: ANDROID_DLEXT_LOAD_AT_FIXED_ADDRESS is not "
2423 "compatible with ANDROID_DLEXT_RESERVED_ADDRESS/ANDROID_DLEXT_RESERVED_ADDRESS_HINT");
2424 return nullptr;
2425 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002426
2427 if ((extinfo->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0) {
2428 if (extinfo->library_namespace == nullptr) {
2429 DL_ERR("ANDROID_DLEXT_USE_NAMESPACE is set but extinfo->library_namespace is null");
2430 return nullptr;
2431 }
2432 ns = extinfo->library_namespace;
2433 }
Torne (Richard Coles)012cb452014-02-06 14:34:21 +00002434 }
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08002435
2436 ProtectedDataGuard guard;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05002437 reset_g_active_shim_libs();
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002438 soinfo* si = find_library(ns, name, flags, extinfo, caller);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002439 if (si != nullptr) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002440 si->call_constructors();
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002441 return si->to_handle();
Elliott Hughesd23736e2012-11-01 15:16:56 -07002442 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002443
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002444 return nullptr;
Elliott Hughesd23736e2012-11-01 15:16:56 -07002445}
2446
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002447int do_dladdr(const void* addr, Dl_info* info) {
2448 // Determine if this address can be found in any library currently mapped.
2449 soinfo* si = find_containing_library(addr);
2450 if (si == nullptr) {
2451 return 0;
2452 }
2453
2454 memset(info, 0, sizeof(Dl_info));
2455
2456 info->dli_fname = si->get_realpath();
2457 // Address at which the shared object is loaded.
2458 info->dli_fbase = reinterpret_cast<void*>(si->base);
2459
2460 // Determine if any symbol in the library contains the specified address.
2461 ElfW(Sym)* sym = si->find_symbol_by_address(addr);
2462 if (sym != nullptr) {
2463 info->dli_sname = si->get_string(sym->st_name);
2464 info->dli_saddr = reinterpret_cast<void*>(si->resolve_symbol_address(sym));
2465 }
2466
2467 return 1;
2468}
2469
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002470static soinfo* soinfo_from_handle(void* handle) {
2471 if ((reinterpret_cast<uintptr_t>(handle) & 1) != 0) {
2472 auto it = g_soinfo_handles_map.find(reinterpret_cast<uintptr_t>(handle));
2473 if (it == g_soinfo_handles_map.end()) {
2474 return nullptr;
2475 } else {
2476 return it->second;
2477 }
2478 }
2479
2480 return static_cast<soinfo*>(handle);
2481}
2482
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002483bool do_dlsym(void* handle, const char* sym_name, const char* sym_ver,
2484 void* caller_addr, void** symbol) {
2485#if !defined(__LP64__)
2486 if (handle == nullptr) {
2487 DL_ERR("dlsym failed: library handle is null");
2488 return false;
2489 }
2490#endif
2491
2492 if (sym_name == nullptr) {
2493 DL_ERR("dlsym failed: symbol name is null");
2494 return false;
2495 }
2496
2497 soinfo* found = nullptr;
2498 const ElfW(Sym)* sym = nullptr;
2499 soinfo* caller = find_containing_library(caller_addr);
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07002500 android_namespace_t* ns = get_caller_namespace(caller);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002501
2502 version_info vi_instance;
2503 version_info* vi = nullptr;
2504
2505 if (sym_ver != nullptr) {
Dimitry Ivanov9cf99cb2015-12-11 14:22:24 -08002506 vi_instance.name = sym_ver;
2507 vi_instance.elf_hash = calculate_elf_hash(sym_ver);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002508 vi = &vi_instance;
2509 }
2510
2511 if (handle == RTLD_DEFAULT || handle == RTLD_NEXT) {
2512 sym = dlsym_linear_lookup(ns, sym_name, vi, &found, caller, handle);
2513 } else {
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002514 soinfo* si = soinfo_from_handle(handle);
2515 if (si == nullptr) {
2516 DL_ERR("dlsym failed: invalid handle: %p", handle);
2517 return false;
2518 }
2519 sym = dlsym_handle_lookup(si, &found, sym_name, vi);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002520 }
2521
2522 if (sym != nullptr) {
2523 uint32_t bind = ELF_ST_BIND(sym->st_info);
2524
2525 if ((bind == STB_GLOBAL || bind == STB_WEAK) && sym->st_shndx != 0) {
2526 *symbol = reinterpret_cast<void*>(found->resolve_symbol_address(sym));
2527 return true;
2528 }
2529
2530 DL_ERR("symbol \"%s\" found but not global", symbol_display_name(sym_name, sym_ver).c_str());
2531 return false;
2532 }
2533
2534 DL_ERR("undefined symbol: %s", symbol_display_name(sym_name, sym_ver).c_str());
2535 return false;
2536}
2537
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002538int do_dlclose(void* handle) {
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08002539 ProtectedDataGuard guard;
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002540 soinfo* si = soinfo_from_handle(handle);
2541 if (si == nullptr) {
2542 DL_ERR("invalid handle: %p", handle);
2543 return -1;
2544 }
2545
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07002546 soinfo_unload(si);
Dimitry Ivanovae74e872016-03-24 15:30:30 -07002547 return 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002548}
2549
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002550bool init_namespaces(const char* public_ns_sonames, const char* anon_ns_library_path) {
2551 CHECK(public_ns_sonames != nullptr);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002552 if (g_public_namespace_initialized) {
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002553 DL_ERR("public namespace has already been initialized.");
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002554 return false;
2555 }
2556
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002557 std::vector<std::string> sonames = android::base::Split(public_ns_sonames, ":");
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002558
2559 ProtectedDataGuard guard;
2560
2561 auto failure_guard = make_scope_guard([&]() {
2562 g_public_namespace.clear();
2563 });
2564
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002565 for (const auto& soname : sonames) {
Dmitriy Ivanov3cc35e22015-11-17 18:36:50 -08002566 soinfo* candidate = nullptr;
2567
2568 find_loaded_library_by_soname(&g_default_namespace, soname.c_str(), &candidate);
2569
2570 if (candidate == nullptr) {
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002571 DL_ERR("error initializing public namespace: \"%s\" was not found"
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002572 " in the default namespace", soname.c_str());
2573 return false;
2574 }
2575
2576 candidate->set_nodelete();
2577 g_public_namespace.push_back(candidate);
2578 }
2579
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002580 g_public_namespace_initialized = true;
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002581
2582 // create anonymous namespace
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002583 // When the caller is nullptr - create_namespace will take global group
2584 // from the anonymous namespace, which is fine because anonymous namespace
2585 // is still pointing to the default one.
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002586 android_namespace_t* anon_ns =
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002587 create_namespace(nullptr, "(anonymous)", nullptr, anon_ns_library_path,
Dimitry Ivanov3c9624a2016-05-23 10:31:11 -07002588 ANDROID_NAMESPACE_TYPE_REGULAR, nullptr, &g_default_namespace);
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002589
2590 if (anon_ns == nullptr) {
2591 g_public_namespace_initialized = false;
2592 return false;
2593 }
2594 g_anonymous_namespace = anon_ns;
2595 failure_guard.disable();
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002596 return true;
2597}
2598
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002599android_namespace_t* create_namespace(const void* caller_addr,
2600 const char* name,
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002601 const char* ld_library_path,
2602 const char* default_library_path,
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002603 uint64_t type,
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002604 const char* permitted_when_isolated_path,
2605 android_namespace_t* parent_namespace) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002606 if (!g_public_namespace_initialized) {
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002607 DL_ERR("cannot create namespace: public namespace is not initialized.");
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002608 return nullptr;
2609 }
2610
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002611 if (parent_namespace == nullptr) {
Dimitry Ivanov3c9624a2016-05-23 10:31:11 -07002612 // if parent_namespace is nullptr -> set it to the caller namespace
2613 soinfo* caller_soinfo = find_containing_library(caller_addr);
2614
2615 parent_namespace = caller_soinfo != nullptr ?
2616 caller_soinfo->get_primary_namespace() :
2617 g_anonymous_namespace;
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002618 }
2619
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002620 ProtectedDataGuard guard;
2621 std::vector<std::string> ld_library_paths;
2622 std::vector<std::string> default_library_paths;
Dimitry Ivanov284ae352015-12-08 10:47:13 -08002623 std::vector<std::string> permitted_paths;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002624
2625 parse_path(ld_library_path, ":", &ld_library_paths);
2626 parse_path(default_library_path, ":", &default_library_paths);
Dimitry Ivanov284ae352015-12-08 10:47:13 -08002627 parse_path(permitted_when_isolated_path, ":", &permitted_paths);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002628
2629 android_namespace_t* ns = new (g_namespace_allocator.alloc()) android_namespace_t();
2630 ns->set_name(name);
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002631 ns->set_isolated((type & ANDROID_NAMESPACE_TYPE_ISOLATED) != 0);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002632 ns->set_ld_library_paths(std::move(ld_library_paths));
2633 ns->set_default_library_paths(std::move(default_library_paths));
Dimitry Ivanov284ae352015-12-08 10:47:13 -08002634 ns->set_permitted_paths(std::move(permitted_paths));
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002635
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002636 if ((type & ANDROID_NAMESPACE_TYPE_SHARED) != 0) {
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002637 // If shared - clone the parent namespace
2638 ns->add_soinfos(parent_namespace->soinfo_list());
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002639 } else {
Dimitry Ivanov49cfc892016-05-12 15:20:21 -07002640 // If not shared - copy only the shared group
2641 ns->add_soinfos(get_shared_group(parent_namespace));
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002642 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002643
2644 return ns;
2645}
2646
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002647static ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) {
2648 typedef ElfW(Addr) (*ifunc_resolver_t)(void);
2649 ifunc_resolver_t ifunc_resolver = reinterpret_cast<ifunc_resolver_t>(resolver_addr);
2650 ElfW(Addr) ifunc_addr = ifunc_resolver();
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002651 TRACE_TYPE(RELO, "Called ifunc_resolver@%p. The result is %p",
2652 ifunc_resolver, reinterpret_cast<void*>(ifunc_addr));
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002653
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002654 return ifunc_addr;
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002655}
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002656
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002657const version_info* VersionTracker::get_version_info(ElfW(Versym) source_symver) const {
2658 if (source_symver < 2 ||
2659 source_symver >= version_infos.size() ||
2660 version_infos[source_symver].name == nullptr) {
2661 return nullptr;
2662 }
2663
2664 return &version_infos[source_symver];
2665}
2666
2667void VersionTracker::add_version_info(size_t source_index,
2668 ElfW(Word) elf_hash,
2669 const char* ver_name,
2670 const soinfo* target_si) {
2671 if (source_index >= version_infos.size()) {
2672 version_infos.resize(source_index+1);
2673 }
2674
2675 version_infos[source_index].elf_hash = elf_hash;
2676 version_infos[source_index].name = ver_name;
2677 version_infos[source_index].target_si = target_si;
2678}
2679
2680bool VersionTracker::init_verneed(const soinfo* si_from) {
2681 uintptr_t verneed_ptr = si_from->get_verneed_ptr();
2682
2683 if (verneed_ptr == 0) {
2684 return true;
2685 }
2686
2687 size_t verneed_cnt = si_from->get_verneed_cnt();
2688
2689 for (size_t i = 0, offset = 0; i<verneed_cnt; ++i) {
2690 const ElfW(Verneed)* verneed = reinterpret_cast<ElfW(Verneed)*>(verneed_ptr + offset);
2691 size_t vernaux_offset = offset + verneed->vn_aux;
2692 offset += verneed->vn_next;
2693
2694 if (verneed->vn_version != 1) {
2695 DL_ERR("unsupported verneed[%zd] vn_version: %d (expected 1)", i, verneed->vn_version);
2696 return false;
2697 }
2698
2699 const char* target_soname = si_from->get_string(verneed->vn_file);
2700 // find it in dependencies
2701 soinfo* target_si = si_from->get_children().find_if([&](const soinfo* si) {
Dmitriy Ivanov406d9962015-05-06 11:05:27 -07002702 return si->get_soname() != nullptr && strcmp(si->get_soname(), target_soname) == 0;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002703 });
2704
2705 if (target_si == nullptr) {
2706 DL_ERR("cannot find \"%s\" from verneed[%zd] in DT_NEEDED list for \"%s\"",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002707 target_soname, i, si_from->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002708 return false;
2709 }
2710
2711 for (size_t j = 0; j<verneed->vn_cnt; ++j) {
2712 const ElfW(Vernaux)* vernaux = reinterpret_cast<ElfW(Vernaux)*>(verneed_ptr + vernaux_offset);
2713 vernaux_offset += vernaux->vna_next;
2714
2715 const ElfW(Word) elf_hash = vernaux->vna_hash;
2716 const char* ver_name = si_from->get_string(vernaux->vna_name);
2717 ElfW(Half) source_index = vernaux->vna_other;
2718
2719 add_version_info(source_index, elf_hash, ver_name, target_si);
2720 }
2721 }
2722
2723 return true;
2724}
2725
2726bool VersionTracker::init_verdef(const soinfo* si_from) {
2727 return for_each_verdef(si_from,
2728 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
2729 add_version_info(verdef->vd_ndx, verdef->vd_hash,
2730 si_from->get_string(verdaux->vda_name), si_from);
2731 return false;
2732 }
2733 );
2734}
2735
2736bool VersionTracker::init(const soinfo* si_from) {
2737 if (!si_from->has_min_version(2)) {
2738 return true;
2739 }
2740
2741 return init_verneed(si_from) && init_verdef(si_from);
2742}
2743
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002744bool soinfo::lookup_version_info(const VersionTracker& version_tracker, ElfW(Word) sym,
2745 const char* sym_name, const version_info** vi) {
2746 const ElfW(Versym)* sym_ver_ptr = get_versym(sym);
2747 ElfW(Versym) sym_ver = sym_ver_ptr == nullptr ? 0 : *sym_ver_ptr;
2748
2749 if (sym_ver != VER_NDX_LOCAL && sym_ver != VER_NDX_GLOBAL) {
2750 *vi = version_tracker.get_version_info(sym_ver);
2751
2752 if (*vi == nullptr) {
2753 DL_ERR("cannot find verneed/verdef for version index=%d "
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002754 "referenced by symbol \"%s\" at \"%s\"", sym_ver, sym_name, get_realpath());
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002755 return false;
2756 }
2757 } else {
2758 // there is no version info
2759 *vi = nullptr;
2760 }
2761
2762 return true;
2763}
2764
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002765#if !defined(__mips__)
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002766#if defined(USE_RELA)
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002767static ElfW(Addr) get_addend(ElfW(Rela)* rela, ElfW(Addr) reloc_addr __unused) {
2768 return rela->r_addend;
2769}
2770#else
2771static ElfW(Addr) get_addend(ElfW(Rel)* rel, ElfW(Addr) reloc_addr) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002772 if (ELFW(R_TYPE)(rel->r_info) == R_GENERIC_RELATIVE ||
2773 ELFW(R_TYPE)(rel->r_info) == R_GENERIC_IRELATIVE) {
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002774 return *reinterpret_cast<ElfW(Addr)*>(reloc_addr);
2775 }
2776 return 0;
2777}
2778#endif
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002779
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -08002780template<typename ElfRelIteratorT>
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07002781bool soinfo::relocate(const VersionTracker& version_tracker, ElfRelIteratorT&& rel_iterator,
2782 const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
Dmitriy Ivanovfa26eee2015-02-03 16:06:47 -08002783 for (size_t idx = 0; rel_iterator.has_next(); ++idx) {
2784 const auto rel = rel_iterator.next();
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002785 if (rel == nullptr) {
2786 return false;
2787 }
2788
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002789 ElfW(Word) type = ELFW(R_TYPE)(rel->r_info);
2790 ElfW(Word) sym = ELFW(R_SYM)(rel->r_info);
2791
2792 ElfW(Addr) reloc = static_cast<ElfW(Addr)>(rel->r_offset + load_bias);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002793 ElfW(Addr) sym_addr = 0;
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002794 const char* sym_name = nullptr;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002795 ElfW(Addr) addend = get_addend(rel, reloc);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002796
Elliott Hughes38b88a42016-04-01 10:10:54 -07002797 DEBUG("Processing \"%s\" relocation at index %zd", get_realpath(), idx);
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002798 if (type == R_GENERIC_NONE) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002799 continue;
2800 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002801
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002802 const ElfW(Sym)* s = nullptr;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07002803 soinfo* lsi = nullptr;
2804
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002805 if (sym != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002806 sym_name = get_string(symtab_[sym].st_name);
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002807 const version_info* vi = nullptr;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002808
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002809 if (!lookup_version_info(version_tracker, sym, sym_name, &vi)) {
2810 return false;
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002811 }
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002812
2813 if (!soinfo_do_lookup(this, sym_name, vi, &lsi, global_group, local_group, &s)) {
2814 return false;
2815 }
2816
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002817 if (s == nullptr) {
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002818 // We only allow an undefined symbol if this is a weak reference...
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002819 s = &symtab_[sym];
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002820 if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002821 DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08002822 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002823 }
2824
2825 /* IHI0044C AAELF 4.5.1.1:
2826
2827 Libraries are not searched to resolve weak references.
2828 It is not an error for a weak reference to remain unsatisfied.
2829
2830 During linking, the value of an undefined weak reference is:
2831 - Zero if the relocation type is absolute
2832 - The address of the place if the relocation is pc-relative
2833 - The address of nominal base address if the relocation
2834 type is base-relative.
2835 */
2836
2837 switch (type) {
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08002838 case R_GENERIC_JUMP_SLOT:
2839 case R_GENERIC_GLOB_DAT:
2840 case R_GENERIC_RELATIVE:
2841 case R_GENERIC_IRELATIVE:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002842#if defined(__aarch64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002843 case R_AARCH64_ABS64:
2844 case R_AARCH64_ABS32:
2845 case R_AARCH64_ABS16:
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08002846#elif defined(__x86_64__)
2847 case R_X86_64_32:
2848 case R_X86_64_64:
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002849#elif defined(__arm__)
2850 case R_ARM_ABS32:
2851#elif defined(__i386__)
2852 case R_386_32:
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08002853#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002854 /*
2855 * The sym_addr was initialized to be zero above, or the relocation
2856 * code below does not care about value of sym_addr.
2857 * No need to do anything.
2858 */
2859 break;
Dmitriy Ivanov1b694692015-01-13 12:17:31 -08002860#if defined(__x86_64__)
Dimitry Ivanovd338aac2015-01-13 22:31:54 +00002861 case R_X86_64_PC32:
2862 sym_addr = reloc;
2863 break;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002864#elif defined(__i386__)
2865 case R_386_PC32:
2866 sym_addr = reloc;
2867 break;
2868#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002869 default:
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002870 DL_ERR("unknown weak reloc type %d @ %p (%zu)", type, rel, idx);
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08002871 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002872 }
Dmitriy Ivanovec83a612015-07-26 07:37:09 -07002873 } else { // We got a definition.
2874#if !defined(__LP64__)
2875 // When relocating dso with text_relocation .text segment is
2876 // not executable. We need to restore elf flags before resolving
2877 // STT_GNU_IFUNC symbol.
2878 bool protect_segments = has_text_relocations &&
2879 lsi == this &&
2880 ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC;
2881 if (protect_segments) {
2882 if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) {
2883 DL_ERR("can't protect segments for \"%s\": %s",
2884 get_realpath(), strerror(errno));
2885 return false;
2886 }
2887 }
2888#endif
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002889 sym_addr = lsi->resolve_symbol_address(s);
Dmitriy Ivanovec83a612015-07-26 07:37:09 -07002890#if !defined(__LP64__)
2891 if (protect_segments) {
2892 if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) {
2893 DL_ERR("can't unprotect loadable segments for \"%s\": %s",
2894 get_realpath(), strerror(errno));
2895 return false;
2896 }
2897 }
2898#endif
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002899 }
2900 count_relocation(kRelocSymbol);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002901 }
2902
2903 switch (type) {
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002904 case R_GENERIC_JUMP_SLOT:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002905 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002906 MARK(rel->r_offset);
2907 TRACE_TYPE(RELO, "RELO JMP_SLOT %16p <- %16p %s\n",
2908 reinterpret_cast<void*>(reloc),
2909 reinterpret_cast<void*>(sym_addr + addend), sym_name);
2910
2911 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002912 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002913 case R_GENERIC_GLOB_DAT:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002914 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002915 MARK(rel->r_offset);
2916 TRACE_TYPE(RELO, "RELO GLOB_DAT %16p <- %16p %s\n",
2917 reinterpret_cast<void*>(reloc),
2918 reinterpret_cast<void*>(sym_addr + addend), sym_name);
2919 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002920 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002921 case R_GENERIC_RELATIVE:
2922 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002923 MARK(rel->r_offset);
2924 TRACE_TYPE(RELO, "RELO RELATIVE %16p <- %16p\n",
2925 reinterpret_cast<void*>(reloc),
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002926 reinterpret_cast<void*>(load_bias + addend));
2927 *reinterpret_cast<ElfW(Addr)*>(reloc) = (load_bias + addend);
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002928 break;
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002929 case R_GENERIC_IRELATIVE:
2930 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002931 MARK(rel->r_offset);
2932 TRACE_TYPE(RELO, "RELO IRELATIVE %16p <- %16p\n",
2933 reinterpret_cast<void*>(reloc),
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08002934 reinterpret_cast<void*>(load_bias + addend));
Dmitriy Ivanovec83a612015-07-26 07:37:09 -07002935 {
2936#if !defined(__LP64__)
2937 // When relocating dso with text_relocation .text segment is
2938 // not executable. We need to restore elf flags for this
2939 // particular call.
2940 if (has_text_relocations) {
2941 if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) {
2942 DL_ERR("can't protect segments for \"%s\": %s",
2943 get_realpath(), strerror(errno));
2944 return false;
2945 }
2946 }
2947#endif
2948 ElfW(Addr) ifunc_addr = call_ifunc_resolver(load_bias + addend);
2949#if !defined(__LP64__)
2950 // Unprotect it afterwards...
2951 if (has_text_relocations) {
2952 if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) {
2953 DL_ERR("can't unprotect loadable segments for \"%s\": %s",
2954 get_realpath(), strerror(errno));
2955 return false;
2956 }
2957 }
2958#endif
2959 *reinterpret_cast<ElfW(Addr)*>(reloc) = ifunc_addr;
2960 }
Dmitriy Ivanovcefef7d2015-01-08 23:30:15 -08002961 break;
2962
2963#if defined(__aarch64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002964 case R_AARCH64_ABS64:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002965 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002966 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002967 TRACE_TYPE(RELO, "RELO ABS64 %16llx <- %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002968 reloc, sym_addr + addend, sym_name);
2969 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend;
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002970 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002971 case R_AARCH64_ABS32:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002972 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002973 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002974 TRACE_TYPE(RELO, "RELO ABS32 %16llx <- %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002975 reloc, sym_addr + addend, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002976 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002977 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN);
2978 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX);
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002979 if ((min_value <= (sym_addr + addend)) &&
2980 ((sym_addr + addend) <= max_value)) {
2981 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend;
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002982 } else {
2983 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002984 sym_addr + addend, min_value, max_value);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002985 return false;
2986 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002987 }
2988 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002989 case R_AARCH64_ABS16:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01002990 count_relocation(kRelocAbsolute);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08002991 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08002992 TRACE_TYPE(RELO, "RELO ABS16 %16llx <- %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002993 reloc, sym_addr + addend, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002994 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002995 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN);
2996 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX);
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07002997 if ((min_value <= (sym_addr + addend)) &&
2998 ((sym_addr + addend) <= max_value)) {
2999 *reinterpret_cast<ElfW(Addr)*>(reloc) = (sym_addr + addend);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003000 } else {
3001 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003002 sym_addr + addend, min_value, max_value);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003003 return false;
3004 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003005 }
3006 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003007 case R_AARCH64_PREL64:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003008 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003009 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003010 TRACE_TYPE(RELO, "RELO REL64 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003011 reloc, sym_addr + addend, rel->r_offset, sym_name);
3012 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend - rel->r_offset;
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003013 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003014 case R_AARCH64_PREL32:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003015 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003016 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003017 TRACE_TYPE(RELO, "RELO REL32 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003018 reloc, sym_addr + addend, rel->r_offset, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003019 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003020 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT32_MIN);
3021 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT32_MAX);
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003022 if ((min_value <= (sym_addr + addend - rel->r_offset)) &&
3023 ((sym_addr + addend - rel->r_offset) <= max_value)) {
3024 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend - rel->r_offset;
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003025 } else {
3026 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003027 sym_addr + addend - rel->r_offset, min_value, max_value);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003028 return false;
3029 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003030 }
3031 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003032 case R_AARCH64_PREL16:
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003033 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003034 MARK(rel->r_offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08003035 TRACE_TYPE(RELO, "RELO REL16 %16llx <- %16llx - %16llx %s\n",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003036 reloc, sym_addr + addend, rel->r_offset, sym_name);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003037 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003038 const ElfW(Addr) min_value = static_cast<ElfW(Addr)>(INT16_MIN);
3039 const ElfW(Addr) max_value = static_cast<ElfW(Addr)>(UINT16_MAX);
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003040 if ((min_value <= (sym_addr + addend - rel->r_offset)) &&
3041 ((sym_addr + addend - rel->r_offset) <= max_value)) {
3042 *reinterpret_cast<ElfW(Addr)*>(reloc) = sym_addr + addend - rel->r_offset;
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003043 } else {
3044 DL_ERR("0x%016llx out of range 0x%016llx to 0x%016llx",
Dmitriy Ivanov77f91c62015-10-15 13:26:03 -07003045 sym_addr + addend - rel->r_offset, min_value, max_value);
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003046 return false;
3047 }
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003048 }
3049 break;
3050
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003051 case R_AARCH64_COPY:
Nick Kralevich76e289c2014-07-03 12:04:31 -07003052 /*
3053 * ET_EXEC is not supported so this should not happen.
3054 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003055 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0056b/IHI0056B_aaelf64.pdf
Nick Kralevich76e289c2014-07-03 12:04:31 -07003056 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003057 * Section 4.6.11 "Dynamic relocations"
Nick Kralevich76e289c2014-07-03 12:04:31 -07003058 * R_AARCH64_COPY may only appear in executable objects where e_type is
3059 * set to ET_EXEC.
3060 */
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003061 DL_ERR("%s R_AARCH64_COPY relocations are not supported", get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08003062 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003063 case R_AARCH64_TLS_TPREL64:
Elliott Hughes0266ae52014-02-10 17:46:57 -08003064 TRACE_TYPE(RELO, "RELO TLS_TPREL64 *** %16llx <- %16llx - %16llx\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003065 reloc, (sym_addr + addend), rel->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003066 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003067 case R_AARCH64_TLS_DTPREL32:
Elliott Hughes0266ae52014-02-10 17:46:57 -08003068 TRACE_TYPE(RELO, "RELO TLS_DTPREL32 *** %16llx <- %16llx - %16llx\n",
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003069 reloc, (sym_addr + addend), rel->r_offset);
Marcus Oaklande365f9d2013-10-10 15:19:31 +01003070 break;
3071#elif defined(__x86_64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003072 case R_X86_64_32:
3073 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003074 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003075 TRACE_TYPE(RELO, "RELO R_X86_64_32 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
3076 static_cast<size_t>(sym_addr), sym_name);
Junichi Uekawaff35b1e2015-11-18 10:18:59 +09003077 *reinterpret_cast<Elf32_Addr*>(reloc) = sym_addr + addend;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003078 break;
3079 case R_X86_64_64:
3080 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003081 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003082 TRACE_TYPE(RELO, "RELO R_X86_64_64 %08zx <- +%08zx %s", static_cast<size_t>(reloc),
3083 static_cast<size_t>(sym_addr), sym_name);
Junichi Uekawaff35b1e2015-11-18 10:18:59 +09003084 *reinterpret_cast<Elf64_Addr*>(reloc) = sym_addr + addend;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003085 break;
3086 case R_X86_64_PC32:
3087 count_relocation(kRelocRelative);
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003088 MARK(rel->r_offset);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003089 TRACE_TYPE(RELO, "RELO R_X86_64_PC32 %08zx <- +%08zx (%08zx - %08zx) %s",
3090 static_cast<size_t>(reloc), static_cast<size_t>(sym_addr - reloc),
3091 static_cast<size_t>(sym_addr), static_cast<size_t>(reloc), sym_name);
Junichi Uekawaff35b1e2015-11-18 10:18:59 +09003092 *reinterpret_cast<Elf32_Addr*>(reloc) = sym_addr + addend - reloc;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003093 break;
Dmitriy Ivanovbcc04d02015-01-13 12:12:38 -08003094#elif defined(__arm__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003095 case R_ARM_ABS32:
3096 count_relocation(kRelocAbsolute);
3097 MARK(rel->r_offset);
3098 TRACE_TYPE(RELO, "RELO ABS %08x <- %08x %s", reloc, sym_addr, sym_name);
3099 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
3100 break;
3101 case R_ARM_REL32:
3102 count_relocation(kRelocRelative);
3103 MARK(rel->r_offset);
3104 TRACE_TYPE(RELO, "RELO REL32 %08x <- %08x - %08x %s",
3105 reloc, sym_addr, rel->r_offset, sym_name);
3106 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr - rel->r_offset;
3107 break;
3108 case R_ARM_COPY:
3109 /*
3110 * ET_EXEC is not supported so this should not happen.
3111 *
3112 * http://infocenter.arm.com/help/topic/com.arm.doc.ihi0044d/IHI0044D_aaelf.pdf
3113 *
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003114 * Section 4.6.1.10 "Dynamic relocations"
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003115 * R_ARM_COPY may only appear in executable objects where e_type is
3116 * set to ET_EXEC.
3117 */
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003118 DL_ERR("%s R_ARM_COPY relocations are not supported", get_realpath());
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08003119 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003120#elif defined(__i386__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003121 case R_386_32:
3122 count_relocation(kRelocRelative);
3123 MARK(rel->r_offset);
3124 TRACE_TYPE(RELO, "RELO R_386_32 %08x <- +%08x %s", reloc, sym_addr, sym_name);
3125 *reinterpret_cast<ElfW(Addr)*>(reloc) += sym_addr;
3126 break;
3127 case R_386_PC32:
3128 count_relocation(kRelocRelative);
3129 MARK(rel->r_offset);
3130 TRACE_TYPE(RELO, "RELO R_386_PC32 %08x <- +%08x (%08x - %08x) %s",
3131 reloc, (sym_addr - reloc), sym_addr, reloc, sym_name);
3132 *reinterpret_cast<ElfW(Addr)*>(reloc) += (sym_addr - reloc);
3133 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003134#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003135 default:
3136 DL_ERR("unknown reloc type %d @ %p (%zu)", type, rel, idx);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003137 return false;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003138 }
3139 }
3140 return true;
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07003141}
Dmitriy Ivanov114ff692015-01-14 11:36:38 -08003142#endif // !defined(__mips__)
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07003143
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003144void soinfo::call_array(const char* array_name __unused, linker_function_t* functions,
3145 size_t count, bool reverse) {
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07003146 if (functions == nullptr) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07003147 return;
3148 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02003149
Elliott Hughes38b88a42016-04-01 10:10:54 -07003150 TRACE("[ Calling %s (size %zd) @ %p for \"%s\" ]", array_name, count, functions, get_realpath());
Elliott Hughesca0c11b2013-03-12 10:40:45 -07003151
3152 int begin = reverse ? (count - 1) : 0;
3153 int end = reverse ? -1 : count;
3154 int step = reverse ? -1 : 1;
3155
3156 for (int i = begin; i != end; i += step) {
3157 TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003158 call_function("function", functions[i]);
Elliott Hughesd23736e2012-11-01 15:16:56 -07003159 }
David 'Digit' Turner82156792009-05-18 14:37:41 +02003160
Elliott Hughes38b88a42016-04-01 10:10:54 -07003161 TRACE("[ Done calling %s for \"%s\" ]", array_name, get_realpath());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003162}
3163
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003164void soinfo::call_function(const char* function_name __unused, linker_function_t function) {
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07003165 if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
Elliott Hughesd23736e2012-11-01 15:16:56 -07003166 return;
3167 }
3168
Elliott Hughes38b88a42016-04-01 10:10:54 -07003169 TRACE("[ Calling %s @ %p for \"%s\" ]", function_name, function, get_realpath());
Elliott Hughesd23736e2012-11-01 15:16:56 -07003170 function();
Elliott Hughes38b88a42016-04-01 10:10:54 -07003171 TRACE("[ Done calling %s @ %p for \"%s\" ]", function_name, function, get_realpath());
Evgeniy Stepanov9181a5d2012-08-13 17:58:37 +04003172}
3173
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003174void soinfo::call_pre_init_constructors() {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07003175 // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
3176 // but ignored in a shared library.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003177 call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false);
Elliott Hughesd23736e2012-11-01 15:16:56 -07003178}
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04003179
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003180void soinfo::call_constructors() {
Elliott Hughesd23736e2012-11-01 15:16:56 -07003181 if (constructors_called) {
3182 return;
3183 }
Jesse Hallf5d16932012-01-30 15:39:57 -08003184
Elliott Hughesd23736e2012-11-01 15:16:56 -07003185 // We set constructors_called before actually calling the constructors, otherwise it doesn't
3186 // protect against recursive constructor calls. One simple example of constructor recursion
3187 // is the libc debug malloc, which is implemented in libc_malloc_debug_leak.so:
3188 // 1. The program depends on libc, so libc's constructor is called here.
3189 // 2. The libc constructor calls dlopen() to load libc_malloc_debug_leak.so.
3190 // 3. dlopen() calls the constructors on the newly created
3191 // soinfo for libc_malloc_debug_leak.so.
3192 // 4. The debug .so depends on libc, so CallConstructors is
3193 // called again with the libc soinfo. If it doesn't trigger the early-
3194 // out above, the libc constructor will be called again (recursively!).
3195 constructors_called = true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003196
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003197 if (!is_main_executable() && preinit_array_ != nullptr) {
Elliott Hughes8147d3c2013-05-09 14:19:58 -07003198 // The GNU dynamic linker silently ignores these, but we warn the developer.
Dimitry Ivanovbee85722016-05-04 17:19:14 -07003199 PRINT("\"%s\": ignoring DT_PREINIT_ARRAY in shared library!", get_realpath());
Elliott Hughesd23736e2012-11-01 15:16:56 -07003200 }
3201
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003202 get_children().for_each([] (soinfo* si) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003203 si->call_constructors();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003204 });
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04003205
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003206 TRACE("\"%s\": calling constructors", get_realpath());
Elliott Hughes8147d3c2013-05-09 14:19:58 -07003207
3208 // DT_INIT should be called before DT_INIT_ARRAY if both are present.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003209 call_function("DT_INIT", init_func_);
3210 call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false);
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04003211}
David 'Digit' Turner82156792009-05-18 14:37:41 +02003212
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003213void soinfo::call_destructors() {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003214 if (!constructors_called) {
3215 return;
3216 }
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003217 TRACE("\"%s\": calling destructors", get_realpath());
Elliott Hughes8147d3c2013-05-09 14:19:58 -07003218
3219 // DT_FINI_ARRAY must be parsed in reverse order.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003220 call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true);
Elliott Hughes8147d3c2013-05-09 14:19:58 -07003221
3222 // DT_FINI should be called after DT_FINI_ARRAY if both are present.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003223 call_function("DT_FINI", fini_func_);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07003224
3225 // This is needed on second call to dlopen
3226 // after library has been unloaded with RTLD_NODELETE
3227 constructors_called = false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003228}
3229
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003230void soinfo::add_child(soinfo* child) {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003231 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003232 child->parents_.push_back(this);
3233 this->children_.push_back(child);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003234 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003235}
3236
3237void soinfo::remove_all_links() {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003238 if (!has_min_version(0)) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003239 return;
3240 }
3241
3242 // 1. Untie connected soinfos from 'this'.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003243 children_.for_each([&] (soinfo* child) {
3244 child->parents_.remove_if([&] (const soinfo* parent) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003245 return parent == this;
3246 });
3247 });
3248
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003249 parents_.for_each([&] (soinfo* parent) {
3250 parent->children_.remove_if([&] (const soinfo* child) {
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003251 return child == this;
3252 });
3253 });
3254
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07003255 // 2. Remove from the primary namespace
3256 primary_namespace_->remove_soinfo(this);
3257 primary_namespace_ = nullptr;
3258
3259 // 3. Remove from secondary namespaces
3260 secondary_namespaces_.for_each([&](android_namespace_t* ns) {
3261 ns->remove_soinfo(this);
3262 });
3263
3264
3265 // 4. Once everything untied - clear local lists.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003266 parents_.clear();
3267 children_.clear();
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07003268 secondary_namespaces_.clear();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003269}
3270
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003271dev_t soinfo::get_st_dev() const {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003272 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003273 return st_dev_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003274 }
3275
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003276 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003277};
3278
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003279ino_t soinfo::get_st_ino() const {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003280 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003281 return st_ino_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003282 }
3283
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003284 return 0;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003285}
3286
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003287off64_t soinfo::get_file_offset() const {
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07003288 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003289 return file_offset_;
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07003290 }
3291
3292 return 0;
3293}
3294
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003295uint32_t soinfo::get_rtld_flags() const {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07003296 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003297 return rtld_flags_;
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07003298 }
3299
3300 return 0;
3301}
3302
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003303uint32_t soinfo::get_dt_flags_1() const {
3304 if (has_min_version(1)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003305 return dt_flags_1_;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003306 }
3307
3308 return 0;
3309}
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003310
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003311void soinfo::set_dt_flags_1(uint32_t dt_flags_1) {
3312 if (has_min_version(1)) {
3313 if ((dt_flags_1 & DF_1_GLOBAL) != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003314 rtld_flags_ |= RTLD_GLOBAL;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003315 }
3316
3317 if ((dt_flags_1 & DF_1_NODELETE) != 0) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003318 rtld_flags_ |= RTLD_NODELETE;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003319 }
3320
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003321 dt_flags_1_ = dt_flags_1;
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003322 }
3323}
3324
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003325void soinfo::set_nodelete() {
3326 rtld_flags_ |= RTLD_NODELETE;
3327}
3328
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003329const char* soinfo::get_realpath() const {
Dmitriy Ivanov280d5462015-09-28 10:14:17 -07003330#if defined(__work_around_b_24465209__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003331 if (has_min_version(2)) {
3332 return realpath_.c_str();
3333 } else {
3334 return old_name_;
3335 }
3336#else
3337 return realpath_.c_str();
3338#endif
3339}
3340
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07003341void soinfo::set_soname(const char* soname) {
3342#if defined(__work_around_b_24465209__)
3343 if (has_min_version(2)) {
3344 soname_ = soname;
3345 }
3346 strlcpy(old_name_, soname_, sizeof(old_name_));
3347#else
3348 soname_ = soname;
3349#endif
3350}
3351
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003352const char* soinfo::get_soname() const {
Dmitriy Ivanov280d5462015-09-28 10:14:17 -07003353#if defined(__work_around_b_24465209__)
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003354 if (has_min_version(2)) {
3355 return soname_;
3356 } else {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003357 return old_name_;
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003358 }
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003359#else
3360 return soname_;
3361#endif
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003362}
3363
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003364// This is a return on get_children()/get_parents() if
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003365// 'this->flags' does not have FLAG_NEW_SOINFO set.
3366static soinfo::soinfo_list_t g_empty_list;
3367
3368soinfo::soinfo_list_t& soinfo::get_children() {
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003369 if (has_min_version(0)) {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003370 return children_;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003371 }
3372
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07003373 return g_empty_list;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07003374}
3375
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003376const soinfo::soinfo_list_t& soinfo::get_children() const {
3377 if (has_min_version(0)) {
3378 return children_;
3379 }
3380
3381 return g_empty_list;
3382}
3383
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003384soinfo::soinfo_list_t& soinfo::get_parents() {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003385 if (has_min_version(0)) {
3386 return parents_;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003387 }
3388
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003389 return g_empty_list;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003390}
3391
Evgenii Stepanov68650822015-06-10 13:38:39 -07003392static std::vector<std::string> g_empty_runpath;
3393
3394const std::vector<std::string>& soinfo::get_dt_runpath() const {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003395 if (has_min_version(3)) {
Evgenii Stepanov68650822015-06-10 13:38:39 -07003396 return dt_runpath_;
3397 }
3398
3399 return g_empty_runpath;
3400}
3401
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07003402android_namespace_t* soinfo::get_primary_namespace() {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003403 if (has_min_version(3)) {
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07003404 return primary_namespace_;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003405 }
3406
3407 return &g_default_namespace;
3408}
3409
Dimitry Ivanov0551c1d2016-04-11 12:42:58 -07003410void soinfo::add_secondary_namespace(android_namespace_t* secondary_ns) {
3411 CHECK(has_min_version(3));
3412 secondary_namespaces_.push_back(secondary_ns);
3413}
3414
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003415ElfW(Addr) soinfo::resolve_symbol_address(const ElfW(Sym)* s) const {
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07003416 if (ELF_ST_TYPE(s->st_info) == STT_GNU_IFUNC) {
3417 return call_ifunc_resolver(s->st_value + load_bias);
3418 }
3419
3420 return static_cast<ElfW(Addr)>(s->st_value + load_bias);
3421}
3422
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003423const char* soinfo::get_string(ElfW(Word) index) const {
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003424 if (has_min_version(1) && (index >= strtab_size_)) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003425 __libc_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003426 get_realpath(), strtab_size_, index);
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003427 }
3428
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003429 return strtab_ + index;
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003430}
3431
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003432bool soinfo::is_gnu_hash() const {
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003433 return (flags_ & FLAG_GNU_HASH) != 0;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003434}
3435
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07003436bool soinfo::can_unload() const {
Dimitry Ivanov79abce42016-04-13 11:46:59 -07003437 return !is_linked() || ((get_rtld_flags() & (RTLD_NODELETE | RTLD_GLOBAL)) == 0);
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07003438}
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003439
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003440bool soinfo::is_linked() const {
3441 return (flags_ & FLAG_LINKED) != 0;
3442}
3443
3444bool soinfo::is_main_executable() const {
3445 return (flags_ & FLAG_EXE) != 0;
3446}
3447
Dimitry Ivanov9acb3b72016-03-01 15:55:56 -08003448bool soinfo::is_linker() const {
3449 return (flags_ & FLAG_LINKER) != 0;
3450}
3451
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003452void soinfo::set_linked() {
3453 flags_ |= FLAG_LINKED;
3454}
3455
3456void soinfo::set_linker_flag() {
3457 flags_ |= FLAG_LINKER;
3458}
3459
3460void soinfo::set_main_executable() {
3461 flags_ |= FLAG_EXE;
3462}
3463
3464void soinfo::increment_ref_count() {
3465 local_group_root_->ref_count_++;
3466}
3467
3468size_t soinfo::decrement_ref_count() {
3469 return --local_group_root_->ref_count_;
3470}
3471
3472soinfo* soinfo::get_local_group_root() const {
3473 return local_group_root_;
3474}
3475
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -08003476
3477void soinfo::set_mapped_by_caller(bool mapped_by_caller) {
3478 if (mapped_by_caller) {
3479 flags_ |= FLAG_MAPPED_BY_CALLER;
3480 } else {
3481 flags_ &= ~FLAG_MAPPED_BY_CALLER;
3482 }
3483}
3484
3485bool soinfo::is_mapped_by_caller() const {
3486 return (flags_ & FLAG_MAPPED_BY_CALLER) != 0;
3487}
3488
Dmitriy Ivanov19133522015-06-02 17:36:54 -07003489// This function returns api-level at the time of
3490// dlopen/load. Note that libraries opened by system
3491// will always have 'current' api level.
3492uint32_t soinfo::get_target_sdk_version() const {
3493 if (!has_min_version(2)) {
3494 return __ANDROID_API__;
3495 }
3496
3497 return local_group_root_->target_sdk_version_;
3498}
3499
Dimitry Ivanovae74e872016-03-24 15:30:30 -07003500uintptr_t soinfo::get_handle() const {
3501 CHECK(has_min_version(3));
3502 CHECK(handle_ != 0);
3503 return handle_;
3504}
3505
3506void* soinfo::to_handle() {
3507 if (get_application_target_sdk_version() <= 23 || !has_min_version(3)) {
3508 return this;
3509 }
3510
3511 return reinterpret_cast<void*>(get_handle());
3512}
3513
3514void soinfo::generate_handle() {
3515 CHECK(has_min_version(3));
3516 CHECK(handle_ == 0); // Make sure this is the first call
3517
3518 // Make sure the handle is unique and does not collide
3519 // with special values which are RTLD_DEFAULT and RTLD_NEXT.
3520 do {
3521 arc4random_buf(&handle_, sizeof(handle_));
3522 // the least significant bit for the handle is always 1
3523 // making it easy to test the type of handle passed to
3524 // dl* functions.
3525 handle_ = handle_ | 1;
3526 } while (handle_ == reinterpret_cast<uintptr_t>(RTLD_DEFAULT) ||
3527 handle_ == reinterpret_cast<uintptr_t>(RTLD_NEXT) ||
3528 g_soinfo_handles_map.find(handle_) != g_soinfo_handles_map.end());
3529
3530 g_soinfo_handles_map[handle_] = this;
3531}
3532
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003533bool soinfo::prelink_image() {
Ningsheng Jiane93be992014-09-16 15:22:10 +08003534 /* Extract dynamic section */
3535 ElfW(Word) dynamic_flags = 0;
3536 phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);
Dmitriy Ivanov498eb182014-09-05 14:57:59 -07003537
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003538 /* We can't log anything until the linker is relocated */
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003539 bool relocating_linker = (flags_ & FLAG_LINKER) != 0;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003540 if (!relocating_linker) {
Elliott Hughes38b88a42016-04-01 10:10:54 -07003541 INFO("[ Linking \"%s\" ]", get_realpath());
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003542 DEBUG("si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003543 }
3544
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003545 if (dynamic == nullptr) {
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02003546 if (!relocating_linker) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003547 DL_ERR("missing PT_DYNAMIC in \"%s\"", get_realpath());
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02003548 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003549 return false;
3550 } else {
3551 if (!relocating_linker) {
3552 DEBUG("dynamic = %p", dynamic);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02003553 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003554 }
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02003555
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003556#if defined(__arm__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003557 (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias,
3558 &ARM_exidx, &ARM_exidx_count);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02003559#endif
3560
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003561 // Extract useful information from dynamic section.
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003562 // Note that: "Except for the DT_NULL element at the end of the array,
3563 // and the relative order of DT_NEEDED elements, entries may appear in any order."
3564 //
3565 // source: http://www.sco.com/developers/gabi/1998-04-29/ch5.dynamic.html
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003566 uint32_t needed_count = 0;
3567 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
3568 DEBUG("d = %p, d[0](tag) = %p d[1](val) = %p",
3569 d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
3570 switch (d->d_tag) {
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003571 case DT_SONAME:
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07003572 // this is parsed after we have strtab initialized (see below).
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003573 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003574
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003575 case DT_HASH:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003576 nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
3577 nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
3578 bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
3579 chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003580 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003581
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003582 case DT_GNU_HASH:
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07003583 gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003584 // skip symndx
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003585 gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
3586 gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003587
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003588 gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07003589 gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003590 // amend chain for symndx = header[1]
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003591 gnu_chain_ = gnu_bucket_ + gnu_nbucket_ -
3592 reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003593
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003594 if (!powerof2(gnu_maskwords_)) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003595 DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two",
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003596 gnu_maskwords_, get_realpath());
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003597 return false;
3598 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003599 --gnu_maskwords_;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003600
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003601 flags_ |= FLAG_GNU_HASH;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08003602 break;
3603
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003604 case DT_STRTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003605 strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003606 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003607
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003608 case DT_STRSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003609 strtab_size_ = d->d_un.d_val;
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003610 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003611
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003612 case DT_SYMTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003613 symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003614 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003615
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003616 case DT_SYMENT:
3617 if (d->d_un.d_val != sizeof(ElfW(Sym))) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003618 DL_ERR("invalid DT_SYMENT: %zd in \"%s\"",
3619 static_cast<size_t>(d->d_un.d_val), get_realpath());
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003620 return false;
3621 }
3622 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003623
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003624 case DT_PLTREL:
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003625#if defined(USE_RELA)
3626 if (d->d_un.d_val != DT_RELA) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003627 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_RELA", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003628 return false;
3629 }
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003630#else
3631 if (d->d_un.d_val != DT_REL) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003632 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_REL", get_realpath());
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003633 return false;
3634 }
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003635#endif
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003636 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003637
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003638 case DT_JMPREL:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003639#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003640 plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003641#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003642 plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003643#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003644 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003645
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003646 case DT_PLTRELSZ:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003647#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003648 plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003649#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003650 plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003651#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003652 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003653
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003654 case DT_PLTGOT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003655#if defined(__mips__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003656 // Used by mips and mips64.
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003657 plt_got_ = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003658#endif
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003659 // Ignore for other platforms... (because RTLD_LAZY is not supported)
3660 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003661
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003662 case DT_DEBUG:
3663 // Set the DT_DEBUG entry to the address of _r_debug for GDB
3664 // if the dynamic table is writable
Chris Dearman99186652014-02-06 20:36:51 -08003665// FIXME: not working currently for N64
3666// The flags for the LOAD and DYNAMIC program headers do not agree.
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003667// The LOAD section containing the dynamic table has been mapped as
Chris Dearman99186652014-02-06 20:36:51 -08003668// read-only, but the DYNAMIC header claims it is writable.
3669#if !(defined(__mips__) && defined(__LP64__))
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003670 if ((dynamic_flags & PF_W) != 0) {
3671 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
3672 }
Chris Dearman99186652014-02-06 20:36:51 -08003673#endif
Dmitriy Ivanovc6292ea2015-02-13 16:29:50 -08003674 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003675#if defined(USE_RELA)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003676 case DT_RELA:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003677 rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003678 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003679
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003680 case DT_RELASZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003681 rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003682 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003683
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003684 case DT_ANDROID_RELA:
3685 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
3686 break;
3687
3688 case DT_ANDROID_RELASZ:
3689 android_relocs_size_ = d->d_un.d_val;
3690 break;
3691
3692 case DT_ANDROID_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003693 DL_ERR("unsupported DT_ANDROID_REL in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003694 return false;
3695
3696 case DT_ANDROID_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003697 DL_ERR("unsupported DT_ANDROID_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003698 return false;
3699
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003700 case DT_RELAENT:
3701 if (d->d_un.d_val != sizeof(ElfW(Rela))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07003702 DL_ERR("invalid DT_RELAENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003703 return false;
3704 }
3705 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003706
3707 // ignored (see DT_RELCOUNT comments for details)
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003708 case DT_RELACOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003709 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003710
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003711 case DT_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003712 DL_ERR("unsupported DT_REL in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003713 return false;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003714
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003715 case DT_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003716 DL_ERR("unsupported DT_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003717 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003718
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003719#else
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003720 case DT_REL:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003721 rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003722 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003723
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003724 case DT_RELSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003725 rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003726 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003727
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003728 case DT_RELENT:
3729 if (d->d_un.d_val != sizeof(ElfW(Rel))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07003730 DL_ERR("invalid DT_RELENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003731 return false;
3732 }
3733 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003734
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003735 case DT_ANDROID_REL:
3736 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
3737 break;
3738
3739 case DT_ANDROID_RELSZ:
3740 android_relocs_size_ = d->d_un.d_val;
3741 break;
3742
3743 case DT_ANDROID_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003744 DL_ERR("unsupported DT_ANDROID_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003745 return false;
3746
3747 case DT_ANDROID_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003748 DL_ERR("unsupported DT_ANDROID_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003749 return false;
3750
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003751 // "Indicates that all RELATIVE relocations have been concatenated together,
3752 // and specifies the RELATIVE relocation count."
3753 //
3754 // TODO: Spec also mentions that this can be used to optimize relocation process;
3755 // Not currently used by bionic linker - ignored.
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003756 case DT_RELCOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003757 break;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003758
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003759 case DT_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003760 DL_ERR("unsupported DT_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003761 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003762
3763 case DT_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003764 DL_ERR("unsupported DT_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003765 return false;
3766
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003767#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003768 case DT_INIT:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003769 init_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003770 DEBUG("%s constructors (DT_INIT) found at %p", get_realpath(), init_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003771 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003772
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003773 case DT_FINI:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003774 fini_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003775 DEBUG("%s destructors (DT_FINI) found at %p", get_realpath(), fini_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003776 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003777
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003778 case DT_INIT_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003779 init_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003780 DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", get_realpath(), init_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003781 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003782
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003783 case DT_INIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003784 init_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003785 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003786
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003787 case DT_FINI_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003788 fini_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003789 DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", get_realpath(), fini_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003790 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003791
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003792 case DT_FINI_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003793 fini_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003794 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003795
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003796 case DT_PREINIT_ARRAY:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003797 preinit_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003798 DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", get_realpath(), preinit_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003799 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003800
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003801 case DT_PREINIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003802 preinit_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003803 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003804
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003805 case DT_TEXTREL:
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003806#if defined(__LP64__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003807 DL_ERR("text relocations (DT_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003808 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003809#else
3810 has_text_relocations = true;
3811 break;
3812#endif
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003813
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003814 case DT_SYMBOLIC:
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07003815 has_DT_SYMBOLIC = true;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003816 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003817
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003818 case DT_NEEDED:
3819 ++needed_count;
3820 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003821
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003822 case DT_FLAGS:
3823 if (d->d_un.d_val & DF_TEXTREL) {
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003824#if defined(__LP64__)
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003825 DL_ERR("text relocations (DF_TEXTREL) found in 64-bit ELF file \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003826 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003827#else
3828 has_text_relocations = true;
3829#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003830 }
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07003831 if (d->d_un.d_val & DF_SYMBOLIC) {
3832 has_DT_SYMBOLIC = true;
3833 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003834 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003835
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003836 case DT_FLAGS_1:
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003837 set_dt_flags_1(d->d_un.d_val);
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07003838
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003839 if ((d->d_un.d_val & ~SUPPORTED_DT_FLAGS_1) != 0) {
Dmitriy Ivanov087005f2015-05-28 11:44:31 -07003840 DL_WARN("%s: unsupported flags DT_FLAGS_1=%p", get_realpath(), reinterpret_cast<void*>(d->d_un.d_val));
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003841 }
3842 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003843#if defined(__mips__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003844 case DT_MIPS_RLD_MAP:
3845 // Set the DT_MIPS_RLD_MAP entry to the address of _r_debug for GDB.
3846 {
3847 r_debug** dp = reinterpret_cast<r_debug**>(load_bias + d->d_un.d_ptr);
3848 *dp = &_r_debug;
3849 }
3850 break;
Raghu Gandham68815722014-12-18 19:12:19 -08003851 case DT_MIPS_RLD_MAP2:
3852 // Set the DT_MIPS_RLD_MAP2 entry to the address of _r_debug for GDB.
3853 {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07003854 r_debug** dp = reinterpret_cast<r_debug**>(
3855 reinterpret_cast<ElfW(Addr)>(d) + d->d_un.d_val);
Raghu Gandham68815722014-12-18 19:12:19 -08003856 *dp = &_r_debug;
3857 }
3858 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003859
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003860 case DT_MIPS_RLD_VERSION:
3861 case DT_MIPS_FLAGS:
3862 case DT_MIPS_BASE_ADDRESS:
3863 case DT_MIPS_UNREFEXTNO:
3864 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003865
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003866 case DT_MIPS_SYMTABNO:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003867 mips_symtabno_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003868 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003869
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003870 case DT_MIPS_LOCAL_GOTNO:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003871 mips_local_gotno_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003872 break;
3873
3874 case DT_MIPS_GOTSYM:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003875 mips_gotsym_ = d->d_un.d_val;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003876 break;
3877#endif
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003878 // Ignored: "Its use has been superseded by the DF_BIND_NOW flag"
3879 case DT_BIND_NOW:
3880 break;
3881
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003882 case DT_VERSYM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003883 versym_ = reinterpret_cast<ElfW(Versym)*>(load_bias + d->d_un.d_ptr);
3884 break;
3885
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003886 case DT_VERDEF:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003887 verdef_ptr_ = load_bias + d->d_un.d_ptr;
3888 break;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003889 case DT_VERDEFNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003890 verdef_cnt_ = d->d_un.d_val;
3891 break;
3892
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03003893 case DT_VERNEED:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003894 verneed_ptr_ = load_bias + d->d_un.d_ptr;
3895 break;
3896
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03003897 case DT_VERNEEDNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003898 verneed_cnt_ = d->d_un.d_val;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003899 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003900
Evgenii Stepanov68650822015-06-10 13:38:39 -07003901 case DT_RUNPATH:
3902 // this is parsed after we have strtab initialized (see below).
3903 break;
3904
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003905 default:
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07003906 if (!relocating_linker) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003907 DL_WARN("%s: unused DT entry: type %p arg %p", get_realpath(),
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07003908 reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
3909 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003910 break;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08003911 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003912 }
3913
Duane Sandbc425c72015-06-01 16:29:14 -07003914#if defined(__mips__) && !defined(__LP64__)
3915 if (!mips_check_and_adjust_fp_modes()) {
3916 return false;
3917 }
3918#endif
3919
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003920 DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p",
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003921 reinterpret_cast<void*>(base), strtab_, symtab_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003922
3923 // Sanity checks.
3924 if (relocating_linker && needed_count != 0) {
3925 DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
3926 return false;
3927 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07003928 if (nbucket_ == 0 && gnu_nbucket_ == 0) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003929 DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" "
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003930 "(new hash type from the future?)", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003931 return false;
3932 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003933 if (strtab_ == 0) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003934 DL_ERR("empty/missing DT_STRTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003935 return false;
3936 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003937 if (symtab_ == 0) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003938 DL_ERR("empty/missing DT_SYMTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003939 return false;
3940 }
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003941
Dmitriy Ivanov624b8f12015-06-08 10:41:33 -07003942 // second pass - parse entries relying on strtab
3943 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
Evgenii Stepanov68650822015-06-10 13:38:39 -07003944 switch (d->d_tag) {
3945 case DT_SONAME:
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07003946 set_soname(get_string(d->d_un.d_val));
Evgenii Stepanov68650822015-06-10 13:38:39 -07003947 break;
3948 case DT_RUNPATH:
Evgenii Stepanov68650822015-06-10 13:38:39 -07003949 set_dt_runpath(get_string(d->d_un.d_val));
3950 break;
Dmitriy Ivanov624b8f12015-06-08 10:41:33 -07003951 }
3952 }
3953
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003954 // Before M release linker was using basename in place of soname.
Dmitriy Ivanov19133522015-06-02 17:36:54 -07003955 // In the case when dt_soname is absent some apps stop working
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003956 // because they can't find dt_needed library by soname.
3957 // This workaround should keep them working. (applies only
Dmitriy Ivanov19133522015-06-02 17:36:54 -07003958 // for apps targeting sdk version <=22). Make an exception for
3959 // the main executable and linker; they do not need to have dt_soname
3960 if (soname_ == nullptr && this != somain && (flags_ & FLAG_LINKER) == 0 &&
3961 get_application_target_sdk_version() <= 22) {
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003962 soname_ = basename(realpath_.c_str());
3963 DL_WARN("%s: is missing DT_SONAME will use basename as a replacement: \"%s\"",
3964 get_realpath(), soname_);
Dimitry Ivanov19930d52016-03-14 22:14:23 -07003965 // Don't call add_dlwarning because a missing DT_SONAME isn't important enough to show in the UI
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003966 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003967 return true;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003968}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003969
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003970bool soinfo::link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group,
3971 const android_dlextinfo* extinfo) {
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003972
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003973 local_group_root_ = local_group.front();
3974 if (local_group_root_ == nullptr) {
3975 local_group_root_ = this;
3976 }
3977
Dmitriy Ivanov19133522015-06-02 17:36:54 -07003978 if ((flags_ & FLAG_LINKER) == 0 && local_group_root_ == this) {
3979 target_sdk_version_ = get_application_target_sdk_version();
3980 }
3981
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07003982 VersionTracker version_tracker;
3983
3984 if (!version_tracker.init(this)) {
3985 return false;
3986 }
3987
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003988#if !defined(__LP64__)
3989 if (has_text_relocations) {
Dmitriy Ivanove4ad91f2015-06-12 15:00:31 -07003990 // Fail if app is targeting sdk version > 22
Christopher R. Palmer952d1a32016-02-07 06:46:05 -05003991#if !defined(__i386__) // ffmpeg says that they require text relocations on x86
Adrian DCf1b6adb2016-08-27 15:09:36 +02003992#if defined(TARGET_NEEDS_PLATFORM_TEXT_RELOCATIONS)
3993 if (get_application_target_sdk_version() != __ANDROID_API__
3994 && get_application_target_sdk_version() > 22) {
3995#else
Dmitriy Ivanov80687862015-10-09 13:58:46 -07003996 if (get_application_target_sdk_version() > 22) {
Adrian DCf1b6adb2016-08-27 15:09:36 +02003997#endif
Dmitriy Ivanovfae39d22015-10-13 11:07:56 -07003998 PRINT("%s: has text relocations", get_realpath());
Dmitriy Ivanove4ad91f2015-06-12 15:00:31 -07003999 DL_ERR("%s: has text relocations", get_realpath());
4000 return false;
4001 }
Christopher R. Palmer952d1a32016-02-07 06:46:05 -05004002#endif
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004003 // Make segments writable to allow text relocations to work properly. We will later call
Dmitriy Ivanov7e039932015-10-01 14:02:19 -07004004 // phdr_table_protect_segments() after all of them are applied.
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004005 DL_WARN("%s has text relocations. This is wasting memory and prevents "
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004006 "security hardening. Please fix.", get_realpath());
Dimitry Ivanovdf91dc22016-02-25 15:22:04 -08004007 add_dlwarning(get_realpath(), "text relocations");
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004008 if (phdr_table_unprotect_segments(phdr, phnum, load_bias) < 0) {
4009 DL_ERR("can't unprotect loadable segments for \"%s\": %s",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004010 get_realpath(), strerror(errno));
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004011 return false;
4012 }
4013 }
4014#endif
4015
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08004016 if (android_relocs_ != nullptr) {
4017 // check signature
4018 if (android_relocs_size_ > 3 &&
4019 android_relocs_[0] == 'A' &&
4020 android_relocs_[1] == 'P' &&
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07004021 android_relocs_[2] == 'S' &&
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08004022 android_relocs_[3] == '2') {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004023 DEBUG("[ android relocating %s ]", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08004024
4025 bool relocated = false;
4026 const uint8_t* packed_relocs = android_relocs_ + 4;
4027 const size_t packed_relocs_size = android_relocs_size_ - 4;
4028
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07004029 relocated = relocate(
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07004030 version_tracker,
Dmitriy Ivanov18870d32015-04-22 13:10:04 -07004031 packed_reloc_iterator<sleb128_decoder>(
4032 sleb128_decoder(packed_relocs, packed_relocs_size)),
4033 global_group, local_group);
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08004034
4035 if (!relocated) {
4036 return false;
4037 }
4038 } else {
4039 DL_ERR("bad android relocation header.");
4040 return false;
4041 }
4042 }
4043
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07004044#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004045 if (rela_ != nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004046 DEBUG("[ relocating %s ]", get_realpath());
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07004047 if (!relocate(version_tracker,
4048 plain_reloc_iterator(rela_, rela_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004049 return false;
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07004050 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004051 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004052 if (plt_rela_ != nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004053 DEBUG("[ relocating %s plt ]", get_realpath());
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07004054 if (!relocate(version_tracker,
4055 plain_reloc_iterator(plt_rela_, plt_rela_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004056 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004057 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004058 }
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07004059#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004060 if (rel_ != nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004061 DEBUG("[ relocating %s ]", get_realpath());
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07004062 if (!relocate(version_tracker,
4063 plain_reloc_iterator(rel_, rel_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004064 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004065 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004066 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004067 if (plt_rel_ != nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004068 DEBUG("[ relocating %s plt ]", get_realpath());
Dmitriy Ivanov7e4bbba2015-04-30 19:49:19 -07004069 if (!relocate(version_tracker,
4070 plain_reloc_iterator(plt_rel_, plt_rel_count_), global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004071 return false;
Brigid Smithc5a13ef2014-07-23 11:22:25 -07004072 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004073 }
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07004074#endif
Brigid Smithc5a13ef2014-07-23 11:22:25 -07004075
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07004076#if defined(__mips__)
Dmitriy Ivanovf39cb632015-04-30 20:17:03 -07004077 if (!mips_relocate_got(version_tracker, global_group, local_group)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004078 return false;
4079 }
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07004080#endif
4081
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004082 DEBUG("[ finished linking %s ]", get_realpath());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004083
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004084#if !defined(__LP64__)
4085 if (has_text_relocations) {
4086 // All relocations are done, we can protect our segments back to read-only.
4087 if (phdr_table_protect_segments(phdr, phnum, load_bias) < 0) {
4088 DL_ERR("can't protect segments for \"%s\": %s",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004089 get_realpath(), strerror(errno));
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00004090 return false;
4091 }
4092 }
4093#endif
4094
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004095 // We can also turn on GNU RELRO protection if we're not linking the dynamic linker
4096 // itself --- it can't make system calls yet, and will have to call protect_relro later.
4097 if (!is_linker() && !protect_relro()) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004098 return false;
4099 }
Nick Kralevich9ec0f032012-02-28 10:40:00 -08004100
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004101 /* Handle serializing/sharing the RELRO segment */
4102 if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
4103 if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias,
4104 extinfo->relro_fd) < 0) {
4105 DL_ERR("failed serializing GNU RELRO section for \"%s\": %s",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004106 get_realpath(), strerror(errno));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004107 return false;
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00004108 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004109 } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
4110 if (phdr_table_map_gnu_relro(phdr, phnum, load_bias,
4111 extinfo->relro_fd) < 0) {
4112 DL_ERR("failed mapping GNU RELRO section for \"%s\": %s",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004113 get_realpath(), strerror(errno));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004114 return false;
4115 }
4116 }
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00004117
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004118 notify_gdb_of_load(this);
4119 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004120}
4121
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004122bool soinfo::protect_relro() {
4123 if (phdr_table_protect_gnu_relro(phdr, phnum, load_bias) < 0) {
4124 DL_ERR("can't enable GNU RELRO protection for \"%s\": %s",
4125 get_realpath(), strerror(errno));
4126 return false;
4127 }
4128 return true;
4129}
4130
Nick Kralevich468319c2011-11-11 15:53:17 -08004131/*
Sergey Melnikovc45087b2013-01-25 16:40:13 +04004132 * This function add vdso to internal dso list.
4133 * It helps to stack unwinding through signal handlers.
4134 * Also, it makes bionic more like glibc.
4135 */
Kito Cheng812fd422014-03-25 22:53:56 +08004136static void add_vdso(KernelArgumentBlock& args __unused) {
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07004137#if defined(AT_SYSINFO_EHDR)
Elliott Hughes0266ae52014-02-10 17:46:57 -08004138 ElfW(Ehdr)* ehdr_vdso = reinterpret_cast<ElfW(Ehdr)*>(args.getauxval(AT_SYSINFO_EHDR));
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07004139 if (ehdr_vdso == nullptr) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08004140 return;
4141 }
Sergey Melnikovc45087b2013-01-25 16:40:13 +04004142
Dmitriy Ivanovd9b08a02015-11-16 13:17:27 -08004143 soinfo* si = soinfo_alloc(&g_default_namespace, "[vdso]", nullptr, 0, 0);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04004144
Elliott Hughes0266ae52014-02-10 17:46:57 -08004145 si->phdr = reinterpret_cast<ElfW(Phdr)*>(reinterpret_cast<char*>(ehdr_vdso) + ehdr_vdso->e_phoff);
4146 si->phnum = ehdr_vdso->e_phnum;
4147 si->base = reinterpret_cast<ElfW(Addr)>(ehdr_vdso);
4148 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
Elliott Hughes0266ae52014-02-10 17:46:57 -08004149 si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
Sergey Melnikovebd506c2013-10-31 18:02:12 +04004150
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004151 si->prelink_image();
4152 si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr);
Sergey Melnikovc45087b2013-01-25 16:40:13 +04004153#endif
4154}
4155
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07004156/* gdb expects the linker to be in the debug shared object list.
4157 * Without this, gdb has trouble locating the linker's ".text"
4158 * and ".plt" sections. Gdb could also potentially use this to
4159 * relocate the offset of our exported 'rtld_db_dlactivity' symbol.
Dimitry Ivanovfefb4d32016-02-17 14:13:06 -08004160 * Note that the linker shouldn't be on the soinfo list.
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07004161 */
4162static void init_linker_info_for_gdb(ElfW(Addr) linker_base) {
Dimitry Ivanov05b60b22016-02-16 13:43:35 -08004163 static link_map linker_link_map_for_gdb;
4164#if defined(__LP64__)
4165 static char kLinkerPath[] = "/system/bin/linker64";
4166#else
4167 static char kLinkerPath[] = "/system/bin/linker";
4168#endif
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07004169
Dimitry Ivanov05b60b22016-02-16 13:43:35 -08004170 linker_link_map_for_gdb.l_addr = linker_base;
4171 linker_link_map_for_gdb.l_name = kLinkerPath;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07004172
4173 /*
4174 * Set the dynamic field in the link map otherwise gdb will complain with
4175 * the following:
4176 * warning: .dynamic section for "/system/bin/linker" is not at the
4177 * expected address (wrong library or version mismatch?)
4178 */
4179 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_base);
4180 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_base + elf_hdr->e_phoff);
4181 phdr_table_get_dynamic_section(phdr, elf_hdr->e_phnum, linker_base,
Dimitry Ivanov05b60b22016-02-16 13:43:35 -08004182 &linker_link_map_for_gdb.l_ld, nullptr);
4183
4184 insert_link_map_into_debug_map(&linker_link_map_for_gdb);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07004185}
4186
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004187static void init_default_namespace() {
4188 g_default_namespace.set_name("(default)");
4189 g_default_namespace.set_isolated(false);
4190
Evgenii Stepanovd640b222015-07-10 17:54:01 -07004191 const char *interp = phdr_table_get_interpreter_name(somain->phdr, somain->phnum,
4192 somain->load_bias);
4193 const char* bname = basename(interp);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004194 if (bname && (strcmp(bname, "linker_asan") == 0 || strcmp(bname, "linker_asan64") == 0)) {
Evgenii Stepanovd640b222015-07-10 17:54:01 -07004195 g_default_ld_paths = kAsanDefaultLdPaths;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004196 } else {
Evgenii Stepanovd640b222015-07-10 17:54:01 -07004197 g_default_ld_paths = kDefaultLdPaths;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004198 }
4199
4200 std::vector<std::string> ld_default_paths;
4201 for (size_t i = 0; g_default_ld_paths[i] != nullptr; ++i) {
4202 ld_default_paths.push_back(g_default_ld_paths[i]);
4203 }
4204
4205 g_default_namespace.set_default_library_paths(std::move(ld_default_paths));
Evgenii Stepanovd640b222015-07-10 17:54:01 -07004206};
4207
Dmitriy Ivanovb4e50672015-04-28 15:49:26 -07004208extern "C" int __system_properties_init(void);
4209
Dimitry Ivanovdcaef372016-05-17 13:29:37 -07004210static const char* get_executable_path() {
4211 static std::string executable_path;
4212 if (executable_path.empty()) {
4213 char path[PATH_MAX];
4214 ssize_t path_len = readlink("/proc/self/exe", path, sizeof(path));
4215 if (path_len == -1 || path_len >= static_cast<ssize_t>(sizeof(path))) {
4216 __libc_fatal("readlink('/proc/self/exe') failed: %s", strerror(errno));
4217 }
4218 executable_path = std::string(path, path_len);
4219 }
4220
4221 return executable_path.c_str();
4222}
4223
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07004224/*
Nick Kralevich468319c2011-11-11 15:53:17 -08004225 * This code is called after the linker has linked itself and
4226 * fixed it's own GOT. It is safe to make references to externs
4227 * and other non-local data at this point.
4228 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08004229static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW(Addr) linker_base) {
Evgeniy Stepanov1a78fbb2012-03-22 18:01:53 +04004230#if TIMING
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004231 struct timeval t0, t1;
4232 gettimeofday(&t0, 0);
Evgeniy Stepanov1a78fbb2012-03-22 18:01:53 +04004233#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004234
Elliott Hughes1801db32015-06-08 18:04:00 -07004235 // Sanitize the environment.
4236 __libc_init_AT_SECURE(args);
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01004237
Dmitriy Ivanovb4e50672015-04-28 15:49:26 -07004238 // Initialize system properties
4239 __system_properties_init(); // may use 'environ'
4240
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004241 debuggerd_init();
4242
4243 // Get a few environment variables.
Elliott Hughes1801db32015-06-08 18:04:00 -07004244 const char* LD_DEBUG = getenv("LD_DEBUG");
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004245 if (LD_DEBUG != nullptr) {
4246 g_ld_debug_verbosity = atoi(LD_DEBUG);
4247 }
4248
Elliott Hughes116b5692016-01-04 17:45:36 -08004249#if defined(__LP64__)
4250 INFO("[ Android dynamic linker (64-bit) ]");
4251#else
4252 INFO("[ Android dynamic linker (32-bit) ]");
4253#endif
4254
Elliott Hughes1801db32015-06-08 18:04:00 -07004255 // These should have been sanitized by __libc_init_AT_SECURE, but the test
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004256 // doesn't cost us anything.
4257 const char* ldpath_env = nullptr;
4258 const char* ldpreload_env = nullptr;
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05004259 const char* ldshim_libs_env = nullptr;
Elliott Hughes1801db32015-06-08 18:04:00 -07004260 if (!getauxval(AT_SECURE)) {
4261 ldpath_env = getenv("LD_LIBRARY_PATH");
Elliott Hughes116b5692016-01-04 17:45:36 -08004262 if (ldpath_env != nullptr) {
Elliott Hughes38b88a42016-04-01 10:10:54 -07004263 INFO("[ LD_LIBRARY_PATH set to \"%s\" ]", ldpath_env);
Elliott Hughes116b5692016-01-04 17:45:36 -08004264 }
Elliott Hughes1801db32015-06-08 18:04:00 -07004265 ldpreload_env = getenv("LD_PRELOAD");
Elliott Hughes116b5692016-01-04 17:45:36 -08004266 if (ldpreload_env != nullptr) {
Elliott Hughes38b88a42016-04-01 10:10:54 -07004267 INFO("[ LD_PRELOAD set to \"%s\" ]", ldpreload_env);
Elliott Hughes116b5692016-01-04 17:45:36 -08004268 }
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05004269 ldshim_libs_env = getenv("LD_SHIM_LIBS");
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004270 }
4271
Dimitry Ivanovdcaef372016-05-17 13:29:37 -07004272 const char* executable_path = get_executable_path();
4273 struct stat file_stat;
4274 if (TEMP_FAILURE_RETRY(stat(executable_path, &file_stat)) != 0) {
4275 __libc_fatal("unable to stat file for the executable \"%s\": %s", executable_path, strerror(errno));
4276 }
4277
4278 soinfo* si = soinfo_alloc(&g_default_namespace, executable_path, &file_stat, 0, RTLD_GLOBAL);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004279 if (si == nullptr) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004280 __libc_fatal("Couldn't allocate soinfo: out of memory?");
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004281 }
4282
4283 /* bootstrap the link map, the main exe always needs to be first */
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08004284 si->set_main_executable();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004285 link_map* map = &(si->link_map_head);
4286
Dimitry Ivanov9acb3b72016-03-01 15:55:56 -08004287 // Register the main executable and the linker upfront to have
4288 // gdb aware of them before loading the rest of the dependency
4289 // tree.
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004290 map->l_addr = 0;
Dimitry Ivanovdcaef372016-05-17 13:29:37 -07004291 map->l_name = const_cast<char*>(executable_path);
Dimitry Ivanov0f478e82016-02-17 15:25:25 -08004292 insert_link_map_into_debug_map(map);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004293 init_linker_info_for_gdb(linker_base);
4294
4295 // Extract information passed from the kernel.
4296 si->phdr = reinterpret_cast<ElfW(Phdr)*>(args.getauxval(AT_PHDR));
4297 si->phnum = args.getauxval(AT_PHNUM);
4298 si->entry = args.getauxval(AT_ENTRY);
4299
4300 /* Compute the value of si->base. We can't rely on the fact that
4301 * the first entry is the PHDR because this will not be true
4302 * for certain executables (e.g. some in the NDK unit test suite)
4303 */
4304 si->base = 0;
4305 si->size = phdr_table_get_load_size(si->phdr, si->phnum);
4306 si->load_bias = 0;
4307 for (size_t i = 0; i < si->phnum; ++i) {
4308 if (si->phdr[i].p_type == PT_PHDR) {
4309 si->load_bias = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_vaddr;
4310 si->base = reinterpret_cast<ElfW(Addr)>(si->phdr) - si->phdr[i].p_offset;
4311 break;
Nick Kralevich8d3e91d2013-04-25 13:15:24 -07004312 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004313 }
4314 si->dynamic = nullptr;
Nick Kralevich8d3e91d2013-04-25 13:15:24 -07004315
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004316 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(si->base);
4317 if (elf_hdr->e_type != ET_DYN) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004318 __libc_fatal("\"%s\": error: only position independent executables (PIE) are supported.",
4319 args.argv[0]);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004320 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004321
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004322 // Use LD_LIBRARY_PATH and LD_PRELOAD (but only if we aren't setuid/setgid).
4323 parse_LD_LIBRARY_PATH(ldpath_env);
4324 parse_LD_PRELOAD(ldpreload_env);
Christopher R. Palmerb8a914f2015-11-03 16:44:44 -05004325 parse_LD_SHIM_LIBS(ldshim_libs_env);
David 'Digit' Turnerbe575592010-12-16 19:52:02 +01004326
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004327 somain = si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004328
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004329 init_default_namespace();
Evgenii Stepanovd640b222015-07-10 17:54:01 -07004330
Dmitriy Ivanov67181252015-01-07 15:48:25 -08004331 if (!si->prelink_image()) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004332 __libc_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", args.argv[0], linker_get_error_buffer());
Dmitriy Ivanov67181252015-01-07 15:48:25 -08004333 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004334
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07004335 // add somain to global group
4336 si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
4337
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004338 // Load ld_preloads and dependencies.
4339 StringLinkedList needed_library_name_list;
4340 size_t needed_libraries_count = 0;
4341 size_t ld_preloads_count = 0;
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07004342
4343 for (const auto& ld_preload_name : g_ld_preload_names) {
4344 needed_library_name_list.push_back(ld_preload_name.c_str());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004345 ++needed_libraries_count;
Dmitriy Ivanovf8093a92015-04-28 18:09:53 -07004346 ++ld_preloads_count;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004347 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004348
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004349 for_each_dt_needed(si, [&](const char* name) {
4350 needed_library_name_list.push_back(name);
4351 ++needed_libraries_count;
4352 });
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004353
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004354 const char* needed_library_names[needed_libraries_count];
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004355
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004356 memset(needed_library_names, 0, sizeof(needed_library_names));
4357 needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004358
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07004359 if (needed_libraries_count > 0 &&
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004360 !find_libraries(&g_default_namespace, si, needed_library_names, needed_libraries_count,
4361 nullptr, &g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr,
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07004362 /* add_as_children */ true)) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004363 __libc_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", args.argv[0], linker_get_error_buffer());
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08004364 } else if (needed_libraries_count == 0) {
4365 if (!si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr)) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004366 __libc_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", args.argv[0], linker_get_error_buffer());
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08004367 }
4368 si->increment_ref_count();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004369 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004370
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004371 add_vdso(args);
Nick Kralevich2aebf542014-05-07 10:32:39 -07004372
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08004373 {
4374 ProtectedDataGuard guard;
Matt Fischer4fd42c12009-12-31 12:09:10 -06004375
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08004376 si->call_pre_init_constructors();
4377
4378 /* After the prelink_image, the si->load_bias is initialized.
4379 * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
4380 * We need to update this value for so exe here. So Unwind_Backtrace
4381 * for some arch like x86 could work correctly within so exe.
4382 */
4383 map->l_addr = si->load_bias;
4384 si->call_constructors();
4385 }
Evgeniy Stepanove83c56d2011-12-21 13:03:54 +04004386
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004387#if TIMING
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004388 gettimeofday(&t1, nullptr);
4389 PRINT("LINKER TIME: %s: %d microseconds", args.argv[0], (int) (
4390 (((long long)t1.tv_sec * 1000000LL) + (long long)t1.tv_usec) -
4391 (((long long)t0.tv_sec * 1000000LL) + (long long)t0.tv_usec)));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004392#endif
4393#if STATS
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004394 PRINT("RELO STATS: %s: %d abs, %d rel, %d copy, %d symbol", args.argv[0],
4395 linker_stats.count[kRelocAbsolute],
4396 linker_stats.count[kRelocRelative],
4397 linker_stats.count[kRelocCopy],
4398 linker_stats.count[kRelocSymbol]);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004399#endif
4400#if COUNT_PAGES
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004401 {
4402 unsigned n;
4403 unsigned i;
4404 unsigned count = 0;
4405 for (n = 0; n < 4096; n++) {
4406 if (bitmask[n]) {
4407 unsigned x = bitmask[n];
Marcus Oaklande365f9d2013-10-10 15:19:31 +01004408#if defined(__LP64__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004409 for (i = 0; i < 32; i++) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01004410#else
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004411 for (i = 0; i < 8; i++) {
Marcus Oaklande365f9d2013-10-10 15:19:31 +01004412#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004413 if (x & 1) {
4414 count++;
4415 }
4416 x >>= 1;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004417 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004418 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004419 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004420 PRINT("PAGES MODIFIED: %s: %d (%dKB)", args.argv[0], count, count * 4);
4421 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004422#endif
4423
4424#if TIMING || STATS || COUNT_PAGES
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004425 fflush(stdout);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004426#endif
4427
Elliott Hughes38b88a42016-04-01 10:10:54 -07004428 TRACE("[ Ready to execute \"%s\" @ %p ]", si->get_realpath(), reinterpret_cast<void*>(si->entry));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07004429 return si->entry;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08004430}
Nick Kralevich468319c2011-11-11 15:53:17 -08004431
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02004432/* Compute the load-bias of an existing executable. This shall only
4433 * be used to compute the load bias of an executable or shared library
4434 * that was loaded by the kernel itself.
4435 *
4436 * Input:
4437 * elf -> address of ELF header, assumed to be at the start of the file.
4438 * Return:
4439 * load bias, i.e. add the value of any p_vaddr in the file to get
4440 * the corresponding address in memory.
4441 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08004442static ElfW(Addr) get_elf_exec_load_bias(const ElfW(Ehdr)* elf) {
4443 ElfW(Addr) offset = elf->e_phoff;
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07004444 const ElfW(Phdr)* phdr_table =
4445 reinterpret_cast<const ElfW(Phdr)*>(reinterpret_cast<uintptr_t>(elf) + offset);
Elliott Hughes0266ae52014-02-10 17:46:57 -08004446 const ElfW(Phdr)* phdr_end = phdr_table + elf->e_phnum;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02004447
Elliott Hughes0266ae52014-02-10 17:46:57 -08004448 for (const ElfW(Phdr)* phdr = phdr_table; phdr < phdr_end; phdr++) {
Kito Chengfa8c05d2013-03-12 14:58:06 +08004449 if (phdr->p_type == PT_LOAD) {
Elliott Hughes0266ae52014-02-10 17:46:57 -08004450 return reinterpret_cast<ElfW(Addr)>(elf) + phdr->p_offset - phdr->p_vaddr;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02004451 }
Kito Chengfa8c05d2013-03-12 14:58:06 +08004452 }
4453 return 0;
David 'Digit' Turnerbea23e52012-06-18 23:38:46 +02004454}
4455
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004456static void __linker_cannot_link(KernelArgumentBlock& args) {
4457 __libc_fatal("CANNOT LINK EXECUTABLE \"%s\": %s", args.argv[0], linker_get_error_buffer());
4458}
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07004459
Nick Kralevich468319c2011-11-11 15:53:17 -08004460/*
4461 * This is the entry point for the linker, called from begin.S. This
4462 * method is responsible for fixing the linker's own relocations, and
4463 * then calling __linker_init_post_relocation().
4464 *
4465 * Because this method is called before the linker has fixed it's own
4466 * relocations, any attempt to reference an extern variable, extern
4467 * function, or other GOT reference will generate a segfault.
4468 */
Elliott Hughes0266ae52014-02-10 17:46:57 -08004469extern "C" ElfW(Addr) __linker_init(void* raw_args) {
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004470 KernelArgumentBlock args(raw_args);
Nick Kralevich468319c2011-11-11 15:53:17 -08004471
Elliott Hughes0266ae52014-02-10 17:46:57 -08004472 ElfW(Addr) linker_addr = args.getauxval(AT_BASE);
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07004473 ElfW(Addr) entry_point = args.getauxval(AT_ENTRY);
Elliott Hughes0266ae52014-02-10 17:46:57 -08004474 ElfW(Ehdr)* elf_hdr = reinterpret_cast<ElfW(Ehdr)*>(linker_addr);
Elliott Hughesfaf05ba2014-02-11 16:59:37 -08004475 ElfW(Phdr)* phdr = reinterpret_cast<ElfW(Phdr)*>(linker_addr + elf_hdr->e_phoff);
Nick Kralevich468319c2011-11-11 15:53:17 -08004476
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07004477 soinfo linker_so(nullptr, nullptr, nullptr, 0, 0);
Nick Kralevich468319c2011-11-11 15:53:17 -08004478
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07004479 // If the linker is not acting as PT_INTERP entry_point is equal to
4480 // _start. Which means that the linker is running as an executable and
4481 // already linked by PT_INTERP.
4482 //
4483 // This happens when user tries to run 'adb shell /system/bin/linker'
4484 // see also https://code.google.com/p/android/issues/detail?id=63174
4485 if (reinterpret_cast<ElfW(Addr)>(&_start) == entry_point) {
Dimitry Ivanovb6ac9aa2016-02-18 14:37:44 -08004486 __libc_format_fd(STDOUT_FILENO,
4487 "This is %s, the helper program for shared library executables.\n",
4488 args.argv[0]);
4489 exit(0);
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07004490 }
4491
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004492 linker_so.base = linker_addr;
4493 linker_so.size = phdr_table_get_load_size(phdr, elf_hdr->e_phnum);
4494 linker_so.load_bias = get_elf_exec_load_bias(elf_hdr);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07004495 linker_so.dynamic = nullptr;
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004496 linker_so.phdr = phdr;
4497 linker_so.phnum = elf_hdr->e_phnum;
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08004498 linker_so.set_linker_flag();
Elliott Hughes5419b942012-10-16 15:54:46 -07004499
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004500 // Prelink the linker so we can access linker globals.
4501 if (!linker_so.prelink_image()) __linker_cannot_link(args);
4502
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07004503 // This might not be obvious... The reasons why we pass g_empty_list
4504 // in place of local_group here are (1) we do not really need it, because
4505 // linker is built with DT_SYMBOLIC and therefore relocates its symbols against
4506 // itself without having to look into local_group and (2) allocators
4507 // are not yet initialized, and therefore we cannot use linked_list.push_*
4508 // functions at this point.
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004509 if (!linker_so.link_image(g_empty_list, g_empty_list, nullptr)) __linker_cannot_link(args);
Elliott Hughesd23736e2012-11-01 15:16:56 -07004510
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004511#if defined(__i386__)
4512 // On x86, we can't make system calls before this point.
4513 // We can't move this up because this needs to assign to a global.
4514 // Note that until we call __libc_init_main_thread below we have
4515 // no TLS, so you shouldn't make a system call that can fail, because
4516 // it will SEGV when it tries to set errno.
4517 __libc_init_sysinfo(args);
4518#endif
4519
4520 // Initialize the main thread (including TLS, so system calls really work).
Elliott Hughesd2948632015-07-21 11:57:09 -07004521 __libc_init_main_thread(args);
Dmitriy Ivanov14241402014-08-26 14:16:52 -07004522
Mingwei Shi9ce09e42015-11-12 07:02:14 +00004523 // We didn't protect the linker's RELRO pages in link_image because we
4524 // couldn't make system calls on x86 at that point, but we can now...
4525 if (!linker_so.protect_relro()) __linker_cannot_link(args);
4526
Josh Gao93c0f5e2015-10-06 11:08:13 -07004527 // Initialize the linker's static libc's globals
4528 __libc_init_globals(args);
4529
Dmitriy Ivanovefe13832014-07-28 15:05:51 -07004530 // Initialize the linker's own global variables
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08004531 linker_so.call_constructors();
Dmitriy Ivanov4151ea72014-07-24 15:33:25 -07004532
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07004533 // Initialize static variables. Note that in order to
4534 // get correct libdl_info we need to call constructors
4535 // before get_libdl_info().
4536 solist = get_libdl_info();
4537 sonext = get_libdl_info();
Dimitry Ivanovae74e872016-03-24 15:30:30 -07004538 g_default_namespace.add_soinfo(get_libdl_info());
Dmitriy Ivanov0d150942014-08-22 12:25:04 -07004539
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004540 // We have successfully fixed our own relocations. It's safe to run
4541 // the main part of the linker now.
Elliott Hughes1728b232014-05-14 10:02:03 -07004542 args.abort_message_ptr = &g_abort_message;
Elliott Hughes0266ae52014-02-10 17:46:57 -08004543 ElfW(Addr) start_address = __linker_init_post_relocation(args, linker_addr);
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004544
Elliott Hughes116b5692016-01-04 17:45:36 -08004545 INFO("[ Jumping to _start (%p)... ]", reinterpret_cast<void*>(start_address));
Elliott Hughes611f9562015-01-23 10:43:58 -08004546
Elliott Hughes42b2c6a2013-02-07 10:14:39 -08004547 // Return the address that the calling assembly stub should jump to.
4548 return start_address;
Nick Kralevich468319c2011-11-11 15:53:17 -08004549}