libsanitizer/sanitizer_common/sanitizer_libignore.h

   1 //===-- sanitizer_libignore.h -----------------------------------*- C++ -*-===//
   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 // LibIgnore allows to ignore all interceptors called from a particular set
  10 // of dynamic libraries. LibIgnore can be initialized with several templates
  11 // of names of libraries to be ignored. It finds code ranges for the libraries;
  12 // and checks whether the provided PC value belongs to the code ranges.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #ifndef SANITIZER_LIBIGNORE_H
  17 #define SANITIZER_LIBIGNORE_H
  18
  19 #include "sanitizer_internal_defs.h"
  20 #include "sanitizer_common.h"
  21 #include "sanitizer_atomic.h"
  22 #include "sanitizer_mutex.h"
  23
  24 namespace __sanitizer {
  25
  26 class LibIgnore {
  27  public:
  28   explicit LibIgnore(LinkerInitialized);
  29
  30   // Must be called during initialization.
  31   void AddIgnoredLibrary(const char *name_templ);
  32   void IgnoreNoninstrumentedModules(bool enable) {
  33     track_instrumented_libs_ = enable;
  34   }
  35
  36   // Must be called after a new dynamic library is loaded.
  37   void OnLibraryLoaded(const char *name);
  38
  39   // Must be called after a dynamic library is unloaded.
  40   void OnLibraryUnloaded();
  41
  42   // Checks whether the provided PC belongs to one of the ignored libraries or
  43   // the PC should be ignored because it belongs to an non-instrumented module
  44   // (when ignore_noninstrumented_modules=1). Also returns true via
  45   // "pc_in_ignored_lib" if the PC is in an ignored library, false otherwise.
  46   bool IsIgnored(uptr pc, bool *pc_in_ignored_lib) const;
  47
  48   // Checks whether the provided PC belongs to an instrumented module.
  49   bool IsPcInstrumented(uptr pc) const;
  50
  51  private:
  52   struct Lib {
  53     char *templ;
  54     char *name;
  55     char *real_name;  // target of symlink
  56     bool loaded;
  57   };
  58
  59   struct LibCodeRange {
  60     uptr begin;
  61     uptr end;
  62   };
  63
  64   inline bool IsInRange(uptr pc, const LibCodeRange &range) const {
  65     return (pc >= range.begin && pc < range.end);
  66   }
  67
  68   static const uptr kMaxIgnoredRanges = 128;
  69   static const uptr kMaxInstrumentedRanges = 1024;
  70   static const uptr kMaxLibs = 1024;
  71
  72   // Hot part:
  73   atomic_uintptr_t ignored_ranges_count_;
  74   LibCodeRange ignored_code_ranges_[kMaxIgnoredRanges];
  75
  76   atomic_uintptr_t instrumented_ranges_count_;
  77   LibCodeRange instrumented_code_ranges_[kMaxInstrumentedRanges];
  78
  79   // Cold part:
  80   Mutex mutex_;
  81   uptr count_;
  82   Lib libs_[kMaxLibs];
  83   bool track_instrumented_libs_;
  84
  85   // Disallow copying of LibIgnore objects.
  86   LibIgnore(const LibIgnore&);  // not implemented
  87   void operator = (const LibIgnore&);  // not implemented
  88 };
  89
  90 inline bool LibIgnore::IsIgnored(uptr pc, bool *pc_in_ignored_lib) const {
  91   const uptr n = atomic_load(&ignored_ranges_count_, memory_order_acquire);
  92   for (uptr i = 0; i < n; i++) {
  93     if (IsInRange(pc, ignored_code_ranges_[i])) {
  94       *pc_in_ignored_lib = true;
  95       return true;
  96     }
  97   }
  98   *pc_in_ignored_lib = false;
  99   if (track_instrumented_libs_ && !IsPcInstrumented(pc))
 100     return true;
 101   return false;
 102 }
 103
 104 inline bool LibIgnore::IsPcInstrumented(uptr pc) const {
 105   const uptr n = atomic_load(&instrumented_ranges_count_, memory_order_acquire);
 106   for (uptr i = 0; i < n; i++) {
 107     if (IsInRange(pc, instrumented_code_ranges_[i]))
 108       return true;
 109   }
 110   return false;
 111 }
 112
 113 }  // namespace __sanitizer
 114
 115 #endif  // SANITIZER_LIBIGNORE_H