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