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#include <dlfcn.h>
17#include <pthread.h>
18#include <stdio.h>
19#include "linker.h"
20#include "linker_format.h"
21
22/* This file hijacks the symbols stubbed out in libdl.so. */
23
24#define DL_SUCCESS                    0
25#define DL_ERR_CANNOT_LOAD_LIBRARY    1
26#define DL_ERR_INVALID_LIBRARY_HANDLE 2
27#define DL_ERR_BAD_SYMBOL_NAME        3
28#define DL_ERR_SYMBOL_NOT_FOUND       4
29#define DL_ERR_SYMBOL_NOT_GLOBAL      5
30
31static char dl_err_buf[1024];
32static const char *dl_err_str;
33
34static const char *dl_errors[] = {
35    [DL_ERR_CANNOT_LOAD_LIBRARY] = "Cannot load library",
36    [DL_ERR_INVALID_LIBRARY_HANDLE] = "Invalid library handle",
37    [DL_ERR_BAD_SYMBOL_NAME] = "Invalid symbol name",
38    [DL_ERR_SYMBOL_NOT_FOUND] = "Symbol not found",
39    [DL_ERR_SYMBOL_NOT_GLOBAL] = "Symbol is not global",
40};
41
42#define likely(expr)   __builtin_expect (expr, 1)
43#define unlikely(expr) __builtin_expect (expr, 0)
44
45pthread_mutex_t dl_lock = PTHREAD_RECURSIVE_MUTEX_INITIALIZER;
46
47static void set_dlerror(int err)
48{
49    format_buffer(dl_err_buf, sizeof(dl_err_buf), "%s: %s", dl_errors[err],
50             linker_get_error());
51    dl_err_str = (const char *)&dl_err_buf[0];
52};
53
54void *dlopen(const char *filename, int flag)
55{
56    soinfo *ret;
57
58    pthread_mutex_lock(&dl_lock);
59    ret = find_library(filename);
60    if (unlikely(ret == NULL)) {
61        set_dlerror(DL_ERR_CANNOT_LOAD_LIBRARY);
62    } else {
63        call_constructors_recursive(ret);
64        ret->refcount++;
65    }
66    pthread_mutex_unlock(&dl_lock);
67    return ret;
68}
69
70const char *dlerror(void)
71{
72    const char *tmp = dl_err_str;
73    dl_err_str = NULL;
74    return (const char *)tmp;
75}
76
77void *dlsym(void *handle, const char *symbol)
78{
79    soinfo *found;
80    Elf32_Sym *sym;
81    unsigned bind;
82
83    pthread_mutex_lock(&dl_lock);
84
85    if(unlikely(handle == 0)) {
86        set_dlerror(DL_ERR_INVALID_LIBRARY_HANDLE);
87        goto err;
88    }
89    if(unlikely(symbol == 0)) {
90        set_dlerror(DL_ERR_BAD_SYMBOL_NAME);
91        goto err;
92    }
93
94    if(handle == RTLD_DEFAULT) {
95        sym = lookup(symbol, &found, NULL);
96    } else if(handle == RTLD_NEXT) {
97        void *ret_addr = __builtin_return_address(0);
98        soinfo *si = find_containing_library(ret_addr);
99
100        sym = NULL;
101        if(si && si->next) {
102            sym = lookup(symbol, &found, si->next);
103        }
104    } else {
105        found = (soinfo*)handle;
106        sym = lookup_in_library(found, symbol);
107    }
108
109    if(likely(sym != 0)) {
110        bind = ELF32_ST_BIND(sym->st_info);
111
112        if(likely((bind == STB_GLOBAL) && (sym->st_shndx != 0))) {
113            unsigned ret = sym->st_value + found->base;
114            pthread_mutex_unlock(&dl_lock);
115            return (void*)ret;
116        }
117
118        set_dlerror(DL_ERR_SYMBOL_NOT_GLOBAL);
119    }
120    else
121        set_dlerror(DL_ERR_SYMBOL_NOT_FOUND);
122
123err:
124    pthread_mutex_unlock(&dl_lock);
125    return 0;
126}
127
128int dladdr(const void *addr, Dl_info *info)
129{
130    int ret = 0;
131
132    pthread_mutex_lock(&dl_lock);
133
134    /* Determine if this address can be found in any library currently mapped */
135    soinfo *si = find_containing_library(addr);
136
137    if(si) {
138        memset(info, 0, sizeof(Dl_info));
139
140        info->dli_fname = si->name;
141        info->dli_fbase = (void*)si->base;
142
143        /* Determine if any symbol in the library contains the specified address */
144        Elf32_Sym *sym = find_containing_symbol(addr, si);
145
146        if(sym != NULL) {
147            info->dli_sname = si->strtab + sym->st_name;
148            info->dli_saddr = (void*)(si->base + sym->st_value);
149        }
150
151        ret = 1;
152    }
153
154    pthread_mutex_unlock(&dl_lock);
155
156    return ret;
157}
158
159int dlclose(void *handle)
160{
161    pthread_mutex_lock(&dl_lock);
162    (void)unload_library((soinfo*)handle);
163    pthread_mutex_unlock(&dl_lock);
164    return 0;
165}
166
167#if defined(ANDROID_ARM_LINKER)
168//                     0000000 00011111 111112 22222222 2333333 333344444444445555555
169//                     0123456 78901234 567890 12345678 9012345 678901234567890123456
170#define ANDROID_LIBDL_STRTAB \
171                      "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_unwind_find_exidx\0"
172
173#elif defined(ANDROID_X86_LINKER)
174//                     0000000 00011111 111112 22222222 2333333 3333444444444455
175//                     0123456 78901234 567890 12345678 9012345 6789012345678901
176#define ANDROID_LIBDL_STRTAB \
177                      "dlopen\0dlclose\0dlsym\0dlerror\0dladdr\0dl_iterate_phdr\0"
178#else
179#error Unsupported architecture. Only ARM and x86 are presently supported.
180#endif
181
182
183static Elf32_Sym libdl_symtab[] = {
184      // total length of libdl_info.strtab, including trailing 0
185      // This is actually the the STH_UNDEF entry. Technically, it's
186      // supposed to have st_name == 0, but instead, it points to an index
187      // in the strtab with a \0 to make iterating through the symtab easier.
188    { st_name: sizeof(ANDROID_LIBDL_STRTAB) - 1,
189    },
190    { st_name: 0,   // starting index of the name in libdl_info.strtab
191      st_value: (Elf32_Addr) &dlopen,
192      st_info: STB_GLOBAL << 4,
193      st_shndx: 1,
194    },
195    { st_name: 7,
196      st_value: (Elf32_Addr) &dlclose,
197      st_info: STB_GLOBAL << 4,
198      st_shndx: 1,
199    },
200    { st_name: 15,
201      st_value: (Elf32_Addr) &dlsym,
202      st_info: STB_GLOBAL << 4,
203      st_shndx: 1,
204    },
205    { st_name: 21,
206      st_value: (Elf32_Addr) &dlerror,
207      st_info: STB_GLOBAL << 4,
208      st_shndx: 1,
209    },
210    { st_name: 29,
211      st_value: (Elf32_Addr) &dladdr,
212      st_info: STB_GLOBAL << 4,
213      st_shndx: 1,
214    },
215#ifdef ANDROID_ARM_LINKER
216    { st_name: 36,
217      st_value: (Elf32_Addr) &dl_unwind_find_exidx,
218      st_info: STB_GLOBAL << 4,
219      st_shndx: 1,
220    },
221#elif defined(ANDROID_X86_LINKER)
222    { st_name: 36,
223      st_value: (Elf32_Addr) &dl_iterate_phdr,
224      st_info: STB_GLOBAL << 4,
225      st_shndx: 1,
226    },
227#endif
228};
229
230/* Fake out a hash table with a single bucket.
231 * A search of the hash table will look through
232 * libdl_symtab starting with index [1], then
233 * use libdl_chains to find the next index to
234 * look at.  libdl_chains should be set up to
235 * walk through every element in libdl_symtab,
236 * and then end with 0 (sentinel value).
237 *
238 * I.e., libdl_chains should look like
239 * { 0, 2, 3, ... N, 0 } where N is the number
240 * of actual symbols, or nelems(libdl_symtab)-1
241 * (since the first element of libdl_symtab is not
242 * a real symbol).
243 *
244 * (see _elf_lookup())
245 *
246 * Note that adding any new symbols here requires
247 * stubbing them out in libdl.
248 */
249static unsigned libdl_buckets[1] = { 1 };
250static unsigned libdl_chains[7] = { 0, 2, 3, 4, 5, 6, 0 };
251
252soinfo libdl_info = {
253    name: "libdl.so",
254    flags: FLAG_LINKED,
255
256    strtab: ANDROID_LIBDL_STRTAB,
257    symtab: libdl_symtab,
258
259    nbucket: 1,
260    nchain: 7,
261    bucket: libdl_buckets,
262    chain: libdl_chains,
263};
264
265