dlfcn_test.cpp revision 0416d88f9c90dcb1b97947a27a7c05f3627484c4
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 "private/ScopeGuard.h" 26 27#include <string> 28 29#define ASSERT_SUBSTR(needle, haystack) \ 30 ASSERT_PRED_FORMAT2(::testing::IsSubstring, needle, haystack) 31 32static bool g_called = false; 33extern "C" void DlSymTestFunction() { 34 g_called = true; 35} 36 37static int g_ctor_function_called = 0; 38 39extern "C" void ctor_function() __attribute__ ((constructor)); 40 41extern "C" void ctor_function() { 42 g_ctor_function_called = 17; 43} 44 45TEST(dlfcn, ctor_function_call) { 46 ASSERT_EQ(17, g_ctor_function_called); 47} 48 49TEST(dlfcn, dlsym_in_self) { 50 dlerror(); // Clear any pending errors. 51 void* self = dlopen(NULL, RTLD_NOW); 52 ASSERT_TRUE(self != NULL); 53 ASSERT_TRUE(dlerror() == NULL); 54 55 void* sym = dlsym(self, "DlSymTestFunction"); 56 ASSERT_TRUE(sym != NULL); 57 58 void (*function)() = reinterpret_cast<void(*)()>(sym); 59 60 g_called = false; 61 function(); 62 ASSERT_TRUE(g_called); 63 64 ASSERT_EQ(0, dlclose(self)); 65} 66 67TEST(dlfcn, dlsym_with_dependencies) { 68 void* handle = dlopen("libtest_with_dependency.so", RTLD_NOW); 69 ASSERT_TRUE(handle != NULL); 70 dlerror(); 71 // This symbol is in DT_NEEDED library. 72 void* sym = dlsym(handle, "getRandomNumber"); 73 ASSERT_TRUE(sym != NULL); 74 int (*fn)(void); 75 fn = reinterpret_cast<int (*)(void)>(sym); 76 EXPECT_EQ(4, fn()); 77 dlclose(handle); 78} 79 80TEST(dlfcn, dlopen_noload) { 81 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 82 ASSERT_TRUE(handle == NULL); 83 handle = dlopen("libtest_simple.so", RTLD_NOW); 84 void* handle2 = dlopen("libtest_simple.so", RTLD_NOW | RTLD_NOLOAD); 85 ASSERT_TRUE(handle != NULL); 86 ASSERT_TRUE(handle2 != NULL); 87 ASSERT_TRUE(handle == handle2); 88 ASSERT_EQ(0, dlclose(handle)); 89 ASSERT_EQ(0, dlclose(handle2)); 90} 91 92// ifuncs are only supported on intel and arm64 for now 93#if defined (__aarch64__) || defined(__i386__) || defined(__x86_64__) 94TEST(dlfcn, ifunc) { 95 typedef const char* (*fn_ptr)(); 96 97 // ifunc's choice depends on whether IFUNC_CHOICE has a value 98 // first check the set case 99 setenv("IFUNC_CHOICE", "set", 1); 100 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 101 ASSERT_TRUE(handle != NULL); 102 fn_ptr foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 103 fn_ptr foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 104 ASSERT_TRUE(foo_ptr != NULL); 105 ASSERT_TRUE(foo_library_ptr != NULL); 106 ASSERT_EQ(strncmp("set", foo_ptr(), 3), 0); 107 ASSERT_EQ(strncmp("set", foo_library_ptr(), 3), 0); 108 dlclose(handle); 109 110 // then check the unset case 111 unsetenv("IFUNC_CHOICE"); 112 handle = dlopen("libtest_ifunc.so", RTLD_NOW); 113 ASSERT_TRUE(handle != NULL); 114 foo_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo")); 115 foo_library_ptr = reinterpret_cast<fn_ptr>(dlsym(handle, "foo_library")); 116 ASSERT_TRUE(foo_ptr != NULL); 117 ASSERT_TRUE(foo_library_ptr != NULL); 118 ASSERT_EQ(strncmp("unset", foo_ptr(), 5), 0); 119 ASSERT_EQ(strncmp("unset", foo_library_ptr(), 3), 0); 120 dlclose(handle); 121} 122 123TEST(dlfcn, ifunc_ctor_call) { 124 typedef const char* (*fn_ptr)(); 125 126 void* handle = dlopen("libtest_ifunc.so", RTLD_NOW); 127 ASSERT_TRUE(handle != nullptr) << dlerror(); 128 fn_ptr is_ctor_called = reinterpret_cast<fn_ptr>(dlsym(handle, "is_ctor_called_irelative")); 129 ASSERT_TRUE(is_ctor_called != nullptr) << dlerror(); 130 ASSERT_STREQ("false", is_ctor_called()); 131 132 is_ctor_called = reinterpret_cast<fn_ptr>(dlsym(handle, "is_ctor_called_jump_slot")); 133 ASSERT_TRUE(is_ctor_called != nullptr) << dlerror(); 134 ASSERT_STREQ("true", is_ctor_called()); 135 dlclose(handle); 136} 137#endif 138 139TEST(dlfcn, dlopen_check_relocation_dt_needed_order) { 140 // This is the structure of the test library and 141 // its dt_needed libraries 142 // libtest_relo_check_dt_needed_order.so 143 // | 144 // +-> libtest_relo_check_dt_needed_order_1.so 145 // | 146 // +-> libtest_relo_check_dt_needed_order_2.so 147 // 148 // The root library references relo_test_get_answer_lib - which is defined 149 // in both dt_needed libraries, the correct relocation should 150 // use the function defined in libtest_relo_check_dt_needed_order_1.so 151 void* handle = nullptr; 152 auto guard = make_scope_guard([&]() { 153 dlclose(handle); 154 }); 155 156 handle = dlopen("libtest_relo_check_dt_needed_order.so", RTLD_NOW); 157 ASSERT_TRUE(handle != nullptr) << dlerror(); 158 159 typedef int (*fn_t) (void); 160 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "relo_test_get_answer")); 161 ASSERT_TRUE(fn != nullptr) << dlerror(); 162 ASSERT_EQ(1, fn()); 163} 164 165TEST(dlfcn, dlopen_check_order_dlsym) { 166 // Here is how the test library and its dt_needed 167 // libraries are arranged 168 // 169 // libtest_check_order_children.so 170 // | 171 // +-> ..._1_left.so 172 // | | 173 // | +-> ..._a.so 174 // | | 175 // | +-> ...r_b.so 176 // | 177 // +-> ..._2_right.so 178 // | | 179 // | +-> ..._d.so 180 // | | 181 // | +-> ..._b.so 182 // | 183 // +-> ..._3_c.so 184 // 185 // load order should be (1, 2, 3, a, b, d) 186 // 187 // get_answer() is defined in (2, 3, a, b, c) 188 // get_answer2() is defined in (b, d) 189 void* sym = dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer"); 190 ASSERT_TRUE(sym == nullptr); 191 void* handle = dlopen("libtest_check_order_dlsym.so", RTLD_NOW | RTLD_GLOBAL); 192 ASSERT_TRUE(handle != nullptr) << dlerror(); 193 typedef int (*fn_t) (void); 194 fn_t fn, fn2; 195 fn = reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer")); 196 ASSERT_TRUE(fn != NULL) << dlerror(); 197 fn2 = reinterpret_cast<fn_t>(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer2")); 198 ASSERT_TRUE(fn2 != NULL) << dlerror(); 199 200 ASSERT_EQ(42, fn()); 201 ASSERT_EQ(43, fn2()); 202 dlclose(handle); 203} 204 205TEST(dlfcn, dlopen_check_order_reloc_siblings) { 206 // This is how this one works: 207 // we lookup and call get_answer which is defined in '_2.so' 208 // and in turn calls external get_answer_impl() defined in _1.so and in '_[a-f].so' 209 // the correct _impl() is implemented by '_a.so'; 210 // 211 // Note that this is test for RTLD_LOCAL (TODO: test for GLOBAL?) 212 // 213 // Here is the picture: 214 // 215 // libtest_check_order_reloc_siblings.so 216 // | 217 // +-> ..._1.so <- empty 218 // | | 219 // | +-> ..._a.so <- exports correct answer_impl() 220 // | | 221 // | +-> ..._b.so <- every other letter exporting incorrect one. 222 // | 223 // +-> ..._2.so <- empty 224 // | | 225 // | +-> ..._c.so 226 // | | 227 // | +-> ..._d.so 228 // | 229 // +-> ..._3.so <- empty 230 // | 231 // +-> ..._e.so 232 // | 233 // +-> ..._f.so <- exports get_answer() that calls get_anser_impl(); 234 // implements incorrect get_answer_impl() 235 236 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 237 ASSERT_TRUE(handle == nullptr); 238#ifdef __BIONIC__ 239 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 240 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 241#endif 242 243 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 244 ASSERT_TRUE(handle != nullptr) << dlerror(); 245 246 typedef int (*fn_t) (void); 247 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_get_answer")); 248 ASSERT_TRUE(fn != nullptr) << dlerror(); 249 ASSERT_EQ(42, fn()); 250 251 ASSERT_EQ(0, dlclose(handle)); 252} 253 254TEST(dlfcn, dlopen_check_order_reloc_siblings_with_preload) { 255 // This test uses the same library as dlopen_check_order_reloc_siblings. 256 // Unlike dlopen_check_order_reloc_siblings it preloads 257 // libtest_check_order_reloc_siblings_1.so (first dependency) prior to 258 // dlopen(libtest_check_order_reloc_siblings.so) 259 260 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 261 ASSERT_TRUE(handle == nullptr); 262 handle = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_NOLOAD); 263 ASSERT_TRUE(handle == nullptr); 264 265 void* handle_for_1 = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_LOCAL); 266 ASSERT_TRUE(handle_for_1 != nullptr) << dlerror(); 267 268 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 269 ASSERT_TRUE(handle != nullptr) << dlerror(); 270 271 ASSERT_EQ(0, dlclose(handle_for_1)); 272 273 typedef int (*fn_t) (void); 274 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_get_answer")); 275 ASSERT_TRUE(fn != nullptr) << dlerror(); 276 ASSERT_EQ(42, fn()); 277 278 ASSERT_EQ(0, dlclose(handle)); 279} 280 281TEST(dlfcn, dlopen_check_order_reloc_nephew) { 282 // This is how this one works: 283 // we lookup and call nephew_get_answer which is defined in '_2.so' 284 // and in turn calls external get_answer_impl() defined in '_[a-f].so' 285 // the correct _impl() is implemented by '_a.so'; 286 // 287 // Here is the picture: 288 // 289 // libtest_check_order_reloc_siblings.so 290 // | 291 // +-> ..._1.so <- empty 292 // | | 293 // | +-> ..._a.so <- exports correct answer_impl() 294 // | | 295 // | +-> ..._b.so <- every other letter exporting incorrect one. 296 // | 297 // +-> ..._2.so <- empty 298 // | | 299 // | +-> ..._c.so 300 // | | 301 // | +-> ..._d.so 302 // | 303 // +-> ..._3.so <- nephew_get_answer() that calls get_answer_impl(); 304 // | 305 // +-> ..._e.so 306 // | 307 // +-> ..._f.so 308 309 void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); 310 ASSERT_TRUE(handle == nullptr); 311#ifdef __BIONIC__ 312 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 313 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 314#endif 315 316 handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); 317 ASSERT_TRUE(handle != nullptr) << dlerror(); 318 319 typedef int (*fn_t) (void); 320 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_nephew_get_answer")); 321 ASSERT_TRUE(fn != nullptr) << dlerror(); 322 ASSERT_EQ(42, fn()); 323 324 ASSERT_EQ(0, dlclose(handle)); 325} 326 327extern "C" int check_order_reloc_root_get_answer_impl() { 328 return 42; 329} 330 331TEST(dlfcn, dlopen_check_order_reloc_main_executable) { 332 // This is how this one works: 333 // we lookup and call get_answer3 which is defined in 'root.so' 334 // and in turn calls external root_get_answer_impl() defined in _2.so and 335 // above the correct _impl() is one in the executable. 336 // 337 // libtest_check_order_reloc_root.so 338 // | 339 // +-> ..._1.so <- empty 340 // | 341 // +-> ..._2.so <- gives incorrect answer for answer_main_impl() 342 // 343 344 void* handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_NOLOAD); 345 ASSERT_TRUE(handle == nullptr); 346#ifdef __BIONIC__ 347 // TODO: glibc returns nullptr on dlerror() here. Is it bug? 348 ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_root.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 349#endif 350 351 handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_LOCAL); 352 ASSERT_TRUE(handle != nullptr) << dlerror(); 353 354 typedef int (*fn_t) (void); 355 fn_t fn = reinterpret_cast<fn_t>(dlsym(handle, "check_order_reloc_root_get_answer")); 356 ASSERT_TRUE(fn != nullptr) << dlerror(); 357 ASSERT_EQ(42, fn()); 358 359 ASSERT_EQ(0, dlclose(handle)); 360} 361 362TEST(dlfcn, dlopen_check_rtld_local) { 363 void* sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 364 ASSERT_TRUE(sym == nullptr); 365 366 // implicit RTLD_LOCAL 367 void* handle = dlopen("libtest_simple.so", RTLD_NOW); 368 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 369 ASSERT_TRUE(sym == nullptr); 370 ASSERT_SUBSTR("undefined symbol: dlopen_testlib_simple_func", dlerror()); 371 sym = dlsym(handle, "dlopen_testlib_simple_func"); 372 ASSERT_TRUE(sym != nullptr); 373 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 374 dlclose(handle); 375 376 // explicit RTLD_LOCAL 377 handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_LOCAL); 378 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 379 ASSERT_TRUE(sym == nullptr); 380 ASSERT_SUBSTR("undefined symbol: dlopen_testlib_simple_func", dlerror()); 381 sym = dlsym(handle, "dlopen_testlib_simple_func"); 382 ASSERT_TRUE(sym != nullptr); 383 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 384 dlclose(handle); 385} 386 387TEST(dlfcn, dlopen_check_rtld_global) { 388 void* sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 389 ASSERT_TRUE(sym == nullptr); 390 391 void* handle = dlopen("libtest_simple.so", RTLD_NOW | RTLD_GLOBAL); 392 ASSERT_TRUE(handle != nullptr) << dlerror(); 393 sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 394 ASSERT_TRUE(sym != nullptr) << dlerror(); 395 ASSERT_TRUE(reinterpret_cast<bool (*)(void)>(sym)()); 396 dlclose(handle); 397 398 // RTLD_GLOBAL implies RTLD_NODELETE, let's check that 399 void* sym_after_dlclose = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); 400 ASSERT_EQ(sym, sym_after_dlclose); 401} 402 403// libtest_with_dependency_loop.so -> libtest_with_dependency_loop_a.so -> 404// libtest_with_dependency_loop_b.so -> libtest_with_dependency_loop_c.so -> 405// libtest_with_dependency_loop_a.so 406TEST(dlfcn, dlopen_check_loop) { 407 void* handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW); 408#if defined(__BIONIC__) 409 ASSERT_TRUE(handle == nullptr); 410 ASSERT_STREQ("dlopen failed: recursive link to \"libtest_with_dependency_loop_a.so\"", dlerror()); 411 // This symbol should never be exposed 412 void* f = dlsym(RTLD_DEFAULT, "dlopen_test_invalid_function"); 413 ASSERT_TRUE(f == nullptr); 414 ASSERT_SUBSTR("undefined symbol: dlopen_test_invalid_function", dlerror()); 415 416 // dlopen second time to make sure that the library wasn't loaded even though dlopen returned null. 417 // This may happen if during cleanup the root library or one of the depended libs were not removed 418 // from soinfo list. 419 handle = dlopen("libtest_with_dependency_loop.so", RTLD_NOW | RTLD_NOLOAD); 420 ASSERT_TRUE(handle == nullptr); 421 ASSERT_STREQ("dlopen failed: library \"libtest_with_dependency_loop.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); 422#else // glibc allows recursive links 423 ASSERT_TRUE(handle != nullptr); 424 dlclose(handle); 425#endif 426} 427 428TEST(dlfcn, dlopen_nodelete) { 429 static bool is_unloaded = false; 430 431 void* handle = dlopen("libtest_nodelete_1.so", RTLD_NOW | RTLD_NODELETE); 432 ASSERT_TRUE(handle != nullptr) << dlerror(); 433 void (*set_unload_flag_ptr)(bool*); 434 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_1_set_unload_flag_ptr")); 435 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 436 set_unload_flag_ptr(&is_unloaded); 437 438 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 439 ASSERT_TRUE(taxicab_number != nullptr) << dlerror(); 440 ASSERT_EQ(1729U, *taxicab_number); 441 *taxicab_number = 2; 442 443 dlclose(handle); 444 ASSERT_TRUE(!is_unloaded); 445 446 uint32_t* taxicab_number_after_dlclose = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 447 ASSERT_EQ(taxicab_number_after_dlclose, taxicab_number); 448 ASSERT_EQ(2U, *taxicab_number_after_dlclose); 449 450 451 handle = dlopen("libtest_nodelete_1.so", RTLD_NOW); 452 uint32_t* taxicab_number2 = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_1_taxicab_number")); 453 ASSERT_EQ(taxicab_number2, taxicab_number); 454 455 ASSERT_EQ(2U, *taxicab_number2); 456 457 dlclose(handle); 458 ASSERT_TRUE(!is_unloaded); 459} 460 461TEST(dlfcn, dlopen_nodelete_on_second_dlopen) { 462 static bool is_unloaded = false; 463 464 void* handle = dlopen("libtest_nodelete_2.so", RTLD_NOW); 465 ASSERT_TRUE(handle != nullptr) << dlerror(); 466 void (*set_unload_flag_ptr)(bool*); 467 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_2_set_unload_flag_ptr")); 468 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 469 set_unload_flag_ptr(&is_unloaded); 470 471 uint32_t* taxicab_number = reinterpret_cast<uint32_t*>(dlsym(handle, "dlopen_nodelete_2_taxicab_number")); 472 ASSERT_TRUE(taxicab_number != nullptr) << dlerror(); 473 474 ASSERT_EQ(1729U, *taxicab_number); 475 *taxicab_number = 2; 476 477 // This RTLD_NODELETE should be ignored 478 void* handle1 = dlopen("libtest_nodelete_2.so", RTLD_NOW | RTLD_NODELETE); 479 ASSERT_TRUE(handle1 != nullptr) << dlerror(); 480 ASSERT_EQ(handle, handle1); 481 482 dlclose(handle1); 483 dlclose(handle); 484 485 ASSERT_TRUE(is_unloaded); 486} 487 488TEST(dlfcn, dlopen_nodelete_dt_flags_1) { 489 static bool is_unloaded = false; 490 491 void* handle = dlopen("libtest_nodelete_dt_flags_1.so", RTLD_NOW); 492 ASSERT_TRUE(handle != nullptr) << dlerror(); 493 void (*set_unload_flag_ptr)(bool*); 494 set_unload_flag_ptr = reinterpret_cast<void (*)(bool*)>(dlsym(handle, "dlopen_nodelete_dt_flags_1_set_unload_flag_ptr")); 495 ASSERT_TRUE(set_unload_flag_ptr != nullptr) << dlerror(); 496 set_unload_flag_ptr(&is_unloaded); 497 498 dlclose(handle); 499 ASSERT_TRUE(!is_unloaded); 500} 501 502TEST(dlfcn, dlsym_df_1_global) { 503#if !defined(__arm__) 504 void* handle = dlopen("libtest_dlsym_df_1_global.so", RTLD_NOW); 505 ASSERT_TRUE(handle != nullptr) << dlerror(); 506 int (*get_answer)(); 507 get_answer = reinterpret_cast<int (*)()>(dlsym(handle, "dl_df_1_global_get_answer")); 508 ASSERT_TRUE(get_answer != nullptr) << dlerror(); 509 ASSERT_EQ(42, get_answer()); 510 ASSERT_EQ(0, dlclose(handle)); 511#else 512 GTEST_LOG_(INFO) << "This test does nothing on arm (to be reenabled once b/18137520 or b/18130452 are fixed).\n"; 513#endif 514} 515 516TEST(dlfcn, dlopen_failure) { 517 void* self = dlopen("/does/not/exist", RTLD_NOW); 518 ASSERT_TRUE(self == NULL); 519#if defined(__BIONIC__) 520 ASSERT_STREQ("dlopen failed: library \"/does/not/exist\" not found", dlerror()); 521#else 522 ASSERT_STREQ("/does/not/exist: cannot open shared object file: No such file or directory", dlerror()); 523#endif 524} 525 526static void* ConcurrentDlErrorFn(void*) { 527 dlopen("/child/thread", RTLD_NOW); 528 return reinterpret_cast<void*>(strdup(dlerror())); 529} 530 531TEST(dlfcn, dlerror_concurrent) { 532 dlopen("/main/thread", RTLD_NOW); 533 const char* main_thread_error = dlerror(); 534 ASSERT_SUBSTR("/main/thread", main_thread_error); 535 536 pthread_t t; 537 ASSERT_EQ(0, pthread_create(&t, NULL, ConcurrentDlErrorFn, NULL)); 538 void* result; 539 ASSERT_EQ(0, pthread_join(t, &result)); 540 char* child_thread_error = static_cast<char*>(result); 541 ASSERT_SUBSTR("/child/thread", child_thread_error); 542 free(child_thread_error); 543 544 ASSERT_SUBSTR("/main/thread", main_thread_error); 545} 546 547TEST(dlfcn, dlsym_failures) { 548 dlerror(); // Clear any pending errors. 549 void* self = dlopen(NULL, RTLD_NOW); 550 ASSERT_TRUE(self != NULL); 551 ASSERT_TRUE(dlerror() == NULL); 552 553 void* sym; 554 555#if defined(__BIONIC__) && !defined(__LP64__) 556 // RTLD_DEFAULT in lp32 bionic is not (void*)0 557 // so it can be distinguished from the NULL handle. 558 sym = dlsym(NULL, "test"); 559 ASSERT_TRUE(sym == NULL); 560 ASSERT_SUBSTR("dlsym library handle is null", dlerror()); 561#endif 562 563 // NULL symbol name. 564#if defined(__BIONIC__) 565 // glibc marks this parameter non-null and SEGVs if you cheat. 566 sym = dlsym(self, NULL); 567 ASSERT_TRUE(sym == NULL); 568 ASSERT_SUBSTR("", dlerror()); 569#endif 570 571 // Symbol that doesn't exist. 572 sym = dlsym(self, "ThisSymbolDoesNotExist"); 573 ASSERT_TRUE(sym == NULL); 574 ASSERT_SUBSTR("undefined symbol: ThisSymbolDoesNotExist", dlerror()); 575 576 ASSERT_EQ(0, dlclose(self)); 577} 578 579TEST(dlfcn, dladdr) { 580 dlerror(); // Clear any pending errors. 581 void* self = dlopen(NULL, RTLD_NOW); 582 ASSERT_TRUE(self != NULL); 583 ASSERT_TRUE(dlerror() == NULL); 584 585 void* sym = dlsym(self, "DlSymTestFunction"); 586 ASSERT_TRUE(sym != NULL); 587 588 // Deliberately ask dladdr for an address inside a symbol, rather than the symbol base address. 589 void* addr = reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(sym) + 2); 590 591 Dl_info info; 592 int rc = dladdr(addr, &info); 593 ASSERT_NE(rc, 0); // Zero on error, non-zero on success. 594 595 // Get the name of this executable. 596 char executable_path[PATH_MAX]; 597 rc = readlink("/proc/self/exe", executable_path, sizeof(executable_path)); 598 ASSERT_NE(rc, -1); 599 executable_path[rc] = '\0'; 600 std::string executable_name(basename(executable_path)); 601 602 // The filename should be that of this executable. 603 // Note that we don't know whether or not we have the full path, so we want an "ends_with" test. 604 std::string dli_fname(info.dli_fname); 605 dli_fname = basename(&dli_fname[0]); 606 ASSERT_EQ(dli_fname, executable_name); 607 608 // The symbol name should be the symbol we looked up. 609 ASSERT_STREQ(info.dli_sname, "DlSymTestFunction"); 610 611 // The address should be the exact address of the symbol. 612 ASSERT_EQ(info.dli_saddr, sym); 613 614 // Look in /proc/pid/maps to find out what address we were loaded at. 615 // TODO: factor /proc/pid/maps parsing out into a class and reuse all over bionic. 616 void* base_address = NULL; 617 char line[BUFSIZ]; 618 FILE* fp = fopen("/proc/self/maps", "r"); 619 ASSERT_TRUE(fp != NULL); 620 while (fgets(line, sizeof(line), fp) != NULL) { 621 uintptr_t start = strtoul(line, 0, 16); 622 line[strlen(line) - 1] = '\0'; // Chomp the '\n'. 623 char* path = strchr(line, '/'); 624 if (path != NULL && strcmp(executable_path, path) == 0) { 625 base_address = reinterpret_cast<void*>(start); 626 break; 627 } 628 } 629 fclose(fp); 630 631 // The base address should be the address we were loaded at. 632 ASSERT_EQ(info.dli_fbase, base_address); 633 634 ASSERT_EQ(0, dlclose(self)); 635} 636 637TEST(dlfcn, dladdr_invalid) { 638 Dl_info info; 639 640 dlerror(); // Clear any pending errors. 641 642 // No symbol corresponding to NULL. 643 ASSERT_EQ(dladdr(NULL, &info), 0); // Zero on error, non-zero on success. 644 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 645 646 // No symbol corresponding to a stack address. 647 ASSERT_EQ(dladdr(&info, &info), 0); // Zero on error, non-zero on success. 648 ASSERT_TRUE(dlerror() == NULL); // dladdr(3) doesn't set dlerror(3). 649} 650 651// Our dynamic linker doesn't support GNU hash tables. 652#if defined(__BIONIC__) 653// GNU-style ELF hash tables are incompatible with the MIPS ABI. 654// MIPS requires .dynsym to be sorted to match the GOT but GNU-style requires sorting by hash code. 655#if !defined(__mips__) 656TEST(dlfcn, dlopen_library_with_only_gnu_hash) { 657 dlerror(); // Clear any pending errors. 658 void* handle = dlopen("no-elf-hash-table-library.so", RTLD_NOW); 659 ASSERT_TRUE(handle == NULL); 660 ASSERT_STREQ("dlopen failed: empty/missing DT_HASH in \"no-elf-hash-table-library.so\" (built with --hash-style=gnu?)", dlerror()); 661} 662#endif 663#endif 664 665TEST(dlfcn, dlopen_bad_flags) { 666 dlerror(); // Clear any pending errors. 667 void* handle; 668 669#if defined(__GLIBC__) 670 // glibc was smart enough not to define RTLD_NOW as 0, so it can detect missing flags. 671 handle = dlopen(NULL, 0); 672 ASSERT_TRUE(handle == NULL); 673 ASSERT_SUBSTR("invalid", dlerror()); 674#endif 675 676 handle = dlopen(NULL, 0xffffffff); 677 ASSERT_TRUE(handle == NULL); 678 ASSERT_SUBSTR("invalid", dlerror()); 679 680 // glibc actually allows you to choose both RTLD_NOW and RTLD_LAZY at the same time, and so do we. 681 handle = dlopen(NULL, RTLD_NOW|RTLD_LAZY); 682 ASSERT_TRUE(handle != NULL); 683 ASSERT_SUBSTR(NULL, dlerror()); 684} 685 686TEST(dlfcn, rtld_default_unknown_symbol) { 687 void* addr = dlsym(RTLD_DEFAULT, "ANY_UNKNOWN_SYMBOL_NAME"); 688 ASSERT_TRUE(addr == NULL); 689} 690 691TEST(dlfcn, rtld_default_known_symbol) { 692 void* addr = dlsym(RTLD_DEFAULT, "fopen"); 693 ASSERT_TRUE(addr != NULL); 694} 695 696TEST(dlfcn, rtld_next_unknown_symbol) { 697 void* addr = dlsym(RTLD_NEXT, "ANY_UNKNOWN_SYMBOL_NAME"); 698 ASSERT_TRUE(addr == NULL); 699} 700 701TEST(dlfcn, rtld_next_known_symbol) { 702 void* addr = dlsym(RTLD_NEXT, "fopen"); 703 ASSERT_TRUE(addr != NULL); 704} 705 706TEST(dlfcn, dlsym_weak_func) { 707 dlerror(); 708 void* handle = dlopen("libtest_dlsym_weak_func.so",RTLD_NOW); 709 ASSERT_TRUE(handle != NULL); 710 711 int (*weak_func)(); 712 weak_func = reinterpret_cast<int (*)()>(dlsym(handle, "weak_func")); 713 ASSERT_TRUE(weak_func != NULL) << "dlerror: " << dlerror(); 714 EXPECT_EQ(42, weak_func()); 715 dlclose(handle); 716} 717 718TEST(dlfcn, dlopen_symlink) { 719 void* handle1 = dlopen("libdlext_test.so", RTLD_NOW); 720 void* handle2 = dlopen("libdlext_test_v2.so", RTLD_NOW); 721 ASSERT_TRUE(handle1 != NULL); 722 ASSERT_TRUE(handle2 != NULL); 723 ASSERT_EQ(handle1, handle2); 724 dlclose(handle1); 725 dlclose(handle2); 726} 727