dlfcn.cpp revision a4aafd156068ee174012f28cd894dbecf0e4ab90
1/* 2 * Copyright (C) 2007 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "linker.h" 18 19#include <dlfcn.h> 20#include <pthread.h> 21#include <stdio.h> 22#include <stdlib.h> 23 24#include <bionic/pthread_internal.h> 25#include "private/bionic_tls.h" 26#include "private/ScopedPthreadMutexLocker.h" 27#include "private/ThreadLocalBuffer.h" 28 29/* This file hijacks the symbols stubbed out in libdl.so. */ 30 31static pthread_mutex_t gDlMutex = PTHREAD_RECURSIVE_MUTEX_INITIALIZER; 32 33static const char* __bionic_set_dlerror(char* new_value) { 34 char** dlerror_slot = &reinterpret_cast<char**>(__get_tls())[TLS_SLOT_DLERROR]; 35 36 const char* old_value = *dlerror_slot; 37 *dlerror_slot = new_value; 38 return old_value; 39} 40 41static void __bionic_format_dlerror(const char* msg, const char* detail) { 42 char* buffer = __get_thread()->dlerror_buffer; 43 strlcpy(buffer, msg, __BIONIC_DLERROR_BUFFER_SIZE); 44 if (detail != NULL) { 45 strlcat(buffer, ": ", __BIONIC_DLERROR_BUFFER_SIZE); 46 strlcat(buffer, detail, __BIONIC_DLERROR_BUFFER_SIZE); 47 } 48 49 __bionic_set_dlerror(buffer); 50} 51 52const char* dlerror() { 53 const char* old_value = __bionic_set_dlerror(NULL); 54 return old_value; 55} 56 57void android_get_LD_LIBRARY_PATH(char* buffer, size_t buffer_size) { 58 ScopedPthreadMutexLocker locker(&gDlMutex); 59 do_android_get_LD_LIBRARY_PATH(buffer, buffer_size); 60} 61 62void android_update_LD_LIBRARY_PATH(const char* ld_library_path) { 63 ScopedPthreadMutexLocker locker(&gDlMutex); 64 do_android_update_LD_LIBRARY_PATH(ld_library_path); 65} 66 67void* dlopen(const char* filename, int flags) { 68 ScopedPthreadMutexLocker locker(&gDlMutex); 69 soinfo* result = do_dlopen(filename, flags); 70 if (result == NULL) { 71 __bionic_format_dlerror("dlopen failed", linker_get_error_buffer()); 72 return NULL; 73 } 74 return result; 75} 76 77void* dlsym(void* handle, const char* symbol) { 78 ScopedPthreadMutexLocker locker(&gDlMutex); 79 80 if (handle == NULL) { 81 __bionic_format_dlerror("dlsym library handle is null", NULL); 82 return NULL; 83 } 84 if (symbol == NULL) { 85 __bionic_format_dlerror("dlsym symbol name is null", NULL); 86 return NULL; 87 } 88 89 soinfo* found = NULL; 90 Elf_Sym* sym = NULL; 91 if (handle == RTLD_DEFAULT) { 92 sym = dlsym_linear_lookup(symbol, &found, NULL); 93 } else if (handle == RTLD_NEXT) { 94 void* ret_addr = __builtin_return_address(0); 95 soinfo* si = find_containing_library(ret_addr); 96 97 sym = NULL; 98 if (si && si->next) { 99 sym = dlsym_linear_lookup(symbol, &found, si->next); 100 } 101 } else { 102 found = reinterpret_cast<soinfo*>(handle); 103 sym = dlsym_handle_lookup(found, symbol); 104 } 105 106 if (sym != NULL) { 107 unsigned bind = ELF_ST_BIND(sym->st_info); 108 109 if (bind == STB_GLOBAL && sym->st_shndx != 0) { 110 return reinterpret_cast<void*>(sym->st_value + found->load_bias); 111 } 112 113 __bionic_format_dlerror("symbol found but not global", symbol); 114 return NULL; 115 } else { 116 __bionic_format_dlerror("undefined symbol", symbol); 117 return NULL; 118 } 119} 120 121int dladdr(const void* addr, Dl_info* info) { 122 ScopedPthreadMutexLocker locker(&gDlMutex); 123 124 // Determine if this address can be found in any library currently mapped. 125 soinfo* si = find_containing_library(addr); 126 if (si == NULL) { 127 return 0; 128 } 129 130 memset(info, 0, sizeof(Dl_info)); 131 132 info->dli_fname = si->name; 133 // Address at which the shared object is loaded. 134 info->dli_fbase = (void*) si->base; 135 136 // Determine if any symbol in the library contains the specified address. 137 Elf_Sym *sym = dladdr_find_symbol(si, addr); 138 if (sym != NULL) { 139 info->dli_sname = si->strtab + sym->st_name; 140 info->dli_saddr = (void*)(si->load_bias + sym->st_value); 141 } 142 143 return 1; 144} 145 146int dlclose(void* handle) { 147 ScopedPthreadMutexLocker locker(&gDlMutex); 148 return do_dlclose(reinterpret_cast<soinfo*>(handle)); 149} 150 151// name_offset: starting index of the name in libdl_info.strtab 152#define ELF32_SYM_INITIALIZER(name_offset, value, shndx) \ 153 { name_offset, \ 154 reinterpret_cast<Elf32_Addr>(reinterpret_cast<void*>(value)), \ 155 /* st_size */ 0, \ 156 (shndx == 0) ? 0 : (STB_GLOBAL << 4), \ 157 /* st_other */ 0, \ 158 shndx, \ 159 } 160 161#define ELF64_SYM_INITIALIZER(name_offset, value, shndx) \ 162 { name_offset, \ 163 (shndx == 0) ? 0 : (STB_GLOBAL << 4), \ 164 /* st_other */ 0, \ 165 shndx, \ 166 reinterpret_cast<Elf64_Addr>(reinterpret_cast<void*>(value)), \ 167 /* st_size */ 0, \ 168 } 169 170#if defined(__LP64__) 171# define ELF_SYM_INITIALIZER ELF64_SYM_INITIALIZER 172#else 173# define ELF_SYM_INITIALIZER ELF32_SYM_INITIALIZER 174#endif 175 176#if defined(__arm__) 177 // 0000000 00011111 111112 22222222 2333333 3333444444444455555555556666666 6667777777777888888888899999 9999900000000001 1 178 // 0123456 78901234 567890 12345678 9012345 6789012345678901234567890123456 7890123456789012345678901234 5678901234567890 1 179# define ANDROID_LIBDL_STRTAB \ 180 "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0android_update_LD_LIBRARY_PATH\0android_get_LD_LIBRARY_PATH\0dl_iterate_phdr\0dl_unwind_find_exidx\0" 181#elif defined(__aarch64__) || defined(__i386__) || defined(__mips__) || defined(__x86_64__) 182 // 0000000 00011111 111112 22222222 2333333 3333444444444455555555556666666 6667777777777888888888899999 9999900000000001 1 183 // 0123456 78901234 567890 12345678 9012345 6789012345678901234567890123456 7890123456789012345678901234 5678901234567890 1 184# define ANDROID_LIBDL_STRTAB \ 185 "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0android_update_LD_LIBRARY_PATH\0android_get_LD_LIBRARY_PATH\0dl_iterate_phdr\0" 186#else 187# error Unsupported architecture. Only aarch64, arm, mips, x86, and x86_64 are presently supported. 188#endif 189 190static Elf_Sym gLibDlSymtab[] = { 191 // Total length of libdl_info.strtab, including trailing 0. 192 // This is actually the STH_UNDEF entry. Technically, it's 193 // supposed to have st_name == 0, but instead, it points to an index 194 // in the strtab with a \0 to make iterating through the symtab easier. 195 ELF_SYM_INITIALIZER(sizeof(ANDROID_LIBDL_STRTAB) - 1, NULL, 0), 196 ELF_SYM_INITIALIZER( 0, &dlopen, 1), 197 ELF_SYM_INITIALIZER( 7, &dlclose, 1), 198 ELF_SYM_INITIALIZER( 15, &dlsym, 1), 199 ELF_SYM_INITIALIZER( 21, &dlerror, 1), 200 ELF_SYM_INITIALIZER( 29, &dladdr, 1), 201 ELF_SYM_INITIALIZER( 36, &android_update_LD_LIBRARY_PATH, 1), 202 ELF_SYM_INITIALIZER( 67, &android_get_LD_LIBRARY_PATH, 1), 203 ELF_SYM_INITIALIZER( 95, &dl_iterate_phdr, 1), 204#if defined(__arm__) 205 ELF_SYM_INITIALIZER(111, &dl_unwind_find_exidx, 1), 206#endif 207}; 208 209// Fake out a hash table with a single bucket. 210// 211// A search of the hash table will look through gLibDlSymtab starting with index 1, then 212// use gLibDlChains to find the next index to look at. gLibDlChains should be set up to 213// walk through every element in gLibDlSymtab, and then end with 0 (sentinel value). 214// 215// That is, gLibDlChains should look like { 0, 2, 3, ... N, 0 } where N is the number 216// of actual symbols, or nelems(gLibDlSymtab)-1 (since the first element of gLibDlSymtab is not 217// a real symbol). (See soinfo_elf_lookup().) 218// 219// Note that adding any new symbols here requires stubbing them out in libdl. 220static unsigned gLibDlBuckets[1] = { 1 }; 221#if defined(__arm__) 222static unsigned gLibDlChains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 9, 0 }; 223#else 224static unsigned gLibDlChains[] = { 0, 2, 3, 4, 5, 6, 7, 8, 0 }; 225#endif 226 227// This is used by the dynamic linker. Every process gets these symbols for free. 228soinfo libdl_info = { 229 "libdl.so", 230 231 .phdr = 0, 232 .phnum = 0, 233 .entry = 0, 234 .base = 0, 235 .size = 0, 236 237#if !defined(__LP64__) 238 .unused1 = 0, 239#endif 240 241 .dynamic = 0, 242 243#if !defined(__LP64__) 244 .unused2 = 0, .unused3 = 0, 245#endif 246 247 .next = 0, 248 249 .flags = FLAG_LINKED, 250 251 .strtab = ANDROID_LIBDL_STRTAB, 252 .symtab = gLibDlSymtab, 253 254 .nbucket = sizeof(gLibDlBuckets)/sizeof(unsigned), 255 .nchain = sizeof(gLibDlChains)/sizeof(unsigned), 256 .bucket = gLibDlBuckets, 257 .chain = gLibDlChains, 258 259#if defined(USE_RELA) 260 .plt_rela = 0, 261 .plt_rela_count = 0, 262 .rela = 0, 263 .rela_count = 0, 264#else 265 .plt_got = 0, 266 .plt_rel = 0, 267 .plt_rel_count = 0, 268 .rel = 0, 269 .rel_count = 0, 270#endif 271 272 .preinit_array = 0, 273 .preinit_array_count = 0, 274 275 .init_array = 0, 276 .init_array_count = 0, 277 278 .fini_array = 0, 279 .fini_array_count = 0, 280 281 .init_func = 0, 282 .fini_func = 0, 283 284#if defined(__arm__) 285 .ARM_exidx = 0, 286 .ARM_exidx_count = 0, 287#elif defined(__mips__) 288 .mips_symtabno = 0, 289 .mips_local_gotno = 0, 290 .mips_gotsym = 0, 291#endif 292 293 .ref_count = 0, 294 { .l_addr = 0, .l_name = 0, .l_ld = 0, .l_next = 0, .l_prev = 0, }, 295 .constructors_called = false, 296 .load_bias = 0, 297#if !defined(__LP64__) 298 .has_text_relocations = false, 299#endif 300 .has_DT_SYMBOLIC = true, 301}; 302