/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include "linker.h" /* This file hijacks the symbols stubbed out in libdl.so. */ #define DL_SUCCESS 0 #define DL_ERR_CANNOT_LOAD_LIBRARY 1 #define DL_ERR_INVALID_LIBRARY_HANDLE 2 #define DL_ERR_BAD_SYMBOL_NAME 3 #define DL_ERR_SYMBOL_NOT_FOUND 4 #define DL_ERR_SYMBOL_NOT_GLOBAL 5 static char dl_err_buf[1024]; static const char *dl_err_str; static const char *dl_errors[] = { [DL_ERR_CANNOT_LOAD_LIBRARY] = "Cannot load library", [DL_ERR_INVALID_LIBRARY_HANDLE] = "Invalid library handle", [DL_ERR_BAD_SYMBOL_NAME] = "Invalid symbol name", [DL_ERR_SYMBOL_NOT_FOUND] = "Symbol not found", [DL_ERR_SYMBOL_NOT_GLOBAL] = "Symbol is not global", }; #define likely(expr) __builtin_expect (expr, 1) #define unlikely(expr) __builtin_expect (expr, 0) static pthread_mutex_t dl_lock = PTHREAD_MUTEX_INITIALIZER; static void set_dlerror(int err) { snprintf(dl_err_buf, sizeof(dl_err_buf), "%s: %s", dl_errors[err], linker_get_error()); dl_err_str = (const char *)&dl_err_buf[0]; }; void *dlopen(const char *filename, int flag) { soinfo *ret; pthread_mutex_lock(&dl_lock); ret = find_library(filename); if (unlikely(ret == NULL)) { set_dlerror(DL_ERR_CANNOT_LOAD_LIBRARY); } else { ret->refcount++; } pthread_mutex_unlock(&dl_lock); return ret; } const char *dlerror(void) { const char *tmp = dl_err_str; dl_err_str = NULL; return (const char *)tmp; } void *dlsym(void *handle, const char *symbol) { soinfo *found; Elf32_Sym *sym; unsigned bind; pthread_mutex_lock(&dl_lock); if(unlikely(handle == 0)) { set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE); goto err; } if(unlikely(symbol == 0)) { set_dlerror(DL_ERR_BAD_SYMBOL_NAME); goto err; } if(handle == RTLD_DEFAULT) { sym = lookup(symbol, &found); } else if(handle == RTLD_NEXT) { sym = lookup(symbol, &found); } else { found = (soinfo*)handle; sym = lookup_in_library(found, symbol); } if(likely(sym != 0)) { bind = ELF32_ST_BIND(sym->st_info); if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) { unsigned ret = sym->st_value + found->base; pthread_mutex_unlock(&dl_lock); return (void*)ret; } set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL); } else set_dlerror(DL_ERR_SYMBOL_NOT_FOUND); err: pthread_mutex_unlock(&dl_lock); return 0; } int dlclose(void *handle) { pthread_mutex_lock(&dl_lock); (void)unload_library((soinfo*)handle); pthread_mutex_unlock(&dl_lock); return 0; } #if defined(ANDROID_ARM_LINKER) // 0000000 00011111 111112 22222222 233333333334444444444 // 0123456 78901234 567890 12345678 901234567890123456789 #define ANDROID_LIBDL_STRTAB \ "dlopen\0dlclose\0dlsym\0dlerror\0dl_unwind_find_exidx\0" #elif defined(ANDROID_X86_LINKER) // 0000000 00011111 111112 22222222 2333333333344444 // 0123456 78901234 567890 12345678 9012345678901234 #define ANDROID_LIBDL_STRTAB \ "dlopen\0dlclose\0dlsym\0dlerror\0dl_iterate_phdr\0" #elif defined(ANDROID_SH_LINKER) // 0000000 00011111 111112 22222222 2333333333344444 // 0123456 78901234 567890 12345678 9012345678901234 #define ANDROID_LIBDL_STRTAB \ "dlopen\0dlclose\0dlsym\0dlerror\0dl_iterate_phdr\0" #else /* !defined(ANDROID_ARM_LINKER) && !defined(ANDROID_X86_LINKER) */ #error Unsupported architecture. Only ARM and x86 are presently supported. #endif static Elf32_Sym libdl_symtab[] = { // total length of libdl_info.strtab, including trailing 0 // This is actually the the STH_UNDEF entry. Technically, it's // supposed to have st_name == 0, but instead, it points to an index // in the strtab with a \0 to make iterating through the symtab easier. { st_name: sizeof(ANDROID_LIBDL_STRTAB) - 1, }, { st_name: 0, // starting index of the name in libdl_info.strtab st_value: (Elf32_Addr) &dlopen, st_info: STB_GLOBAL << 4, st_shndx: 1, }, { st_name: 7, st_value: (Elf32_Addr) &dlclose, st_info: STB_GLOBAL << 4, st_shndx: 1, }, { st_name: 15, st_value: (Elf32_Addr) &dlsym, st_info: STB_GLOBAL << 4, st_shndx: 1, }, { st_name: 21, st_value: (Elf32_Addr) &dlerror, st_info: STB_GLOBAL << 4, st_shndx: 1, }, #ifdef ANDROID_ARM_LINKER { st_name: 29, st_value: (Elf32_Addr) &dl_unwind_find_exidx, st_info: STB_GLOBAL << 4, st_shndx: 1, }, #elif defined(ANDROID_X86_LINKER) { st_name: 29, st_value: (Elf32_Addr) &dl_iterate_phdr, st_info: STB_GLOBAL << 4, st_shndx: 1, }, #elif defined(ANDROID_SH_LINKER) { st_name: 29, st_value: (Elf32_Addr) &dl_iterate_phdr, st_info: STB_GLOBAL << 4, st_shndx: 1, }, #endif }; /* Fake out a hash table with a single bucket. * A search of the hash table will look through * libdl_symtab starting with index [1], then * use libdl_chains to find the next index to * look at. libdl_chains should be set up to * walk through every element in libdl_symtab, * and then end with 0 (sentinel value). * * I.e., libdl_chains should look like * { 0, 2, 3, ... N, 0 } where N is the number * of actual symbols, or nelems(libdl_symtab)-1 * (since the first element of libdl_symtab is not * a real symbol). * * (see _elf_lookup()) * * Note that adding any new symbols here requires * stubbing them out in libdl. */ static unsigned libdl_buckets[1] = { 1 }; static unsigned libdl_chains[6] = { 0, 2, 3, 4, 5, 0 }; soinfo libdl_info = { name: "libdl.so", flags: FLAG_LINKED, strtab: ANDROID_LIBDL_STRTAB, symtab: libdl_symtab, nbucket: 1, nchain: 6, bucket: libdl_buckets, chain: libdl_chains, };