dlfcn_test.cpp revision 9598b8c415e2fa9f240508185fe8c964b83f538d
1/* 2 * Copyright (C) 2012 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 <gtest/gtest.h> 18 19#include <dlfcn.h> 20#include <libgen.h> 21#include <limits.h> 22#include <stdio.h> 23#include <stdint.h> 24 25#include <string> 26 27#define ASSERT_SUBSTR(needle, haystack) \ 28 ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack) 29 30static bool g_called = false; 31extern "C" void DlSymTestFunction() { 32 g_called = true; 33} 34 35static int g_ctor_function_called = 0; 36 37extern "C" void ctor_function() __attribute__ ((constructor)); 38 39extern "C" void ctor_function() { 40 g_ctor_function_called = 17; 41} 42 43TEST(dlfcn, ctor_function_call) { 44 ASSERT_EQ(17, g_ctor_function_called); 45} 46 47TEST(dlfcn, dlsym_in_self) { 48 dlerror(); // Clear any pending errors. 49 void* self = dlopen(NULL, RTLD_NOW); 50 ASSERT_TRUE(self != NULL); 51 ASSERT_TRUE(dlerror() == NULL); 52 53 void* sym = dlsym(self, "DlSymTestFunction"); 54 ASSERT_TRUE(sym != NULL); 55 56 void (*function)() = reinterpret_cast<void(*)()>(sym); 57 58 g_called = false; 59 function(); 60 ASSERT_TRUE(g_called); 61 62 ASSERT_EQ(0, dlclose(self)); 63} 64 65TEST(dlfcn, dlsym_with_dependencies) { 66 void* handle = dlopen("libtest_with_dependency.so", RTLD_NOW); 67 ASSERT_TRUE(handle != NULL); 68 dlerror(); 69 // This symbol is in DT_NEEDED library. 70 void* sym = dlsym(handle, "getRandomNumber"); 71 ASSERT_TRUE(sym != NULL); 72 int (*fn)(void); 73 fn = reinterpret_cast<int (*)(void)>(sym); 74 EXPECT_EQ(4, fn()); 75 dlclose(handle); 76} 77 78TEST(dlfcn, dlopen_noload) { 79 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 80 ASSERT_TRUE(handle == NULL); 81 handle = dlopen("libtest_simple.so", RTLD_NOW); 82 void* handle2 = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 83 ASSERT_TRUE(handle != NULL); 84 ASSERT_TRUE(handle2 != NULL); 85 ASSERT_TRUE(handle == handle2); 86 ASSERT_EQ(0, dlclose(handle)); 87 ASSERT_EQ(0, dlclose(handle2)); 88} 89 90// ifuncs are only supported on intel for now 91#if defined(__i386__) || defined(__x86_64__) 92TEST(dlfcn, ifunc) { 93 typedef const char* (*fn_ptr)(); 94 95 // ifunc's choice depends on whether IFUNC_CHOICE has a value 96 // first check the set case 97 setenv("IFUNC_CHOICE", "set", 1); 98 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 99 ASSERT_TRUE(handle != NULL); 100 fn_ptr foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 101 fn_ptr foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 102 ASSERT_TRUE(foo_ptr != NULL); 103 ASSERT_TRUE(foo_library_ptr != NULL); 104 ASSERT_EQ(strncmp("set", foo_ptr(), 3), 0); 105 ASSERT_EQ(strncmp("set", foo_library_ptr(), 3), 0); 106 dlclose(handle); 107 108 // then check the unset case 109 unsetenv("IFUNC_CHOICE"); 110 handle = dlopen("libtest_ifunc.so", RTLD_NOW); 111 ASSERT_TRUE(handle != NULL); 112 foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 113 foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 114 ASSERT_TRUE(foo_ptr != NULL); 115 ASSERT_TRUE(foo_library_ptr != NULL); 116 ASSERT_EQ(strncmp("unset", foo_ptr(), 5), 0); 117 ASSERT_EQ(strncmp("unset", foo_library_ptr(), 3), 0); 118 dlclose(handle); 119} 120 121TEST(dlfcn, ifunc_ctor_call) { 122 typedef const char* (*fn_ptr)(); 123 124 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 125 ASSERT_TRUE(handle != NULL) << dlerror(); 126 fn_ptr is_ctor_called = reinterpret_cast<fn_ptr>(dlsym(handle, "is_ctor_called")); 127 ASSERT_TRUE(is_ctor_called != NULL) << dlerror(); 128 ASSERT_STREQ("true", is_ctor_called()); 129 dlclose(handle); 130} 131#endif 132 133TEST(dlfcn, dlopen_failure) { 134 void* self = dlopen("/does/not/exist", RTLD_NOW); 135 ASSERT_TRUE(self == NULL); 136#if defined(__BIONIC__) 137 ASSERT_STREQ("dlopen failed: library \"/does/not/exist\" not found", dlerror()); 138#else 139 ASSERT_STREQ("/does/not/exist: cannot open shared object file: No such file or directory", dlerror()); 140#endif 141} 142 143static void* ConcurrentDlErrorFn(void*) { 144 dlopen("/child/thread", RTLD_NOW); 145 return reinterpret_cast<void*>(strdup(dlerror())); 146} 147 148TEST(dlfcn, dlerror_concurrent) { 149 dlopen("/main/thread", RTLD_NOW); 150 const char* main_thread_error = dlerror(); 151 ASSERT_SUBSTR("/main/thread", main_thread_error); 152 153 pthread_t t; 154 ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentDlErrorFn, NULL)); 155 void* result; 156 ASSERT_EQ(0, pthread_join(t, &result)); 157 char* child_thread_error = static_cast<char*>(result); 158 ASSERT_SUBSTR("/child/thread", child_thread_error); 159 free(child_thread_error); 160 161 ASSERT_SUBSTR("/main/thread", main_thread_error); 162} 163 164TEST(dlfcn, dlsym_failures) { 165 dlerror(); // Clear any pending errors. 166 void* self = dlopen(NULL, RTLD_NOW); 167 ASSERT_TRUE(self != NULL); 168 ASSERT_TRUE(dlerror() == NULL); 169 170 void* sym; 171 172#if defined(__BIONIC__) && !defined(__LP64__) 173 // RTLD_DEFAULT in lp32 bionic is not (void*)0 174 // so it can be distinguished from the NULL handle. 175 sym = dlsym(NULL, "test"); 176 ASSERT_TRUE(sym == NULL); 177 ASSERT_SUBSTR("dlsym library handle is null", dlerror()); 178#endif 179 180 // NULL symbol name. 181#if defined(__BIONIC__) 182 // glibc marks this parameter non-null and SEGVs if you cheat. 183 sym = dlsym(self, NULL); 184 ASSERT_TRUE(sym == NULL); 185 ASSERT_SUBSTR("", dlerror()); 186#endif 187 188 // Symbol that doesn't exist. 189 sym = dlsym(self, "ThisSymbolDoesNotExist"); 190 ASSERT_TRUE(sym == NULL); 191 ASSERT_SUBSTR("undefined symbol: ThisSymbolDoesNotExist", dlerror()); 192 193 ASSERT_EQ(0, dlclose(self)); 194} 195 196TEST(dlfcn, dladdr) { 197 dlerror(); // Clear any pending errors. 198 void* self = dlopen(NULL, RTLD_NOW); 199 ASSERT_TRUE(self != NULL); 200 ASSERT_TRUE(dlerror() == NULL); 201 202 void* sym = dlsym(self, "DlSymTestFunction"); 203 ASSERT_TRUE(sym != NULL); 204 205 // Deliberately ask dladdr for an address inside a symbol, rather than the symbol base address. 206 void* addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(sym) + 2); 207 208 Dl_info info; 209 int rc = dladdr(addr, &info); 210 ASSERT_NE(rc, 0); // Zero on error, non-zero on success. 211 212 // Get the name of this executable. 213 char executable_path[PATH_MAX]; 214 rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path)); 215 ASSERT_NE(rc, -1); 216 executable_path[rc] = '\0'; 217 std::string executable_name(basename(executable_path)); 218 219 // The filename should be that of this executable. 220 // Note that we don't know whether or not we have the full path, so we want an "ends_with" test. 221 std::string dli_fname(info.dli_fname); 222 dli_fname = basename(&dli_fname[0]); 223 ASSERT_EQ(dli_fname, executable_name); 224 225 // The symbol name should be the symbol we looked up. 226 ASSERT_STREQ(info.dli_sname, "DlSymTestFunction"); 227 228 // The address should be the exact address of the symbol. 229 ASSERT_EQ(info.dli_saddr, sym); 230 231 // Look in /proc/pid/maps to find out what address we were loaded at. 232 // TODO: factor /proc/pid/maps parsing out into a class and reuse all over bionic. 233 void* base_address = NULL; 234 char path[PATH_MAX]; 235 snprintf(path, sizeof(path), "/proc/%d/maps", getpid()); 236 char line[BUFSIZ]; 237 FILE* fp = fopen(path, "r"); 238 ASSERT_TRUE(fp != NULL); 239 while (fgets(line, sizeof(line), fp) != NULL) { 240 uintptr_t start = strtoul(line, 0, 16); 241 line[strlen(line) - 1] = '\0'; // Chomp the '\n'. 242 char* path = strchr(line, '/'); 243 if (path != NULL && strcmp(executable_path, path) == 0) { 244 base_address = reinterpret_cast<void*>(start); 245 break; 246 } 247 } 248 fclose(fp); 249 250 // The base address should be the address we were loaded at. 251 ASSERT_EQ(info.dli_fbase, base_address); 252 253 ASSERT_EQ(0, dlclose(self)); 254} 255 256TEST(dlfcn, dladdr_invalid) { 257 Dl_info info; 258 259 dlerror(); // Clear any pending errors. 260 261 // No symbol corresponding to NULL. 262 ASSERT_EQ(dladdr(NULL, &info), 0); // Zero on error, non-zero on success. 263 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 264 265 // No symbol corresponding to a stack address. 266 ASSERT_EQ(dladdr(&info, &info), 0); // Zero on error, non-zero on success. 267 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 268} 269 270// Our dynamic linker doesn't support GNU hash tables. 271#if defined(__BIONIC__) 272// GNU-style ELF hash tables are incompatible with the MIPS ABI. 273// MIPS requires .dynsym to be sorted to match the GOT but GNU-style requires sorting by hash code. 274#if !defined(__mips__) 275TEST(dlfcn, dlopen_library_with_only_gnu_hash) { 276 dlerror(); // Clear any pending errors. 277 void* handle = dlopen("no-elf-hash-table-library.so", RTLD_NOW); 278 ASSERT_TRUE(handle == NULL); 279 ASSERT_STREQ("dlopen failed: empty/missing DT_HASH in \"no-elf-hash-table-library.so\" (built with --hash-style=gnu?)", dlerror()); 280} 281#endif 282#endif 283 284TEST(dlfcn, dlopen_bad_flags) { 285 dlerror(); // Clear any pending errors. 286 void* handle; 287 288#if defined(__GLIBC__) 289 // glibc was smart enough not to define RTLD_NOW as 0, so it can detect missing flags. 290 handle = dlopen(NULL, 0); 291 ASSERT_TRUE(handle == NULL); 292 ASSERT_SUBSTR("invalid", dlerror()); 293#endif 294 295 handle = dlopen(NULL, 0xffffffff); 296 ASSERT_TRUE(handle == NULL); 297 ASSERT_SUBSTR("invalid", dlerror()); 298 299 // glibc actually allows you to choose both RTLD_NOW and RTLD_LAZY at the same time, and so do we. 300 handle = dlopen(NULL, RTLD_NOW|RTLD_LAZY); 301 ASSERT_TRUE(handle != NULL); 302 ASSERT_SUBSTR(NULL, dlerror()); 303} 304 305TEST(dlfcn, rtld_default_unknown_symbol) { 306 void* addr = dlsym(RTLD_DEFAULT, "ANY_UNKNOWN_SYMBOL_NAME"); 307 ASSERT_TRUE(addr == NULL); 308} 309 310TEST(dlfcn, rtld_default_known_symbol) { 311 void* addr = dlsym(RTLD_DEFAULT, "fopen"); 312 ASSERT_TRUE(addr != NULL); 313} 314 315TEST(dlfcn, rtld_next_unknown_symbol) { 316 void* addr = dlsym(RTLD_NEXT, "ANY_UNKNOWN_SYMBOL_NAME"); 317 ASSERT_TRUE(addr == NULL); 318} 319 320TEST(dlfcn, rtld_next_known_symbol) { 321 void* addr = dlsym(RTLD_NEXT, "fopen"); 322 ASSERT_TRUE(addr != NULL); 323} 324 325TEST(dlfcn, dlsym_weak_func) { 326 dlerror(); 327 void* handle = dlopen("libtest_dlsym_weak_func.so",RTLD_NOW); 328 ASSERT_TRUE(handle != NULL); 329 330 int (*weak_func)(); 331 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "weak_func")); 332 ASSERT_TRUE(weak_func != NULL) << "dlerror: " << dlerror(); 333 EXPECT_EQ(42, weak_func()); 334 dlclose(handle); 335} 336 337TEST(dlfcn, dlopen_symlink) { 338 void* handle1 = dlopen("libdlext_test.so", RTLD_NOW); 339 void* handle2 = dlopen("libdlext_test_v2.so", RTLD_NOW); 340 ASSERT_TRUE(handle1 != NULL); 341 ASSERT_TRUE(handle2 != NULL); 342 ASSERT_EQ(handle1, handle2); 343} 344