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
__bionic_set_dlerror(char * new_value)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
__bionic_format_dlerror(const char * msg,const char * detail)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
__loader_dlerror()116 char* __loader_dlerror() {
117 char* old_value = __bionic_set_dlerror(nullptr);
118 return old_value;
119 }
120
__loader_android_get_LD_LIBRARY_PATH(char * buffer,size_t buffer_size)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
__loader_android_update_LD_LIBRARY_PATH(const char * ld_library_path)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
dlopen_ext(const char * filename,int flags,const android_dlextinfo * extinfo,const void * caller_addr)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
__loader_android_dlopen_ext(const char * filename,int flags,const android_dlextinfo * extinfo,const void * caller_addr)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
__loader_dlopen(const char * filename,int flags,const void * caller_addr)152 void* __loader_dlopen(const char* filename, int flags, const void* caller_addr) {
153 return dlopen_ext(filename, flags, nullptr, caller_addr);
154 }
155
dlsym_impl(void * handle,const char * symbol,const char * version,const void * caller_addr)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
__loader_dlsym(void * handle,const char * symbol,const void * caller_addr)168 void* __loader_dlsym(void* handle, const char* symbol, const void* caller_addr) {
169 return dlsym_impl(handle, symbol, nullptr, caller_addr);
170 }
171
__loader_dlvsym(void * handle,const char * symbol,const char * version,const void * caller_addr)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
__loader_dladdr(const void * addr,Dl_info * info)176 int __loader_dladdr(const void* addr, Dl_info* info) {
177 ScopedPthreadMutexLocker locker(&g_dl_mutex);
178 return do_dladdr(addr, info);
179 }
180
__loader_dlclose(void * handle)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
__loader_dl_iterate_phdr(int (* cb)(dl_phdr_info * info,size_t size,void * data),void * data)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
dl_iterate_phdr(int (* cb)(dl_phdr_info * info,size_t size,void * data),void * data)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__)
__loader_dl_unwind_find_exidx(_Unwind_Ptr pc,int * pcount)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
__loader_android_set_application_target_sdk_version(uint32_t target)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
__loader_android_get_application_target_sdk_version()213 uint32_t __loader_android_get_application_target_sdk_version() {
214 return get_application_target_sdk_version();
215 }
216
__loader_android_dlwarning(void * obj,void (* f)(void *,const char *))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
__loader_android_init_anonymous_namespace(const char * shared_libs_sonames,const char * library_search_path)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
__loader_android_create_namespace(const char * name,const char * ld_library_path,const char * default_library_path,uint64_t type,const char * permitted_when_isolated_path,android_namespace_t * parent_namespace,const void * caller_addr)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
__loader_android_link_namespaces(android_namespace_t * namespace_from,android_namespace_t * namespace_to,const char * shared_libs_sonames)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
__loader_android_link_namespaces_all_libs(android_namespace_t * namespace_from,android_namespace_t * namespace_to)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
__loader_android_get_exported_namespace(const char * name)284 android_namespace_t* __loader_android_get_exported_namespace(const char* name) {
285 return get_exported_namespace(name);
286 }
287
__loader_cfi_fail(uint64_t CallSiteTypeId,void * Ptr,void * DiagData,void * CallerPc)288 void __loader_cfi_fail(uint64_t CallSiteTypeId, void* Ptr, void *DiagData, void *CallerPc) {
289 CFIShadowWriter::CfiFail(CallSiteTypeId, Ptr, DiagData, CallerPc);
290 }
291
__loader_add_thread_local_dtor(void * dso_handle)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
__loader_remove_thread_local_dtor(void * dso_handle)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.
get_libdl_info(const char * linker_path,const soinfo & linker_si,const link_map & linker_map)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