1 //===-- sanitizer_libignore.cpp -------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "sanitizer_platform.h" 10 11 #if SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || \ 12 SANITIZER_NETBSD || SANITIZER_OPENBSD 13 14 #include "sanitizer_libignore.h" 15 #include "sanitizer_flags.h" 16 #include "sanitizer_posix.h" 17 #include "sanitizer_procmaps.h" 18 19 namespace __sanitizer { 20 21 LibIgnore::LibIgnore(LinkerInitialized) { 22 } 23 24 void LibIgnore::AddIgnoredLibrary(const char *name_templ) { 25 BlockingMutexLock lock(&mutex_); 26 if (count_ >= kMaxLibs) { 27 Report("%s: too many ignored libraries (max: %d)\n", SanitizerToolName, 28 kMaxLibs); 29 Die(); 30 } 31 Lib *lib = &libs_[count_++]; 32 lib->templ = internal_strdup(name_templ); 33 lib->name = nullptr; 34 lib->real_name = nullptr; 35 lib->loaded = false; 36 } 37 38 void LibIgnore::OnLibraryLoaded(const char *name) { 39 BlockingMutexLock lock(&mutex_); 40 // Try to match suppressions with symlink target. 41 InternalScopedString buf(kMaxPathLength); 42 if (name && internal_readlink(name, buf.data(), buf.size() - 1) > 0 && 43 buf[0]) { 44 for (uptr i = 0; i < count_; i++) { 45 Lib *lib = &libs_[i]; 46 if (!lib->loaded && (!lib->real_name) && 47 TemplateMatch(lib->templ, name)) 48 lib->real_name = internal_strdup(buf.data()); 49 } 50 } 51 52 // Scan suppressions list and find newly loaded and unloaded libraries. 53 ListOfModules modules; 54 modules.init(); 55 for (uptr i = 0; i < count_; i++) { 56 Lib *lib = &libs_[i]; 57 bool loaded = false; 58 for (const auto &mod : modules) { 59 for (const auto &range : mod.ranges()) { 60 if (!range.executable) 61 continue; 62 if (!TemplateMatch(lib->templ, mod.full_name()) && 63 !(lib->real_name && 64 internal_strcmp(lib->real_name, mod.full_name()) == 0)) 65 continue; 66 if (loaded) { 67 Report("%s: called_from_lib suppression '%s' is matched against" 68 " 2 libraries: '%s' and '%s'\n", 69 SanitizerToolName, lib->templ, lib->name, mod.full_name()); 70 Die(); 71 } 72 loaded = true; 73 if (lib->loaded) 74 continue; 75 VReport(1, 76 "Matched called_from_lib suppression '%s' against library" 77 " '%s'\n", 78 lib->templ, mod.full_name()); 79 lib->loaded = true; 80 lib->name = internal_strdup(mod.full_name()); 81 const uptr idx = 82 atomic_load(&ignored_ranges_count_, memory_order_relaxed); 83 CHECK_LT(idx, ARRAY_SIZE(ignored_code_ranges_)); 84 ignored_code_ranges_[idx].begin = range.beg; 85 ignored_code_ranges_[idx].end = range.end; 86 atomic_store(&ignored_ranges_count_, idx + 1, memory_order_release); 87 break; 88 } 89 } 90 if (lib->loaded && !loaded) { 91 Report("%s: library '%s' that was matched against called_from_lib" 92 " suppression '%s' is unloaded\n", 93 SanitizerToolName, lib->name, lib->templ); 94 Die(); 95 } 96 } 97 98 // Track instrumented ranges. 99 if (track_instrumented_libs_) { 100 for (const auto &mod : modules) { 101 if (!mod.instrumented()) 102 continue; 103 for (const auto &range : mod.ranges()) { 104 if (!range.executable) 105 continue; 106 if (IsPcInstrumented(range.beg) && IsPcInstrumented(range.end - 1)) 107 continue; 108 VReport(1, "Adding instrumented range %p-%p from library '%s'\n", 109 range.beg, range.end, mod.full_name()); 110 const uptr idx = 111 atomic_load(&instrumented_ranges_count_, memory_order_relaxed); 112 CHECK_LT(idx, ARRAY_SIZE(instrumented_code_ranges_)); 113 instrumented_code_ranges_[idx].begin = range.beg; 114 instrumented_code_ranges_[idx].end = range.end; 115 atomic_store(&instrumented_ranges_count_, idx + 1, 116 memory_order_release); 117 } 118 } 119 } 120 } 121 122 void LibIgnore::OnLibraryUnloaded() { 123 OnLibraryLoaded(nullptr); 124 } 125 126 } // namespace __sanitizer 127 128 #endif // SANITIZER_FREEBSD || SANITIZER_LINUX || SANITIZER_MAC || 129 // SANITIZER_NETBSD 130