Home | History | Annotate | Line # | Download | only in sanitizer_common 
      1 //===-- sanitizer_procmaps.h ------------------------------------*- C++ -*-===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file is shared between AddressSanitizer and ThreadSanitizer.
     11 //
     12 // Information about the process mappings.
     13 //===----------------------------------------------------------------------===//
     14 #ifndef SANITIZER_PROCMAPS_H
     15 #define SANITIZER_PROCMAPS_H
     16 
     17 #include "sanitizer_platform.h"
     18 
     19 #if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD ||                \
     20     SANITIZER_OPENBSD || SANITIZER_MAC || SANITIZER_SOLARIS
     21 
     22 #include "sanitizer_common.h"
     23 #include "sanitizer_internal_defs.h"
     24 #include "sanitizer_linux.h"
     25 #include "sanitizer_mac.h"
     26 #include "sanitizer_mutex.h"
     27 
     28 namespace __sanitizer {
     29 
     30 
     31 // Memory protection masks.
     32 static const uptr kProtectionRead = 1;
     33 static const uptr kProtectionWrite = 2;
     34 static const uptr kProtectionExecute = 4;
     35 static const uptr kProtectionShared = 8;
     36 
     37 struct MemoryMappedSegmentData;
     38 
     39 class MemoryMappedSegment {
     40  public:
     41   MemoryMappedSegment(char *buff = nullptr, uptr size = 0)
     42       : filename(buff), filename_size(size), data_(nullptr) {}
     43   ~MemoryMappedSegment() {}
     44 
     45   bool IsReadable() const { return protection & kProtectionRead; }
     46   bool IsWritable() const { return protection & kProtectionWrite; }
     47   bool IsExecutable() const { return protection & kProtectionExecute; }
     48   bool IsShared() const { return protection & kProtectionShared; }
     49 
     50   void AddAddressRanges(LoadedModule *module);
     51 
     52   uptr start;
     53   uptr end;
     54   uptr offset;
     55   char *filename;  // owned by caller
     56   uptr filename_size;
     57   uptr protection;
     58   ModuleArch arch;
     59   u8 uuid[kModuleUUIDSize];
     60 
     61  private:
     62   friend class MemoryMappingLayout;
     63 
     64   // This field is assigned and owned by MemoryMappingLayout if needed
     65   MemoryMappedSegmentData *data_;
     66 };
     67 
     68 class MemoryMappingLayout {
     69  public:
     70   explicit MemoryMappingLayout(bool cache_enabled);
     71   ~MemoryMappingLayout();
     72   bool Next(MemoryMappedSegment *segment);
     73   bool Error() const;
     74   void Reset();
     75   // In some cases, e.g. when running under a sandbox on Linux, ASan is unable
     76   // to obtain the memory mappings. It should fall back to pre-cached data
     77   // instead of aborting.
     78   static void CacheMemoryMappings();
     79 
     80   // Adds all mapped objects into a vector.
     81   void DumpListOfModules(InternalMmapVectorNoCtor<LoadedModule> *modules);
     82 
     83  private:
     84   void LoadFromCache();
     85 
     86   MemoryMappingLayoutData data_;
     87 };
     88 
     89 // Returns code range for the specified module.
     90 bool GetCodeRangeForFile(const char *module, uptr *start, uptr *end);
     91 
     92 bool IsDecimal(char c);
     93 uptr ParseDecimal(const char **p);
     94 bool IsHex(char c);
     95 uptr ParseHex(const char **p);
     96 
     97 }  // namespace __sanitizer
     98 
     99 #endif
    100 #endif  // SANITIZER_PROCMAPS_H
    101