1 /* 2 * Copyright (C) 2007 The Android Open Source Project 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * * Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * * Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in 12 * the documentation and/or other materials provided with the 13 * distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 16 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 17 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 18 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 19 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 21 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 22 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 23 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 24 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 25 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 */ 28 29 #include "linker.h" 30 #include "linker_cfi.h" 31 #include "linker_globals.h" 32 #include "linker_dlwarning.h" 33 34 #include <pthread.h> 35 #include <stdio.h> 36 #include <stdlib.h> 37 #include <string.h> 38 #include <android/api-level.h> 39 40 #include <bionic/pthread_internal.h> 41 #include "private/bionic_tls.h" 42 #include "private/ScopedPthreadMutexLocker.h" 43 44 #define __LINKER_PUBLIC__ __attribute__((visibility("default"))) 45 46 extern "C" { 47 48 android_namespace_t* __loader_android_create_namespace(const char* name, 49 const char* ld_library_path, 50 const char* default_library_path, 51 uint64_t type, 52 const char* permitted_when_isolated_path, 53 android_namespace_t* parent_namespace, 54 const void* caller_addr) __LINKER_PUBLIC__; 55 void* __loader_android_dlopen_ext(const char* filename, 56 int flags, 57 const android_dlextinfo* extinfo, 58 const void* caller_addr) __LINKER_PUBLIC__; 59 void __loader_android_dlwarning(void* obj, void (*f)(void*, const char*)) __LINKER_PUBLIC__; 60 uint32_t __loader_android_get_application_target_sdk_version() __LINKER_PUBLIC__; 61 void __loader_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) __LINKER_PUBLIC__; 62 android_namespace_t* __loader_android_get_exported_namespace(const char* name) __LINKER_PUBLIC__; 63 bool __loader_android_init_anonymous_namespace(const char* shared_libs_sonames, 64 const char* library_search_path) __LINKER_PUBLIC__; 65 bool __loader_android_link_namespaces(android_namespace_t* namespace_from, 66 android_namespace_t* namespace_to, 67 const char* shared_libs_sonames) __LINKER_PUBLIC__; 68 bool __loader_android_link_namespaces_all_libs(android_namespace_t* namespace_from, 69 android_namespace_t* namespace_to) __LINKER_PUBLIC__; 70 void __loader_android_set_application_target_sdk_version(uint32_t target) __LINKER_PUBLIC__; 71 void __loader_android_update_LD_LIBRARY_PATH(const char* ld_library_path) __LINKER_PUBLIC__; 72 void __loader_cfi_fail(uint64_t CallSiteTypeId, 73 void* Ptr, 74 void *DiagData, 75 void *CallerPc) __LINKER_PUBLIC__; 76 int __loader_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), 77 void* data) __LINKER_PUBLIC__; 78 int __loader_dladdr(const void* addr, Dl_info* info) __LINKER_PUBLIC__; 79 int __loader_dlclose(void* handle) __LINKER_PUBLIC__; 80 char* __loader_dlerror() __LINKER_PUBLIC__; 81 void* __loader_dlopen(const char* filename, int flags, const void* caller_addr) __LINKER_PUBLIC__; 82 void* __loader_dlsym(void* handle, const char* symbol, const void* caller_addr) __LINKER_PUBLIC__; 83 void* __loader_dlvsym(void* handle, 84 const char* symbol, 85 const char* version, 86 const void* caller_addr) __LINKER_PUBLIC__; 87 void __loader_add_thread_local_dtor(void* dso_handle) __LINKER_PUBLIC__; 88 void __loader_remove_thread_local_dtor(void* dso_handle) __LINKER_PUBLIC__; 89 #if defined(__arm__) 90 _Unwind_Ptr __loader_dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) __LINKER_PUBLIC__; 91 #endif 92 } 93 94 static pthread_mutex_t g_dl_mutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP; 95 96 static char* __bionic_set_dlerror(char* new_value) { 97 char** dlerror_slot = &reinterpret_cast<char**>(__get_tls())[TLS_SLOT_DLERROR]; 98 99 char* old_value = *dlerror_slot; 100 *dlerror_slot = new_value; 101 if (new_value != nullptr) LD_LOG(kLogErrors, "dlerror set to \"%s\"", new_value); 102 return old_value; 103 } 104 105 static void __bionic_format_dlerror(const char* msg, const char* detail) { 106 char* buffer = __get_thread()->dlerror_buffer; 107 strlcpy(buffer, msg, __BIONIC_DLERROR_BUFFER_SIZE); 108 if (detail != nullptr) { 109 strlcat(buffer, ": ", __BIONIC_DLERROR_BUFFER_SIZE); 110 strlcat(buffer, detail, __BIONIC_DLERROR_BUFFER_SIZE); 111 } 112 113 __bionic_set_dlerror(buffer); 114 } 115 116 char* __loader_dlerror() { 117 char* old_value = __bionic_set_dlerror(nullptr); 118 return old_value; 119 } 120 121 void __loader_android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) { 122 ScopedPthreadMutexLocker locker(&g_dl_mutex); 123 do_android_get_LD_LIBRARY_PATH(buffer, buffer_size); 124 } 125 126 void __loader_android_update_LD_LIBRARY_PATH(const char* ld_library_path) { 127 ScopedPthreadMutexLocker locker(&g_dl_mutex); 128 do_android_update_LD_LIBRARY_PATH(ld_library_path); 129 } 130 131 static void* dlopen_ext(const char* filename, 132 int flags, 133 const android_dlextinfo* extinfo, 134 const void* caller_addr) { 135 ScopedPthreadMutexLocker locker(&g_dl_mutex); 136 g_linker_logger.ResetState(); 137 void* result = do_dlopen(filename, flags, extinfo, caller_addr); 138 if (result == nullptr) { 139 __bionic_format_dlerror("dlopen failed", linker_get_error_buffer()); 140 return nullptr; 141 } 142 return result; 143 } 144 145 void* __loader_android_dlopen_ext(const char* filename, 146 int flags, 147 const android_dlextinfo* extinfo, 148 const void* caller_addr) { 149 return dlopen_ext(filename, flags, extinfo, caller_addr); 150 } 151 152 void* __loader_dlopen(const char* filename, int flags, const void* caller_addr) { 153 return dlopen_ext(filename, flags, nullptr, caller_addr); 154 } 155 156 void* dlsym_impl(void* handle, const char* symbol, const char* version, const void* caller_addr) { 157 ScopedPthreadMutexLocker locker(&g_dl_mutex); 158 g_linker_logger.ResetState(); 159 void* result; 160 if (!do_dlsym(handle, symbol, version, caller_addr, &result)) { 161 __bionic_format_dlerror(linker_get_error_buffer(), nullptr); 162 return nullptr; 163 } 164 165 return result; 166 } 167 168 void* __loader_dlsym(void* handle, const char* symbol, const void* caller_addr) { 169 return dlsym_impl(handle, symbol, nullptr, caller_addr); 170 } 171 172 void* __loader_dlvsym(void* handle, const char* symbol, const char* version, const void* caller_addr) { 173 return dlsym_impl(handle, symbol, version, caller_addr); 174 } 175 176 int __loader_dladdr(const void* addr, Dl_info* info) { 177 ScopedPthreadMutexLocker locker(&g_dl_mutex); 178 return do_dladdr(addr, info); 179 } 180 181 int __loader_dlclose(void* handle) { 182 ScopedPthreadMutexLocker locker(&g_dl_mutex); 183 int result = do_dlclose(handle); 184 if (result != 0) { 185 __bionic_format_dlerror("dlclose failed", linker_get_error_buffer()); 186 } 187 return result; 188 } 189 190 int __loader_dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) { 191 ScopedPthreadMutexLocker locker(&g_dl_mutex); 192 return do_dl_iterate_phdr(cb, data); 193 } 194 195 // This function is needed by libgcc.a 196 int dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void* data) { 197 return __loader_dl_iterate_phdr(cb, data); 198 } 199 200 #if defined(__arm__) 201 _Unwind_Ptr __loader_dl_unwind_find_exidx(_Unwind_Ptr pc, int* pcount) { 202 ScopedPthreadMutexLocker locker(&g_dl_mutex); 203 return do_dl_unwind_find_exidx(pc, pcount); 204 } 205 #endif 206 207 void __loader_android_set_application_target_sdk_version(uint32_t target) { 208 // lock to avoid modification in the middle of dlopen. 209 ScopedPthreadMutexLocker locker(&g_dl_mutex); 210 set_application_target_sdk_version(target); 211 } 212 213 uint32_t __loader_android_get_application_target_sdk_version() { 214 return get_application_target_sdk_version(); 215 } 216 217 void __loader_android_dlwarning(void* obj, void (*f)(void*, const char*)) { 218 ScopedPthreadMutexLocker locker(&g_dl_mutex); 219 get_dlwarning(obj, f); 220 } 221 222 bool __loader_android_init_anonymous_namespace(const char* shared_libs_sonames, 223 const char* library_search_path) { 224 ScopedPthreadMutexLocker locker(&g_dl_mutex); 225 bool success = init_anonymous_namespace(shared_libs_sonames, library_search_path); 226 if (!success) { 227 __bionic_format_dlerror("android_init_anonymous_namespace failed", linker_get_error_buffer()); 228 } 229 230 return success; 231 } 232 233 android_namespace_t* __loader_android_create_namespace(const char* name, 234 const char* ld_library_path, 235 const char* default_library_path, 236 uint64_t type, 237 const char* permitted_when_isolated_path, 238 android_namespace_t* parent_namespace, 239 const void* caller_addr) { 240 ScopedPthreadMutexLocker locker(&g_dl_mutex); 241 242 android_namespace_t* result = create_namespace(caller_addr, 243 name, 244 ld_library_path, 245 default_library_path, 246 type, 247 permitted_when_isolated_path, 248 parent_namespace); 249 250 if (result == nullptr) { 251 __bionic_format_dlerror("android_create_namespace failed", linker_get_error_buffer()); 252 } 253 254 return result; 255 } 256 257 bool __loader_android_link_namespaces(android_namespace_t* namespace_from, 258 android_namespace_t* namespace_to, 259 const char* shared_libs_sonames) { 260 ScopedPthreadMutexLocker locker(&g_dl_mutex); 261 262 bool success = link_namespaces(namespace_from, namespace_to, shared_libs_sonames); 263 264 if (!success) { 265 __bionic_format_dlerror("android_link_namespaces failed", linker_get_error_buffer()); 266 } 267 268 return success; 269 } 270 271 bool __loader_android_link_namespaces_all_libs(android_namespace_t* namespace_from, 272 android_namespace_t* namespace_to) { 273 ScopedPthreadMutexLocker locker(&g_dl_mutex); 274 275 bool success = link_namespaces_all_libs(namespace_from, namespace_to); 276 277 if (!success) { 278 __bionic_format_dlerror("android_link_namespaces_all_libs failed", linker_get_error_buffer()); 279 } 280 281 return success; 282 } 283 284 android_namespace_t* __loader_android_get_exported_namespace(const char* name) { 285 return get_exported_namespace(name); 286 } 287 288 void __loader_cfi_fail(uint64_t CallSiteTypeId, void* Ptr, void *DiagData, void *CallerPc) { 289 CFIShadowWriter::CfiFail(CallSiteTypeId, Ptr, DiagData, CallerPc); 290 } 291 292 void __loader_add_thread_local_dtor(void* dso_handle) { 293 ScopedPthreadMutexLocker locker(&g_dl_mutex); 294 increment_dso_handle_reference_counter(dso_handle); 295 } 296 297 void __loader_remove_thread_local_dtor(void* dso_handle) { 298 ScopedPthreadMutexLocker locker(&g_dl_mutex); 299 decrement_dso_handle_reference_counter(dso_handle); 300 } 301 302 static uint8_t __libdl_info_buf[sizeof(soinfo)] __attribute__((aligned(8))); 303 static soinfo* __libdl_info = nullptr; 304 305 // This is used by the dynamic linker. Every process gets these symbols for free. 306 soinfo* get_libdl_info(const char* linker_path, 307 const soinfo& linker_si, 308 const link_map& linker_map) { 309 CHECK((linker_si.flags_ & FLAG_GNU_HASH) != 0); 310 311 if (__libdl_info == nullptr) { 312 __libdl_info = new (__libdl_info_buf) soinfo(&g_default_namespace, linker_path, nullptr, 0, 0); 313 __libdl_info->flags_ |= (FLAG_LINKED | FLAG_GNU_HASH); 314 __libdl_info->strtab_ = linker_si.strtab_; 315 __libdl_info->symtab_ = linker_si.symtab_; 316 __libdl_info->load_bias = linker_si.load_bias; 317 318 __libdl_info->gnu_nbucket_ = linker_si.gnu_nbucket_; 319 __libdl_info->gnu_maskwords_ = linker_si.gnu_maskwords_; 320 __libdl_info->gnu_shift2_ = linker_si.gnu_shift2_; 321 __libdl_info->gnu_bloom_filter_ = linker_si.gnu_bloom_filter_; 322 __libdl_info->gnu_bucket_ = linker_si.gnu_bucket_; 323 __libdl_info->gnu_chain_ = linker_si.gnu_chain_; 324 325 __libdl_info->ref_count_ = 1; 326 __libdl_info->strtab_size_ = linker_si.strtab_size_; 327 __libdl_info->local_group_root_ = __libdl_info; 328 __libdl_info->soname_ = linker_si.soname_; 329 __libdl_info->target_sdk_version_ = __ANDROID_API__; 330 __libdl_info->generate_handle(); 331 __libdl_info->link_map_head.l_addr = linker_map.l_addr; 332 __libdl_info->link_map_head.l_name = linker_map.l_name; 333 __libdl_info->link_map_head.l_ld = linker_map.l_ld; 334 #if defined(__work_around_b_24465209__) 335 strlcpy(__libdl_info->old_name_, __libdl_info->soname_, sizeof(__libdl_info->old_name_)); 336 #endif 337 } 338 339 return __libdl_info; 340 } 341
