dlfcn_test.cpp revision ce0ba3c70634d5fe64b9a298d8a305d85bd1e6ac
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 35TEST(dlfcn, dlsym_in_self) { 36 dlerror(); // Clear any pending errors. 37 void* self = dlopen(NULL, RTLD_NOW); 38 ASSERT_TRUE(self != NULL); 39 ASSERT_TRUE(dlerror() == NULL); 40 41 void* sym = dlsym(self, "DlSymTestFunction"); 42 ASSERT_TRUE(sym != NULL); 43 44 void (*function)() = reinterpret_cast<void(*)()>(sym); 45 46 g_called = false; 47 function(); 48 ASSERT_TRUE(g_called); 49 50 ASSERT_EQ(0, dlclose(self)); 51} 52 53#if !defined(__LP64__) 54// Current compiler/static linker used for aarch64 55// platform optimizes LOCAL PROTECTED symbol 56// in libtest_local_symbol.so out of existence 57TEST(dlfcn, dlsym_local_symbol) { 58 void* handle = dlopen("libtest_local_symbol.so", RTLD_NOW); 59 ASSERT_TRUE(handle != NULL); 60 dlerror(); 61 void* sym = dlsym(handle, "private_taxicab_number"); 62 ASSERT_TRUE(sym == NULL); 63 ASSERT_STREQ("undefined symbol: private_taxicab_number", dlerror()); 64 65 uint32_t (*f)(void); 66 f = reinterpret_cast<uint32_t (*)(void)>(dlsym(handle, "dlsym_local_symbol_get_taxicab_number_using_dlsym")); 67 ASSERT_TRUE(f != NULL); 68 ASSERT_EQ(1729U, f()); 69} 70#endif 71 72TEST(dlfcn, dlopen_noload) { 73 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 74 ASSERT_TRUE(handle == NULL); 75 handle = dlopen("libtest_simple.so", RTLD_NOW); 76 void* handle2 = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 77 ASSERT_TRUE(handle != NULL); 78 ASSERT_TRUE(handle2 != NULL); 79 ASSERT_TRUE(handle == handle2); 80 ASSERT_EQ(0, dlclose(handle)); 81 ASSERT_EQ(0, dlclose(handle2)); 82} 83 84TEST(dlfcn, dlopen_failure) { 85 void* self = dlopen("/does/not/exist", RTLD_NOW); 86 ASSERT_TRUE(self == NULL); 87#if defined(__BIONIC__) 88 ASSERT_STREQ("dlopen failed: library \"/does/not/exist\" not found", dlerror()); 89#else 90 ASSERT_STREQ("/does/not/exist: cannot open shared object file: No such file or directory", dlerror()); 91#endif 92} 93 94static void* ConcurrentDlErrorFn(void*) { 95 dlopen("/child/thread", RTLD_NOW); 96 return reinterpret_cast<void*>(strdup(dlerror())); 97} 98 99TEST(dlfcn, dlerror_concurrent) { 100 dlopen("/main/thread", RTLD_NOW); 101 const char* main_thread_error = dlerror(); 102 ASSERT_SUBSTR("/main/thread", main_thread_error); 103 104 pthread_t t; 105 ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentDlErrorFn, NULL)); 106 void* result; 107 ASSERT_EQ(0, pthread_join(t, &result)); 108 char* child_thread_error = static_cast<char*>(result); 109 ASSERT_SUBSTR("/child/thread", child_thread_error); 110 free(child_thread_error); 111 112 ASSERT_SUBSTR("/main/thread", main_thread_error); 113} 114 115TEST(dlfcn, dlsym_failures) { 116 dlerror(); // Clear any pending errors. 117 void* self = dlopen(NULL, RTLD_NOW); 118 ASSERT_TRUE(self != NULL); 119 ASSERT_TRUE(dlerror() == NULL); 120 121 void* sym; 122 123#if defined(__BIONIC__) && !defined(__LP64__) 124 // RTLD_DEFAULT in lp32 bionic is not (void*)0 125 // so it can be distinguished from the NULL handle. 126 sym = dlsym(NULL, "test"); 127 ASSERT_TRUE(sym == NULL); 128 ASSERT_SUBSTR("dlsym library handle is null", dlerror()); 129#endif 130 131 // NULL symbol name. 132#if defined(__BIONIC__) 133 // glibc marks this parameter non-null and SEGVs if you cheat. 134 sym = dlsym(self, NULL); 135 ASSERT_TRUE(sym == NULL); 136 ASSERT_SUBSTR("", dlerror()); 137#endif 138 139 // Symbol that doesn't exist. 140 sym = dlsym(self, "ThisSymbolDoesNotExist"); 141 ASSERT_TRUE(sym == NULL); 142 ASSERT_SUBSTR("undefined symbol: ThisSymbolDoesNotExist", dlerror()); 143 144 ASSERT_EQ(0, dlclose(self)); 145} 146 147TEST(dlfcn, dladdr) { 148 dlerror(); // Clear any pending errors. 149 void* self = dlopen(NULL, RTLD_NOW); 150 ASSERT_TRUE(self != NULL); 151 ASSERT_TRUE(dlerror() == NULL); 152 153 void* sym = dlsym(self, "DlSymTestFunction"); 154 ASSERT_TRUE(sym != NULL); 155 156 // Deliberately ask dladdr for an address inside a symbol, rather than the symbol base address. 157 void* addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(sym) + 2); 158 159 Dl_info info; 160 int rc = dladdr(addr, &info); 161 ASSERT_NE(rc, 0); // Zero on error, non-zero on success. 162 163 // Get the name of this executable. 164 char executable_path[PATH_MAX]; 165 rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path)); 166 ASSERT_NE(rc, -1); 167 executable_path[rc] = '\0'; 168 std::string executable_name(basename(executable_path)); 169 170 // The filename should be that of this executable. 171 // Note that we don't know whether or not we have the full path, so we want an "ends_with" test. 172 std::string dli_fname(info.dli_fname); 173 dli_fname = basename(&dli_fname[0]); 174 ASSERT_EQ(dli_fname, executable_name); 175 176 // The symbol name should be the symbol we looked up. 177 ASSERT_STREQ(info.dli_sname, "DlSymTestFunction"); 178 179 // The address should be the exact address of the symbol. 180 ASSERT_EQ(info.dli_saddr, sym); 181 182 // Look in /proc/pid/maps to find out what address we were loaded at. 183 // TODO: factor /proc/pid/maps parsing out into a class and reuse all over bionic. 184 void* base_address = NULL; 185 char path[PATH_MAX]; 186 snprintf(path, sizeof(path), "/proc/%d/maps", getpid()); 187 char line[BUFSIZ]; 188 FILE* fp = fopen(path, "r"); 189 ASSERT_TRUE(fp != NULL); 190 while (fgets(line, sizeof(line), fp) != NULL) { 191 uintptr_t start = strtoul(line, 0, 16); 192 line[strlen(line) - 1] = '\0'; // Chomp the '\n'. 193 char* path = strchr(line, '/'); 194 if (path != NULL && strcmp(executable_path, path) == 0) { 195 base_address = reinterpret_cast<void*>(start); 196 break; 197 } 198 } 199 fclose(fp); 200 201 // The base address should be the address we were loaded at. 202 ASSERT_EQ(info.dli_fbase, base_address); 203 204 ASSERT_EQ(0, dlclose(self)); 205} 206 207TEST(dlfcn, dladdr_invalid) { 208 Dl_info info; 209 210 dlerror(); // Clear any pending errors. 211 212 // No symbol corresponding to NULL. 213 ASSERT_EQ(dladdr(NULL, &info), 0); // Zero on error, non-zero on success. 214 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 215 216 // No symbol corresponding to a stack address. 217 ASSERT_EQ(dladdr(&info, &info), 0); // Zero on error, non-zero on success. 218 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 219} 220 221// Our dynamic linker doesn't support GNU hash tables. 222#if defined(__BIONIC__) 223// GNU-style ELF hash tables are incompatible with the MIPS ABI. 224// MIPS requires .dynsym to be sorted to match the GOT but GNU-style requires sorting by hash code. 225#if !defined(__mips__) 226TEST(dlfcn, dlopen_library_with_only_gnu_hash) { 227 dlerror(); // Clear any pending errors. 228 void* handle = dlopen("no-elf-hash-table-library.so", RTLD_NOW); 229 ASSERT_TRUE(handle == NULL); 230 ASSERT_STREQ("dlopen failed: empty/missing DT_HASH in \"no-elf-hash-table-library.so\" (built with --hash-style=gnu?)", dlerror()); 231} 232#endif 233#endif 234 235TEST(dlfcn, dlopen_bad_flags) { 236 dlerror(); // Clear any pending errors. 237 void* handle; 238 239#if defined(__GLIBC__) 240 // glibc was smart enough not to define RTLD_NOW as 0, so it can detect missing flags. 241 handle = dlopen(NULL, 0); 242 ASSERT_TRUE(handle == NULL); 243 ASSERT_SUBSTR("invalid", dlerror()); 244#endif 245 246 handle = dlopen(NULL, 0xffffffff); 247 ASSERT_TRUE(handle == NULL); 248 ASSERT_SUBSTR("invalid", dlerror()); 249 250 // glibc actually allows you to choose both RTLD_NOW and RTLD_LAZY at the same time, and so do we. 251 handle = dlopen(NULL, RTLD_NOW|RTLD_LAZY); 252 ASSERT_TRUE(handle != NULL); 253 ASSERT_SUBSTR(NULL, dlerror()); 254} 255 256TEST(dlfcn, rtld_default_unknown_symbol) { 257 void* addr = dlsym(RTLD_DEFAULT, "ANY_UNKNOWN_SYMBOL_NAME"); 258 ASSERT_TRUE(addr == NULL); 259} 260 261TEST(dlfcn, rtld_default_known_symbol) { 262 void* addr = dlsym(RTLD_DEFAULT, "fopen"); 263 ASSERT_TRUE(addr != NULL); 264} 265 266TEST(dlfcn, rtld_next_unknown_symbol) { 267 void* addr = dlsym(RTLD_NEXT, "ANY_UNKNOWN_SYMBOL_NAME"); 268 ASSERT_TRUE(addr == NULL); 269} 270 271TEST(dlfcn, rtld_next_known_symbol) { 272 void* addr = dlsym(RTLD_NEXT, "fopen"); 273 ASSERT_TRUE(addr != NULL); 274} 275 276TEST(dlfcn, dlsym_weak_func) { 277 dlerror(); 278 void* handle = dlopen("libtest_dlsym_weak_func.so",RTLD_NOW); 279 ASSERT_TRUE(handle != NULL); 280 281 int (*weak_func)(); 282 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "weak_func")); 283 ASSERT_TRUE(weak_func != NULL) << "dlerror: " << dlerror(); 284 EXPECT_EQ(42, weak_func()); 285 dlclose(handle); 286} 287 288TEST(dlfcn, dlopen_symlink) { 289 void* handle1 = dlopen("libdlext_test.so", RTLD_NOW); 290 void* handle2 = dlopen("libdlext_test_v2.so", RTLD_NOW); 291 ASSERT_TRUE(handle1 != NULL); 292 ASSERT_TRUE(handle2 != NULL); 293 ASSERT_EQ(handle1, handle2); 294} 295