xpcom/base/MemoryMapping.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef mozilla_MemoryMapping_h
   8 #define mozilla_MemoryMapping_h
   9
  10 #include <cstdint>
  11 #include "mozilla/EnumSet.h"
  12 #include "nsString.h"
  13 #include "nsTArrayForwardDeclare.h"
  14
  15 /**
  16  * MemoryMapping is a helper class which describes an entry in the Linux
  17  * /proc/<pid>/smaps file. See procfs(5) for details on the entry format.
  18  *
  19  * The GetMemoryMappings() function returns an array of such entries, sorted by
  20  * start address, one for each entry in the current process's address space.
  21  */
  22
  23 namespace mozilla {
  24
  25 enum class VMFlag : uint8_t {
  26   Readable,       // rd  - readable
  27   Writable,       // wr  - writable
  28   Executable,     // ex  - executable
  29   Shared,         // sh  - shared
  30   MayRead,        // mr  - may read
  31   MayWrite,       // mw  - may write
  32   MayExecute,     // me  - may execute
  33   MayShare,       // ms  - may share
  34   GrowsDown,      // gd  - stack segment grows down
  35   PurePFN,        // pf  - pure PFN range
  36   DisabledWrite,  // dw  - disabled write to the mapped file
  37   Locked,         // lo  - pages are locked in memory
  38   IO,             // io  - memory mapped I/O area
  39   Sequential,     // sr  - sequential read advise provided
  40   Random,         // rr  - random read advise provided
  41   NoFork,         // dc  - do not copy area on fork
  42   NoExpand,       // de  - do not expand area on remapping
  43   Accountable,    // ac  - area is accountable
  44   NotReserved,    // nr  - swap space is not reserved for the area
  45   HugeTLB,        // ht  - area uses huge tlb pages
  46   NonLinear,      // nl  - non-linear mapping
  47   ArchSpecific,   // ar  - architecture specific flag
  48   NoCore,         // dd  - do not include area into core dump
  49   SoftDirty,      // sd  - soft-dirty flag
  50   MixedMap,       // mm  - mixed map area
  51   HugePage,       // hg  - huge page advise flag
  52   NoHugePage,     // nh  - no-huge page advise flag
  53   Mergeable,      // mg  - mergeable advise flag
  54 };
  55
  56 using VMFlagSet = EnumSet<VMFlag, uint32_t>;
  57
  58 class MemoryMapping final {
  59  public:
  60   enum class Perm : uint8_t {
  61     Read,
  62     Write,
  63     Execute,
  64     Shared,
  65     Private,
  66   };
  67
  68   using PermSet = EnumSet<Perm>;
  69
  70   MemoryMapping(uintptr_t aStart, uintptr_t aEnd, PermSet aPerms,
  71                 size_t aOffset, const char* aName)
  72       : mStart(aStart),
  73         mEnd(aEnd),
  74         mOffset(aOffset),
  75         mName(aName),
  76         mPerms(aPerms) {}
  77
  78   const nsCString& Name() const { return mName; }
  79
  80   uintptr_t Start() const { return mStart; }
  81   uintptr_t End() const { return mEnd; }
  82
  83   bool Includes(const void* aPtr) const {
  84     auto ptr = uintptr_t(aPtr);
  85     return ptr >= mStart && ptr < mEnd;
  86   }
  87
  88   PermSet Perms() const { return mPerms; }
  89   VMFlagSet VMFlags() const { return mFlags; }
  90
  91   // For file mappings, the offset in the mapped file which corresponds to the
  92   // start of the mapped region.
  93   size_t Offset() const { return mOffset; }
  94
  95   size_t AnonHugePages() const { return mAnonHugePages; }
  96   size_t Anonymous() const { return mAnonymous; }
  97   size_t KernelPageSize() const { return mKernelPageSize; }
  98   size_t LazyFree() const { return mLazyFree; }
  99   size_t Locked() const { return mLocked; }
 100   size_t MMUPageSize() const { return mMMUPageSize; }
 101   size_t Private_Clean() const { return mPrivate_Clean; }
 102   size_t Private_Dirty() const { return mPrivate_Dirty; }
 103   size_t Private_Hugetlb() const { return mPrivate_Hugetlb; }
 104   size_t Pss() const { return mPss; }
 105   size_t Referenced() const { return mReferenced; }
 106   size_t Rss() const { return mRss; }
 107   size_t Shared_Clean() const { return mShared_Clean; }
 108   size_t Shared_Dirty() const { return mShared_Dirty; }
 109   size_t Shared_Hugetlb() const { return mShared_Hugetlb; }
 110   size_t ShmemPmdMapped() const { return mShmemPmdMapped; }
 111   size_t Size() const { return mSize; }
 112   size_t Swap() const { return mSwap; }
 113   size_t SwapPss() const { return mSwapPss; }
 114
 115   // Dumps a string representation of the entry, similar to its format in the
 116   // smaps file, to the given string. Mainly useful for debugging.
 117   void Dump(nsACString& aOut) const;
 118
 119   // These comparison operators are used for binary searching sorted arrays of
 120   // MemoryMapping entries to find the one which contains a given pointer.
 121   bool operator==(const void* aPtr) const { return Includes(aPtr); }
 122   bool operator<(const void* aPtr) const { return mStart < uintptr_t(aPtr); }
 123
 124  private:
 125   friend nsresult GetMemoryMappings(nsTArray<MemoryMapping>& aMappings,
 126                                     pid_t aPid);
 127
 128   uintptr_t mStart = 0;
 129   uintptr_t mEnd = 0;
 130
 131   size_t mOffset = 0;
 132
 133   nsCString mName;
 134
 135   // Members for size fields in the smaps file. Please keep these in sync with
 136   // the sFields array.
 137   size_t mAnonHugePages = 0;
 138   size_t mAnonymous = 0;
 139   size_t mKernelPageSize = 0;
 140   size_t mLazyFree = 0;
 141   size_t mLocked = 0;
 142   size_t mMMUPageSize = 0;
 143   size_t mPrivate_Clean = 0;
 144   size_t mPrivate_Dirty = 0;
 145   size_t mPrivate_Hugetlb = 0;
 146   size_t mPss = 0;
 147   size_t mReferenced = 0;
 148   size_t mRss = 0;
 149   size_t mShared_Clean = 0;
 150   size_t mShared_Dirty = 0;
 151   size_t mShared_Hugetlb = 0;
 152   size_t mShmemPmdMapped = 0;
 153   size_t mSize = 0;
 154   size_t mSwap = 0;
 155   size_t mSwapPss = 0;
 156
 157   PermSet mPerms{};
 158   VMFlagSet mFlags{};
 159
 160   // Contains the name and offset of one of the above size_t fields, for use in
 161   // parsing in dumping. The below helpers contain a list of the fields, and map
 162   // Field entries to the appropriate member in a class instance.
 163   struct Field {
 164     const char* mName;
 165     size_t mOffset;
 166   };
 167
 168   static const Field sFields[20];
 169
 170   size_t& ValueForField(const Field& aField) {
 171     char* fieldPtr = reinterpret_cast<char*>(this) + aField.mOffset;
 172     return reinterpret_cast<size_t*>(fieldPtr)[0];
 173   }
 174   size_t ValueForField(const Field& aField) const {
 175     return const_cast<MemoryMapping*>(this)->ValueForField(aField);
 176   }
 177 };
 178
 179 nsresult GetMemoryMappings(nsTArray<MemoryMapping>& aMappings, pid_t aPid = 0);
 180
 181 }  // namespace mozilla
 182
 183 #endif  // mozilla_MemoryMapping_h