blob: c42712a74f51acdeee41b394f892abe804b2a8a4 [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>
Ryan Prichard3714f212023-07-20 15:54:14 -070030#include <assert.h>
Elliott Hughes46882792012-08-03 16:49:39 -070031#include <errno.h>
32#include <fcntl.h>
Elliott Hughes0266ae52014-02-10 17:46:57 -080033#include <inttypes.h>
Elliott Hughes46882792012-08-03 16:49:39 -070034#include <pthread.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080035#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
Florian Mayerc10d0642023-03-22 16:12:49 -070038#include <sys/auxv.h>
Elliott Hughes46882792012-08-03 16:49:39 -070039#include <sys/mman.h>
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -080040#include <sys/param.h>
Dimitry Ivanovbf34ba32017-04-21 13:12:05 -070041#include <sys/vfs.h>
Elliott Hughes46882792012-08-03 16:49:39 -070042#include <unistd.h>
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080043
Jooyung Han57b03de2022-12-01 16:23:03 +090044#include <iterator>
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070045#include <new>
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070046#include <string>
Dmitriy Ivanovb4827502015-09-28 16:38:31 -070047#include <unordered_map>
Dmitriy Ivanovd165f562015-03-23 18:43:02 -070048#include <vector>
Dmitriy Ivanov0d150942014-08-22 12:25:04 -070049
Logan Chienbcfe3cf2018-05-08 20:17:26 +080050#include <android-base/properties.h>
Tom Cherryb8ab6182017-04-05 16:20:29 -070051#include <android-base/scopeguard.h>
Christopher Ferris7a3681e2017-04-24 17:48:32 -070052#include <async_safe/log.h>
Ryan Pricharda2e83ab2019-08-16 17:25:43 -070053#include <bionic/pthread_internal.h>
Florian Mayer4edc20d2024-10-30 14:24:26 -070054#include <platform/bionic/mte.h>
Christopher Ferris7a3681e2017-04-24 17:48:32 -070055
Elliott Hughes46882792012-08-03 16:49:39 -070056// Private C library headers.
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080057
58#include "linker.h"
Dmitriy Ivanovc9ce70d2015-03-10 15:30:26 -070059#include "linker_block_allocator.h"
Evgenii Stepanov0a3637d2016-07-06 13:20:59 -070060#include "linker_cfi.h"
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -080061#include "linker_config.h"
Dimitry Ivanov6b788ee2016-02-17 16:08:03 -080062#include "linker_gdb_support.h"
Dimitry Ivanov48ec2882016-08-04 11:50:36 -070063#include "linker_globals.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080064#include "linker_debug.h"
Dimitry Ivanov769b33f2016-07-21 11:33:40 -070065#include "linker_dlwarning.h"
Dimitry Ivanov3f660572016-09-09 10:00:39 -070066#include "linker_main.h"
Dimitry Ivanovb943f302016-08-03 16:00:10 -070067#include "linker_namespaces.h"
Dmitriy Ivanov18870d32015-04-22 13:10:04 -070068#include "linker_sleb128.h"
David 'Digit' Turner23363ed2012-06-18 18:13:49 +020069#include "linker_phdr.h"
Ryan Prichard339ecef2020-01-02 16:36:06 -080070#include "linker_relocate.h"
Ryan Pricharde5e69e02019-01-01 18:53:48 -080071#include "linker_tls.h"
Victor Khimenko01790fd2020-05-12 22:59:04 +020072#include "linker_translate_path.h"
Dmitriy Ivanova1feb112015-10-01 18:41:57 -070073#include "linker_utils.h"
tony.ys_liub4474402015-07-29 18:00:22 +080074
Mitch Phillips7c1f3772023-09-28 13:45:59 +020075#include "android-base/macros.h"
76#include "android-base/stringprintf.h"
77#include "android-base/strings.h"
78#include "private/bionic_asm_note.h"
Peter Collingbournee9491952019-10-28 10:57:26 -070079#include "private/bionic_call_ifunc_resolver.h"
Ryan Pricharde5e69e02019-01-01 18:53:48 -080080#include "private/bionic_globals.h"
Simon Baldwinaef71952015-01-16 13:22:54 +000081#include "ziparchive/zip_archive.h"
The Android Open Source Project1dc9e472009-03-03 19:28:35 -080082
dimitry06016f22018-01-05 11:39:28 +010083static std::unordered_map<void*, size_t> g_dso_handle_counters;
84
Jiyong Park25bedfd2019-05-16 21:00:39 +090085static bool g_anonymous_namespace_set = false;
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -070086static android_namespace_t* g_anonymous_namespace = &g_default_namespace;
Jiyong Park01de74e2017-04-03 23:10:37 +090087static std::unordered_map<std::string, android_namespace_t*> g_exported_namespaces;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -070088
Dmitriy Ivanov600bc3c2015-03-10 15:43:50 -070089static LinkerTypeAllocator<soinfo> g_soinfo_allocator;
90static LinkerTypeAllocator<LinkedListEntry<soinfo>> g_soinfo_links_allocator;
Magnus Malmbornba98d922012-09-12 13:00:55 +020091
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -070092static LinkerTypeAllocator<android_namespace_t> g_namespace_allocator;
Dimitry Ivanovaca299a2016-04-11 12:42:58 -070093static LinkerTypeAllocator<LinkedListEntry<android_namespace_t>> g_namespace_list_allocator;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -070094
Ryan Pricharda2e83ab2019-08-16 17:25:43 -070095static uint64_t g_module_load_counter = 0;
96static uint64_t g_module_unload_counter = 0;
97
dimitryfe1b27c2017-08-11 14:43:21 +020098static const char* const kLdConfigArchFilePath = "/system/etc/ld.config." ABI_STRING ".txt";
99
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -0800100static const char* const kLdConfigFilePath = "/system/etc/ld.config.txt";
Roland Levillain09bde952019-10-29 19:17:49 +0000101static const char* const kLdConfigVndkLiteFilePath = "/system/etc/ld.config.vndk_lite.txt";
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -0800102
Kiyoung Kim1a2460d2019-11-22 14:38:25 +0900103static const char* const kLdGeneratedConfigFilePath = "/linkerconfig/ld.config.txt";
Kiyoung Kim35e3b4b2019-08-07 19:24:13 +0900104
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700105#if defined(__LP64__)
Victor Chang6cb719f2019-02-06 17:19:10 +0000106static const char* const kSystemLibDir = "/system/lib64";
107static const char* const kOdmLibDir = "/odm/lib64";
108static const char* const kVendorLibDir = "/vendor/lib64";
109static const char* const kAsanSystemLibDir = "/data/asan/system/lib64";
110static const char* const kAsanOdmLibDir = "/data/asan/odm/lib64";
111static const char* const kAsanVendorLibDir = "/data/asan/vendor/lib64";
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700112#else
Victor Chang6cb719f2019-02-06 17:19:10 +0000113static const char* const kSystemLibDir = "/system/lib";
114static const char* const kOdmLibDir = "/odm/lib";
115static const char* const kVendorLibDir = "/vendor/lib";
116static const char* const kAsanSystemLibDir = "/data/asan/system/lib";
117static const char* const kAsanOdmLibDir = "/data/asan/odm/lib";
118static const char* const kAsanVendorLibDir = "/data/asan/vendor/lib";
Elliott Hughes011bc0b2013-10-08 14:27:10 -0700119#endif
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700120
Vishwath Mohan4113def2017-03-29 15:31:34 -0700121static const char* const kAsanLibDirPrefix = "/data/asan";
122
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700123static const char* const kDefaultLdPaths[] = {
124 kSystemLibDir,
Alin Jerpelea074a9fd2017-09-25 17:47:49 +0200125 kOdmLibDir,
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700126 kVendorLibDir,
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700127 nullptr
Elliott Hughes124fae92012-10-31 14:20:03 -0700128};
David Bartleybc3a5c22009-06-02 18:27:28 -0700129
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700130static const char* const kAsanDefaultLdPaths[] = {
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700131 kAsanSystemLibDir,
132 kSystemLibDir,
Alin Jerpelea074a9fd2017-09-25 17:47:49 +0200133 kAsanOdmLibDir,
134 kOdmLibDir,
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700135 kAsanVendorLibDir,
136 kVendorLibDir,
Evgenii Stepanovd640b222015-07-10 17:54:01 -0700137 nullptr
138};
139
Florian Mayerc10d0642023-03-22 16:12:49 -0700140#if defined(__aarch64__)
141static const char* const kHwasanSystemLibDir = "/system/lib64/hwasan";
142static const char* const kHwasanOdmLibDir = "/odm/lib64/hwasan";
143static const char* const kHwasanVendorLibDir = "/vendor/lib64/hwasan";
144
145// HWASan is only supported on aarch64.
146static const char* const kHwsanDefaultLdPaths[] = {
147 kHwasanSystemLibDir,
148 kSystemLibDir,
149 kHwasanOdmLibDir,
150 kOdmLibDir,
151 kHwasanVendorLibDir,
152 kVendorLibDir,
153 nullptr
154};
155
156// Is HWASAN enabled?
157static bool g_is_hwasan = false;
158#else
159static const char* const kHwsanDefaultLdPaths[] = {
160 kSystemLibDir,
161 kOdmLibDir,
162 kVendorLibDir,
163 nullptr
164};
165
166// Never any HWASan. Help the compiler remove the code we don't need.
167constexpr bool g_is_hwasan = false;
168#endif
169
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700170// Is ASAN enabled?
171static bool g_is_asan = false;
172
Evgenii Stepanov0a3637d2016-07-06 13:20:59 -0700173static CFIShadowWriter g_cfi_shadow;
174
175CFIShadowWriter* get_cfi_shadow() {
176 return &g_cfi_shadow;
177}
178
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700179static bool is_system_library(const std::string& realpath) {
180 for (const auto& dir : g_default_namespace.get_default_library_paths()) {
181 if (file_is_in_dir(realpath, dir)) {
182 return true;
183 }
184 }
185 return false;
186}
187
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700188// Checks if the file exists and not a directory.
189static bool file_exists(const char* path) {
Dimitry Ivanov4cf70242016-08-11 11:11:52 -0700190 struct stat s;
191
192 if (stat(path, &s) != 0) {
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700193 return false;
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700194 }
Dimitry Ivanov4cf70242016-08-11 11:11:52 -0700195
196 return S_ISREG(s.st_mode);
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -0700197}
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700198
Dimitry Ivanov35c8e3b2017-02-27 12:17:47 -0800199static std::string resolve_soname(const std::string& name) {
200 // We assume that soname equals to basename here
201
202 // TODO(dimitry): consider having honest absolute-path -> soname resolution
203 // note that since we might end up refusing to load this library because
204 // it is not in shared libs list we need to get the soname without actually loading
205 // the library.
206 //
207 // On the other hand there are several places where we already assume that
208 // soname == basename in particular for any not-loaded library mentioned
209 // in DT_NEEDED list.
210 return basename(name.c_str());
211}
212
213static bool maybe_accessible_via_namespace_links(android_namespace_t* ns, const char* name) {
214 std::string soname = resolve_soname(name);
215 for (auto& ns_link : ns->linked_namespaces()) {
216 if (ns_link.is_accessible(soname.c_str())) {
217 return true;
218 }
219 }
220
221 return false;
222}
223
Ryan Prichardaff9a342020-08-03 15:29:12 -0700224// TODO(dimitry): The exempt-list is a workaround for http://b/26394120 ---
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700225// gradually remove libraries from this list until it is gone.
Ryan Prichardaff9a342020-08-03 15:29:12 -0700226static bool is_exempt_lib(android_namespace_t* ns, const char* name, const soinfo* needed_by) {
227 static const char* const kLibraryExemptList[] = {
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700228 "libandroid_runtime.so",
229 "libbinder.so",
230 "libcrypto.so",
231 "libcutils.so",
232 "libexpat.so",
233 "libgui.so",
234 "libmedia.so",
235 "libnativehelper.so",
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700236 "libssl.so",
237 "libstagefright.so",
238 "libsqlite.so",
239 "libui.so",
240 "libutils.so",
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700241 nullptr
242 };
243
Ryan Prichardaff9a342020-08-03 15:29:12 -0700244 // If you're targeting N, you don't get the exempt-list.
Ryan Prichard23860932020-07-30 19:16:20 -0700245 if (get_application_target_sdk_version() >= 24) {
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700246 return false;
247 }
248
249 // if the library needed by a system library - implicitly assume it
Ryan Prichardaff9a342020-08-03 15:29:12 -0700250 // is exempt unless it is in the list of shared libraries for one or
Dimitry Ivanov35c8e3b2017-02-27 12:17:47 -0800251 // more linked namespaces
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700252 if (needed_by != nullptr && is_system_library(needed_by->get_realpath())) {
Dimitry Ivanov35c8e3b2017-02-27 12:17:47 -0800253 return !maybe_accessible_via_namespace_links(ns, name);
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700254 }
255
256 // if this is an absolute path - make sure it points to /system/lib(64)
257 if (name[0] == '/' && dirname(name) == kSystemLibDir) {
258 // and reduce the path to basename
259 name = basename(name);
260 }
261
Ryan Prichardaff9a342020-08-03 15:29:12 -0700262 for (size_t i = 0; kLibraryExemptList[i] != nullptr; ++i) {
263 if (strcmp(name, kLibraryExemptList[i]) == 0) {
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700264 return true;
265 }
266 }
267
268 return false;
269}
270// END OF WORKAROUND
271
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700272static std::vector<std::string> g_ld_preload_names;
Elliott Hughesa4aafd12014-01-13 16:37:47 -0800273
Elliott Hughesbedfe382012-08-14 14:07:59 -0700274static void notify_gdb_of_load(soinfo* info) {
Dimitry Ivanove97d8ed2016-03-01 15:55:56 -0800275 if (info->is_linker() || info->is_main_executable()) {
276 // gdb already knows about the linker and the main executable.
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700277 return;
278 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800279
Dimitry Ivanov6b788ee2016-02-17 16:08:03 -0800280 link_map* map = &(info->link_map_head);
Nicolas Geoffray0fa54102016-02-18 09:31:24 +0000281
Dimitry Ivanov6b788ee2016-02-17 16:08:03 -0800282 map->l_addr = info->load_bias;
283 // link_map l_name field is not const.
284 map->l_name = const_cast<char*>(info->get_realpath());
285 map->l_ld = info->dynamic;
Nicolas Geoffray0fa54102016-02-18 09:31:24 +0000286
Dimitry Ivanove97d8ed2016-03-01 15:55:56 -0800287 CHECK(map->l_name != nullptr);
288 CHECK(map->l_name[0] != '\0');
289
Dimitry Ivanov6b788ee2016-02-17 16:08:03 -0800290 notify_gdb_of_load(map);
Iliyan Malchev5e12d7e2009-03-24 19:02:00 -0700291}
292
Elliott Hughesbedfe382012-08-14 14:07:59 -0700293static void notify_gdb_of_unload(soinfo* info) {
Dimitry Ivanov6b788ee2016-02-17 16:08:03 -0800294 notify_gdb_of_unload(&(info->link_map_head));
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800295}
296
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700297LinkedListEntry<soinfo>* SoinfoListAllocator::alloc() {
298 return g_soinfo_links_allocator.alloc();
299}
300
301void SoinfoListAllocator::free(LinkedListEntry<soinfo>* entry) {
302 g_soinfo_links_allocator.free(entry);
303}
304
Dimitry Ivanovaca299a2016-04-11 12:42:58 -0700305LinkedListEntry<android_namespace_t>* NamespaceListAllocator::alloc() {
306 return g_namespace_list_allocator.alloc();
307}
308
309void NamespaceListAllocator::free(LinkedListEntry<android_namespace_t>* entry) {
310 g_namespace_list_allocator.free(entry);
311}
312
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700313soinfo* soinfo_alloc(android_namespace_t* ns, const char* name,
Ryan Prichard8f639a42018-10-01 23:10:05 -0700314 const struct stat* file_stat, off64_t file_offset,
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700315 uint32_t rtld_flags) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700316 if (strlen(name) >= PATH_MAX) {
Elliott Hughes7b0af7a2017-09-15 16:09:22 -0700317 async_safe_fatal("library name \"%s\" too long", name);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200318 }
319
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400320 LD_DEBUG(any, "name %s: allocating soinfo for ns=%p", name, ns);
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700321
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700322 soinfo* si = new (g_soinfo_allocator.alloc()) soinfo(ns, name, file_stat,
323 file_offset, rtld_flags);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700324
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700325 solist_add_soinfo(si);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200326
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -0700327 si->generate_handle();
328 ns->add_soinfo(si);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700329
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400330 LD_DEBUG(any, "name %s: allocated soinfo @ %p", name, si);
Magnus Malmbornba98d922012-09-12 13:00:55 +0200331 return si;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800332}
333
Elliott Hughesfaf05ba2014-02-11 16:59:37 -0800334static void soinfo_free(soinfo* si) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700335 if (si == nullptr) {
336 return;
337 }
338
Evgenii Stepanov474f2f52020-07-06 19:25:43 +0000339 if (si->base != 0 && si->size != 0) {
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -0800340 if (!si->is_mapped_by_caller()) {
Evgenii Stepanov474f2f52020-07-06 19:25:43 +0000341 munmap(reinterpret_cast<void*>(si->base), si->size);
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -0800342 } else {
343 // remap the region as PROT_NONE, MAP_ANONYMOUS | MAP_NORESERVE
Evgenii Stepanov474f2f52020-07-06 19:25:43 +0000344 mmap(reinterpret_cast<void*>(si->base), si->size, PROT_NONE,
345 MAP_FIXED | MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE, -1, 0);
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -0800346 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700347 }
348
Evgenii Stepanove0848bb2020-07-14 16:44:57 -0700349 if (si->has_min_version(6) && si->get_gap_size()) {
350 munmap(reinterpret_cast<void*>(si->get_gap_start()), si->get_gap_size());
351 }
352
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400353 LD_DEBUG(any, "name %s: freeing soinfo @ %p", si->get_realpath(), si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700354
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700355 if (!solist_remove_soinfo(si)) {
dimitry965d06d2017-11-28 16:03:07 +0100356 async_safe_fatal("soinfo=%p is not in soinfo_list (double unload?)", si);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700357 }
Elliott Hughes46882792012-08-03 16:49:39 -0700358
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700359 // clear links to/from si
360 si->remove_all_links();
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -0700361
Dmitriy Ivanov609f11b2015-07-08 15:26:46 -0700362 si->~soinfo();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700363 g_soinfo_allocator.free(si);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800364}
365
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700366static void parse_path(const char* path, const char* delimiters,
367 std::vector<std::string>* resolved_paths) {
368 std::vector<std::string> paths;
369 split_path(path, delimiters, &paths);
370 resolve_paths(paths, resolved_paths);
371}
372
Elliott Hughescade4c32012-12-20 14:42:14 -0800373static void parse_LD_LIBRARY_PATH(const char* path) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700374 std::vector<std::string> ld_libary_paths;
375 parse_path(path, ":", &ld_libary_paths);
376 g_default_namespace.set_ld_library_paths(std::move(ld_libary_paths));
Elliott Hughescade4c32012-12-20 14:42:14 -0800377}
378
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700379static bool realpath_fd(int fd, std::string* realpath) {
Vic Yangd8bef672019-05-15 21:10:22 -0700380 // proc_self_fd needs to be large enough to hold "/proc/self/fd/" plus an
381 // integer, plus the NULL terminator.
382 char proc_self_fd[32];
383 // We want to statically allocate this large buffer so that we don't grow
384 // the stack by too much.
385 static char buf[PATH_MAX];
386
387 async_safe_format_buffer(proc_self_fd, sizeof(proc_self_fd), "/proc/self/fd/%d", fd);
388 auto length = readlink(proc_self_fd, buf, sizeof(buf));
389 if (length == -1) {
Tom Cherry66bc4282018-11-08 13:40:52 -0800390 if (!is_first_stage_init()) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400391 DL_WARN("readlink(\"%s\" [fd=%d]) failed: %m", proc_self_fd, fd);
Tom Cherry66bc4282018-11-08 13:40:52 -0800392 }
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700393 return false;
394 }
395
Vic Yangd8bef672019-05-15 21:10:22 -0700396 realpath->assign(buf, length);
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -0700397 return true;
398}
399
Ryan Pricharda2e83ab2019-08-16 17:25:43 -0700400// Returns the address of the current thread's copy of a TLS module. If the current thread doesn't
401// have a copy yet, allocate one on-demand if should_alloc is true, and return nullptr otherwise.
402static inline void* get_tls_block_for_this_thread(const soinfo_tls* si_tls, bool should_alloc) {
403 const TlsModule& tls_mod = get_tls_module(si_tls->module_id);
404 if (tls_mod.static_offset != SIZE_MAX) {
405 const StaticTlsLayout& layout = __libc_shared_globals()->static_tls_layout;
406 char* static_tls = reinterpret_cast<char*>(__get_bionic_tcb()) - layout.offset_bionic_tcb();
407 return static_tls + tls_mod.static_offset;
408 } else if (should_alloc) {
Elliott Hughes43462702022-10-10 19:21:44 +0000409 const TlsIndex ti { si_tls->module_id, static_cast<size_t>(0 - TLS_DTV_OFFSET) };
Ryan Pricharda2e83ab2019-08-16 17:25:43 -0700410 return TLS_GET_ADDR(&ti);
411 } else {
412 TlsDtv* dtv = __get_tcb_dtv(__get_bionic_tcb());
413 if (dtv->generation < tls_mod.first_generation) return nullptr;
414 return dtv->modules[__tls_module_id_to_idx(si_tls->module_id)];
415 }
416}
417
Elliott Hughes4eeb1f12013-10-25 17:38:02 -0700418#if defined(__arm__)
Elliott Hughes46882792012-08-03 16:49:39 -0700419
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700420// For a given PC, find the .so that it belongs to.
421// Returns the base address of the .ARM.exidx section
422// for that .so, and the number of 8-byte entries
423// in that section (via *pcount).
424//
425// Intended to be called by libc's __gnu_Unwind_Find_exidx().
Dimitry Ivanovd9e427c2016-11-22 16:55:25 -0800426_Unwind_Ptr do_dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) {
Peter Collingbourneb39cb3c2019-03-01 13:12:49 -0800427 if (soinfo* si = find_containing_library(reinterpret_cast<void*>(pc))) {
428 *pcount = si->ARM_exidx_count;
429 return reinterpret_cast<_Unwind_Ptr>(si->ARM_exidx);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700430 }
431 *pcount = 0;
Elliott Hughesf2c6ad62017-04-21 10:25:56 -0700432 return 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800433}
Elliott Hughes46882792012-08-03 16:49:39 -0700434
Christopher Ferris24053a42013-08-19 17:45:09 -0700435#endif
Elliott Hughes46882792012-08-03 16:49:39 -0700436
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700437// Here, we only have to provide a callback to iterate across all the
438// loaded libraries. gcc_eh does the rest.
Dmitriy Ivanov7271caf2015-06-29 14:48:25 -0700439int do_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700440 int rv = 0;
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700441 for (soinfo* si = solist_get_head(); si != nullptr; si = si->next) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700442 dl_phdr_info dl_info;
443 dl_info.dlpi_addr = si->link_map_head.l_addr;
444 dl_info.dlpi_name = si->link_map_head.l_name;
445 dl_info.dlpi_phdr = si->phdr;
446 dl_info.dlpi_phnum = si->phnum;
Ryan Pricharda2e83ab2019-08-16 17:25:43 -0700447 dl_info.dlpi_adds = g_module_load_counter;
448 dl_info.dlpi_subs = g_module_unload_counter;
449 if (soinfo_tls* tls_module = si->get_tls()) {
450 dl_info.dlpi_tls_modid = tls_module->module_id;
451 dl_info.dlpi_tls_data = get_tls_block_for_this_thread(tls_module, /*should_alloc=*/false);
452 } else {
453 dl_info.dlpi_tls_modid = 0;
454 dl_info.dlpi_tls_data = nullptr;
455 }
456
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700457 rv = cb(&dl_info, sizeof(dl_phdr_info), data);
458 if (rv != 0) {
459 break;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800460 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -0700461 }
462 return rv;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800463}
Elliott Hughes46882792012-08-03 16:49:39 -0700464
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700465ProtectedDataGuard::ProtectedDataGuard() {
466 if (ref_count_++ == 0) {
467 protect_data(PROT_READ | PROT_WRITE);
468 }
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700469
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700470 if (ref_count_ == 0) { // overflow
Christopher Ferris7a3681e2017-04-24 17:48:32 -0700471 async_safe_fatal("Too many nested calls to dlopen()");
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800472 }
Dimitry Ivanov68e6c032017-02-01 12:55:11 -0800473}
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800474
Dimitry Ivanov68e6c032017-02-01 12:55:11 -0800475ProtectedDataGuard::~ProtectedDataGuard() {
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700476 if (--ref_count_ == 0) {
477 protect_data(PROT_READ);
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800478 }
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700479}
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800480
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700481void ProtectedDataGuard::protect_data(int protection) {
482 g_soinfo_allocator.protect_all(protection);
483 g_soinfo_links_allocator.protect_all(protection);
484 g_namespace_allocator.protect_all(protection);
485 g_namespace_list_allocator.protect_all(protection);
486}
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -0800487
488size_t ProtectedDataGuard::ref_count_ = 0;
489
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700490// Each size has it's own allocator.
491template<size_t size>
492class SizeBasedAllocator {
493 public:
494 static void* alloc() {
495 return allocator_.alloc();
496 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -0700497
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700498 static void free(void* ptr) {
499 allocator_.free(ptr);
500 }
Dmitriy Ivanov4bea4982014-08-29 14:01:48 -0700501
Vic Yangbb7e1232019-01-29 20:23:16 -0800502 static void purge() {
503 allocator_.purge();
504 }
505
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700506 private:
507 static LinkerBlockAllocator allocator_;
508};
509
510template<size_t size>
511LinkerBlockAllocator SizeBasedAllocator<size>::allocator_(size);
512
513template<typename T>
514class TypeBasedAllocator {
515 public:
516 static T* alloc() {
517 return reinterpret_cast<T*>(SizeBasedAllocator<sizeof(T)>::alloc());
518 }
519
520 static void free(T* ptr) {
521 SizeBasedAllocator<sizeof(T)>::free(ptr);
522 }
Vic Yangbb7e1232019-01-29 20:23:16 -0800523
524 static void purge() {
525 SizeBasedAllocator<sizeof(T)>::purge();
526 }
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700527};
528
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700529class LoadTask {
530 public:
531 struct deleter_t {
532 void operator()(LoadTask* t) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700533 t->~LoadTask();
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700534 TypeBasedAllocator<LoadTask>::free(t);
535 }
536 };
537
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700538 static deleter_t deleter;
539
Ryan Prichardaa2db962020-03-24 20:25:53 -0700540 // needed_by is NULL iff dlopen is called from memory that isn't part of any known soinfo.
541 static LoadTask* create(const char* _Nonnull name, soinfo* _Nullable needed_by,
542 android_namespace_t* _Nonnull start_from,
543 std::unordered_map<const soinfo*, ElfReader>* _Nonnull readers_map) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700544 LoadTask* ptr = TypeBasedAllocator<LoadTask>::alloc();
Jiyong Park02586a22017-05-20 01:01:24 +0900545 return new (ptr) LoadTask(name, needed_by, start_from, readers_map);
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700546 }
547
548 const char* get_name() const {
549 return name_;
550 }
551
552 soinfo* get_needed_by() const {
553 return needed_by_;
554 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700555
556 soinfo* get_soinfo() const {
557 return si_;
558 }
559
560 void set_soinfo(soinfo* si) {
561 si_ = si;
562 }
563
564 off64_t get_file_offset() const {
565 return file_offset_;
566 }
567
568 void set_file_offset(off64_t offset) {
569 file_offset_ = offset;
570 }
571
572 int get_fd() const {
573 return fd_;
574 }
575
576 void set_fd(int fd, bool assume_ownership) {
Martin Stjernholmde853ff2019-01-17 00:18:44 +0000577 if (fd_ != -1 && close_fd_) {
578 close(fd_);
579 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700580 fd_ = fd;
581 close_fd_ = assume_ownership;
582 }
583
584 const android_dlextinfo* get_extinfo() const {
585 return extinfo_;
586 }
587
588 void set_extinfo(const android_dlextinfo* extinfo) {
589 extinfo_ = extinfo;
590 }
591
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700592 bool is_dt_needed() const {
593 return is_dt_needed_;
594 }
595
596 void set_dt_needed(bool is_dt_needed) {
597 is_dt_needed_ = is_dt_needed;
598 }
599
Jiyong Park02586a22017-05-20 01:01:24 +0900600 // returns the namespace from where we need to start loading this.
601 const android_namespace_t* get_start_from() const {
602 return start_from_;
603 }
604
Ryan Prichard4fa6d992020-03-26 21:31:43 -0700605 void remove_cached_elf_reader() {
606 CHECK(si_ != nullptr);
607 (*elf_readers_map_).erase(si_);
608 }
609
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700610 const ElfReader& get_elf_reader() const {
611 CHECK(si_ != nullptr);
612 return (*elf_readers_map_)[si_];
613 }
614
615 ElfReader& get_elf_reader() {
616 CHECK(si_ != nullptr);
617 return (*elf_readers_map_)[si_];
618 }
619
620 std::unordered_map<const soinfo*, ElfReader>* get_readers_map() {
621 return elf_readers_map_;
622 }
623
624 bool read(const char* realpath, off64_t file_size) {
625 ElfReader& elf_reader = get_elf_reader();
626 return elf_reader.Read(realpath, fd_, file_offset_, file_size);
627 }
628
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -0400629 bool load(address_space_params* address_space) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700630 ElfReader& elf_reader = get_elf_reader();
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -0400631 if (!elf_reader.Load(address_space)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700632 return false;
633 }
634
635 si_->base = elf_reader.load_start();
636 si_->size = elf_reader.load_size();
Dimitry Ivanovf45b0e92016-01-15 11:13:35 -0800637 si_->set_mapped_by_caller(elf_reader.is_mapped_by_caller());
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700638 si_->load_bias = elf_reader.load_bias();
639 si_->phnum = elf_reader.phdr_count();
640 si_->phdr = elf_reader.loaded_phdr();
Evgenii Stepanove0848bb2020-07-14 16:44:57 -0700641 si_->set_gap_start(elf_reader.gap_start());
642 si_->set_gap_size(elf_reader.gap_size());
Kalesh Singh377f0b92024-01-31 20:23:39 -0800643 si_->set_should_pad_segments(elf_reader.should_pad_segments());
Kalesh Singhb23787f2024-09-05 08:22:06 +0000644 si_->set_should_use_16kib_app_compat(elf_reader.should_use_16kib_app_compat());
Kalesh Singhce1c3cf2024-09-30 13:26:23 -0700645 if (si_->should_use_16kib_app_compat()) {
646 si_->set_compat_relro_start(elf_reader.compat_relro_start());
647 si_->set_compat_relro_size(elf_reader.compat_relro_size());
648 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700649
650 return true;
651 }
652
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700653 private:
Dimitry Ivanov7d429d32017-02-01 15:28:52 -0800654 LoadTask(const char* name,
655 soinfo* needed_by,
Jiyong Park02586a22017-05-20 01:01:24 +0900656 android_namespace_t* start_from,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700657 std::unordered_map<const soinfo*, ElfReader>* readers_map)
658 : name_(name), needed_by_(needed_by), si_(nullptr),
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700659 fd_(-1), close_fd_(false), file_offset_(0), elf_readers_map_(readers_map),
Jiyong Park02586a22017-05-20 01:01:24 +0900660 is_dt_needed_(false), start_from_(start_from) {}
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700661
662 ~LoadTask() {
663 if (fd_ != -1 && close_fd_) {
664 close(fd_);
665 }
666 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700667
668 const char* name_;
669 soinfo* needed_by_;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700670 soinfo* si_;
671 const android_dlextinfo* extinfo_;
672 int fd_;
673 bool close_fd_;
674 off64_t file_offset_;
675 std::unordered_map<const soinfo*, ElfReader>* elf_readers_map_;
Ryan Prichardaff9a342020-08-03 15:29:12 -0700676 // TODO(dimitry): needed by workaround for http://b/26394120 (the exempt-list)
Dimitry Ivanov769b33f2016-07-21 11:33:40 -0700677 bool is_dt_needed_;
678 // END OF WORKAROUND
Jiyong Park02586a22017-05-20 01:01:24 +0900679 const android_namespace_t* const start_from_;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700680
681 DISALLOW_IMPLICIT_CONSTRUCTORS(LoadTask);
682};
683
Ningsheng Jiane93be992014-09-16 15:22:10 +0800684LoadTask::deleter_t LoadTask::deleter;
685
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700686template <typename T>
687using linked_list_t = LinkedList<T, TypeBasedAllocator<LinkedListEntry<T>>>;
688
689typedef linked_list_t<soinfo> SoinfoLinkedList;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -0700690typedef linked_list_t<const char> StringLinkedList;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -0700691typedef std::vector<LoadTask*> LoadTaskList;
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700692
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800693enum walk_action_result_t : uint32_t {
694 kWalkStop = 0,
695 kWalkContinue = 1,
696 kWalkSkip = 2
697};
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700698
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700699// This function walks down the tree of soinfo dependencies
700// in breadth-first order and
701// * calls action(soinfo* si) for each node, and
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800702// * terminates walk if action returns kWalkStop
703// * skips children of the node if action
704// return kWalkSkip
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700705//
706// walk_dependencies_tree returns false if walk was terminated
707// by the action and true otherwise.
708template<typename F>
dimitry965d06d2017-11-28 16:03:07 +0100709static bool walk_dependencies_tree(soinfo* root_soinfo, F action) {
Dmitriy Ivanov0cd83eb2014-09-01 16:15:52 -0700710 SoinfoLinkedList visit_list;
711 SoinfoLinkedList visited;
712
dimitry965d06d2017-11-28 16:03:07 +0100713 visit_list.push_back(root_soinfo);
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700714
715 soinfo* si;
716 while ((si = visit_list.pop_front()) != nullptr) {
717 if (visited.contains(si)) {
Dmitriy Ivanov042426b2014-08-12 21:02:13 -0700718 continue;
719 }
720
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800721 walk_action_result_t result = action(si);
722
723 if (result == kWalkStop) {
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700724 return false;
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700725 }
726
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700727 visited.push_back(si);
728
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800729 if (result != kWalkSkip) {
730 si->get_children().for_each([&](soinfo* child) {
731 visit_list.push_back(child);
732 });
733 }
Dmitriy Ivanovaa0f2bd2014-07-28 17:32:20 -0700734 }
735
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700736 return true;
737}
738
739
Ryan Prichard272458e2020-01-23 16:07:27 -0800740static const ElfW(Sym)* dlsym_handle_lookup_impl(android_namespace_t* ns,
741 soinfo* root,
742 soinfo* skip_until,
743 soinfo** found,
744 SymbolName& symbol_name,
745 const version_info* vi) {
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700746 const ElfW(Sym)* result = nullptr;
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -0700747 bool skip_lookup = skip_until != nullptr;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700748
dimitry965d06d2017-11-28 16:03:07 +0100749 walk_dependencies_tree(root, [&](soinfo* current_soinfo) {
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -0700750 if (skip_lookup) {
751 skip_lookup = current_soinfo != skip_until;
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800752 return kWalkContinue;
753 }
754
755 if (!ns->is_accessible(current_soinfo)) {
756 return kWalkSkip;
Dmitriy Ivanov697bd9f2015-05-12 11:12:27 -0700757 }
758
Ryan Prichard0e12cce2020-01-02 14:59:11 -0800759 result = current_soinfo->find_symbol_by_name(symbol_name, vi);
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700760 if (result != nullptr) {
761 *found = current_soinfo;
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800762 return kWalkStop;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700763 }
764
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800765 return kWalkContinue;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -0700766 });
767
768 return result;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800769}
770
Brian Carlstromd4ee82d2013-02-28 15:58:45 -0800771/* This is used by dlsym(3) to performs a global symbol lookup. If the
772 start value is null (for RTLD_DEFAULT), the search starts at the
773 beginning of the global solist. Otherwise the search starts at the
774 specified soinfo (for RTLD_NEXT).
Iliyan Malchev6ed80c82009-09-28 19:38:04 -0700775 */
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -0800776static const ElfW(Sym)* dlsym_linear_lookup(android_namespace_t* ns,
777 const char* name,
778 const version_info* vi,
779 soinfo** found,
780 soinfo* caller,
781 void* handle) {
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -0800782 SymbolName symbol_name(name);
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800783
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -0700784 auto& soinfo_list = ns->soinfo_list();
785 auto start = soinfo_list.begin();
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700786
787 if (handle == RTLD_NEXT) {
Dmitriy Ivanovb96ac412015-05-22 12:34:42 -0700788 if (caller == nullptr) {
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700789 return nullptr;
790 } else {
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -0700791 auto it = soinfo_list.find(caller);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700792 CHECK (it != soinfo_list.end());
793 start = ++it;
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700794 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800795 }
796
Dmitriy Ivanov2a815362015-04-09 13:42:33 -0700797 const ElfW(Sym)* s = nullptr;
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -0700798 for (auto it = start, end = soinfo_list.end(); it != end; ++it) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -0700799 soinfo* si = *it;
Dmitriy Ivanov19133522015-06-02 17:36:54 -0700800 // Do not skip RTLD_LOCAL libraries in dlsym(RTLD_DEFAULT, ...)
Elliott Hughes5bc78c82016-11-16 11:35:43 -0800801 // if the library is opened by application with target api level < M.
Dmitriy Ivanov19133522015-06-02 17:36:54 -0700802 // See http://b/21565766
Elliott Hughes95c6cd72019-12-20 13:26:14 -0800803 if ((si->get_rtld_flags() & RTLD_GLOBAL) == 0 && si->get_target_sdk_version() >= 23) {
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -0700804 continue;
805 }
806
Ryan Prichard0e12cce2020-01-02 14:59:11 -0800807 s = si->find_symbol_by_name(symbol_name, vi);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700808 if (s != nullptr) {
Elliott Hughescade4c32012-12-20 14:42:14 -0800809 *found = si;
810 break;
Matt Fischer1698d9e2009-12-31 12:17:56 -0600811 }
Elliott Hughescade4c32012-12-20 14:42:14 -0800812 }
Matt Fischer1698d9e2009-12-31 12:17:56 -0600813
Ryan Prichard272458e2020-01-23 16:07:27 -0800814 // If not found - use dlsym_handle_lookup_impl for caller's local_group
dimitry153168c2018-02-20 16:51:41 +0100815 if (s == nullptr && caller != nullptr) {
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -0800816 soinfo* local_group_root = caller->get_local_group_root();
817
Ryan Prichard272458e2020-01-23 16:07:27 -0800818 return dlsym_handle_lookup_impl(local_group_root->get_primary_namespace(),
819 local_group_root,
820 (handle == RTLD_NEXT) ? caller : nullptr,
821 found,
822 symbol_name,
823 vi);
Dmitriy Ivanov76ac1ac2015-04-01 14:45:10 -0700824 }
825
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700826 if (s != nullptr) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400827 LD_DEBUG(lookup, "%s s->st_value = %p, found->base = %p",
828 name, reinterpret_cast<void*>(s->st_value), reinterpret_cast<void*>((*found)->base));
Elliott Hughescade4c32012-12-20 14:42:14 -0800829 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800830
Elliott Hughescade4c32012-12-20 14:42:14 -0800831 return s;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800832}
833
Ryan Prichard272458e2020-01-23 16:07:27 -0800834// This is used by dlsym(3). It performs symbol lookup only within the
835// specified soinfo object and its dependencies in breadth first order.
836static const ElfW(Sym)* dlsym_handle_lookup(soinfo* si,
837 soinfo** found,
838 const char* name,
839 const version_info* vi) {
840 // According to man dlopen(3) and posix docs in the case when si is handle
841 // of the main executable we need to search not only in the executable and its
842 // dependencies but also in all libraries loaded with RTLD_GLOBAL.
843 //
844 // Since RTLD_GLOBAL is always set for the main executable and all dt_needed shared
845 // libraries and they are loaded in breath-first (correct) order we can just execute
846 // dlsym(RTLD_DEFAULT, ...); instead of doing two stage lookup.
847 if (si == solist_get_somain()) {
848 return dlsym_linear_lookup(&g_default_namespace, name, vi, found, nullptr, RTLD_DEFAULT);
849 }
850
851 SymbolName symbol_name(name);
852 // note that the namespace is not the namespace associated with caller_addr
853 // we use ns associated with root si intentionally here. Using caller_ns
854 // causes problems when user uses dlopen_ext to open a library in the separate
855 // namespace and then calls dlsym() on the handle.
856 return dlsym_handle_lookup_impl(si->get_primary_namespace(), si, nullptr, found, symbol_name, vi);
857}
858
Kito Chengfa8c05d2013-03-12 14:58:06 +0800859soinfo* find_containing_library(const void* p) {
Peter Collingbourne191ecdc2019-08-07 19:06:00 -0700860 // Addresses within a library may be tagged if they point to globals. Untag
861 // them so that the bounds check succeeds.
862 ElfW(Addr) address = reinterpret_cast<ElfW(Addr)>(untag_address(p));
Dimitry Ivanov3f660572016-09-09 10:00:39 -0700863 for (soinfo* si = solist_get_head(); si != nullptr; si = si->next) {
Peter Collingbourneb39cb3c2019-03-01 13:12:49 -0800864 if (address < si->base || address - si->base >= si->size) {
865 continue;
866 }
867 ElfW(Addr) vaddr = address - si->load_bias;
868 for (size_t i = 0; i != si->phnum; ++i) {
869 const ElfW(Phdr)* phdr = &si->phdr[i];
870 if (phdr->p_type != PT_LOAD) {
871 continue;
872 }
873 if (vaddr >= phdr->p_vaddr && vaddr < phdr->p_vaddr + phdr->p_memsz) {
874 return si;
875 }
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600876 }
Kito Chengfa8c05d2013-03-12 14:58:06 +0800877 }
Dmitriy Ivanov851135b2014-08-29 12:02:36 -0700878 return nullptr;
Matt Fischere2a8b1f2009-12-31 12:17:40 -0600879}
880
Dmitriy Ivanovb4827502015-09-28 16:38:31 -0700881class ZipArchiveCache {
882 public:
883 ZipArchiveCache() {}
884 ~ZipArchiveCache();
885
886 bool get_or_open(const char* zip_path, ZipArchiveHandle* handle);
887 private:
888 DISALLOW_COPY_AND_ASSIGN(ZipArchiveCache);
889
890 std::unordered_map<std::string, ZipArchiveHandle> cache_;
891};
892
893bool ZipArchiveCache::get_or_open(const char* zip_path, ZipArchiveHandle* handle) {
894 std::string key(zip_path);
895
896 auto it = cache_.find(key);
897 if (it != cache_.end()) {
898 *handle = it->second;
899 return true;
900 }
901
902 int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC));
903 if (fd == -1) {
904 return false;
905 }
906
907 if (OpenArchiveFd(fd, "", handle) != 0) {
908 // invalid zip-file (?)
Ryan Prichard0adf09b2018-10-01 18:35:46 -0700909 CloseArchive(*handle);
Dmitriy Ivanovb4827502015-09-28 16:38:31 -0700910 return false;
911 }
912
913 cache_[key] = *handle;
914 return true;
915}
916
917ZipArchiveCache::~ZipArchiveCache() {
Dmitriy Ivanov5dce8942015-10-13 12:14:16 -0700918 for (const auto& it : cache_) {
Dmitriy Ivanovb4827502015-09-28 16:38:31 -0700919 CloseArchive(it.second);
920 }
921}
922
923static int open_library_in_zipfile(ZipArchiveCache* zip_archive_cache,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700924 const char* const input_path,
925 off64_t* file_offset, std::string* realpath) {
926 std::string normalized_path;
927 if (!normalize_path(input_path, &normalized_path)) {
928 return -1;
929 }
930
931 const char* const path = normalized_path.c_str();
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400932 LD_DEBUG(any, "Trying zip file open from path \"%s\" -> normalized \"%s\"", input_path, path);
Simon Baldwinaef71952015-01-16 13:22:54 +0000933
Dmitriy Ivanov402a7502015-06-09 13:46:51 -0700934 // Treat an '!/' separator inside a path as the separator between the name
Simon Baldwinaef71952015-01-16 13:22:54 +0000935 // of the zip file on disk and the subdirectory to search within it.
Dmitriy Ivanov402a7502015-06-09 13:46:51 -0700936 // For example, if path is "foo.zip!/bar/bas/x.so", then we search for
Simon Baldwinaef71952015-01-16 13:22:54 +0000937 // "bar/bas/x.so" within "foo.zip".
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700938 const char* const separator = strstr(path, kZipFileSeparator);
Simon Baldwinaef71952015-01-16 13:22:54 +0000939 if (separator == nullptr) {
940 return -1;
Elliott Hughes124fae92012-10-31 14:20:03 -0700941 }
Simon Baldwinaef71952015-01-16 13:22:54 +0000942
943 char buf[512];
944 if (strlcpy(buf, path, sizeof(buf)) >= sizeof(buf)) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400945 DL_WARN("ignoring very long library path: %s", path);
Simon Baldwinaef71952015-01-16 13:22:54 +0000946 return -1;
947 }
948
949 buf[separator - path] = '\0';
950
951 const char* zip_path = buf;
Dmitriy Ivanov402a7502015-06-09 13:46:51 -0700952 const char* file_path = &buf[separator - path + 2];
Simon Baldwinaef71952015-01-16 13:22:54 +0000953 int fd = TEMP_FAILURE_RETRY(open(zip_path, O_RDONLY | O_CLOEXEC));
954 if (fd == -1) {
955 return -1;
956 }
957
958 ZipArchiveHandle handle;
Dmitriy Ivanovb4827502015-09-28 16:38:31 -0700959 if (!zip_archive_cache->get_or_open(zip_path, &handle)) {
Simon Baldwinaef71952015-01-16 13:22:54 +0000960 // invalid zip-file (?)
961 close(fd);
962 return -1;
963 }
964
Simon Baldwinaef71952015-01-16 13:22:54 +0000965 ZipEntry entry;
966
Elliott Hughesb51bb502019-05-03 22:45:41 -0700967 if (FindEntry(handle, file_path, &entry) != 0) {
Simon Baldwinaef71952015-01-16 13:22:54 +0000968 // Entry was not found.
969 close(fd);
970 return -1;
971 }
972
973 // Check if it is properly stored
Peter Collingbournebb11ee62022-05-02 12:26:16 -0700974 if (entry.method != kCompressStored || (entry.offset % page_size()) != 0) {
Simon Baldwinaef71952015-01-16 13:22:54 +0000975 close(fd);
976 return -1;
977 }
978
979 *file_offset = entry.offset;
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700980
981 if (realpath_fd(fd, realpath)) {
982 *realpath += separator;
983 } else {
Tom Cherry66bc4282018-11-08 13:40:52 -0800984 if (!is_first_stage_init()) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400985 DL_WARN("unable to get realpath for the library \"%s\". Will use given path.",
986 normalized_path.c_str());
Tom Cherry66bc4282018-11-08 13:40:52 -0800987 }
Dmitriy Ivanova1feb112015-10-01 18:41:57 -0700988 *realpath = normalized_path;
989 }
990
Simon Baldwinaef71952015-01-16 13:22:54 +0000991 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -0800992}
993
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700994static bool format_path(char* buf, size_t buf_size, const char* path, const char* name) {
Christopher Ferris7a3681e2017-04-24 17:48:32 -0700995 int n = async_safe_format_buffer(buf, buf_size, "%s/%s", path, name);
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700996 if (n < 0 || n >= static_cast<int>(buf_size)) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -0400997 DL_WARN("ignoring very long library path: %s/%s", path, name);
Dmitriy Ivanovd165f562015-03-23 18:43:02 -0700998 return false;
999 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001000
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001001 return true;
1002}
1003
Ryan Prichard8f639a42018-10-01 23:10:05 -07001004static int open_library_at_path(ZipArchiveCache* zip_archive_cache,
1005 const char* path, off64_t* file_offset,
1006 std::string* realpath) {
1007 int fd = -1;
1008 if (strstr(path, kZipFileSeparator) != nullptr) {
1009 fd = open_library_in_zipfile(zip_archive_cache, path, file_offset, realpath);
1010 }
1011
1012 if (fd == -1) {
1013 fd = TEMP_FAILURE_RETRY(open(path, O_RDONLY | O_CLOEXEC));
1014 if (fd != -1) {
1015 *file_offset = 0;
1016 if (!realpath_fd(fd, realpath)) {
Tom Cherry66bc4282018-11-08 13:40:52 -08001017 if (!is_first_stage_init()) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001018 DL_WARN("unable to get realpath for the library \"%s\". Will use given path.", path);
Tom Cherry66bc4282018-11-08 13:40:52 -08001019 }
Ryan Prichard8f639a42018-10-01 23:10:05 -07001020 *realpath = path;
1021 }
1022 }
1023 }
1024
1025 return fd;
1026}
1027
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001028static int open_library_on_paths(ZipArchiveCache* zip_archive_cache,
1029 const char* name, off64_t* file_offset,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001030 const std::vector<std::string>& paths,
1031 std::string* realpath) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001032 for (const auto& path : paths) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001033 char buf[512];
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001034 if (!format_path(buf, sizeof(buf), path.c_str(), name)) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001035 continue;
1036 }
1037
Ryan Prichard8f639a42018-10-01 23:10:05 -07001038 int fd = open_library_at_path(zip_archive_cache, buf, file_offset, realpath);
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001039 if (fd != -1) {
1040 return fd;
1041 }
Simon Baldwinaef71952015-01-16 13:22:54 +00001042 }
1043
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001044 return -1;
Simon Baldwinaef71952015-01-16 13:22:54 +00001045}
1046
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001047static int open_library(android_namespace_t* ns,
1048 ZipArchiveCache* zip_archive_cache,
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001049 const char* name, soinfo *needed_by,
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001050 off64_t* file_offset, std::string* realpath) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001051 LD_DEBUG(any, "[ opening %s from namespace %s ]", name, ns->get_name());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001052
Elliott Hughes124fae92012-10-31 14:20:03 -07001053 // 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 -07001054 if (strchr(name, '/') != nullptr) {
Ryan Prichardaa2db962020-03-24 20:25:53 -07001055 return open_library_at_path(zip_archive_cache, name, file_offset, realpath);
Elliott Hughes124fae92012-10-31 14:20:03 -07001056 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001057
Ryan Prichardaa2db962020-03-24 20:25:53 -07001058 // LD_LIBRARY_PATH has the highest priority. We don't have to check accessibility when searching
1059 // the namespace's path lists, because anything found on a namespace path list should always be
1060 // accessible.
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001061 int fd = open_library_on_paths(zip_archive_cache, name, file_offset, ns->get_ld_library_paths(), realpath);
Ryan Prichardaa2db962020-03-24 20:25:53 -07001062
1063 // Try the DT_RUNPATH, and verify that the library is accessible.
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001064 if (fd == -1 && needed_by != nullptr) {
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001065 fd = open_library_on_paths(zip_archive_cache, name, file_offset, needed_by->get_dt_runpath(), realpath);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001066 if (fd != -1 && !ns->is_accessible(*realpath)) {
Vic Yang48b69112018-10-24 14:14:26 -07001067 close(fd);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001068 fd = -1;
1069 }
Evgenii Stepanov68650822015-06-10 13:38:39 -07001070 }
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001071
Ryan Prichardaa2db962020-03-24 20:25:53 -07001072 // Finally search the namespace's main search path list.
Elliott Hughes124fae92012-10-31 14:20:03 -07001073 if (fd == -1) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001074 fd = open_library_on_paths(zip_archive_cache, name, file_offset, ns->get_default_library_paths(), realpath);
Elliott Hughes124fae92012-10-31 14:20:03 -07001075 }
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001076
Elliott Hughes124fae92012-10-31 14:20:03 -07001077 return fd;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001078}
1079
Ryan Prichard8f639a42018-10-01 23:10:05 -07001080int open_executable(const char* path, off64_t* file_offset, std::string* realpath) {
1081 ZipArchiveCache zip_archive_cache;
1082 return open_library_at_path(&zip_archive_cache, path, file_offset, realpath);
1083}
1084
Dimitry Ivanov3f660572016-09-09 10:00:39 -07001085const char* fix_dt_needed(const char* dt_needed, const char* sopath __unused) {
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001086#if !defined(__LP64__)
Elliott Hughesc14f5452025-01-30 13:33:04 -08001087 if (get_application_target_sdk_version() < 23) {
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001088 const char* bname = basename(dt_needed);
1089 if (bname != dt_needed) {
Elliott Hughesc14f5452025-01-30 13:33:04 -08001090 // Work around incorrect DT_NEEDED entries for old apps: http://b/21364029
1091 if (!DL_ERROR_AFTER(23, "library \"%s\" has invalid DT_NEEDED entry \"%s\"",
1092 sopath, dt_needed)) {
1093 add_dlwarning(sopath, "invalid DT_NEEDED entry", dt_needed);
1094 return bname;
1095 }
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001096 }
Dmitriy Ivanovd974e882015-05-27 18:29:41 -07001097 }
1098#endif
1099 return dt_needed;
1100}
1101
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001102template<typename F>
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001103static void for_each_dt_needed(const ElfReader& elf_reader, F action) {
1104 for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
1105 if (d->d_tag == DT_NEEDED) {
1106 action(fix_dt_needed(elf_reader.get_string(d->d_un.d_val), elf_reader.name()));
1107 }
1108 }
1109}
1110
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001111static bool find_loaded_library_by_inode(android_namespace_t* ns,
1112 const struct stat& file_stat,
1113 off64_t file_offset,
1114 bool search_linked_namespaces,
1115 soinfo** candidate) {
Vic Yang3ec16be2019-06-02 21:10:53 -07001116 if (file_stat.st_dev == 0 || file_stat.st_ino == 0) {
1117 *candidate = nullptr;
1118 return false;
1119 }
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001120
1121 auto predicate = [&](soinfo* si) {
Vic Yang3ec16be2019-06-02 21:10:53 -07001122 return si->get_st_ino() == file_stat.st_ino &&
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001123 si->get_st_dev() == file_stat.st_dev &&
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001124 si->get_file_offset() == file_offset;
1125 };
1126
1127 *candidate = ns->soinfo_list().find_if(predicate);
1128
1129 if (*candidate == nullptr && search_linked_namespaces) {
1130 for (auto& link : ns->linked_namespaces()) {
1131 android_namespace_t* linked_ns = link.linked_namespace();
1132 soinfo* si = linked_ns->soinfo_list().find_if(predicate);
1133
1134 if (si != nullptr && link.is_accessible(si->get_soname())) {
1135 *candidate = si;
1136 return true;
1137 }
1138 }
1139 }
1140
1141 return *candidate != nullptr;
1142}
1143
Evgenii Stepanov9e77a642017-07-27 14:55:44 -07001144static bool find_loaded_library_by_realpath(android_namespace_t* ns, const char* realpath,
1145 bool search_linked_namespaces, soinfo** candidate) {
1146 auto predicate = [&](soinfo* si) { return strcmp(realpath, si->get_realpath()) == 0; };
1147
1148 *candidate = ns->soinfo_list().find_if(predicate);
1149
1150 if (*candidate == nullptr && search_linked_namespaces) {
1151 for (auto& link : ns->linked_namespaces()) {
1152 android_namespace_t* linked_ns = link.linked_namespace();
1153 soinfo* si = linked_ns->soinfo_list().find_if(predicate);
1154
1155 if (si != nullptr && link.is_accessible(si->get_soname())) {
1156 *candidate = si;
1157 return true;
1158 }
1159 }
1160 }
1161
1162 return *candidate != nullptr;
1163}
1164
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001165static bool load_library(android_namespace_t* ns,
1166 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001167 LoadTaskList* load_tasks,
1168 int rtld_flags,
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001169 const std::string& realpath,
1170 bool search_linked_namespaces) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001171 off64_t file_offset = task->get_file_offset();
1172 const char* name = task->get_name();
1173 const android_dlextinfo* extinfo = task->get_extinfo();
1174
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001175 LD_LOG(kLogDlopen,
1176 "load_library(ns=%s, task=%s, flags=0x%x, realpath=%s, search_linked_namespaces=%d)",
1177 ns->get_name(), name, rtld_flags, realpath.c_str(), search_linked_namespaces);
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001178
Peter Collingbournebb11ee62022-05-02 12:26:16 -07001179 if ((file_offset % page_size()) != 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001180 DL_OPEN_ERR("file offset for the library \"%s\" is not page-aligned: %" PRId64, name, file_offset);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001181 return false;
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001182 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001183 if (file_offset < 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001184 DL_OPEN_ERR("file offset for the library \"%s\" is negative: %" PRId64, name, file_offset);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001185 return false;
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001186 }
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07001187
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001188 struct stat file_stat;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001189 if (TEMP_FAILURE_RETRY(fstat(task->get_fd(), &file_stat)) != 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00001190 DL_OPEN_ERR("unable to stat file for the library \"%s\": %m", name);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001191 return false;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001192 }
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001193 if (file_offset >= file_stat.st_size) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001194 DL_OPEN_ERR("file offset for the library \"%s\" >= file size: %" PRId64 " >= %" PRId64,
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07001195 name, file_offset, file_stat.st_size);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001196 return false;
Yabin Cui16f7f8d2014-11-04 11:08:05 -08001197 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001198
1199 // Check for symlink and other situations where
Dmitriy Ivanov9b821362015-04-02 16:03:56 -07001200 // file can have different names, unless ANDROID_DLEXT_FORCE_LOAD is set
1201 if (extinfo == nullptr || (extinfo->flags & ANDROID_DLEXT_FORCE_LOAD) == 0) {
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001202 soinfo* si = nullptr;
1203 if (find_loaded_library_by_inode(ns, file_stat, file_offset, search_linked_namespaces, &si)) {
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001204 LD_LOG(kLogDlopen,
1205 "load_library(ns=%s, task=%s): Already loaded under different name/path \"%s\" - "
1206 "will return existing soinfo",
1207 ns->get_name(), name, si->get_realpath());
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001208 task->set_soinfo(si);
1209 return true;
1210 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001211 }
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001212
Dmitriy Ivanove8ba50f2014-09-15 17:00:10 -07001213 if ((rtld_flags & RTLD_NOLOAD) != 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001214 DL_OPEN_ERR("library \"%s\" wasn't loaded and RTLD_NOLOAD prevented it", name);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001215 return false;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001216 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001217
Dimitry Ivanovbf34ba32017-04-21 13:12:05 -07001218 struct statfs fs_stat;
1219 if (TEMP_FAILURE_RETRY(fstatfs(task->get_fd(), &fs_stat)) != 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00001220 DL_OPEN_ERR("unable to fstatfs file for the library \"%s\": %m", name);
Dimitry Ivanovbf34ba32017-04-21 13:12:05 -07001221 return false;
1222 }
1223
1224 // do not check accessibility using realpath if fd is located on tmpfs
1225 // this enables use of memfd_create() for apps
1226 if ((fs_stat.f_type != TMPFS_MAGIC) && (!ns->is_accessible(realpath))) {
Ryan Prichardaff9a342020-08-03 15:29:12 -07001227 // TODO(dimitry): workaround for http://b/26394120 - the exempt-list
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001228
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001229 const soinfo* needed_by = task->is_dt_needed() ? task->get_needed_by() : nullptr;
Ryan Prichardaff9a342020-08-03 15:29:12 -07001230 if (is_exempt_lib(ns, name, needed_by)) {
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001231 // print warning only if needed by non-system library
1232 if (needed_by == nullptr || !is_system_library(needed_by->get_realpath())) {
1233 const soinfo* needed_or_dlopened_by = task->get_needed_by();
1234 const char* sopath = needed_or_dlopened_by == nullptr ? "(unknown)" :
1235 needed_or_dlopened_by->get_realpath();
Elliott Hughesc14f5452025-01-30 13:33:04 -08001236 // is_exempt_lib() always returns true for api levels < 24,
1237 // so no need to check the return value of DL_ERROR_AFTER().
1238 // We still call it rather than DL_WARN() to get the extra clarification.
1239 DL_ERROR_AFTER(24, "library \"%s\" (\"%s\") needed or dlopened by \"%s\" "
1240 "is not accessible by namespace \"%s\"",
1241 name, realpath.c_str(), sopath, ns->get_name());
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001242 add_dlwarning(sopath, "unauthorized access to", name);
1243 }
1244 } else {
1245 // do not load libraries if they are not accessible for the specified namespace.
1246 const char* needed_or_dlopened_by = task->get_needed_by() == nullptr ?
1247 "(unknown)" :
1248 task->get_needed_by()->get_realpath();
Dimitry Ivanovd17a3772016-03-01 13:11:28 -08001249
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001250 DL_OPEN_ERR("library \"%s\" needed or dlopened by \"%s\" is not accessible for the namespace \"%s\"",
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001251 name, needed_or_dlopened_by, ns->get_name());
Dimitry Ivanovd17a3772016-03-01 13:11:28 -08001252
Dimitry Ivanov35c8e3b2017-02-27 12:17:47 -08001253 // do not print this if a library is in the list of shared libraries for linked namespaces
1254 if (!maybe_accessible_via_namespace_links(ns, name)) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001255 DL_WARN("library \"%s\" (\"%s\") needed or dlopened by \"%s\" is not accessible for the"
1256 " namespace: [name=\"%s\", ld_library_paths=\"%s\", default_library_paths=\"%s\","
1257 " permitted_paths=\"%s\"]",
1258 name, realpath.c_str(),
1259 needed_or_dlopened_by,
1260 ns->get_name(),
1261 android::base::Join(ns->get_ld_library_paths(), ':').c_str(),
1262 android::base::Join(ns->get_default_library_paths(), ':').c_str(),
1263 android::base::Join(ns->get_permitted_paths(), ':').c_str());
Dimitry Ivanov35c8e3b2017-02-27 12:17:47 -08001264 }
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001265 return false;
1266 }
Dimitry Ivanov22840aa2015-12-04 18:28:49 -08001267 }
1268
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001269 soinfo* si = soinfo_alloc(ns, realpath.c_str(), &file_stat, file_offset, rtld_flags);
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001270
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001271 task->set_soinfo(si);
1272
1273 // Read the ELF header and some of the segments.
1274 if (!task->read(realpath.c_str(), file_stat.st_size)) {
Ryan Prichard4fa6d992020-03-26 21:31:43 -07001275 task->remove_cached_elf_reader();
Dmitriy Ivanovfd7a91e2015-11-06 10:44:37 -08001276 task->set_soinfo(nullptr);
Ryan Prichard4fa6d992020-03-26 21:31:43 -07001277 soinfo_free(si);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001278 return false;
1279 }
1280
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001281 // Find and set DT_RUNPATH, DT_SONAME, and DT_FLAGS_1.
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001282 // Note that these field values are temporary and are
1283 // going to be overwritten on soinfo::prelink_image
1284 // with values from PT_LOAD segments.
1285 const ElfReader& elf_reader = task->get_elf_reader();
1286 for (const ElfW(Dyn)* d = elf_reader.dynamic(); d->d_tag != DT_NULL; ++d) {
1287 if (d->d_tag == DT_RUNPATH) {
1288 si->set_dt_runpath(elf_reader.get_string(d->d_un.d_val));
1289 }
1290 if (d->d_tag == DT_SONAME) {
1291 si->set_soname(elf_reader.get_string(d->d_un.d_val));
1292 }
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001293 // We need to identify a DF_1_GLOBAL library early so we can link it to namespaces.
1294 if (d->d_tag == DT_FLAGS_1) {
1295 si->set_dt_flags_1(d->d_un.d_val);
1296 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001297 }
1298
Dan Willemsen5038ef62018-10-21 17:45:04 -07001299#if !defined(__ANDROID__)
1300 // Bionic on the host currently uses some Android prebuilts, which don't set
1301 // DT_RUNPATH with any relative paths, so they can't find their dependencies.
1302 // b/118058804
1303 if (si->get_dt_runpath().empty()) {
1304 si->set_dt_runpath("$ORIGIN/../lib64:$ORIGIN/lib64");
1305 }
1306#endif
1307
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001308 for_each_dt_needed(task->get_elf_reader(), [&](const char* name) {
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001309 LD_LOG(kLogDlopen, "load_library(ns=%s, task=%s): Adding DT_NEEDED task: %s",
1310 ns->get_name(), task->get_name(), name);
Jiyong Park02586a22017-05-20 01:01:24 +09001311 load_tasks->push_back(LoadTask::create(name, si, ns, task->get_readers_map()));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001312 });
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07001313
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001314 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001315}
1316
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001317static bool load_library(android_namespace_t* ns,
1318 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001319 ZipArchiveCache* zip_archive_cache,
1320 LoadTaskList* load_tasks,
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001321 int rtld_flags,
1322 bool search_linked_namespaces) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001323 const char* name = task->get_name();
1324 soinfo* needed_by = task->get_needed_by();
1325 const android_dlextinfo* extinfo = task->get_extinfo();
1326
Spencer Low0346ad72015-04-22 18:06:51 -07001327 if (extinfo != nullptr && (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) != 0) {
Ryan Prichardaa2db962020-03-24 20:25:53 -07001328 off64_t file_offset = 0;
Spencer Low0346ad72015-04-22 18:06:51 -07001329 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
1330 file_offset = extinfo->library_fd_offset;
1331 }
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001332
Ryan Prichardaa2db962020-03-24 20:25:53 -07001333 std::string realpath;
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001334 if (!realpath_fd(extinfo->library_fd, &realpath)) {
Tom Cherry66bc4282018-11-08 13:40:52 -08001335 if (!is_first_stage_init()) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001336 DL_WARN("unable to get realpath for the library \"%s\" by extinfo->library_fd. "
1337 "Will use given name.",
1338 name);
Tom Cherry66bc4282018-11-08 13:40:52 -08001339 }
Dmitriy Ivanova1feb112015-10-01 18:41:57 -07001340 realpath = name;
1341 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001342
1343 task->set_fd(extinfo->library_fd, false);
1344 task->set_file_offset(file_offset);
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001345 return load_library(ns, task, load_tasks, rtld_flags, realpath, search_linked_namespaces);
Spencer Low0346ad72015-04-22 18:06:51 -07001346 }
1347
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001348 LD_LOG(kLogDlopen,
1349 "load_library(ns=%s, task=%s, flags=0x%x, search_linked_namespaces=%d): calling "
Ryan Prichardaa2db962020-03-24 20:25:53 -07001350 "open_library",
1351 ns->get_name(), name, rtld_flags, search_linked_namespaces);
Martin Stjernholm9fe38262019-08-27 17:08:45 +01001352
Spencer Low0346ad72015-04-22 18:06:51 -07001353 // Open the file.
Ryan Prichardaa2db962020-03-24 20:25:53 -07001354 off64_t file_offset;
1355 std::string realpath;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001356 int fd = open_library(ns, zip_archive_cache, name, needed_by, &file_offset, &realpath);
Spencer Low0346ad72015-04-22 18:06:51 -07001357 if (fd == -1) {
Josh Gao16269572019-10-29 13:41:00 -07001358 if (task->is_dt_needed()) {
1359 if (needed_by->is_main_executable()) {
1360 DL_OPEN_ERR("library \"%s\" not found: needed by main executable", name);
1361 } else {
1362 DL_OPEN_ERR("library \"%s\" not found: needed by %s in namespace %s", name,
1363 needed_by->get_realpath(), task->get_start_from()->get_name());
1364 }
1365 } else {
1366 DL_OPEN_ERR("library \"%s\" not found", name);
1367 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001368 return false;
Spencer Low0346ad72015-04-22 18:06:51 -07001369 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001370
1371 task->set_fd(fd, true);
1372 task->set_file_offset(file_offset);
1373
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001374 return load_library(ns, task, load_tasks, rtld_flags, realpath, search_linked_namespaces);
Spencer Low0346ad72015-04-22 18:06:51 -07001375}
1376
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001377static bool find_loaded_library_by_soname(android_namespace_t* ns,
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001378 const char* name,
1379 soinfo** candidate) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001380 return !ns->soinfo_list().visit([&](soinfo* si) {
Elliott Hughesf9dd1a72021-01-11 09:04:58 -08001381 if (strcmp(name, si->get_soname()) == 0) {
Dimitry Ivanov3bd90612017-02-01 08:54:43 -08001382 *candidate = si;
1383 return false;
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001384 }
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001385
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001386 return true;
1387 });
Ard Biesheuvel12c78bb2012-08-14 12:30:09 +02001388}
1389
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001390// Returns true if library was found and false otherwise
1391static bool find_loaded_library_by_soname(android_namespace_t* ns,
1392 const char* name,
1393 bool search_linked_namespaces,
1394 soinfo** candidate) {
1395 *candidate = nullptr;
1396
1397 // Ignore filename with path.
1398 if (strchr(name, '/') != nullptr) {
1399 return false;
1400 }
1401
1402 bool found = find_loaded_library_by_soname(ns, name, candidate);
1403
1404 if (!found && search_linked_namespaces) {
1405 // if a library was not found - look into linked namespaces
1406 for (auto& link : ns->linked_namespaces()) {
1407 if (!link.is_accessible(name)) {
1408 continue;
1409 }
1410
1411 android_namespace_t* linked_ns = link.linked_namespace();
1412
1413 if (find_loaded_library_by_soname(linked_ns, name, candidate)) {
1414 return true;
1415 }
1416 }
1417 }
1418
1419 return found;
1420}
1421
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001422static bool find_library_in_linked_namespace(const android_namespace_link_t& namespace_link,
Jiyong Park02586a22017-05-20 01:01:24 +09001423 LoadTask* task) {
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001424 android_namespace_t* ns = namespace_link.linked_namespace();
1425
1426 soinfo* candidate;
1427 bool loaded = false;
1428
1429 std::string soname;
Dimitry Ivanovd3e7d082017-03-27 14:11:02 -07001430 if (find_loaded_library_by_soname(ns, task->get_name(), false, &candidate)) {
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001431 loaded = true;
1432 soname = candidate->get_soname();
1433 } else {
1434 soname = resolve_soname(task->get_name());
1435 }
1436
1437 if (!namespace_link.is_accessible(soname.c_str())) {
1438 // the library is not accessible via namespace_link
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001439 LD_LOG(kLogDlopen,
1440 "find_library_in_linked_namespace(ns=%s, task=%s): Not accessible (soname=%s)",
1441 ns->get_name(), task->get_name(), soname.c_str());
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001442 return false;
1443 }
1444
1445 // if library is already loaded - return it
1446 if (loaded) {
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001447 LD_LOG(kLogDlopen, "find_library_in_linked_namespace(ns=%s, task=%s): Already loaded",
1448 ns->get_name(), task->get_name());
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001449 task->set_soinfo(candidate);
1450 return true;
1451 }
1452
Jiyong Park02586a22017-05-20 01:01:24 +09001453 // returning true with empty soinfo means that the library is okay to be
Logan Chien9ee45912018-01-18 12:05:09 +08001454 // loaded in the namespace but has not yet been loaded there before.
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001455 LD_LOG(kLogDlopen, "find_library_in_linked_namespace(ns=%s, task=%s): Ok to load", ns->get_name(),
1456 task->get_name());
Jiyong Park02586a22017-05-20 01:01:24 +09001457 task->set_soinfo(nullptr);
1458 return true;
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001459}
1460
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001461static bool find_library_internal(android_namespace_t* ns,
1462 LoadTask* task,
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001463 ZipArchiveCache* zip_archive_cache,
1464 LoadTaskList* load_tasks,
Ryan Prichard323d7df2020-03-24 21:19:06 -07001465 int rtld_flags) {
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001466 soinfo* candidate;
1467
Ryan Prichard323d7df2020-03-24 21:19:06 -07001468 if (find_loaded_library_by_soname(ns, task->get_name(), true /* search_linked_namespaces */,
1469 &candidate)) {
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001470 LD_LOG(kLogDlopen,
1471 "find_library_internal(ns=%s, task=%s): Already loaded (by soname): %s",
1472 ns->get_name(), task->get_name(), candidate->get_realpath());
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001473 task->set_soinfo(candidate);
1474 return true;
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001475 }
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07001476
1477 // Library might still be loaded, the accurate detection
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001478 // of this fact is done by load_library.
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001479 LD_DEBUG(any, "[ \"%s\" find_loaded_library_by_soname failed (*candidate=%s@%p). Trying harder... ]",
1480 task->get_name(), candidate == nullptr ? "n/a" : candidate->get_realpath(), candidate);
Dmitriy Ivanova9703332015-06-16 15:38:21 -07001481
Ryan Prichard323d7df2020-03-24 21:19:06 -07001482 if (load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags,
1483 true /* search_linked_namespaces */)) {
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001484 return true;
1485 }
1486
Ryan Prichardaff9a342020-08-03 15:29:12 -07001487 // TODO(dimitry): workaround for http://b/26394120 (the exempt-list)
1488 if (ns->is_exempt_list_enabled() && is_exempt_lib(ns, task->get_name(), task->get_needed_by())) {
1489 // For the libs in the exempt-list, switch to the default namespace and then
Jiyong Parkefc503d2019-02-12 01:08:57 +09001490 // try the load again from there. The library could be loaded from the
1491 // default namespace or from another namespace (e.g. runtime) that is linked
1492 // from the default namespace.
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001493 LD_LOG(kLogDlopen,
Ryan Prichardaff9a342020-08-03 15:29:12 -07001494 "find_library_internal(ns=%s, task=%s): Exempt system library - trying namespace %s",
Martin Stjernholm95252ee2019-02-22 22:48:59 +00001495 ns->get_name(), task->get_name(), g_default_namespace.get_name());
Jiyong Parkefc503d2019-02-12 01:08:57 +09001496 ns = &g_default_namespace;
1497 if (load_library(ns, task, zip_archive_cache, load_tasks, rtld_flags,
Ryan Prichard323d7df2020-03-24 21:19:06 -07001498 true /* search_linked_namespaces */)) {
Jiyong Parkefc503d2019-02-12 01:08:57 +09001499 return true;
1500 }
1501 }
1502 // END OF WORKAROUND
1503
Ryan Prichard323d7df2020-03-24 21:19:06 -07001504 // if a library was not found - look into linked namespaces
1505 // preserve current dlerror in the case it fails.
1506 DlErrorRestorer dlerror_restorer;
1507 LD_LOG(kLogDlopen, "find_library_internal(ns=%s, task=%s): Trying %zu linked namespaces",
1508 ns->get_name(), task->get_name(), ns->linked_namespaces().size());
1509 for (auto& linked_namespace : ns->linked_namespaces()) {
1510 if (find_library_in_linked_namespace(linked_namespace, task)) {
1511 // Library is already loaded.
1512 if (task->get_soinfo() != nullptr) {
1513 // n.b. This code path runs when find_library_in_linked_namespace found an already-loaded
Ryan Prichardaff9a342020-08-03 15:29:12 -07001514 // library by soname. That should only be possible with a exempt-list lookup, where we
1515 // switch the namespace, because otherwise, find_library_in_linked_namespace is duplicating
1516 // the soname scan done in this function's first call to find_loaded_library_by_soname.
Ryan Prichard323d7df2020-03-24 21:19:06 -07001517 return true;
1518 }
1519
1520 if (load_library(linked_namespace.linked_namespace(), task, zip_archive_cache, load_tasks,
1521 rtld_flags, false /* search_linked_namespaces */)) {
1522 LD_LOG(kLogDlopen, "find_library_internal(ns=%s, task=%s): Found in linked namespace %s",
1523 ns->get_name(), task->get_name(), linked_namespace.linked_namespace()->get_name());
1524 return true;
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001525 }
1526 }
1527 }
1528
1529 return false;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001530}
1531
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001532static void soinfo_unload(soinfo* si);
1533
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001534static void shuffle(std::vector<LoadTask*>* v) {
Tom Cherry66bc4282018-11-08 13:40:52 -08001535 if (is_first_stage_init()) {
1536 // arc4random* is not available in first stage init because /dev/random
1537 // hasn't yet been created.
Jiyong Park31cd08f2018-06-01 19:18:56 +09001538 return;
1539 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001540 for (size_t i = 0, size = v->size(); i < size; ++i) {
1541 size_t n = size - i;
1542 size_t r = arc4random_uniform(n);
1543 std::swap((*v)[n-1], (*v)[r]);
1544 }
1545}
1546
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07001547// add_as_children - add first-level loaded libraries (i.e. library_names[], but
1548// not their transitive dependencies) as children of the start_with library.
1549// This is false when find_libraries is called for dlopen(), when newly loaded
1550// libraries must form a disjoint tree.
Dimitry Ivanov3f660572016-09-09 10:00:39 -07001551bool find_libraries(android_namespace_t* ns,
1552 soinfo* start_with,
1553 const char* const library_names[],
1554 size_t library_names_count,
1555 soinfo* soinfos[],
1556 std::vector<soinfo*>* ld_preloads,
1557 size_t ld_preloads_count,
1558 int rtld_flags,
1559 const android_dlextinfo* extinfo,
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001560 bool add_as_children,
Jiyong Park02586a22017-05-20 01:01:24 +09001561 std::vector<android_namespace_t*>* namespaces) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001562 // Step 0: prepare.
dimitry965d06d2017-11-28 16:03:07 +01001563 std::unordered_map<const soinfo*, ElfReader> readers_map;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001564 LoadTaskList load_tasks;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001565
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001566 for (size_t i = 0; i < library_names_count; ++i) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001567 const char* name = library_names[i];
Jiyong Park02586a22017-05-20 01:01:24 +09001568 load_tasks.push_back(LoadTask::create(name, start_with, ns, &readers_map));
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001569 }
1570
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001571 // If soinfos array is null allocate one on stack.
1572 // The array is needed in case of failure; for example
1573 // when library_names[] = {libone.so, libtwo.so} and libone.so
1574 // is loaded correctly but libtwo.so failed for some reason.
1575 // In this case libone.so should be unloaded on return.
1576 // See also implementation of failure_guard below.
1577
1578 if (soinfos == nullptr) {
1579 size_t soinfos_size = sizeof(soinfo*)*library_names_count;
1580 soinfos = reinterpret_cast<soinfo**>(alloca(soinfos_size));
1581 memset(soinfos, 0, soinfos_size);
1582 }
1583
1584 // list of libraries to link - see step 2.
1585 size_t soinfos_count = 0;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001586
Tom Cherryb8ab6182017-04-05 16:20:29 -07001587 auto scope_guard = android::base::make_scope_guard([&]() {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001588 for (LoadTask* t : load_tasks) {
1589 LoadTask::deleter(t);
1590 }
1591 });
1592
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001593 ZipArchiveCache zip_archive_cache;
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001594 soinfo_list_t new_global_group_members;
Dmitriy Ivanovb4827502015-09-28 16:38:31 -07001595
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001596 // Step 1: expand the list of load_tasks to include
1597 // all DT_NEEDED libraries (do not load them just yet)
1598 for (size_t i = 0; i<load_tasks.size(); ++i) {
1599 LoadTask* task = load_tasks[i];
Evgenii Stepanov68650822015-06-10 13:38:39 -07001600 soinfo* needed_by = task->get_needed_by();
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001601
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07001602 bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001603 task->set_extinfo(is_dt_needed ? nullptr : extinfo);
Dimitry Ivanov769b33f2016-07-21 11:33:40 -07001604 task->set_dt_needed(is_dt_needed);
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07001605
Jiyong Park02586a22017-05-20 01:01:24 +09001606 // Note: start from the namespace that is stored in the LoadTask. This namespace
1607 // is different from the current namespace when the LoadTask is for a transitive
1608 // dependency and the lib that created the LoadTask is not found in the
Martin Stjernholm964b14c2022-09-30 20:39:14 +01001609 // current namespace but in one of the linked namespaces.
1610 android_namespace_t* start_ns = const_cast<android_namespace_t*>(task->get_start_from());
1611
1612 LD_LOG(kLogDlopen, "find_library_internal(ns=%s@%p): task=%s, is_dt_needed=%d",
1613 start_ns->get_name(), start_ns, task->get_name(), is_dt_needed);
1614
1615 if (!find_library_internal(start_ns, task, &zip_archive_cache, &load_tasks, rtld_flags)) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001616 return false;
1617 }
1618
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001619 soinfo* si = task->get_soinfo();
1620
Dmitriy Ivanovedfc9f62015-09-02 16:32:02 -07001621 if (is_dt_needed) {
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001622 needed_by->add_child(si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001623 }
1624
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001625 // When ld_preloads is not null, the first
1626 // ld_preloads_count libs are in fact ld_preloads.
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001627 bool is_ld_preload = false;
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001628 if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) {
Dmitriy Ivanovd165f562015-03-23 18:43:02 -07001629 ld_preloads->push_back(si);
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001630 is_ld_preload = true;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001631 }
1632
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001633 if (soinfos_count < library_names_count) {
1634 soinfos[soinfos_count++] = si;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001635 }
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001636
1637 // Add the new global group members to all initial namespaces. Do this secondary namespace setup
1638 // at the same time that libraries are added to their primary namespace so that the order of
1639 // global group members is the same in the every namespace. Only add a library to a namespace
1640 // once, even if it appears multiple times in the dependency graph.
1641 if (is_ld_preload || (si->get_dt_flags_1() & DF_1_GLOBAL) != 0) {
1642 if (!si->is_linked() && namespaces != nullptr && !new_global_group_members.contains(si)) {
1643 new_global_group_members.push_back(si);
1644 for (auto linked_ns : *namespaces) {
1645 if (si->get_primary_namespace() != linked_ns) {
1646 linked_ns->add_soinfo(si);
1647 si->add_secondary_namespace(linked_ns);
1648 }
1649 }
1650 }
1651 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001652 }
1653
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001654 // Step 2: Load libraries in random order (see b/24047022)
1655 LoadTaskList load_list;
1656 for (auto&& task : load_tasks) {
1657 soinfo* si = task->get_soinfo();
1658 auto pred = [&](const LoadTask* t) {
1659 return t->get_soinfo() == si;
1660 };
1661
1662 if (!si->is_linked() &&
1663 std::find_if(load_list.begin(), load_list.end(), pred) == load_list.end() ) {
1664 load_list.push_back(task);
1665 }
1666 }
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -04001667 bool reserved_address_recursive = false;
1668 if (extinfo) {
1669 reserved_address_recursive = extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS_RECURSIVE;
1670 }
1671 if (!reserved_address_recursive) {
1672 // Shuffle the load order in the normal case, but not if we are loading all
1673 // the libraries to a reserved address range.
1674 shuffle(&load_list);
1675 }
1676
1677 // Set up address space parameters.
1678 address_space_params extinfo_params, default_params;
1679 size_t relro_fd_offset = 0;
1680 if (extinfo) {
1681 if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS) {
1682 extinfo_params.start_addr = extinfo->reserved_addr;
1683 extinfo_params.reserved_size = extinfo->reserved_size;
1684 extinfo_params.must_use_address = true;
1685 } else if (extinfo->flags & ANDROID_DLEXT_RESERVED_ADDRESS_HINT) {
1686 extinfo_params.start_addr = extinfo->reserved_addr;
1687 extinfo_params.reserved_size = extinfo->reserved_size;
1688 }
1689 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001690
1691 for (auto&& task : load_list) {
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -04001692 address_space_params* address_space =
1693 (reserved_address_recursive || !task->is_dt_needed()) ? &extinfo_params : &default_params;
1694 if (!task->load(address_space)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001695 return false;
1696 }
1697 }
1698
Mitch Phillips28057b82024-08-21 19:43:08 +02001699 // The WebView loader uses RELRO sharing in order to promote page sharing of the large RELRO
1700 // segment, as it's full of C++ vtables. Because MTE globals, by default, applies random tags to
1701 // each global variable, the RELRO segment is polluted and unique for each process. In order to
1702 // allow sharing, but still provide some protection, we use deterministic global tagging schemes
1703 // for DSOs that are loaded through android_dlopen_ext, such as those loaded by WebView.
1704 bool dlext_use_relro =
1705 extinfo && extinfo->flags & (ANDROID_DLEXT_WRITE_RELRO | ANDROID_DLEXT_USE_RELRO);
1706
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001707 // Step 3: pre-link all DT_NEEDED libraries in breadth first order.
Florian Mayere65e1932024-02-15 22:20:54 +00001708 bool any_memtag_stack = false;
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001709 for (auto&& task : load_tasks) {
1710 soinfo* si = task->get_soinfo();
Mitch Phillips28057b82024-08-21 19:43:08 +02001711 if (!si->is_linked() && !si->prelink_image(dlext_use_relro)) {
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001712 return false;
1713 }
Florian Mayere65e1932024-02-15 22:20:54 +00001714 // si->memtag_stack() needs to be called after si->prelink_image() which populates
1715 // the dynamic section.
Florian Mayer3e56e562024-10-29 17:57:24 -07001716 if (si->memtag_stack()) {
Florian Mayere65e1932024-02-15 22:20:54 +00001717 any_memtag_stack = true;
1718 LD_LOG(kLogDlopen,
1719 "... load_library requesting stack MTE for: realpath=\"%s\", soname=\"%s\"",
1720 si->get_realpath(), si->get_soname());
1721 }
Ryan Pricharde5e69e02019-01-01 18:53:48 -08001722 register_soinfo_tls(si);
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001723 }
Florian Mayere65e1932024-02-15 22:20:54 +00001724 if (any_memtag_stack) {
1725 if (auto* cb = __libc_shared_globals()->memtag_stack_dlopen_callback) {
1726 cb();
1727 } else {
1728 // find_library is used by the initial linking step, so we communicate that we
1729 // want memtag_stack enabled to __libc_init_mte.
Florian Mayerc138f812024-10-29 15:26:13 -07001730 __libc_shared_globals()->initial_memtag_stack_abi = true;
Florian Mayere65e1932024-02-15 22:20:54 +00001731 }
1732 }
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001733
Ryan Prichard058eb8f2020-12-17 22:59:04 -08001734 // Step 4: Construct the global group. DF_1_GLOBAL bit is force set for LD_PRELOADed libs because
1735 // they must be added to the global group. Note: The DF_1_GLOBAL bit for a library is normally set
1736 // in step 3.
Dmitriy Ivanov4f7a7ad2015-10-15 12:07:25 -07001737 if (ld_preloads != nullptr) {
1738 for (auto&& si : *ld_preloads) {
1739 si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
1740 }
1741 }
1742
dimitry965d06d2017-11-28 16:03:07 +01001743 // Step 5: Collect roots of local_groups.
1744 // Whenever needed_by->si link crosses a namespace boundary it forms its own local_group.
1745 // Here we collect new roots to link them separately later on. Note that we need to avoid
1746 // collecting duplicates. Also the order is important. They need to be linked in the same
1747 // BFS order we link individual libraries.
1748 std::vector<soinfo*> local_group_roots;
1749 if (start_with != nullptr && add_as_children) {
1750 local_group_roots.push_back(start_with);
1751 } else {
1752 CHECK(soinfos_count == 1);
1753 local_group_roots.push_back(soinfos[0]);
1754 }
1755
Jiyong Park02586a22017-05-20 01:01:24 +09001756 for (auto&& task : load_tasks) {
1757 soinfo* si = task->get_soinfo();
dimitry965d06d2017-11-28 16:03:07 +01001758 soinfo* needed_by = task->get_needed_by();
1759 bool is_dt_needed = needed_by != nullptr && (needed_by != start_with || add_as_children);
1760 android_namespace_t* needed_by_ns =
1761 is_dt_needed ? needed_by->get_primary_namespace() : ns;
1762
1763 if (!si->is_linked() && si->get_primary_namespace() != needed_by_ns) {
1764 auto it = std::find(local_group_roots.begin(), local_group_roots.end(), si);
1765 LD_LOG(kLogDlopen,
1766 "Crossing namespace boundary (si=%s@%p, si_ns=%s@%p, needed_by=%s@%p, ns=%s@%p, needed_by_ns=%s@%p) adding to local_group_roots: %s",
1767 si->get_realpath(),
1768 si,
1769 si->get_primary_namespace()->get_name(),
1770 si->get_primary_namespace(),
1771 needed_by == nullptr ? "(nullptr)" : needed_by->get_realpath(),
1772 needed_by,
1773 ns->get_name(),
1774 ns,
1775 needed_by_ns->get_name(),
1776 needed_by_ns,
1777 it == local_group_roots.end() ? "yes" : "no");
1778
1779 if (it == local_group_roots.end()) {
1780 local_group_roots.push_back(si);
Jiyong Park02586a22017-05-20 01:01:24 +09001781 }
1782 }
1783 }
1784
dimitry965d06d2017-11-28 16:03:07 +01001785 // Step 6: Link all local groups
1786 for (auto root : local_group_roots) {
1787 soinfo_list_t local_group;
1788 android_namespace_t* local_group_ns = root->get_primary_namespace();
1789
1790 walk_dependencies_tree(root,
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001791 [&] (soinfo* si) {
dimitry965d06d2017-11-28 16:03:07 +01001792 if (local_group_ns->is_accessible(si)) {
1793 local_group.push_back(si);
1794 return kWalkContinue;
1795 } else {
1796 return kWalkSkip;
1797 }
1798 });
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001799
dimitry965d06d2017-11-28 16:03:07 +01001800 soinfo_list_t global_group = local_group_ns->get_global_group();
Ryan Prichard339ecef2020-01-02 16:36:06 -08001801 SymbolLookupList lookup_list(global_group, local_group);
1802 soinfo* local_group_root = local_group.front();
1803
dimitry965d06d2017-11-28 16:03:07 +01001804 bool linked = local_group.visit([&](soinfo* si) {
Torne (Richard Coles)5d103742019-04-11 12:25:06 -04001805 // Even though local group may contain accessible soinfos from other namespaces
dimitry965d06d2017-11-28 16:03:07 +01001806 // we should avoid linking them (because if they are not linked -> they
1807 // are in the local_group_roots and will be linked later).
1808 if (!si->is_linked() && si->get_primary_namespace() == local_group_ns) {
Torne (Richard Coles)5d103742019-04-11 12:25:06 -04001809 const android_dlextinfo* link_extinfo = nullptr;
1810 if (si == soinfos[0] || reserved_address_recursive) {
1811 // Only forward extinfo for the first library unless the recursive
1812 // flag is set.
1813 link_extinfo = extinfo;
1814 }
Peter Collingbourne191ecdc2019-08-07 19:06:00 -07001815 if (__libc_shared_globals()->load_hook) {
1816 __libc_shared_globals()->load_hook(si->load_bias, si->phdr, si->phnum);
1817 }
Ryan Prichard339ecef2020-01-02 16:36:06 -08001818 lookup_list.set_dt_symbolic_lib(si->has_DT_SYMBOLIC ? si : nullptr);
1819 if (!si->link_image(lookup_list, local_group_root, link_extinfo, &relro_fd_offset) ||
dimitry965d06d2017-11-28 16:03:07 +01001820 !get_cfi_shadow()->AfterLoad(si, solist_get_head())) {
1821 return false;
1822 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001823 }
Dmitriy Ivanovcfa97f12014-10-21 09:23:18 -07001824
dimitry965d06d2017-11-28 16:03:07 +01001825 return true;
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001826 });
Elliott Hughes27f18062017-11-29 18:47:42 +00001827
dimitry965d06d2017-11-28 16:03:07 +01001828 if (!linked) {
1829 return false;
1830 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001831 }
1832
dimitry965d06d2017-11-28 16:03:07 +01001833 // Step 7: Mark all load_tasks as linked and increment refcounts
1834 // for references between load_groups (at this point it does not matter if
1835 // referenced load_groups were loaded by previous dlopen or as part of this
1836 // one on step 6)
1837 if (start_with != nullptr && add_as_children) {
1838 start_with->set_linked();
1839 }
1840
1841 for (auto&& task : load_tasks) {
1842 soinfo* si = task->get_soinfo();
1843 si->set_linked();
1844 }
1845
1846 for (auto&& task : load_tasks) {
1847 soinfo* si = task->get_soinfo();
1848 soinfo* needed_by = task->get_needed_by();
1849 if (needed_by != nullptr &&
1850 needed_by != start_with &&
1851 needed_by->get_local_group_root() != si->get_local_group_root()) {
1852 si->increment_ref_count();
1853 }
1854 }
1855
1856
1857 return true;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001858}
1859
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07001860static soinfo* find_library(android_namespace_t* ns,
1861 const char* name, int rtld_flags,
Evgenii Stepanov0cdef7e2015-07-06 17:56:31 -07001862 const android_dlextinfo* extinfo,
1863 soinfo* needed_by) {
dimitry965d06d2017-11-28 16:03:07 +01001864 soinfo* si = nullptr;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001865
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001866 if (name == nullptr) {
Dimitry Ivanov3f660572016-09-09 10:00:39 -07001867 si = solist_get_somain();
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001868 } else if (!find_libraries(ns,
1869 needed_by,
1870 &name,
1871 1,
1872 &si,
1873 nullptr,
1874 0,
1875 rtld_flags,
1876 extinfo,
Ryan Prichard323d7df2020-03-24 21:19:06 -07001877 false /* add_as_children */)) {
dimitry965d06d2017-11-28 16:03:07 +01001878 if (si != nullptr) {
1879 soinfo_unload(si);
1880 }
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07001881 return nullptr;
1882 }
1883
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08001884 si->increment_ref_count();
1885
Elliott Hughesd23736e2012-11-01 15:16:56 -07001886 return si;
1887}
Elliott Hughesbedfe382012-08-14 14:07:59 -07001888
dimitry06016f22018-01-05 11:39:28 +01001889static void soinfo_unload_impl(soinfo* root) {
Dimitry Ivanov6705e8c2017-03-21 10:29:06 -07001890 ScopedTrace trace((std::string("unload ") + root->get_realpath()).c_str());
dimitry06016f22018-01-05 11:39:28 +01001891 bool is_linked = root->is_linked();
Dimitry Ivanov6705e8c2017-03-21 10:29:06 -07001892
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001893 if (!root->can_unload()) {
dimitryc92ce712017-10-27 14:12:53 +02001894 LD_LOG(kLogDlopen,
1895 "... dlclose(root=\"%s\"@%p) ... not unloading - the load group is flagged with NODELETE",
1896 root->get_realpath(),
1897 root);
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07001898 return;
1899 }
1900
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001901
Dimitry Ivanovb943f302016-08-03 16:00:10 -07001902 soinfo_list_t unload_list;
dimitry965d06d2017-11-28 16:03:07 +01001903 unload_list.push_back(root);
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001904
Dimitry Ivanovb943f302016-08-03 16:00:10 -07001905 soinfo_list_t local_unload_list;
1906 soinfo_list_t external_unload_list;
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001907 soinfo* si = nullptr;
1908
1909 while ((si = unload_list.pop_front()) != nullptr) {
1910 if (local_unload_list.contains(si)) {
1911 continue;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08001912 }
Elliott Hughesd23736e2012-11-01 15:16:56 -07001913
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001914 local_unload_list.push_back(si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001915
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001916 if (si->has_min_version(0)) {
1917 soinfo* child = nullptr;
1918 while ((child = si->get_children().pop_front()) != nullptr) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04001919 LD_DEBUG(any, "%s@%p needs to unload %s@%p", si->get_realpath(), si,
1920 child->get_realpath(), child);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001921
Dimitry Ivanovec90e242017-02-10 11:04:20 -08001922 child->get_parents().remove(si);
1923
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001924 if (local_unload_list.contains(child)) {
1925 continue;
1926 } else if (child->is_linked() && child->get_local_group_root() != root) {
1927 external_unload_list.push_back(child);
Dimitry Ivanovec90e242017-02-10 11:04:20 -08001928 } else if (child->get_parents().empty()) {
1929 unload_list.push_back(child);
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001930 }
1931 }
1932 } else {
Christopher Ferris7a3681e2017-04-24 17:48:32 -07001933 async_safe_fatal("soinfo for \"%s\"@%p has no version", si->get_realpath(), si);
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08001934 }
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001935 }
1936
1937 local_unload_list.for_each([](soinfo* si) {
dimitryc92ce712017-10-27 14:12:53 +02001938 LD_LOG(kLogDlopen,
1939 "... dlclose: calling destructors for \"%s\"@%p ... ",
1940 si->get_realpath(),
1941 si);
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001942 si->call_destructors();
dimitryc92ce712017-10-27 14:12:53 +02001943 LD_LOG(kLogDlopen,
1944 "... dlclose: calling destructors for \"%s\"@%p ... done",
1945 si->get_realpath(),
1946 si);
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001947 });
1948
1949 while ((si = local_unload_list.pop_front()) != nullptr) {
dimitryc92ce712017-10-27 14:12:53 +02001950 LD_LOG(kLogDlopen,
1951 "... dlclose: unloading \"%s\"@%p ...",
1952 si->get_realpath(),
1953 si);
Ryan Pricharda2e83ab2019-08-16 17:25:43 -07001954 ++g_module_unload_counter;
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001955 notify_gdb_of_unload(si);
Ryan Pricharde5e69e02019-01-01 18:53:48 -08001956 unregister_soinfo_tls(si);
Peter Collingbourne65332082019-08-05 16:16:14 -07001957 if (__libc_shared_globals()->unload_hook) {
1958 __libc_shared_globals()->unload_hook(si->load_bias, si->phdr, si->phnum);
1959 }
Evgenii Stepanov0a3637d2016-07-06 13:20:59 -07001960 get_cfi_shadow()->BeforeUnload(si);
Dimitry Ivanov83fcb542016-05-04 17:19:14 -07001961 soinfo_free(si);
1962 }
1963
dimitry965d06d2017-11-28 16:03:07 +01001964 if (is_linked) {
1965 while ((si = external_unload_list.pop_front()) != nullptr) {
1966 LD_LOG(kLogDlopen,
1967 "... dlclose: unloading external reference \"%s\"@%p ...",
1968 si->get_realpath(),
1969 si);
1970 soinfo_unload(si);
1971 }
1972 } else {
1973 LD_LOG(kLogDlopen,
1974 "... dlclose: unload_si was not linked - not unloading external references ...");
Dmitriy Ivanova2547052014-11-18 12:03:09 -08001975 }
1976}
1977
dimitry06016f22018-01-05 11:39:28 +01001978static void soinfo_unload(soinfo* unload_si) {
1979 // Note that the library can be loaded but not linked;
1980 // in which case there is no root but we still need
1981 // to walk the tree and unload soinfos involved.
1982 //
1983 // This happens on unsuccessful dlopen, when one of
1984 // the DT_NEEDED libraries could not be linked/found.
1985 bool is_linked = unload_si->is_linked();
1986 soinfo* root = is_linked ? unload_si->get_local_group_root() : unload_si;
1987
1988 LD_LOG(kLogDlopen,
1989 "... dlclose(realpath=\"%s\"@%p) ... load group root is \"%s\"@%p",
1990 unload_si->get_realpath(),
1991 unload_si,
1992 root->get_realpath(),
1993 root);
1994
1995
1996 size_t ref_count = is_linked ? root->decrement_ref_count() : 0;
1997 if (ref_count > 0) {
1998 LD_LOG(kLogDlopen,
1999 "... dlclose(root=\"%s\"@%p) ... not unloading - decrementing ref_count to %zd",
2000 root->get_realpath(),
2001 root,
2002 ref_count);
2003 return;
2004 }
2005
2006 soinfo_unload_impl(root);
2007}
2008
2009void increment_dso_handle_reference_counter(void* dso_handle) {
2010 if (dso_handle == nullptr) {
2011 return;
2012 }
2013
2014 auto it = g_dso_handle_counters.find(dso_handle);
2015 if (it != g_dso_handle_counters.end()) {
2016 CHECK(++it->second != 0);
2017 } else {
2018 soinfo* si = find_containing_library(dso_handle);
2019 if (si != nullptr) {
2020 ProtectedDataGuard guard;
dimitry55547db2018-05-25 14:17:37 +02002021 si->increment_ref_count();
dimitry06016f22018-01-05 11:39:28 +01002022 } else {
2023 async_safe_fatal(
2024 "increment_dso_handle_reference_counter: Couldn't find soinfo by dso_handle=%p",
2025 dso_handle);
2026 }
2027 g_dso_handle_counters[dso_handle] = 1U;
2028 }
2029}
2030
2031void decrement_dso_handle_reference_counter(void* dso_handle) {
2032 if (dso_handle == nullptr) {
2033 return;
2034 }
2035
2036 auto it = g_dso_handle_counters.find(dso_handle);
2037 CHECK(it != g_dso_handle_counters.end());
2038 CHECK(it->second != 0);
2039
2040 if (--it->second == 0) {
2041 soinfo* si = find_containing_library(dso_handle);
2042 if (si != nullptr) {
2043 ProtectedDataGuard guard;
dimitry55547db2018-05-25 14:17:37 +02002044 soinfo_unload(si);
dimitry06016f22018-01-05 11:39:28 +01002045 } else {
2046 async_safe_fatal(
2047 "decrement_dso_handle_reference_counter: Couldn't find soinfo by dso_handle=%p",
2048 dso_handle);
2049 }
2050 g_dso_handle_counters.erase(it);
2051 }
2052}
2053
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002054static std::string symbol_display_name(const char* sym_name, const char* sym_ver) {
2055 if (sym_ver == nullptr) {
2056 return sym_name;
2057 }
2058
Dimitry Ivanov9cf99cb2015-12-11 14:22:24 -08002059 return std::string(sym_name) + ", version " + sym_ver;
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002060}
2061
Dimitry Ivanovaca299a2016-04-11 12:42:58 -07002062static android_namespace_t* get_caller_namespace(soinfo* caller) {
2063 return caller != nullptr ? caller->get_primary_namespace() : g_anonymous_namespace;
2064}
2065
Elliott Hughesa4aafd12014-01-13 16:37:47 -08002066void do_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) {
Christopher Ferris052fa3a2014-08-26 20:48:11 -07002067 // Use basic string manipulation calls to avoid snprintf.
2068 // snprintf indirectly calls pthread_getspecific to get the size of a buffer.
2069 // When debug malloc is enabled, this call returns 0. This in turn causes
2070 // snprintf to do nothing, which causes libraries to fail to load.
2071 // See b/17302493 for further details.
2072 // Once the above bug is fixed, this code can be modified to use
2073 // snprintf again.
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08002074 const auto& default_ld_paths = g_default_namespace.get_default_library_paths();
2075
2076 size_t required_size = 0;
2077 for (const auto& path : default_ld_paths) {
2078 required_size += path.size() + 1;
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002079 }
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08002080
2081 if (buffer_size < required_size) {
Christopher Ferris7a3681e2017-04-24 17:48:32 -07002082 async_safe_fatal("android_get_LD_LIBRARY_PATH failed, buffer too small: "
2083 "buffer len %zu, required len %zu", buffer_size, required_size);
Christopher Ferris052fa3a2014-08-26 20:48:11 -07002084 }
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08002085
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002086 char* end = buffer;
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08002087 for (size_t i = 0; i < default_ld_paths.size(); ++i) {
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002088 if (i > 0) *end++ = ':';
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08002089 end = stpcpy(end, default_ld_paths[i].c_str());
Evgenii Stepanovd640b222015-07-10 17:54:01 -07002090 }
Elliott Hughesa4aafd12014-01-13 16:37:47 -08002091}
2092
Elliott Hughescade4c32012-12-20 14:42:14 -08002093void do_android_update_LD_LIBRARY_PATH(const char* ld_library_path) {
Nick Kralevich6bb01b62015-03-07 13:37:05 -08002094 parse_LD_LIBRARY_PATH(ld_library_path);
Elliott Hughescade4c32012-12-20 14:42:14 -08002095}
2096
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002097static std::string android_dlextinfo_to_string(const android_dlextinfo* info) {
2098 if (info == nullptr) {
2099 return "(null)";
2100 }
2101
2102 return android::base::StringPrintf("[flags=0x%" PRIx64 ","
2103 " reserved_addr=%p,"
2104 " reserved_size=0x%zx,"
2105 " relro_fd=%d,"
2106 " library_fd=%d,"
2107 " library_fd_offset=0x%" PRIx64 ","
2108 " library_namespace=%s@%p]",
2109 info->flags,
2110 info->reserved_addr,
2111 info->reserved_size,
2112 info->relro_fd,
2113 info->library_fd,
2114 info->library_fd_offset,
2115 (info->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0 ?
2116 (info->library_namespace != nullptr ?
2117 info->library_namespace->get_name() : "(null)") : "(n/a)",
2118 (info->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0 ?
2119 info->library_namespace : nullptr);
2120}
2121
Dimitry Ivanovd9e427c2016-11-22 16:55:25 -08002122void* do_dlopen(const char* name, int flags,
2123 const android_dlextinfo* extinfo,
2124 const void* caller_addr) {
Dimitry Ivanov5c4a5802017-03-17 16:41:34 -07002125 std::string trace_prefix = std::string("dlopen: ") + (name == nullptr ? "(nullptr)" : name);
2126 ScopedTrace trace(trace_prefix.c_str());
2127 ScopedTrace loading_trace((trace_prefix + " - loading and linking").c_str());
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002128 soinfo* const caller = find_containing_library(caller_addr);
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002129 android_namespace_t* ns = get_caller_namespace(caller);
2130
2131 LD_LOG(kLogDlopen,
Victor Chang6cb719f2019-02-06 17:19:10 +00002132 "dlopen(name=\"%s\", flags=0x%x, extinfo=%s, caller=\"%s\", caller_ns=%s@%p, targetSdkVersion=%i) ...",
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002133 name,
2134 flags,
2135 android_dlextinfo_to_string(extinfo).c_str(),
2136 caller == nullptr ? "(null)" : caller->get_realpath(),
2137 ns == nullptr ? "(null)" : ns->get_name(),
Victor Chang6cb719f2019-02-06 17:19:10 +00002138 ns,
2139 get_application_target_sdk_version());
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002140
Vic Yangbb7e1232019-01-29 20:23:16 -08002141 auto purge_guard = android::base::make_scope_guard([&]() { purge_unused_memory(); });
2142
Tom Cherryb8ab6182017-04-05 16:20:29 -07002143 auto failure_guard = android::base::make_scope_guard(
2144 [&]() { LD_LOG(kLogDlopen, "... dlopen failed: %s", linker_get_error_buffer()); });
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002145
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07002146 if ((flags & ~(RTLD_NOW|RTLD_LAZY|RTLD_LOCAL|RTLD_GLOBAL|RTLD_NODELETE|RTLD_NOLOAD)) != 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002147 DL_OPEN_ERR("invalid flags to dlopen: %x", flags);
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002148 return nullptr;
Elliott Hughese66190d2012-12-18 15:57:55 -08002149 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002150
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002151 if (extinfo != nullptr) {
2152 if ((extinfo->flags & ~(ANDROID_DLEXT_VALID_FLAG_BITS)) != 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002153 DL_OPEN_ERR("invalid extended flags to android_dlopen_ext: 0x%" PRIx64, extinfo->flags);
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002154 return nullptr;
2155 }
Dmitriy Ivanov126af752015-10-07 16:34:20 -07002156
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002157 if ((extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD) == 0 &&
Dmitriy Ivanova6c12792014-10-21 12:09:18 -07002158 (extinfo->flags & ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET) != 0) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002159 DL_OPEN_ERR("invalid extended flag combination (ANDROID_DLEXT_USE_LIBRARY_FD_OFFSET without "
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002160 "ANDROID_DLEXT_USE_LIBRARY_FD): 0x%" PRIx64, extinfo->flags);
Dmitriy Ivanov07e5bc12014-10-03 17:52:44 -07002161 return nullptr;
2162 }
Dmitriy Ivanov126af752015-10-07 16:34:20 -07002163
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002164 if ((extinfo->flags & ANDROID_DLEXT_USE_NAMESPACE) != 0) {
2165 if (extinfo->library_namespace == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002166 DL_OPEN_ERR("ANDROID_DLEXT_USE_NAMESPACE is set but extinfo->library_namespace is null");
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002167 return nullptr;
2168 }
2169 ns = extinfo->library_namespace;
2170 }
Torne (Richard Coles)012cb452014-02-06 14:34:21 +00002171 }
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08002172
Victor Chang6cb719f2019-02-06 17:19:10 +00002173 // Workaround for dlopen(/system/lib/<soname>) when .so is in /apex. http://b/121248172
2174 // The workaround works only when targetSdkVersion < Q.
2175 std::string name_to_apex;
2176 if (translateSystemPathToApexPath(name, &name_to_apex)) {
2177 const char* new_name = name_to_apex.c_str();
2178 LD_LOG(kLogDlopen, "dlopen considering translation from %s to APEX path %s",
2179 name,
2180 new_name);
2181 // Some APEXs could be optionally disabled. Only translate the path
2182 // when the old file is absent and the new file exists.
Victor Changaf12c942019-02-11 19:35:24 +00002183 // TODO(b/124218500): Re-enable it once app compat issue is resolved
2184 /*
Victor Chang6cb719f2019-02-06 17:19:10 +00002185 if (file_exists(name)) {
2186 LD_LOG(kLogDlopen, "dlopen %s exists, not translating", name);
Victor Changaf12c942019-02-11 19:35:24 +00002187 } else
2188 */
2189 if (!file_exists(new_name)) {
Victor Chang6cb719f2019-02-06 17:19:10 +00002190 LD_LOG(kLogDlopen, "dlopen %s does not exist, not translating",
2191 new_name);
2192 } else {
2193 LD_LOG(kLogDlopen, "dlopen translation accepted: using %s", new_name);
2194 name = new_name;
2195 }
2196 }
2197 // End Workaround for dlopen(/system/lib/<soname>) when .so is in /apex.
2198
Florian Mayerc10d0642023-03-22 16:12:49 -07002199 std::string translated_name_holder;
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -07002200
Florian Mayerc10d0642023-03-22 16:12:49 -07002201 assert(!g_is_hwasan || !g_is_asan);
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -07002202 const char* translated_name = name;
Dimitry Ivanov6c14f862016-12-05 13:35:47 -08002203 if (g_is_asan && translated_name != nullptr && translated_name[0] == '/') {
Evgenii Stepanov9e77a642017-07-27 14:55:44 -07002204 char original_path[PATH_MAX];
2205 if (realpath(name, original_path) != nullptr) {
Florian Mayerc10d0642023-03-22 16:12:49 -07002206 translated_name_holder = std::string(kAsanLibDirPrefix) + original_path;
2207 if (file_exists(translated_name_holder.c_str())) {
Evgenii Stepanov9e77a642017-07-27 14:55:44 -07002208 soinfo* si = nullptr;
2209 if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002210 DL_WARN("linker_asan dlopen NOT translating \"%s\" -> \"%s\": library already loaded", name,
2211 translated_name_holder.c_str());
Evgenii Stepanov9e77a642017-07-27 14:55:44 -07002212 } else {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002213 DL_WARN("linker_asan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
Florian Mayerc10d0642023-03-22 16:12:49 -07002214 translated_name = translated_name_holder.c_str();
2215 }
2216 }
2217 }
2218 } else if (g_is_hwasan && translated_name != nullptr && translated_name[0] == '/') {
2219 char original_path[PATH_MAX];
2220 if (realpath(name, original_path) != nullptr) {
2221 // Keep this the same as CreateHwasanPath in system/linkerconfig/modules/namespace.cc.
2222 std::string path(original_path);
2223 auto slash = path.rfind('/');
2224 if (slash != std::string::npos || slash != path.size() - 1) {
2225 translated_name_holder = path.substr(0, slash) + "/hwasan" + path.substr(slash);
2226 }
2227 if (!translated_name_holder.empty() && file_exists(translated_name_holder.c_str())) {
2228 soinfo* si = nullptr;
2229 if (find_loaded_library_by_realpath(ns, original_path, true, &si)) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002230 DL_WARN("linker_hwasan dlopen NOT translating \"%s\" -> \"%s\": library already loaded",
2231 name, translated_name_holder.c_str());
Florian Mayerc10d0642023-03-22 16:12:49 -07002232 } else {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002233 DL_WARN("linker_hwasan dlopen translating \"%s\" -> \"%s\"", name, translated_name);
Florian Mayerc10d0642023-03-22 16:12:49 -07002234 translated_name = translated_name_holder.c_str();
Evgenii Stepanov9e77a642017-07-27 14:55:44 -07002235 }
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -07002236 }
2237 }
2238 }
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08002239 ProtectedDataGuard guard;
Dimitry Ivanov45d25ca2016-08-09 19:38:43 -07002240 soinfo* si = find_library(ns, translated_name, flags, extinfo, caller);
Dimitry Ivanov5c4a5802017-03-17 16:41:34 -07002241 loading_trace.End();
2242
Dmitriy Ivanov851135b2014-08-29 12:02:36 -07002243 if (si != nullptr) {
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002244 void* handle = si->to_handle();
2245 LD_LOG(kLogDlopen,
Dimitry Ivanovae4a0c12016-11-21 10:44:35 -08002246 "... dlopen calling constructors: realpath=\"%s\", soname=\"%s\", handle=%p",
2247 si->get_realpath(), si->get_soname(), handle);
2248 si->call_constructors();
Tom Cherryb8ab6182017-04-05 16:20:29 -07002249 failure_guard.Disable();
Dimitry Ivanovae4a0c12016-11-21 10:44:35 -08002250 LD_LOG(kLogDlopen,
Dimitry Ivanovb996d602016-07-11 18:11:39 -07002251 "... dlopen successful: realpath=\"%s\", soname=\"%s\", handle=%p",
2252 si->get_realpath(), si->get_soname(), handle);
2253 return handle;
Elliott Hughesd23736e2012-11-01 15:16:56 -07002254 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002255
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002256 return nullptr;
Elliott Hughesd23736e2012-11-01 15:16:56 -07002257}
2258
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002259int do_dladdr(const void* addr, Dl_info* info) {
2260 // Determine if this address can be found in any library currently mapped.
2261 soinfo* si = find_containing_library(addr);
2262 if (si == nullptr) {
2263 return 0;
2264 }
2265
2266 memset(info, 0, sizeof(Dl_info));
2267
2268 info->dli_fname = si->get_realpath();
2269 // Address at which the shared object is loaded.
2270 info->dli_fbase = reinterpret_cast<void*>(si->base);
2271
2272 // Determine if any symbol in the library contains the specified address.
2273 ElfW(Sym)* sym = si->find_symbol_by_address(addr);
2274 if (sym != nullptr) {
2275 info->dli_sname = si->get_string(sym->st_name);
2276 info->dli_saddr = reinterpret_cast<void*>(si->resolve_symbol_address(sym));
2277 }
2278
2279 return 1;
2280}
2281
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002282static soinfo* soinfo_from_handle(void* handle) {
2283 if ((reinterpret_cast<uintptr_t>(handle) & 1) != 0) {
2284 auto it = g_soinfo_handles_map.find(reinterpret_cast<uintptr_t>(handle));
2285 if (it == g_soinfo_handles_map.end()) {
2286 return nullptr;
2287 } else {
2288 return it->second;
2289 }
2290 }
2291
2292 return static_cast<soinfo*>(handle);
2293}
2294
Dimitry Ivanovd9e427c2016-11-22 16:55:25 -08002295bool do_dlsym(void* handle,
2296 const char* sym_name,
2297 const char* sym_ver,
2298 const void* caller_addr,
2299 void** symbol) {
Dimitry Ivanov6705e8c2017-03-21 10:29:06 -07002300 ScopedTrace trace("dlsym");
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002301#if !defined(__LP64__)
2302 if (handle == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002303 DL_SYM_ERR("dlsym failed: library handle is null");
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002304 return false;
2305 }
2306#endif
2307
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002308 soinfo* found = nullptr;
2309 const ElfW(Sym)* sym = nullptr;
2310 soinfo* caller = find_containing_library(caller_addr);
Dimitry Ivanovaca299a2016-04-11 12:42:58 -07002311 android_namespace_t* ns = get_caller_namespace(caller);
Dimitry Ivanov4742abd2016-12-12 16:30:15 -08002312 soinfo* si = nullptr;
2313 if (handle != RTLD_DEFAULT && handle != RTLD_NEXT) {
2314 si = soinfo_from_handle(handle);
2315 }
2316
2317 LD_LOG(kLogDlsym,
2318 "dlsym(handle=%p(\"%s\"), sym_name=\"%s\", sym_ver=\"%s\", caller=\"%s\", caller_ns=%s@%p) ...",
2319 handle,
2320 si != nullptr ? si->get_realpath() : "n/a",
2321 sym_name,
2322 sym_ver,
2323 caller == nullptr ? "(null)" : caller->get_realpath(),
2324 ns == nullptr ? "(null)" : ns->get_name(),
2325 ns);
2326
Tom Cherryb8ab6182017-04-05 16:20:29 -07002327 auto failure_guard = android::base::make_scope_guard(
2328 [&]() { LD_LOG(kLogDlsym, "... dlsym failed: %s", linker_get_error_buffer()); });
Dimitry Ivanov4742abd2016-12-12 16:30:15 -08002329
2330 if (sym_name == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002331 DL_SYM_ERR("dlsym failed: symbol name is null");
Dimitry Ivanov4742abd2016-12-12 16:30:15 -08002332 return false;
2333 }
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002334
2335 version_info vi_instance;
2336 version_info* vi = nullptr;
2337
2338 if (sym_ver != nullptr) {
Dimitry Ivanov9cf99cb2015-12-11 14:22:24 -08002339 vi_instance.name = sym_ver;
2340 vi_instance.elf_hash = calculate_elf_hash(sym_ver);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002341 vi = &vi_instance;
2342 }
2343
2344 if (handle == RTLD_DEFAULT || handle == RTLD_NEXT) {
2345 sym = dlsym_linear_lookup(ns, sym_name, vi, &found, caller, handle);
2346 } else {
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002347 if (si == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002348 DL_SYM_ERR("dlsym failed: invalid handle: %p", handle);
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002349 return false;
2350 }
2351 sym = dlsym_handle_lookup(si, &found, sym_name, vi);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002352 }
2353
2354 if (sym != nullptr) {
2355 uint32_t bind = ELF_ST_BIND(sym->st_info);
Ryan Pricharde4d620b2019-04-01 17:42:14 -07002356 uint32_t type = ELF_ST_TYPE(sym->st_info);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002357
2358 if ((bind == STB_GLOBAL || bind == STB_WEAK) && sym->st_shndx != 0) {
Ryan Pricharde4d620b2019-04-01 17:42:14 -07002359 if (type == STT_TLS) {
2360 // For a TLS symbol, dlsym returns the address of the current thread's
Ryan Pricharda2e83ab2019-08-16 17:25:43 -07002361 // copy of the symbol.
2362 const soinfo_tls* tls_module = found->get_tls();
Ryan Pricharde4d620b2019-04-01 17:42:14 -07002363 if (tls_module == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002364 DL_SYM_ERR("TLS symbol \"%s\" in solib \"%s\" with no TLS segment",
2365 sym_name, found->get_realpath());
Ryan Pricharde4d620b2019-04-01 17:42:14 -07002366 return false;
2367 }
Ryan Pricharda2e83ab2019-08-16 17:25:43 -07002368 void* tls_block = get_tls_block_for_this_thread(tls_module, /*should_alloc=*/true);
2369 *symbol = static_cast<char*>(tls_block) + sym->st_value;
Florian Mayere6f83212025-01-14 14:40:18 -08002370 } else if (__libc_mte_enabled()) {
Florian Mayer4edc20d2024-10-30 14:24:26 -07002371 *symbol = get_tagged_address(reinterpret_cast<void*>(found->resolve_symbol_address(sym)));
Florian Mayere6f83212025-01-14 14:40:18 -08002372 } else {
2373 *symbol = reinterpret_cast<void*>(found->resolve_symbol_address(sym));
Ryan Pricharde4d620b2019-04-01 17:42:14 -07002374 }
Tom Cherryb8ab6182017-04-05 16:20:29 -07002375 failure_guard.Disable();
Dimitry Ivanov4742abd2016-12-12 16:30:15 -08002376 LD_LOG(kLogDlsym,
2377 "... dlsym successful: sym_name=\"%s\", sym_ver=\"%s\", found in=\"%s\", address=%p",
2378 sym_name, sym_ver, found->get_soname(), *symbol);
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002379 return true;
2380 }
2381
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002382 DL_SYM_ERR("symbol \"%s\" found but not global", symbol_display_name(sym_name, sym_ver).c_str());
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002383 return false;
2384 }
2385
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002386 DL_SYM_ERR("undefined symbol: %s", symbol_display_name(sym_name, sym_ver).c_str());
Dimitry Ivanov4a2c5aa2015-12-10 16:08:14 -08002387 return false;
2388}
2389
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002390int do_dlclose(void* handle) {
Dimitry Ivanov6705e8c2017-03-21 10:29:06 -07002391 ScopedTrace trace("dlclose");
Dmitriy Ivanov279a22f2015-01-23 12:03:53 -08002392 ProtectedDataGuard guard;
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002393 soinfo* si = soinfo_from_handle(handle);
2394 if (si == nullptr) {
Martin Stjernholm9fe38262019-08-27 17:08:45 +01002395 DL_OPEN_ERR("invalid handle: %p", handle);
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002396 return -1;
2397 }
2398
dimitryc92ce712017-10-27 14:12:53 +02002399 LD_LOG(kLogDlopen,
2400 "dlclose(handle=%p, realpath=\"%s\"@%p) ...",
2401 handle,
2402 si->get_realpath(),
2403 si);
Dmitriy Ivanovb648a8a2014-05-19 15:06:58 -07002404 soinfo_unload(si);
dimitryc92ce712017-10-27 14:12:53 +02002405 LD_LOG(kLogDlopen,
2406 "dlclose(handle=%p) ... done",
2407 handle);
Dimitry Ivanovd88e1f32016-03-24 15:30:30 -07002408 return 0;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08002409}
2410
Jiyong Park25bedfd2019-05-16 21:00:39 +09002411// Make ns as the anonymous namespace that is a namespace used when
2412// we fail to determine the caller address (e.g., call from mono-jited code)
2413// Since there can be multiple anonymous namespace in a process, subsequent
2414// call to this function causes an error.
2415static bool set_anonymous_namespace(android_namespace_t* ns) {
2416 if (!g_anonymous_namespace_set && ns != nullptr) {
2417 CHECK(ns->is_also_used_as_anonymous());
2418 g_anonymous_namespace = ns;
2419 g_anonymous_namespace_set = true;
2420 return true;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002421 }
Jiyong Park25bedfd2019-05-16 21:00:39 +09002422 return false;
2423}
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002424
Jiyong Park25bedfd2019-05-16 21:00:39 +09002425// TODO(b/130388701) remove this. Currently, this is used only for testing
2426// where we don't have classloader namespace.
2427bool init_anonymous_namespace(const char* shared_lib_sonames, const char* library_search_path) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002428 ProtectedDataGuard guard;
2429
Jiyong Park25bedfd2019-05-16 21:00:39 +09002430 // Test-only feature: we need to change the anonymous namespace multiple times
2431 // while the test is running.
2432 g_anonymous_namespace_set = false;
2433
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002434 // create anonymous namespace
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002435 // When the caller is nullptr - create_namespace will take global group
2436 // from the anonymous namespace, which is fine because anonymous namespace
2437 // is still pointing to the default one.
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002438 android_namespace_t* anon_ns =
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002439 create_namespace(nullptr,
2440 "(anonymous)",
2441 nullptr,
2442 library_search_path,
Jiyong Park25bedfd2019-05-16 21:00:39 +09002443 ANDROID_NAMESPACE_TYPE_ISOLATED |
2444 ANDROID_NAMESPACE_TYPE_ALSO_USED_AS_ANONYMOUS,
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002445 nullptr,
2446 &g_default_namespace);
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002447
Jiyong Park25bedfd2019-05-16 21:00:39 +09002448 CHECK(anon_ns != nullptr);
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002449
2450 if (!link_namespaces(anon_ns, &g_default_namespace, shared_lib_sonames)) {
Jiyong Park25bedfd2019-05-16 21:00:39 +09002451 // TODO: delete anon_ns
Dmitriy Ivanov1ffec1c2015-11-23 11:26:35 -08002452 return false;
2453 }
Dimitry Ivanov7d429d32017-02-01 15:28:52 -08002454
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002455 return true;
2456}
2457
Dimitry Ivanovb943f302016-08-03 16:00:10 -07002458static void add_soinfos_to_namespace(const soinfo_list_t& soinfos, android_namespace_t* ns) {
2459 ns->add_soinfos(soinfos);
2460 for (auto si : soinfos) {
2461 si->add_secondary_namespace(ns);
2462 }
2463}
2464
Ryan Prichard40494402020-03-24 22:37:50 -07002465std::vector<std::string> fix_lib_paths(std::vector<std::string> paths) {
2466 // For the bootstrap linker, insert /system/${LIB}/bootstrap in front of /system/${LIB} in any
2467 // namespace search path. The bootstrap linker should prefer to use the bootstrap bionic libraries
2468 // (e.g. libc.so).
2469#if !defined(__ANDROID_APEX__)
2470 for (size_t i = 0; i < paths.size(); ++i) {
2471 if (paths[i] == kSystemLibDir) {
2472 paths.insert(paths.begin() + i, std::string(kSystemLibDir) + "/bootstrap");
2473 ++i;
2474 }
2475 }
2476#endif
2477 return paths;
2478}
2479
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002480android_namespace_t* create_namespace(const void* caller_addr,
2481 const char* name,
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002482 const char* ld_library_path,
2483 const char* default_library_path,
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002484 uint64_t type,
Dimitry Ivanovfc2da532016-05-12 15:20:21 -07002485 const char* permitted_when_isolated_path,
2486 android_namespace_t* parent_namespace) {
Dimitry Ivanovfc2da532016-05-12 15:20:21 -07002487 if (parent_namespace == nullptr) {
Dimitry Ivanov52408632016-05-23 10:31:11 -07002488 // if parent_namespace is nullptr -> set it to the caller namespace
2489 soinfo* caller_soinfo = find_containing_library(caller_addr);
2490
2491 parent_namespace = caller_soinfo != nullptr ?
2492 caller_soinfo->get_primary_namespace() :
2493 g_anonymous_namespace;
Dimitry Ivanovfc2da532016-05-12 15:20:21 -07002494 }
2495
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002496 ProtectedDataGuard guard;
2497 std::vector<std::string> ld_library_paths;
2498 std::vector<std::string> default_library_paths;
Dimitry Ivanov284ae352015-12-08 10:47:13 -08002499 std::vector<std::string> permitted_paths;
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002500
2501 parse_path(ld_library_path, ":", &ld_library_paths);
2502 parse_path(default_library_path, ":", &default_library_paths);
Dimitry Ivanov284ae352015-12-08 10:47:13 -08002503 parse_path(permitted_when_isolated_path, ":", &permitted_paths);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002504
2505 android_namespace_t* ns = new (g_namespace_allocator.alloc()) android_namespace_t();
2506 ns->set_name(name);
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002507 ns->set_isolated((type & ANDROID_NAMESPACE_TYPE_ISOLATED) != 0);
Ryan Prichardaff9a342020-08-03 15:29:12 -07002508 ns->set_exempt_list_enabled((type & ANDROID_NAMESPACE_TYPE_EXEMPT_LIST_ENABLED) != 0);
Jiyong Park25bedfd2019-05-16 21:00:39 +09002509 ns->set_also_used_as_anonymous((type & ANDROID_NAMESPACE_TYPE_ALSO_USED_AS_ANONYMOUS) != 0);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002510
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002511 if ((type & ANDROID_NAMESPACE_TYPE_SHARED) != 0) {
Dimitry Ivanovf1cb6692017-05-01 17:45:38 -07002512 // append parent namespace paths.
2513 std::copy(parent_namespace->get_ld_library_paths().begin(),
2514 parent_namespace->get_ld_library_paths().end(),
2515 back_inserter(ld_library_paths));
2516
2517 std::copy(parent_namespace->get_default_library_paths().begin(),
2518 parent_namespace->get_default_library_paths().end(),
2519 back_inserter(default_library_paths));
2520
2521 std::copy(parent_namespace->get_permitted_paths().begin(),
2522 parent_namespace->get_permitted_paths().end(),
2523 back_inserter(permitted_paths));
2524
Dimitry Ivanovfc2da532016-05-12 15:20:21 -07002525 // If shared - clone the parent namespace
Dimitry Ivanovb943f302016-08-03 16:00:10 -07002526 add_soinfos_to_namespace(parent_namespace->soinfo_list(), ns);
Dimitry Ivanovf1cb6692017-05-01 17:45:38 -07002527 // and copy parent namespace links
2528 for (auto& link : parent_namespace->linked_namespaces()) {
Logan Chien9ee45912018-01-18 12:05:09 +08002529 ns->add_linked_namespace(link.linked_namespace(), link.shared_lib_sonames(),
2530 link.allow_all_shared_libs());
Dimitry Ivanovf1cb6692017-05-01 17:45:38 -07002531 }
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002532 } else {
Dimitry Ivanovfc2da532016-05-12 15:20:21 -07002533 // If not shared - copy only the shared group
Jiyong Park02586a22017-05-20 01:01:24 +09002534 add_soinfos_to_namespace(parent_namespace->get_shared_group(), ns);
Dimitry Ivanov7331fe12015-12-14 14:11:17 -08002535 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002536
Dimitry Ivanovf1cb6692017-05-01 17:45:38 -07002537 ns->set_ld_library_paths(std::move(ld_library_paths));
2538 ns->set_default_library_paths(std::move(default_library_paths));
2539 ns->set_permitted_paths(std::move(permitted_paths));
2540
Jiyong Park25bedfd2019-05-16 21:00:39 +09002541 if (ns->is_also_used_as_anonymous() && !set_anonymous_namespace(ns)) {
2542 DL_ERR("failed to set namespace: [name=\"%s\", ld_library_path=\"%s\", default_library_paths=\"%s\""
2543 " permitted_paths=\"%s\"] as the anonymous namespace",
2544 ns->get_name(),
2545 android::base::Join(ns->get_ld_library_paths(), ':').c_str(),
2546 android::base::Join(ns->get_default_library_paths(), ':').c_str(),
2547 android::base::Join(ns->get_permitted_paths(), ':').c_str());
2548 return nullptr;
2549 }
2550
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07002551 return ns;
2552}
2553
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002554bool link_namespaces(android_namespace_t* namespace_from,
2555 android_namespace_t* namespace_to,
2556 const char* shared_lib_sonames) {
2557 if (namespace_to == nullptr) {
2558 namespace_to = &g_default_namespace;
2559 }
2560
2561 if (namespace_from == nullptr) {
2562 DL_ERR("error linking namespaces: namespace_from is null.");
2563 return false;
2564 }
2565
2566 if (shared_lib_sonames == nullptr || shared_lib_sonames[0] == '\0') {
2567 DL_ERR("error linking namespaces \"%s\"->\"%s\": the list of shared libraries is empty.",
2568 namespace_from->get_name(), namespace_to->get_name());
2569 return false;
2570 }
2571
Jooyung Han57b03de2022-12-01 16:23:03 +09002572 std::vector<std::string> sonames = android::base::Split(shared_lib_sonames, ":");
2573 std::unordered_set<std::string> sonames_set(std::make_move_iterator(sonames.begin()),
2574 std::make_move_iterator(sonames.end()));
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002575
2576 ProtectedDataGuard guard;
Jooyung Han57b03de2022-12-01 16:23:03 +09002577 namespace_from->add_linked_namespace(namespace_to, std::move(sonames_set), false);
Logan Chien9ee45912018-01-18 12:05:09 +08002578
2579 return true;
2580}
2581
2582bool link_namespaces_all_libs(android_namespace_t* namespace_from,
2583 android_namespace_t* namespace_to) {
2584 if (namespace_from == nullptr) {
2585 DL_ERR("error linking namespaces: namespace_from is null.");
2586 return false;
2587 }
2588
2589 if (namespace_to == nullptr) {
2590 DL_ERR("error linking namespaces: namespace_to is null.");
2591 return false;
2592 }
2593
2594 ProtectedDataGuard guard;
2595 namespace_from->add_linked_namespace(namespace_to, std::unordered_set<std::string>(), true);
Dimitry Ivanov7a34b9d2017-02-03 14:07:34 -08002596
2597 return true;
2598}
2599
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002600ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) {
Elliott Hughes90f96b92019-05-09 15:56:39 -07002601 if (g_is_ldd) return 0;
2602
Peter Collingbournee9491952019-10-28 10:57:26 -07002603 ElfW(Addr) ifunc_addr = __bionic_call_ifunc_resolver(resolver_addr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002604 LD_DEBUG(calls, "ifunc_resolver@%p returned %p",
2605 reinterpret_cast<void *>(resolver_addr), reinterpret_cast<void*>(ifunc_addr));
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002606
Dmitriy Ivanov9aea1642014-09-11 15:16:03 -07002607 return ifunc_addr;
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002608}
Brigid Smithc5a13ef2014-07-23 11:22:25 -07002609
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002610const version_info* VersionTracker::get_version_info(ElfW(Versym) source_symver) const {
2611 if (source_symver < 2 ||
2612 source_symver >= version_infos.size() ||
2613 version_infos[source_symver].name == nullptr) {
2614 return nullptr;
2615 }
2616
2617 return &version_infos[source_symver];
2618}
2619
2620void VersionTracker::add_version_info(size_t source_index,
2621 ElfW(Word) elf_hash,
2622 const char* ver_name,
2623 const soinfo* target_si) {
2624 if (source_index >= version_infos.size()) {
2625 version_infos.resize(source_index+1);
2626 }
2627
2628 version_infos[source_index].elf_hash = elf_hash;
2629 version_infos[source_index].name = ver_name;
2630 version_infos[source_index].target_si = target_si;
2631}
2632
2633bool VersionTracker::init_verneed(const soinfo* si_from) {
2634 uintptr_t verneed_ptr = si_from->get_verneed_ptr();
2635
2636 if (verneed_ptr == 0) {
2637 return true;
2638 }
2639
2640 size_t verneed_cnt = si_from->get_verneed_cnt();
2641
2642 for (size_t i = 0, offset = 0; i<verneed_cnt; ++i) {
2643 const ElfW(Verneed)* verneed = reinterpret_cast<ElfW(Verneed)*>(verneed_ptr + offset);
2644 size_t vernaux_offset = offset + verneed->vn_aux;
2645 offset += verneed->vn_next;
2646
2647 if (verneed->vn_version != 1) {
2648 DL_ERR("unsupported verneed[%zd] vn_version: %d (expected 1)", i, verneed->vn_version);
2649 return false;
2650 }
2651
2652 const char* target_soname = si_from->get_string(verneed->vn_file);
2653 // find it in dependencies
Elliott Hughesf9dd1a72021-01-11 09:04:58 -08002654 soinfo* target_si = si_from->get_children().find_if(
2655 [&](const soinfo* si) { return strcmp(si->get_soname(), target_soname) == 0; });
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002656
2657 if (target_si == nullptr) {
2658 DL_ERR("cannot find \"%s\" from verneed[%zd] in DT_NEEDED list for \"%s\"",
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002659 target_soname, i, si_from->get_realpath());
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002660 return false;
2661 }
2662
2663 for (size_t j = 0; j<verneed->vn_cnt; ++j) {
2664 const ElfW(Vernaux)* vernaux = reinterpret_cast<ElfW(Vernaux)*>(verneed_ptr + vernaux_offset);
2665 vernaux_offset += vernaux->vna_next;
2666
2667 const ElfW(Word) elf_hash = vernaux->vna_hash;
2668 const char* ver_name = si_from->get_string(vernaux->vna_name);
2669 ElfW(Half) source_index = vernaux->vna_other;
2670
2671 add_version_info(source_index, elf_hash, ver_name, target_si);
2672 }
2673 }
2674
2675 return true;
2676}
2677
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002678template <typename F>
2679static bool for_each_verdef(const soinfo* si, F functor) {
2680 if (!si->has_min_version(2)) {
2681 return true;
2682 }
2683
2684 uintptr_t verdef_ptr = si->get_verdef_ptr();
2685 if (verdef_ptr == 0) {
2686 return true;
2687 }
2688
2689 size_t offset = 0;
2690
2691 size_t verdef_cnt = si->get_verdef_cnt();
2692 for (size_t i = 0; i<verdef_cnt; ++i) {
2693 const ElfW(Verdef)* verdef = reinterpret_cast<ElfW(Verdef)*>(verdef_ptr + offset);
2694 size_t verdaux_offset = offset + verdef->vd_aux;
2695 offset += verdef->vd_next;
2696
2697 if (verdef->vd_version != 1) {
2698 DL_ERR("unsupported verdef[%zd] vd_version: %d (expected 1) library: %s",
2699 i, verdef->vd_version, si->get_realpath());
2700 return false;
2701 }
2702
2703 if ((verdef->vd_flags & VER_FLG_BASE) != 0) {
2704 // "this is the version of the file itself. It must not be used for
2705 // matching a symbol. It can be used to match references."
2706 //
2707 // http://www.akkadia.org/drepper/symbol-versioning
2708 continue;
2709 }
2710
2711 if (verdef->vd_cnt == 0) {
2712 DL_ERR("invalid verdef[%zd] vd_cnt == 0 (version without a name)", i);
2713 return false;
2714 }
2715
2716 const ElfW(Verdaux)* verdaux = reinterpret_cast<ElfW(Verdaux)*>(verdef_ptr + verdaux_offset);
2717
2718 if (functor(i, verdef, verdaux) == true) {
2719 break;
2720 }
2721 }
2722
2723 return true;
2724}
2725
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002726ElfW(Versym) find_verdef_version_index(const soinfo* si, const version_info* vi) {
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002727 if (vi == nullptr) {
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002728 return kVersymNotNeeded;
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002729 }
2730
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002731 ElfW(Versym) result = kVersymGlobal;
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002732
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002733 if (!for_each_verdef(si,
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002734 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
2735 if (verdef->vd_hash == vi->elf_hash &&
2736 strcmp(vi->name, si->get_string(verdaux->vda_name)) == 0) {
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002737 result = verdef->vd_ndx;
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002738 return true;
2739 }
2740
2741 return false;
2742 }
Ryan Prichard0e12cce2020-01-02 14:59:11 -08002743 )) {
2744 // verdef should have already been validated in prelink_image.
2745 async_safe_fatal("invalid verdef after prelinking: %s, %s",
2746 si->get_realpath(), linker_get_error_buffer());
2747 }
2748
2749 return result;
2750}
2751
2752// Validate the library's verdef section. On error, returns false and invokes DL_ERR.
2753bool validate_verdef_section(const soinfo* si) {
2754 return for_each_verdef(si,
2755 [&](size_t, const ElfW(Verdef)*, const ElfW(Verdaux)*) {
2756 return false;
2757 });
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002758}
2759
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07002760bool VersionTracker::init_verdef(const soinfo* si_from) {
2761 return for_each_verdef(si_from,
2762 [&](size_t, const ElfW(Verdef)* verdef, const ElfW(Verdaux)* verdaux) {
2763 add_version_info(verdef->vd_ndx, verdef->vd_hash,
2764 si_from->get_string(verdaux->vda_name), si_from);
2765 return false;
2766 }
2767 );
2768}
2769
2770bool VersionTracker::init(const soinfo* si_from) {
2771 if (!si_from->has_min_version(2)) {
2772 return true;
2773 }
2774
2775 return init_verneed(si_from) && init_verdef(si_from);
2776}
2777
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002778// TODO (dimitry): Methods below need to be moved out of soinfo
2779// and in more isolated file in order minimize dependencies on
2780// unnecessary object in the linker binary. Consider making them
2781// independent from soinfo (?).
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002782bool soinfo::lookup_version_info(const VersionTracker& version_tracker, ElfW(Word) sym,
2783 const char* sym_name, const version_info** vi) {
2784 const ElfW(Versym)* sym_ver_ptr = get_versym(sym);
2785 ElfW(Versym) sym_ver = sym_ver_ptr == nullptr ? 0 : *sym_ver_ptr;
2786
2787 if (sym_ver != VER_NDX_LOCAL && sym_ver != VER_NDX_GLOBAL) {
2788 *vi = version_tracker.get_version_info(sym_ver);
2789
2790 if (*vi == nullptr) {
2791 DL_ERR("cannot find verneed/verdef for version index=%d "
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002792 "referenced by symbol \"%s\" at \"%s\"", sym_ver, sym_name, get_realpath());
Dmitriy Ivanov31b408d2015-04-30 16:11:48 -07002793 return false;
2794 }
2795 } else {
2796 // there is no version info
2797 *vi = nullptr;
2798 }
2799
2800 return true;
2801}
2802
Florian Mayer4edc20d2024-10-30 14:24:26 -07002803static void apply_relr_reloc(ElfW(Addr) offset, ElfW(Addr) load_bias, bool has_memtag_globals) {
2804 ElfW(Addr) destination = offset + load_bias;
2805 if (!has_memtag_globals) {
2806 *reinterpret_cast<ElfW(Addr)*>(destination) += load_bias;
2807 return;
2808 }
2809
2810 ElfW(Addr)* tagged_destination =
2811 reinterpret_cast<ElfW(Addr)*>(get_tagged_address(reinterpret_cast<void*>(destination)));
2812 ElfW(Addr) tagged_value = reinterpret_cast<ElfW(Addr)>(
2813 get_tagged_address(reinterpret_cast<void*>(*tagged_destination + load_bias)));
2814 *tagged_destination = tagged_value;
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002815}
2816
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002817// Process relocations in SHT_RELR section (experimental).
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002818// Details of the encoding are described in this post:
2819// https://groups.google.com/d/msg/generic-abi/bX460iggiKg/Pi9aSwwABgAJ
Florian Mayer4edc20d2024-10-30 14:24:26 -07002820bool relocate_relr(const ElfW(Relr) * begin, const ElfW(Relr) * end, ElfW(Addr) load_bias,
2821 bool has_memtag_globals) {
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002822 constexpr size_t wordsize = sizeof(ElfW(Addr));
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002823
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002824 ElfW(Addr) base = 0;
Ryan Prichard2a901e62024-04-04 03:05:35 -07002825 for (const ElfW(Relr)* current = begin; current < end; ++current) {
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002826 ElfW(Relr) entry = *current;
2827 ElfW(Addr) offset;
2828
2829 if ((entry&1) == 0) {
2830 // Even entry: encodes the offset for next relocation.
2831 offset = static_cast<ElfW(Addr)>(entry);
Florian Mayer4edc20d2024-10-30 14:24:26 -07002832 apply_relr_reloc(offset, load_bias, has_memtag_globals);
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002833 // Set base offset for subsequent bitmap entries.
2834 base = offset + wordsize;
2835 continue;
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002836 }
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002837
2838 // Odd entry: encodes bitmap for relocations starting at base.
2839 offset = base;
2840 while (entry != 0) {
2841 entry >>= 1;
2842 if ((entry&1) != 0) {
Florian Mayer4edc20d2024-10-30 14:24:26 -07002843 apply_relr_reloc(offset, load_bias, has_memtag_globals);
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002844 }
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002845 offset += wordsize;
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002846 }
Rahul Chaudhryf16b6592018-01-25 15:34:15 -08002847
2848 // Advance base offset by 63 words for 64-bit platforms,
2849 // or 31 words for 32-bit platforms.
2850 base += (8*wordsize - 1) * wordsize;
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08002851 }
2852 return true;
2853}
2854
Dimitry Ivanov48ec2882016-08-04 11:50:36 -07002855// An empty list of soinfos
Dimitry Ivanovb943f302016-08-03 16:00:10 -07002856static soinfo_list_t g_empty_list;
Dmitriy Ivanovd59e5002014-05-09 09:10:14 -07002857
Mitch Phillips28057b82024-08-21 19:43:08 +02002858bool soinfo::prelink_image(bool dlext_use_relro) {
Ryan Prichardae320cd2019-12-10 12:39:05 -08002859 if (flags_ & FLAG_PRELINKED) return true;
Ningsheng Jiane93be992014-09-16 15:22:10 +08002860 /* Extract dynamic section */
2861 ElfW(Word) dynamic_flags = 0;
2862 phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);
Dmitriy Ivanov498eb182014-09-05 14:57:59 -07002863
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002864 /* We can't log anything until the linker is relocated */
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002865 bool relocating_linker = (flags_ & FLAG_LINKER) != 0;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002866 if (!relocating_linker) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002867 LD_DEBUG(any, "[ Linking \"%s\" ]", get_realpath());
2868 LD_DEBUG(any, "si->base = %p si->flags = 0x%08x", reinterpret_cast<void*>(base), flags_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002869 }
2870
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002871 if (dynamic == nullptr) {
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002872 if (!relocating_linker) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07002873 DL_ERR("missing PT_DYNAMIC in \"%s\"", get_realpath());
David 'Digit' Turnerb52e4382012-06-19 01:24:17 +02002874 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002875 return false;
2876 } else {
2877 if (!relocating_linker) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002878 LD_DEBUG(dynamic, "dynamic section @%p", dynamic);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002879 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002880 }
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002881
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002882#if defined(__arm__)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002883 (void) phdr_table_get_arm_exidx(phdr, phnum, load_bias,
2884 &ARM_exidx, &ARM_exidx_count);
David 'Digit' Turner63f99f42012-06-19 00:08:39 +02002885#endif
2886
Ryan Pricharde5e69e02019-01-01 18:53:48 -08002887 TlsSegment tls_segment;
Ryan Prichard19883502019-01-16 23:13:38 -08002888 if (__bionic_get_tls_segment(phdr, phnum, load_bias, &tls_segment)) {
Ryan Prichardb4937462024-03-13 23:07:15 -07002889 // The loader does not (currently) support ELF TLS, so it shouldn't have
2890 // a TLS segment.
2891 CHECK(!relocating_linker && "TLS not supported in loader");
Ryan Prichard43963922024-03-14 16:51:27 -07002892 if (!__bionic_check_tls_align(tls_segment.aligned_size.align.value)) {
Ryan Prichardb4937462024-03-13 23:07:15 -07002893 DL_ERR("TLS segment alignment in \"%s\" is not a power of 2: %zu", get_realpath(),
Ryan Prichard43963922024-03-14 16:51:27 -07002894 tls_segment.aligned_size.align.value);
Ryan Prichard19883502019-01-16 23:13:38 -08002895 return false;
2896 }
Ryan Pricharde5e69e02019-01-01 18:53:48 -08002897 tls_ = std::make_unique<soinfo_tls>();
2898 tls_->segment = tls_segment;
2899 }
2900
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002901 // Extract useful information from dynamic section.
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002902 // Note that: "Except for the DT_NULL element at the end of the array,
2903 // and the relative order of DT_NEEDED elements, entries may appear in any order."
2904 //
2905 // source: http://www.sco.com/developers/gabi/1998-04-29/ch5.dynamic.html
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002906 uint32_t needed_count = 0;
2907 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04002908 LD_DEBUG(dynamic, "dynamic entry @%p: d_tag=%p, d_val=%p",
2909 d, reinterpret_cast<void*>(d->d_tag), reinterpret_cast<void*>(d->d_un.d_val));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002910 switch (d->d_tag) {
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002911 case DT_SONAME:
Dmitriy Ivanov618f1a32015-03-17 20:06:36 -07002912 // this is parsed after we have strtab initialized (see below).
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002913 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002914
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002915 case DT_HASH:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002916 nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
2917 nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
2918 bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
2919 chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002920 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002921
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002922 case DT_GNU_HASH:
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07002923 gnu_nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002924 // skip symndx
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002925 gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
2926 gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002927
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002928 gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07002929 gnu_bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002930 // amend chain for symndx = header[1]
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002931 gnu_chain_ = gnu_bucket_ + gnu_nbucket_ -
2932 reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002933
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002934 if (!powerof2(gnu_maskwords_)) {
Dmitriy Ivanov20d89cb2015-03-30 18:43:38 -07002935 DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two",
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002936 gnu_maskwords_, get_realpath());
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002937 return false;
2938 }
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002939 --gnu_maskwords_;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002940
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08002941 flags_ |= FLAG_GNU_HASH;
Dmitriy Ivanovec18ce02014-11-09 19:27:20 -08002942 break;
2943
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002944 case DT_STRTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002945 strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002946 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002947
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002948 case DT_STRSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002949 strtab_size_ = d->d_un.d_val;
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07002950 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002951
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002952 case DT_SYMTAB:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002953 symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002954 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002955
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002956 case DT_SYMENT:
2957 if (d->d_un.d_val != sizeof(ElfW(Sym))) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002958 DL_ERR("invalid DT_SYMENT: %zd in \"%s\"",
2959 static_cast<size_t>(d->d_un.d_val), get_realpath());
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002960 return false;
2961 }
2962 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002963
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002964 case DT_PLTREL:
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002965#if defined(USE_RELA)
2966 if (d->d_un.d_val != DT_RELA) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002967 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_RELA", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002968 return false;
2969 }
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002970#else
2971 if (d->d_un.d_val != DT_REL) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07002972 DL_ERR("unsupported DT_PLTREL in \"%s\"; expected DT_REL", get_realpath());
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002973 return false;
2974 }
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002975#endif
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07002976 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002977
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002978 case DT_JMPREL:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002979#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002980 plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002981#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002982 plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002983#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002984 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002985
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002986 case DT_PLTRELSZ:
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07002987#if defined(USE_RELA)
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002988 plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002989#else
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08002990 plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07002991#endif
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002992 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002993
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002994 case DT_PLTGOT:
Elliott Hughes14798932020-02-13 15:40:07 -08002995 // Ignored (because RTLD_LAZY is not supported).
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07002996 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07002997
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07002998 case DT_DEBUG:
2999 // Set the DT_DEBUG entry to the address of _r_debug for GDB
3000 // if the dynamic table is writable
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003001 if ((dynamic_flags & PF_W) != 0) {
3002 d->d_un.d_val = reinterpret_cast<uintptr_t>(&_r_debug);
3003 }
Dmitriy Ivanovc6292ea2015-02-13 16:29:50 -08003004 break;
Elliott Hughes4eeb1f12013-10-25 17:38:02 -07003005#if defined(USE_RELA)
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003006 case DT_RELA:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003007 rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003008 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003009
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003010 case DT_RELASZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003011 rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003012 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003013
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003014 case DT_ANDROID_RELA:
3015 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
3016 break;
3017
3018 case DT_ANDROID_RELASZ:
3019 android_relocs_size_ = d->d_un.d_val;
3020 break;
3021
3022 case DT_ANDROID_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003023 DL_ERR("unsupported DT_ANDROID_REL in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003024 return false;
3025
3026 case DT_ANDROID_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003027 DL_ERR("unsupported DT_ANDROID_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003028 return false;
3029
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003030 case DT_RELAENT:
3031 if (d->d_un.d_val != sizeof(ElfW(Rela))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07003032 DL_ERR("invalid DT_RELAENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003033 return false;
3034 }
3035 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003036
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003037 // Ignored (see DT_RELCOUNT comments for details).
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003038 case DT_RELACOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003039 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003040
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003041 case DT_REL:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003042 DL_ERR("unsupported DT_REL in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003043 return false;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003044
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003045 case DT_RELSZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003046 DL_ERR("unsupported DT_RELSZ in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003047 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003048
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003049#else
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003050 case DT_REL:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003051 rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003052 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003053
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003054 case DT_RELSZ:
Dmitriy Ivanov047b5932014-11-13 09:39:20 -08003055 rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003056 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003057
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003058 case DT_RELENT:
3059 if (d->d_un.d_val != sizeof(ElfW(Rel))) {
Dmitriy Ivanovf240aa82014-09-16 23:34:20 -07003060 DL_ERR("invalid DT_RELENT: %zd", static_cast<size_t>(d->d_un.d_val));
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003061 return false;
3062 }
3063 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003064
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003065 case DT_ANDROID_REL:
3066 android_relocs_ = reinterpret_cast<uint8_t*>(load_bias + d->d_un.d_ptr);
3067 break;
3068
3069 case DT_ANDROID_RELSZ:
3070 android_relocs_size_ = d->d_un.d_val;
3071 break;
3072
3073 case DT_ANDROID_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003074 DL_ERR("unsupported DT_ANDROID_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003075 return false;
3076
3077 case DT_ANDROID_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003078 DL_ERR("unsupported DT_ANDROID_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003079 return false;
3080
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003081 // "Indicates that all RELATIVE relocations have been concatenated together,
3082 // and specifies the RELATIVE relocation count."
3083 //
3084 // TODO: Spec also mentions that this can be used to optimize relocation process;
3085 // Not currently used by bionic linker - ignored.
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003086 case DT_RELCOUNT:
Dmitriy Ivanov4a6e9a82014-09-16 15:51:25 -07003087 break;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003088
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003089 case DT_RELA:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003090 DL_ERR("unsupported DT_RELA in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003091 return false;
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003092
3093 case DT_RELASZ:
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003094 DL_ERR("unsupported DT_RELASZ in \"%s\"", get_realpath());
Dmitriy Ivanov18a69562015-02-04 16:05:30 -08003095 return false;
3096
Elliott Hughesc00f2cb2013-10-04 17:01:33 -07003097#endif
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003098 case DT_RELR:
Elliott Hughes6663f552020-01-24 14:36:10 -08003099 case DT_ANDROID_RELR:
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003100 relr_ = reinterpret_cast<ElfW(Relr)*>(load_bias + d->d_un.d_ptr);
3101 break;
3102
3103 case DT_RELRSZ:
Elliott Hughes6663f552020-01-24 14:36:10 -08003104 case DT_ANDROID_RELRSZ:
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003105 relr_count_ = d->d_un.d_val / sizeof(ElfW(Relr));
3106 break;
3107
3108 case DT_RELRENT:
Elliott Hughes6663f552020-01-24 14:36:10 -08003109 case DT_ANDROID_RELRENT:
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003110 if (d->d_un.d_val != sizeof(ElfW(Relr))) {
3111 DL_ERR("invalid DT_RELRENT: %zd", static_cast<size_t>(d->d_un.d_val));
3112 return false;
3113 }
3114 break;
3115
3116 // Ignored (see DT_RELCOUNT comments for details).
Elliott Hughes6663f552020-01-24 14:36:10 -08003117 // There is no DT_RELRCOUNT specifically because it would only be ignored.
3118 case DT_ANDROID_RELRCOUNT:
Rahul Chaudhryb7feec72017-12-19 15:25:23 -08003119 break;
3120
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003121 case DT_INIT:
Dimitry Ivanov55437462016-07-20 15:33:07 -07003122 init_func_ = reinterpret_cast<linker_ctor_function_t>(load_bias + d->d_un.d_ptr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003123 LD_DEBUG(dynamic, "%s constructors (DT_INIT) found at %p", get_realpath(), init_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003124 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003125
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003126 case DT_FINI:
Dimitry Ivanov55437462016-07-20 15:33:07 -07003127 fini_func_ = reinterpret_cast<linker_dtor_function_t>(load_bias + d->d_un.d_ptr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003128 LD_DEBUG(dynamic, "%s destructors (DT_FINI) found at %p", get_realpath(), fini_func_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003129 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003130
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003131 case DT_INIT_ARRAY:
Dimitry Ivanov55437462016-07-20 15:33:07 -07003132 init_array_ = reinterpret_cast<linker_ctor_function_t*>(load_bias + d->d_un.d_ptr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003133 LD_DEBUG(dynamic, "%s constructors (DT_INIT_ARRAY) found at %p", get_realpath(), init_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003134 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003135
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003136 case DT_INIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003137 init_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003138 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003139
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003140 case DT_FINI_ARRAY:
Dimitry Ivanov55437462016-07-20 15:33:07 -07003141 fini_array_ = reinterpret_cast<linker_dtor_function_t*>(load_bias + d->d_un.d_ptr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003142 LD_DEBUG(dynamic, "%s destructors (DT_FINI_ARRAY) found at %p", get_realpath(), fini_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003143 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003144
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003145 case DT_FINI_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003146 fini_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003147 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003148
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003149 case DT_PREINIT_ARRAY:
Dimitry Ivanov55437462016-07-20 15:33:07 -07003150 preinit_array_ = reinterpret_cast<linker_ctor_function_t*>(load_bias + d->d_un.d_ptr);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003151 LD_DEBUG(dynamic, "%s constructors (DT_PREINIT_ARRAY) found at %p", get_realpath(), preinit_array_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003152 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003153
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003154 case DT_PREINIT_ARRAYSZ:
Dmitriy Ivanov1649e7e2015-01-22 16:04:25 -08003155 preinit_array_count_ = static_cast<uint32_t>(d->d_un.d_val) / sizeof(ElfW(Addr));
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003156 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003157
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003158 case DT_TEXTREL:
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003159#if defined(__LP64__)
Dimitry Ivanov816676e2016-10-19 11:00:28 -07003160 DL_ERR("\"%s\" has text relocations", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003161 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003162#else
3163 has_text_relocations = true;
3164 break;
3165#endif
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003166
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003167 case DT_SYMBOLIC:
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07003168 has_DT_SYMBOLIC = true;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003169 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003170
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003171 case DT_NEEDED:
3172 ++needed_count;
3173 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003174
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003175 case DT_FLAGS:
3176 if (d->d_un.d_val & DF_TEXTREL) {
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003177#if defined(__LP64__)
Dimitry Ivanov816676e2016-10-19 11:00:28 -07003178 DL_ERR("\"%s\" has text relocations", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003179 return false;
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003180#else
3181 has_text_relocations = true;
3182#endif
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003183 }
Dmitriy Ivanov96bc37f2014-09-29 12:10:36 -07003184 if (d->d_un.d_val & DF_SYMBOLIC) {
3185 has_DT_SYMBOLIC = true;
3186 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003187 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003188
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003189 case DT_FLAGS_1:
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003190 set_dt_flags_1(d->d_un.d_val);
Dmitriy Ivanov1b20daf2014-05-19 15:06:58 -07003191
Dmitriy Ivanovd225a5e2014-08-28 14:12:12 -07003192 if ((d->d_un.d_val & ~SUPPORTED_DT_FLAGS_1) != 0) {
Elliott Hughes9076b0c2018-02-28 11:29:45 -08003193 DL_WARN("Warning: \"%s\" has unsupported flags DT_FLAGS_1=%p "
3194 "(ignoring unsupported flags)",
3195 get_realpath(), reinterpret_cast<void*>(d->d_un.d_val));
Dmitriy Ivanov6cdeb522014-09-29 19:14:45 -07003196 }
3197 break;
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003198
Dmitriy Ivanovea6eae12014-10-15 14:59:01 -07003199 // Ignored: "Its use has been superseded by the DF_BIND_NOW flag"
3200 case DT_BIND_NOW:
3201 break;
3202
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003203 case DT_VERSYM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003204 versym_ = reinterpret_cast<ElfW(Versym)*>(load_bias + d->d_un.d_ptr);
3205 break;
3206
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003207 case DT_VERDEF:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003208 verdef_ptr_ = load_bias + d->d_un.d_ptr;
3209 break;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003210 case DT_VERDEFNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003211 verdef_cnt_ = d->d_un.d_val;
3212 break;
3213
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03003214 case DT_VERNEED:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003215 verneed_ptr_ = load_bias + d->d_un.d_ptr;
3216 break;
3217
Alexander Ivchenkoe8314332014-12-02 15:32:25 +03003218 case DT_VERNEEDNUM:
Dmitriy Ivanov2a815362015-04-09 13:42:33 -07003219 verneed_cnt_ = d->d_un.d_val;
Dmitriy Ivanov513e29e2014-10-06 11:30:43 -07003220 break;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003221
Evgenii Stepanov68650822015-06-10 13:38:39 -07003222 case DT_RUNPATH:
3223 // this is parsed after we have strtab initialized (see below).
3224 break;
3225
Ryan Prichardea41ab02019-01-23 16:33:03 -08003226 case DT_TLSDESC_GOT:
3227 case DT_TLSDESC_PLT:
3228 // These DT entries are used for lazy TLSDESC relocations. Bionic
3229 // resolves everything eagerly, so these can be ignored.
3230 break;
3231
Tamas Petz8d55d182020-02-24 14:15:25 +01003232#if defined(__aarch64__)
3233 case DT_AARCH64_BTI_PLT:
3234 case DT_AARCH64_PAC_PLT:
3235 case DT_AARCH64_VARIANT_PCS:
3236 // Ignored: AArch64 processor-specific dynamic array tags.
3237 break;
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003238 case DT_AARCH64_MEMTAG_MODE:
Mitch Phillips7c1f3772023-09-28 13:45:59 +02003239 memtag_dynamic_entries_.has_memtag_mode = true;
3240 memtag_dynamic_entries_.memtag_mode = d->d_un.d_val;
3241 break;
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003242 case DT_AARCH64_MEMTAG_HEAP:
Mitch Phillips7c1f3772023-09-28 13:45:59 +02003243 memtag_dynamic_entries_.memtag_heap = d->d_un.d_val;
3244 break;
3245 // The AArch64 MemtagABI originally erroneously defined
3246 // DT_AARCH64_MEMTAG_STACK as `d_ptr`, which is why the dynamic tag value
3247 // is odd (`0x7000000c`). `d_val` is clearly the correct semantics, and so
3248 // this was fixed in the ABI, but the value (0x7000000c) didn't change
3249 // because we already had Android binaries floating around with dynamic
3250 // entries, and didn't want to create a whole new dynamic entry and
3251 // reserve a value just to fix that tiny mistake. P.S. lld was always
3252 // outputting DT_AARCH64_MEMTAG_STACK as `d_val` anyway.
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003253 case DT_AARCH64_MEMTAG_STACK:
Mitch Phillips7c1f3772023-09-28 13:45:59 +02003254 memtag_dynamic_entries_.memtag_stack = d->d_un.d_val;
3255 break;
3256 // Same as above, except DT_AARCH64_MEMTAG_GLOBALS was incorrectly defined
3257 // as `d_val` (hence an even value of `0x7000000d`), when it should have
3258 // been `d_ptr` all along. lld has always outputted this as `d_ptr`.
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003259 case DT_AARCH64_MEMTAG_GLOBALS:
Mitch Phillips7c1f3772023-09-28 13:45:59 +02003260 memtag_dynamic_entries_.memtag_globals = reinterpret_cast<void*>(load_bias + d->d_un.d_ptr);
3261 break;
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003262 case DT_AARCH64_MEMTAG_GLOBALSSZ:
Mitch Phillips7c1f3772023-09-28 13:45:59 +02003263 memtag_dynamic_entries_.memtag_globalssz = d->d_un.d_val;
Mitch Phillips2e25c0f2023-03-17 11:29:03 -07003264 break;
Tamas Petz8d55d182020-02-24 14:15:25 +01003265#endif
3266
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003267 default:
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07003268 if (!relocating_linker) {
Elliott Hughes6eae4cc2017-08-30 09:02:33 -07003269 const char* tag_name;
3270 if (d->d_tag == DT_RPATH) {
3271 tag_name = "DT_RPATH";
3272 } else if (d->d_tag == DT_ENCODING) {
3273 tag_name = "DT_ENCODING";
3274 } else if (d->d_tag >= DT_LOOS && d->d_tag <= DT_HIOS) {
3275 tag_name = "unknown OS-specific";
3276 } else if (d->d_tag >= DT_LOPROC && d->d_tag <= DT_HIPROC) {
3277 tag_name = "unknown processor-specific";
3278 } else {
3279 tag_name = "unknown";
3280 }
Elliott Hughes9076b0c2018-02-28 11:29:45 -08003281 DL_WARN("Warning: \"%s\" unused DT entry: %s (type %p arg %p) (ignoring)",
Elliott Hughes6eae4cc2017-08-30 09:02:33 -07003282 get_realpath(),
3283 tag_name,
3284 reinterpret_cast<void*>(d->d_tag),
3285 reinterpret_cast<void*>(d->d_un.d_val));
Dmitriy Ivanov8f61d992014-09-16 14:31:06 -07003286 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003287 break;
Brian Carlstromd4ee82d2013-02-28 15:58:45 -08003288 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003289 }
3290
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003291 LD_DEBUG(dynamic, "si->base = %p, si->strtab = %p, si->symtab = %p",
3292 reinterpret_cast<void*>(base), strtab_, symtab_);
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003293
Elliott Hughes68ae6ad2020-07-21 16:11:30 -07003294 // Validity checks.
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003295 if (relocating_linker && needed_count != 0) {
3296 DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
3297 return false;
3298 }
Dmitriy Ivanov3597b802015-03-09 12:02:02 -07003299 if (nbucket_ == 0 && gnu_nbucket_ == 0) {
Dmitriy Ivanovaae859c2015-03-31 11:14:03 -07003300 DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" "
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003301 "(new hash type from the future?)", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003302 return false;
3303 }
Yi Kong32bc0fc2018-08-02 17:31:13 -07003304 if (strtab_ == nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003305 DL_ERR("empty/missing DT_STRTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003306 return false;
3307 }
Yi Kong32bc0fc2018-08-02 17:31:13 -07003308 if (symtab_ == nullptr) {
Dmitriy Ivanov3edb9182015-05-07 10:48:00 -07003309 DL_ERR("empty/missing DT_SYMTAB in \"%s\"", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003310 return false;
3311 }
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003312
Ryan Prichardbb1e3732021-01-12 23:09:10 -08003313 // Second pass - parse entries relying on strtab. Skip this while relocating the linker so as to
3314 // avoid doing heap allocations until later in the linker's initialization.
3315 if (!relocating_linker) {
3316 for (ElfW(Dyn)* d = dynamic; d->d_tag != DT_NULL; ++d) {
3317 switch (d->d_tag) {
3318 case DT_SONAME:
3319 set_soname(get_string(d->d_un.d_val));
3320 break;
3321 case DT_RUNPATH:
3322 set_dt_runpath(get_string(d->d_un.d_val));
3323 break;
3324 }
Dmitriy Ivanov624b8f12015-06-08 10:41:33 -07003325 }
3326 }
3327
Elliott Hughesc14f5452025-01-30 13:33:04 -08003328 // Before API 23, the linker used the basename in place of DT_SONAME.
3329 // After we switched, apps with libraries without a DT_SONAME stopped working:
3330 // they could no longer be found by DT_NEEDED from another library.
3331 // The main executable does not need to have a DT_SONAME.
3332 // The linker has a DT_SONAME, but the soname_ field is initialized later on.
Ryan Prichardbb1e3732021-01-12 23:09:10 -08003333 if (soname_.empty() && this != solist_get_somain() && !relocating_linker &&
Elliott Hughes95c6cd72019-12-20 13:26:14 -08003334 get_application_target_sdk_version() < 23) {
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003335 soname_ = basename(realpath_.c_str());
Elliott Hughesc14f5452025-01-30 13:33:04 -08003336 // The `if` above means we don't get here for api levels >= 23,
3337 // so no need to check the return value of DL_ERROR_AFTER().
3338 // We still call it rather than DL_WARN() to get the extra clarification.
3339 DL_ERROR_AFTER(23, "\"%s\" has no DT_SONAME (will use %s instead)",
3340 get_realpath(), soname_.c_str());
Dmitriy Ivanov75108f42015-06-02 13:28:06 -07003341 }
Ryan Prichardae320cd2019-12-10 12:39:05 -08003342
Ryan Prichard0e12cce2020-01-02 14:59:11 -08003343 // Validate each library's verdef section once, so we don't have to validate
3344 // it each time we look up a symbol with a version.
3345 if (!validate_verdef_section(this)) return false;
3346
Florian Mayer4edc20d2024-10-30 14:24:26 -07003347 // MTE globals requires remapping data segments with PROT_MTE as anonymous mappings, because file
3348 // based mappings may not be backed by tag-capable memory (see "MAP_ANONYMOUS" on
3349 // https://www.kernel.org/doc/html/latest/arch/arm64/memory-tagging-extension.html). This is only
3350 // done if the binary has MTE globals (evidenced by the dynamic table entries), as it destroys
3351 // page sharing. It's also only done on devices that support MTE, because the act of remapping
3352 // pages is unnecessary on non-MTE devices (where we might still run MTE-globals enabled code).
3353 if (should_tag_memtag_globals() &&
3354 remap_memtag_globals_segments(phdr, phnum, base) == 0) {
Mitch Phillips28057b82024-08-21 19:43:08 +02003355 tag_globals(dlext_use_relro);
Florian Mayer4edc20d2024-10-30 14:24:26 -07003356 protect_memtag_globals_ro_segments(phdr, phnum, base);
3357 }
3358
Ryan Prichardae320cd2019-12-10 12:39:05 -08003359 flags_ |= FLAG_PRELINKED;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003360 return true;
Dmitriy Ivanov14669a92014-09-05 16:42:53 -07003361}
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003362
Ryan Prichard339ecef2020-01-02 16:36:06 -08003363bool soinfo::link_image(const SymbolLookupList& lookup_list, soinfo* local_group_root,
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -04003364 const android_dlextinfo* extinfo, size_t* relro_fd_offset) {
dimitry965d06d2017-11-28 16:03:07 +01003365 if (is_image_linked()) {
3366 // already linked.
3367 return true;
3368 }
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003369
Elliott Hughes90f96b92019-05-09 15:56:39 -07003370 if (g_is_ldd && !is_main_executable()) {
3371 async_safe_format_fd(STDOUT_FILENO, "\t%s => %s (%p)\n", get_soname(),
3372 get_realpath(), reinterpret_cast<void*>(base));
3373 }
3374
Ryan Prichard339ecef2020-01-02 16:36:06 -08003375 local_group_root_ = local_group_root;
Dmitriy Ivanovab972b92014-11-29 13:57:41 -08003376 if (local_group_root_ == nullptr) {
3377 local_group_root_ = this;
3378 }
3379
Dmitriy Ivanov19133522015-06-02 17:36:54 -07003380 if ((flags_ & FLAG_LINKER) == 0 && local_group_root_ == this) {
3381 target_sdk_version_ = get_application_target_sdk_version();
3382 }
3383
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003384#if !defined(__LP64__)
3385 if (has_text_relocations) {
Elliott Hughesc14f5452025-01-30 13:33:04 -08003386 if (DL_ERROR_AFTER(23, "\"%s\" has text relocations", get_realpath())) {
Dmitriy Ivanove4ad91f2015-06-12 15:00:31 -07003387 return false;
3388 }
Elliott Hughesc14f5452025-01-30 13:33:04 -08003389 add_dlwarning(get_realpath(), "text relocations");
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003390 // Make segments writable to allow text relocations to work properly. We will later call
Dmitriy Ivanov7e039932015-10-01 14:02:19 -07003391 // phdr_table_protect_segments() after all of them are applied.
Kalesh Singhb23787f2024-09-05 08:22:06 +00003392 if (phdr_table_unprotect_segments(phdr, phnum, load_bias, should_pad_segments_,
3393 should_use_16kib_app_compat_) < 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00003394 DL_ERR("can't unprotect loadable segments for \"%s\": %m", get_realpath());
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003395 return false;
3396 }
3397 }
3398#endif
3399
Elliott Hughes54564df2024-07-19 13:59:51 -04003400 if (this != solist_get_vdso() && !relocate(lookup_list)) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003401 return false;
3402 }
Raghu Gandhamd7daacb2012-07-31 12:07:22 -07003403
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003404 LD_DEBUG(any, "[ finished linking %s ]", get_realpath());
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003405
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003406#if !defined(__LP64__)
3407 if (has_text_relocations) {
3408 // All relocations are done, we can protect our segments back to read-only.
Kalesh Singhb23787f2024-09-05 08:22:06 +00003409 if (phdr_table_protect_segments(phdr, phnum, load_bias, should_pad_segments_,
3410 should_use_16kib_app_compat_) < 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00003411 DL_ERR("can't protect segments for \"%s\": %m", get_realpath());
Dimitry Ivanov56be6ed2015-04-01 21:18:48 +00003412 return false;
3413 }
3414 }
3415#endif
3416
Mingwei Shibe910522015-11-12 07:02:14 +00003417 // We can also turn on GNU RELRO protection if we're not linking the dynamic linker
3418 // itself --- it can't make system calls yet, and will have to call protect_relro later.
3419 if (!is_linker() && !protect_relro()) {
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003420 return false;
3421 }
Nick Kralevich9ec0f032012-02-28 10:40:00 -08003422
Florian Mayer4edc20d2024-10-30 14:24:26 -07003423 if (should_tag_memtag_globals()) {
3424 std::list<std::string>* vma_names_ptr = vma_names();
3425 // should_tag_memtag_globals -> __aarch64__ -> vma_names() != nullptr
3426 CHECK(vma_names_ptr);
3427 name_memtag_globals_segments(phdr, phnum, base, get_realpath(), vma_names_ptr);
3428 }
3429
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003430 /* Handle serializing/sharing the RELRO segment */
3431 if (extinfo && (extinfo->flags & ANDROID_DLEXT_WRITE_RELRO)) {
3432 if (phdr_table_serialize_gnu_relro(phdr, phnum, load_bias,
Torne (Richard Coles)fa9f7f22019-04-02 17:04:42 -04003433 extinfo->relro_fd, relro_fd_offset) < 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00003434 DL_ERR("failed serializing GNU RELRO section for \"%s\": %m", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003435 return false;
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00003436 }
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003437 } else if (extinfo && (extinfo->flags & ANDROID_DLEXT_USE_RELRO)) {
3438 if (phdr_table_map_gnu_relro(phdr, phnum, load_bias,
Torne (Richard Coles)efbe9a52018-10-17 15:59:38 -04003439 extinfo->relro_fd, relro_fd_offset) < 0) {
Elliott Hughesf5e21d92024-07-26 11:48:19 +00003440 DL_ERR("failed mapping GNU RELRO section for \"%s\": %m", get_realpath());
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003441 return false;
3442 }
3443 }
Torne (Richard Coles)183ad9d2014-02-27 13:18:00 +00003444
Ryan Pricharda2e83ab2019-08-16 17:25:43 -07003445 ++g_module_load_counter;
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003446 notify_gdb_of_load(this);
dimitry965d06d2017-11-28 16:03:07 +01003447 set_image_linked();
Dmitriy Ivanov6abf6242014-09-12 09:43:13 -07003448 return true;
The Android Open Source Project1dc9e472009-03-03 19:28:35 -08003449}
3450
Mingwei Shibe910522015-11-12 07:02:14 +00003451bool soinfo::protect_relro() {
Kalesh Singhce1c3cf2024-09-30 13:26:23 -07003452 if (should_use_16kib_app_compat_) {
3453 if (phdr_table_protect_gnu_relro_16kib_compat(compat_relro_start_, compat_relro_size_) < 0) {
3454 DL_ERR("can't enable COMPAT GNU RELRO protection for \"%s\": %s", get_realpath(),
3455 strerror(errno));
3456 return false;
3457 }
3458 } else {
3459 if (phdr_table_protect_gnu_relro(phdr, phnum, load_bias, should_pad_segments_,
3460 should_use_16kib_app_compat_) < 0) {
3461 DL_ERR("can't enable GNU RELRO protection for \"%s\": %m", get_realpath());
3462 return false;
3463 }
Mingwei Shibe910522015-11-12 07:02:14 +00003464 }
3465 return true;
3466}
3467
Florian Mayer4edc20d2024-10-30 14:24:26 -07003468// https://github.com/ARM-software/abi-aa/blob/main/memtagabielf64/memtagabielf64.rst#global-variable-tagging
Mitch Phillips28057b82024-08-21 19:43:08 +02003469void soinfo::tag_globals(bool dlext_use_relro) {
Florian Mayer4edc20d2024-10-30 14:24:26 -07003470 if (is_linked()) return;
3471 if (flags_ & FLAG_GLOBALS_TAGGED) return;
3472 flags_ |= FLAG_GLOBALS_TAGGED;
3473
3474 constexpr size_t kTagGranuleSize = 16;
3475 const uint8_t* descriptor_stream = reinterpret_cast<const uint8_t*>(memtag_globals());
3476
3477 if (memtag_globalssz() == 0) {
3478 DL_ERR("Invalid memtag descriptor pool size: %zu", memtag_globalssz());
3479 }
3480
3481 uint64_t addr = load_bias;
3482 uleb128_decoder decoder(descriptor_stream, memtag_globalssz());
3483 // Don't ever generate tag zero, to easily distinguish between tagged and
3484 // untagged globals in register/tag dumps.
3485 uint64_t last_tag_mask = 1;
Mitch Phillips28057b82024-08-21 19:43:08 +02003486 uint64_t last_tag = 1;
Florian Mayer4edc20d2024-10-30 14:24:26 -07003487 constexpr uint64_t kDistanceReservedBits = 3;
3488
3489 while (decoder.has_bytes()) {
3490 uint64_t value = decoder.pop_front();
3491 uint64_t distance = (value >> kDistanceReservedBits) * kTagGranuleSize;
3492 uint64_t ngranules = value & ((1 << kDistanceReservedBits) - 1);
3493 if (ngranules == 0) {
3494 ngranules = decoder.pop_front() + 1;
3495 }
3496
3497 addr += distance;
3498 void* tagged_addr;
Mitch Phillips28057b82024-08-21 19:43:08 +02003499 if (dlext_use_relro) {
3500 tagged_addr = reinterpret_cast<void*>(addr | (last_tag++ << 56));
3501 if (last_tag > (1 << kTagGranuleSize)) last_tag = 1;
3502 } else {
3503 tagged_addr = insert_random_tag(reinterpret_cast<void*>(addr), last_tag_mask);
3504 uint64_t tag = (reinterpret_cast<uint64_t>(tagged_addr) >> 56) & 0x0f;
3505 last_tag_mask = 1 | (1 << tag);
3506 }
Florian Mayer4edc20d2024-10-30 14:24:26 -07003507
3508 for (size_t k = 0; k < ngranules; k++) {
3509 auto* granule = static_cast<uint8_t*>(tagged_addr) + k * kTagGranuleSize;
3510 set_memory_tag(static_cast<void*>(granule));
3511 }
3512 addr += ngranules * kTagGranuleSize;
3513 }
3514}
3515
Florian Mayerc10d0642023-03-22 16:12:49 -07003516static std::vector<android_namespace_t*> init_default_namespace_no_config(bool is_asan, bool is_hwasan) {
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003517 g_default_namespace.set_isolated(false);
Florian Mayerc10d0642023-03-22 16:12:49 -07003518 auto default_ld_paths = is_asan ? kAsanDefaultLdPaths : (
3519 is_hwasan ? kHwsanDefaultLdPaths : kDefaultLdPaths);
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003520
neo.chae2589f9d2016-10-04 11:00:27 +09003521 char real_path[PATH_MAX];
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003522 std::vector<std::string> ld_default_paths;
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08003523 for (size_t i = 0; default_ld_paths[i] != nullptr; ++i) {
3524 if (realpath(default_ld_paths[i], real_path) != nullptr) {
neo.chae2589f9d2016-10-04 11:00:27 +09003525 ld_default_paths.push_back(real_path);
3526 } else {
Dimitry Ivanov77ad6422017-03-06 13:02:29 -08003527 ld_default_paths.push_back(default_ld_paths[i]);
neo.chae2589f9d2016-10-04 11:00:27 +09003528 }
Dmitriy Ivanov42d5fcb2015-10-29 17:01:24 -07003529 }
3530
3531 g_default_namespace.set_default_library_paths(std::move(ld_default_paths));
Jiyong Park02586a22017-05-20 01:01:24 +09003532
3533 std::vector<android_namespace_t*> namespaces;
3534 namespaces.push_back(&g_default_namespace);
3535 return namespaces;
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003536}
3537
Roland Levillain57e6b862020-02-12 17:34:20 +00003538// Given an `executable_path` starting with "/apex/<name>/bin/, return
Jiyong Park2bac1f82022-04-05 14:03:34 +09003539// "/linkerconfig/<name>/ld.config.txt", which is the auto-generated config file for the APEX by the
3540// linkerconfig tool.
Jiyong Park35833412018-10-26 14:45:21 +09003541static std::string get_ld_config_file_apex_path(const char* executable_path) {
3542 std::vector<std::string> paths = android::base::Split(executable_path, "/");
Roland Levillaindc25f6c2019-07-02 16:40:19 +01003543 if (paths.size() >= 5 && paths[1] == "apex" && paths[3] == "bin") {
Kiyoung Kimfb587442020-01-29 16:31:54 +09003544 std::string generated_apex_config = "/linkerconfig/" + paths[2] + "/ld.config.txt";
3545 if (file_exists(generated_apex_config.c_str())) {
3546 return generated_apex_config;
3547 }
Jiyong Park35833412018-10-26 14:45:21 +09003548 }
3549 return "";
3550}
3551
Logan Chien886b96e2018-05-08 17:52:18 +08003552static std::string get_ld_config_file_vndk_path() {
Roland Levillain09bde952019-10-29 19:17:49 +00003553 if (android::base::GetBoolProperty("ro.vndk.lite", false)) {
3554 return kLdConfigVndkLiteFilePath;
Logan Chienbcfe3cf2018-05-08 20:17:26 +08003555 }
3556
Roland Levillain09bde952019-10-29 19:17:49 +00003557 std::string ld_config_file_vndk = kLdConfigFilePath;
3558 size_t insert_pos = ld_config_file_vndk.find_last_of('.');
3559 if (insert_pos == std::string::npos) {
3560 insert_pos = ld_config_file_vndk.length();
3561 }
3562 ld_config_file_vndk.insert(insert_pos, Config::get_vndk_version_string('.'));
3563 return ld_config_file_vndk;
Logan Chien886b96e2018-05-08 17:52:18 +08003564}
3565
Kiyoung Kim46e731c2020-06-26 16:54:50 +09003566bool is_linker_config_expected(const char* executable_path) {
3567 // Do not raise message from a host environment which is expected to miss generated linker
3568 // configuration.
3569#if !defined(__ANDROID__)
3570 return false;
3571#endif
3572
3573 if (strcmp(executable_path, "/system/bin/init") == 0) {
3574 // Generated linker configuration can be missed from processes executed
3575 // with init binary
3576 return false;
3577 }
3578
3579 return true;
3580}
3581
Jiyong Park35833412018-10-26 14:45:21 +09003582static std::string get_ld_config_file_path(const char* executable_path) {
Logan Chien886b96e2018-05-08 17:52:18 +08003583#ifdef USE_LD_CONFIG_FILE
3584 // This is a debugging/testing only feature. Must not be available on
3585 // production builds.
3586 const char* ld_config_file_env = getenv("LD_CONFIG_FILE");
3587 if (ld_config_file_env != nullptr && file_exists(ld_config_file_env)) {
3588 return ld_config_file_env;
3589 }
3590#endif
3591
Jiyong Park35833412018-10-26 14:45:21 +09003592 std::string path = get_ld_config_file_apex_path(executable_path);
3593 if (!path.empty()) {
3594 if (file_exists(path.c_str())) {
3595 return path;
3596 }
3597 DL_WARN("Warning: couldn't read config file \"%s\" for \"%s\"",
3598 path.c_str(), executable_path);
Logan Chien886b96e2018-05-08 17:52:18 +08003599 }
3600
Evgeny Eltsinff43ec02019-12-16 19:22:07 +01003601 path = kLdConfigArchFilePath;
3602 if (file_exists(path.c_str())) {
3603 return path;
3604 }
3605
Kiyoung Kim18786902020-02-12 07:47:37 +09003606 if (file_exists(kLdGeneratedConfigFilePath)) {
3607 return kLdGeneratedConfigFilePath;
Kiyoung Kimef04c802019-12-13 12:19:56 +09003608 }
3609
Kiyoung Kim46e731c2020-06-26 16:54:50 +09003610 if (is_linker_config_expected(executable_path)) {
3611 DL_WARN("Warning: failed to find generated linker configuration from \"%s\"",
3612 kLdGeneratedConfigFilePath);
3613 }
Kiyoung Kim8bc03532020-03-16 13:22:27 +09003614
Jiyong Park35833412018-10-26 14:45:21 +09003615 path = get_ld_config_file_vndk_path();
Roland Levillain09bde952019-10-29 19:17:49 +00003616 if (file_exists(path.c_str())) {
Jiyong Park35833412018-10-26 14:45:21 +09003617 return path;
Logan Chien886b96e2018-05-08 17:52:18 +08003618 }
3619
3620 return kLdConfigFilePath;
3621}
3622
Florian Mayerc10d0642023-03-22 16:12:49 -07003623
Jiyong Park02586a22017-05-20 01:01:24 +09003624std::vector<android_namespace_t*> init_default_namespaces(const char* executable_path) {
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003625 g_default_namespace.set_name("(default)");
3626
3627 soinfo* somain = solist_get_somain();
3628
3629 const char *interp = phdr_table_get_interpreter_name(somain->phdr, somain->phnum,
3630 somain->load_bias);
Dan Willemsen7ccc50d2017-09-18 21:28:14 -07003631 const char* bname = (interp != nullptr) ? basename(interp) : nullptr;
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003632
3633 g_is_asan = bname != nullptr &&
3634 (strcmp(bname, "linker_asan") == 0 ||
3635 strcmp(bname, "linker_asan64") == 0);
3636
Florian Mayerc10d0642023-03-22 16:12:49 -07003637#if defined(__aarch64__)
3638 // HWASan is only supported on AArch64.
3639 // The AT_SECURE restriction is because this is a debug feature that does
3640 // not need to work on secure binaries, it doesn't hurt to disallow the
3641 // environment variable for them, as it impacts the program execution.
3642 char* hwasan_env = getenv("LD_HWASAN");
3643 g_is_hwasan = (bname != nullptr &&
3644 strcmp(bname, "linker_hwasan64") == 0) ||
3645 (hwasan_env != nullptr && !getauxval(AT_SECURE) && strcmp(hwasan_env, "1") == 0);
3646#endif
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003647 const Config* config = nullptr;
3648
Elliott Hughes658b9382020-11-06 09:27:36 -08003649 {
3650 std::string ld_config_file_path = get_ld_config_file_path(executable_path);
Elliott Hughesf08d0eb2024-09-03 17:31:29 -04003651 LD_DEBUG(any, "[ Reading linker config \"%s\" ]", ld_config_file_path.c_str());
Elliott Hughes658b9382020-11-06 09:27:36 -08003652 ScopedTrace trace(("linker config " + ld_config_file_path).c_str());
3653 std::string error_msg;
Florian Mayerc10d0642023-03-22 16:12:49 -07003654 if (!Config::read_binary_config(ld_config_file_path.c_str(), executable_path, g_is_asan, g_is_hwasan,
Elliott Hughes658b9382020-11-06 09:27:36 -08003655 &config, &error_msg)) {
3656 if (!error_msg.empty()) {
3657 DL_WARN("Warning: couldn't read '%s' for '%s' (using default configuration instead): %s",
3658 ld_config_file_path.c_str(), executable_path, error_msg.c_str());
3659 }
3660 config = nullptr;
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003661 }
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003662 }
3663
3664 if (config == nullptr) {
Florian Mayerc10d0642023-03-22 16:12:49 -07003665 return init_default_namespace_no_config(g_is_asan, g_is_hwasan);
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003666 }
3667
3668 const auto& namespace_configs = config->namespace_configs();
3669 std::unordered_map<std::string, android_namespace_t*> namespaces;
3670
3671 // 1. Initialize default namespace
3672 const NamespaceConfig* default_ns_config = config->default_namespace_config();
3673
3674 g_default_namespace.set_isolated(default_ns_config->isolated());
3675 g_default_namespace.set_default_library_paths(default_ns_config->search_paths());
3676 g_default_namespace.set_permitted_paths(default_ns_config->permitted_paths());
3677
3678 namespaces[default_ns_config->name()] = &g_default_namespace;
Justin Yun90de9f02017-07-07 16:21:53 +09003679 if (default_ns_config->visible()) {
3680 g_exported_namespaces[default_ns_config->name()] = &g_default_namespace;
3681 }
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003682
3683 // 2. Initialize other namespaces
3684
3685 for (auto& ns_config : namespace_configs) {
Elliott Hughes192f3cf2024-06-25 11:21:41 +00003686 if (namespaces.contains(ns_config->name())) {
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003687 continue;
3688 }
3689
3690 android_namespace_t* ns = new (g_namespace_allocator.alloc()) android_namespace_t();
3691 ns->set_name(ns_config->name());
3692 ns->set_isolated(ns_config->isolated());
3693 ns->set_default_library_paths(ns_config->search_paths());
3694 ns->set_permitted_paths(ns_config->permitted_paths());
Luke Huang30f2f052020-07-30 15:09:18 +08003695 ns->set_allowed_libs(ns_config->allowed_libs());
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003696
3697 namespaces[ns_config->name()] = ns;
Jiyong Park01de74e2017-04-03 23:10:37 +09003698 if (ns_config->visible()) {
3699 g_exported_namespaces[ns_config->name()] = ns;
3700 }
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003701 }
3702
3703 // 3. Establish links between namespaces
3704 for (auto& ns_config : namespace_configs) {
3705 auto it_from = namespaces.find(ns_config->name());
3706 CHECK(it_from != namespaces.end());
3707 android_namespace_t* namespace_from = it_from->second;
3708 for (const NamespaceLinkConfig& ns_link : ns_config->links()) {
3709 auto it_to = namespaces.find(ns_link.ns_name());
3710 CHECK(it_to != namespaces.end());
3711 android_namespace_t* namespace_to = it_to->second;
Logan Chien9ee45912018-01-18 12:05:09 +08003712 if (ns_link.allow_all_shared_libs()) {
3713 link_namespaces_all_libs(namespace_from, namespace_to);
3714 } else {
3715 link_namespaces(namespace_from, namespace_to, ns_link.shared_libs().c_str());
3716 }
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003717 }
3718 }
3719 // we can no longer rely on the fact that libdl.so is part of default namespace
3720 // this is why we want to add ld-android.so to all namespaces from ld.config.txt
3721 soinfo* ld_android_so = solist_get_head();
dimitry8b142562018-05-09 15:22:38 +02003722
3723 // we also need vdso to be available for all namespaces (if present)
3724 soinfo* vdso = solist_get_vdso();
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003725 for (auto it : namespaces) {
NIEJuhue2871bd2019-12-20 18:51:21 +08003726 if (it.second != &g_default_namespace) {
3727 it.second->add_soinfo(ld_android_so);
3728 if (vdso != nullptr) {
3729 it.second->add_soinfo(vdso);
3730 }
3731 // somain and ld_preloads are added to these namespaces after LD_PRELOAD libs are linked
dimitry8b142562018-05-09 15:22:38 +02003732 }
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003733 }
3734
3735 set_application_target_sdk_version(config->target_sdk_version());
Jiyong Park02586a22017-05-20 01:01:24 +09003736
3737 std::vector<android_namespace_t*> created_namespaces;
3738 created_namespaces.reserve(namespaces.size());
Chih-Hung Hsieh0218e922018-12-11 10:22:11 -08003739 for (const auto& kv : namespaces) {
Jiyong Park02586a22017-05-20 01:01:24 +09003740 created_namespaces.push_back(kv.second);
3741 }
3742 return created_namespaces;
Dimitry Ivanov4cabfaa2017-03-07 11:19:05 -08003743}
Jiyong Park01de74e2017-04-03 23:10:37 +09003744
3745// This function finds a namespace exported in ld.config.txt by its name.
3746// A namespace can be exported by setting .visible property to true.
3747android_namespace_t* get_exported_namespace(const char* name) {
3748 if (name == nullptr) {
3749 return nullptr;
3750 }
3751 auto it = g_exported_namespaces.find(std::string(name));
3752 if (it == g_exported_namespaces.end()) {
3753 return nullptr;
3754 }
3755 return it->second;
3756}
Vic Yangbb7e1232019-01-29 20:23:16 -08003757
3758void purge_unused_memory() {
3759 // For now, we only purge the memory used by LoadTask because we know those
3760 // are temporary objects.
3761 //
3762 // Purging other LinkerBlockAllocator hardly yields much because they hold
3763 // information about namespaces and opened libraries, which are not freed
3764 // when the control leaves the linker.
3765 //
3766 // Purging BionicAllocator may give us a few dirty pages back, but those pages
3767 // would be already zeroed out, so they compress easily in ZRAM. Therefore,
3768 // it is not worth munmap()'ing those pages.
3769 TypeBasedAllocator<LoadTask>::purge();
3770}