rust

72 |   return in_interceptor_scope;
73 | }
74 | 
75 | static uptr allocated_for_dlsym;
76 | static const uptr kDlsymAllocPoolSize = 1024;
77 | static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
78 | 
79 | static bool IsInDlsymAllocPool(const void *ptr) {
80 |   uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
81 |   return off < sizeof(alloc_memory_for_dlsym);
82 | }
83 | 
84 | static void *AllocateFromLocalPool(uptr size_in_bytes) {
85 |   uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
86 |   void *mem = (void *)&alloc_memory_for_dlsym[allocated_for_dlsym];
87 |   allocated_for_dlsym += size_in_words;
88 |   CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
89 |   return mem;
90 | }
891 | INTERCEPTOR(void *, realloc, void *ptr, SIZE_T size) {
892 |   GET_MALLOC_STACK_TRACE;
893 |   if (UNLIKELY(IsInDlsymAllocPool(ptr))) {
894 |     uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
895 |     uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
896 |     void *new_ptr;

3206 |       printf("dlerror: %s\n", dlerror());
3207 |       ASSERT_TRUE(lib != NULL);
3208 |     }
3209 |     void **(*get_dso_global)() = (void **(*)())dlsym(lib, "get_dso_global");
3210 |     ASSERT_TRUE(get_dso_global != NULL);
3211 |     void **dso_global = get_dso_global();
4623 |   free(p);
4624 | 
4625 |   typedef void *(*mmap_fn)(void *, size_t, int, int, int, off_t);
4626 |   mmap_fn real_mmap = (mmap_fn)dlsym(RTLD_NEXT, "mmap");
4627 | 
4628 |   // Allocate the page that was released to the OS in free() with the real mmap,

243 | #endif
244 | 
245 | void *AsanDlSymNext(const char *sym) {
246 |   return dlsym(RTLD_NEXT, sym);
247 | }
248 | 

28 | // ---------------------- Replacement functions ---------------- {{{1
29 | using namespace __asan;  // NOLINT
30 | 
31 | static uptr allocated_for_dlsym;
32 | static uptr last_dlsym_alloc_size_in_words;
33 | static const uptr kDlsymAllocPoolSize = SANITIZER_RTEMS ? 4096 : 1024;
34 | static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
35 | 
36 | static INLINE bool IsInDlsymAllocPool(const void *ptr) {
37 |   uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
38 |   return off < allocated_for_dlsym * sizeof(alloc_memory_for_dlsym[0]);
39 | }
40 | 
41 | static void *AllocateFromLocalPool(uptr size_in_bytes) {
42 |   uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
43 |   void *mem = (void*)&alloc_memory_for_dlsym[allocated_for_dlsym];
44 |   last_dlsym_alloc_size_in_words = size_in_words;
45 |   allocated_for_dlsym += size_in_words;
46 |   CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
47 |   return mem;
48 | }
51 |   // Hack: since glibc 2.27 dlsym no longer uses stack-allocated memory to store
52 |   // error messages and instead uses malloc followed by free. To avoid pool
53 |   // exhaustion due to long object filenames, handle that special case here.
54 |   uptr prev_offset = allocated_for_dlsym - last_dlsym_alloc_size_in_words;
55 |   void *prev_mem = (void*)&alloc_memory_for_dlsym[prev_offset];
56 |   if (prev_mem == ptr) {
57 |     REAL(memset)(prev_mem, 0, last_dlsym_alloc_size_in_words * kWordSize);
58 |     allocated_for_dlsym = prev_offset;
59 |     last_dlsym_alloc_size_in_words = 0;
60 |   }
61 | }
67 | 
68 |   CHECK(alignment >= kWordSize);
69 | 
70 |   uptr addr = (uptr)&alloc_memory_for_dlsym[allocated_for_dlsym];
71 |   uptr aligned_addr = RoundUpTo(addr, alignment);
72 |   uptr aligned_size = RoundUpTo(size_in_bytes, kWordSize);
73 | 
74 |   uptr *end_mem = (uptr*)(aligned_addr + aligned_size);
75 |   uptr allocated = end_mem - alloc_memory_for_dlsym;
76 |   if (allocated >= kDlsymAllocPoolSize)
77 |     return errno_ENOMEM;
78 | 
79 |   allocated_for_dlsym = allocated;
80 |   *memptr = (void*)aligned_addr;
81 |   return 0;
104 | }
105 | 
106 | static void *ReallocFromLocalPool(void *ptr, uptr size) {
107 |   const uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
108 |   const uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
109 |   void *new_ptr;

38 |   if (StrCmp(name, "sigaction"))
39 |     name = "__sigaction14";
40 | #endif
41 |   void *addr = dlsym(RTLD_NEXT, name);
42 |   if (!addr) {
43 |     // If the lookup using RTLD_NEXT failed, the sanitizer runtime library is
45 |     // intercept, which means that we cannot intercept this function. We still
46 |     // want the address of the real definition, though, so look it up using
47 |     // RTLD_DEFAULT.
48 |     addr = dlsym(RTLD_DEFAULT, name);
49 |   }
50 |   return addr;

830 |   // "pthread_create", if interceptors are working, it should really point to
831 |   // "wrap_pthread_create" within our own dylib.
832 |   Dl_info info_pthread_create;
833 |   void *dlopen_addr = dlsym(RTLD_DEFAULT, "pthread_create");
834 |   RAW_CHECK(dladdr(dlopen_addr, &info_pthread_create));
835 |   if (internal_strcmp(info.dli_fname, info_pthread_create.dli_fname) != 0) {

74 | // malloc and thread-local storage, which is not a good thing to do during
75 | // symbolication.
76 | static void InitializeSwiftDemangler() {
77 |   swift_demangle_f = (swift_demangle_ft)dlsym(RTLD_DEFAULT, "swift_demangle");
78 |   (void)dlerror(); // Cleanup error message in case of failure
79 | }

74 | namespace __sanitizer {
75 | 
76 | static void *GetRealLibcAddress(const char *symbol) {
77 |   void *real = dlsym(RTLD_NEXT, symbol);
78 |   if (!real)
79 |     real = dlsym(RTLD_DEFAULT, symbol);
80 |   if (!real) {
81 |     Printf("GetRealLibcAddress failed for symbol=%s", symbol);

60 |     return;
61 |   }
62 |   acquire_my_map_info_list =
63 |       (acquire_my_map_info_list_func)(uptr)dlsym(p, "acquire_my_map_info_list");
64 |   release_my_map_info_list =
65 |       (release_my_map_info_list_func)(uptr)dlsym(p, "release_my_map_info_list");
66 |   unwind_backtrace_signal_arch = (unwind_backtrace_signal_arch_func)(uptr)dlsym(
67 |       p, "unwind_backtrace_signal_arch");
68 |   if (!acquire_my_map_info_list || !release_my_map_info_list ||

150 | 
151 | #if !SANITIZER_GO
152 | bool SetEnv(const char *name, const char *value) {
153 |   void *f = dlsym(RTLD_NEXT, "setenv");
154 |   if (!f)
155 |     return false;
241 | void InitTlsSize() {
242 |   // all current supported platforms have 16 bytes stack alignment
243 |   const size_t kStackAlign = 16;
244 |   void *get_tls_static_info_ptr = dlsym(RTLD_NEXT, "_dl_get_tls_static_info");
245 |   size_t tls_size = 0;
246 |   size_t tls_align = 0;

780 |                           const void *newp, uptr newlen) {
781 |   static decltype(sysctlbyname) *real = nullptr;
782 |   if (!real)
783 |     real = (decltype(sysctlbyname) *)dlsym(RTLD_NEXT, "sysctlbyname");
784 |   CHECK(real);
785 |   return real(sname, oldp, (size_t *)oldlenp, newp, (size_t)newlen);

57 | #define LLVM_SYMBOLIZER_GET_FUNC(Function) \
58 |   ((__interceptor_##Function)              \
59 |        ? (__interceptor_##Function)        \
60 |        : reinterpret_cast<decltype(&Function)>(dlsym(RTLD_NEXT, #Function)))
61 | 
62 | #define LLVM_SYMBOLIZER_INTERCEPTOR1(Function, ...)               \

63 |   if (lsan_init_is_running) {
64 |     // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
65 |     const uptr kCallocPoolSize = 1024;
66 |     static uptr calloc_memory_for_dlsym[kCallocPoolSize];
67 |     static uptr allocated;
68 |     uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
69 |     void *mem = (void*)&calloc_memory_for_dlsym[allocated];
70 |     allocated += size_in_words;
71 |     CHECK(allocated < kCallocPoolSize);

33 | #ifdef _WIN32
34 |   return reinterpret_cast<void *>(GetProcAddress(GetModuleHandle(0), name));
35 | #else
36 |   return dlsym(RTLD_DEFAULT, name);
37 | #endif
38 | }

30 | int main(void) {
31 |   // This requires glibc 2.15.
32 |   process_vm_readwritev_fn libc_process_vm_readv =
33 |       (process_vm_readwritev_fn)dlsym(RTLD_NEXT, "process_vm_readv");
34 |   if (!libc_process_vm_readv)
35 |     return exit_dummy();
36 | 
37 |   process_vm_readwritev_fn process_vm_readv =
38 |       (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_readv");
39 |   process_vm_readwritev_fn process_vm_writev =
40 |       (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_writev");
41 | 
42 |   char a[100];

78 |   }
79 | 
80 |   // After this line ASan is activated and starts detecting errors.
81 |   void *fn = dlsym(dso, "do_another_bad_thing");
82 |   if (!fn) {
83 |     fprintf(stderr, "dlsym failed: %s\n", dlerror());
84 |     return 1;
85 |   }

26 |   assert(argc > 2);
27 |   void *handle1 = dlopen(argv[1], RTLD_LAZY);  // %dynamiclib1
28 |   assert(handle1);
29 |   void (*bar1)() = (void (*)())dlsym(handle1, "bar");
30 |   assert(bar1);
31 |   bar1();
32 |   void *handle2 = dlopen(argv[2], RTLD_LAZY);  // %dynamiclib2
33 |   assert(handle2);
34 |   void (*bar2)() = (void (*)())dlsym(handle2, "bar");
35 |   assert(bar2);
36 |   bar2();

54 |     printf("error in dlopen(): %s\n", dlerror());
55 |     return 1;
56 |   }
57 |   fun_t *get = (fun_t*)dlsym(lib, "get_address_of_static_var");
58 |   if (!get) {
59 |     printf("failed dlsym\n");
60 |     return 1;
61 |   }

29 |     printf("error in dlopen(): %s\n", dlerror());
30 |     return 1;
31 |   }
32 |   fun_t *inc2 = (fun_t*)dlsym(lib, "inc2");
33 |   if (!inc2) return 1;
34 |   printf("ok\n");

25 |     printf("error in dlopen(): %s\n", dlerror());
26 |     return 1;
27 |   }
28 |   fun_t *inc = (fun_t*)dlsym(lib, "inc");
29 |   if (!inc) return 1;
30 |   printf("ok\n");

27 | int main(int argc, char **argv) {
28 |   void *handle = dlopen(SO_DIR "/stack_trace_dlclose.so", RTLD_LAZY);
29 |   assert(handle);
30 |   void *(*foo)() = (void *(*)())dlsym(handle, "foo");
31 |   assert(foo);
32 |   void *p = foo();

20 |   assert(handle != 0);
21 | 
22 |   typedef void (*F)();
23 |   F f = (F)dlsym(handle, "call_rtl_from_dso");
24 |   printf("%s\n", dlerror());
25 |   assert(dlerror() == 0);

33 |     return 1;
34 |   }
35 |   // Make sure we can find a function we expect to be in the dylib.
36 |   void *fn = dlsym(handle, "__sanitizer_mz_size");
37 |   if (!fn) {
38 |     fprintf(stderr, "Failed to get symbol: %s\n", dlerror());

41 |     return 1;
42 |   }
43 | 
44 |   auto run_test = reinterpret_cast<run_test_fn *>(dlsym(lib, "run_test"));
45 |   if (!run_test) {
46 |     printf("failed dlsym\n");
47 |     return 1;
48 |   }

35 | void TestDlsym() {
36 |   void *handle = dlopen(SO_DIR "/get_module_and_offset_for_pc.so", RTLD_LAZY);
37 |   assert(handle);
38 |   void *foo = dlsym(handle, "foo");
39 |   assert(foo);
40 |   Test(foo, "foo");

25 |   void *handle = dlopen(path.c_str(), RTLD_LAZY);
26 |   assert(handle != 0);
27 |   typedef void **(* store_t)(void *p);
28 |   store_t StoreToTLS = (store_t)dlsym(handle, "StoreToTLS");
29 |   assert(dlerror() == 0);
30 | 

29 |   void *h = dlopen(lib.c_str(), RTLD_GLOBAL | RTLD_NOW);
30 |   if (h == 0)
31 |     exit(printf("failed to load the library (%d)\n", errno));
32 |   void (*f)() = (void(*)())dlsym(h, "libfunc");
33 |   if (f == 0)
34 |     exit(printf("failed to find the func (%d)\n", errno));

37 | int main(int argc, char **argv) {
38 |   std::string lib = std::string(dirname(argv[0])) + "/libignore_lib4.so";
39 |   void *h = dlopen(lib.c_str(), RTLD_GLOBAL | RTLD_NOW);
40 |   void (*func)() = (void(*)())dlsym(h, "myfunc");
41 |   func();
42 |   fprintf(stderr, "DONE\n");

62 |   void *h = dlopen(lib.c_str(), RTLD_GLOBAL | RTLD_NOW);
63 |   if (h == 0)
64 |     exit(printf("failed to load the library (%d)\n", errno));
65 |   void (*f)() = (void(*)())dlsym(h, "libfunc");
66 |   if (f == 0)
67 |     exit(printf("failed to find the func (%d)\n", errno));

38 |     printf("error in dlopen: %s\n", dlerror());
39 |     return 1;
40 |   }
41 |   void *f = dlsym(lib, "sofunc");
42 |   if (f == 0) {
43 |     printf("error in dlsym: %s\n", dlerror());
44 |     return 1;
45 |   }

29 | int main(int argc, char *argv[]) {
30 |   void *handle = dlopen(argv[1], RTLD_NOW);
31 |   fprintf(stderr, "handle = %p\n", handle);
32 |   void (*foo)() = (void (*)())dlsym(handle, "foo");
33 |   fprintf(stderr, "foo = %p\n", foo);
34 |   foo();

29 | 
30 | void InitializeLibrary() {
31 | #if defined(USE_TSAN_CALLBACKS)
32 |   callback_register_tag = (decltype(callback_register_tag))dlsym(RTLD_DEFAULT, "__tsan_external_register_tag");
33 |   callback_assign_tag = (decltype(callback_assign_tag))dlsym(RTLD_DEFAULT, "__tsan_external_assign_tag");
34 |   callback_read = (decltype(callback_read))dlsym(RTLD_DEFAULT, "__tsan_external_read");
35 |   callback_write = (decltype(callback_write))dlsym(RTLD_DEFAULT, "__tsan_external_write");
36 |   tag = callback_register_tag("MyLibrary::MyObject");
37 | #endif