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