/cvmfs/atlas.cern.ch/repo/sw/ASG/AnalysisBase/2.4.31/CxxUtils/CxxUtils/PageAccessControl.h

// This file's extension implies that it's C, but it's really -*- C++ -*-.
#ifndef CXXUTILS_PAGEACCESSCONTROL_H
#define CXXUTILS_PAGEACCESSCONTROL_H 1

#include <vector>
#include <sys/mman.h> /*PROT_NONE*/

#include "CxxUtils/procmaps.h"

class PageAccessControl {
public:
  PageAccessControl(size_t reservedSize=65535) :
    m_pmaps(),
    m_protectedIsSorted(false)
  {
    //we must reserve enough elements, or we risk vector allocating in a protected page during handle()...
    m_protected.reserve(reservedSize);
  }
  PageAccessControl(procmaps& pmaps, size_t reservedSize=65535) :
    m_pmaps(pmaps),
    m_protectedIsSorted(false)
  {
    //we must reserve enough elements, or we risk vector allocating in a protected page during handle()...
    m_protected.reserve(reservedSize);
  }

  template <typename T>
  bool protectPage(T* addr, int prot) {
    return protectPage(addr, sizeof(T), prot);
  }
  
  template <typename T>
  bool forbidPage(const T* addr) {
    return forbidPage(addr, sizeof(T));
  }

  bool forbidPage(const void* addr, size_t objSize) {
    return protectPage(addr, objSize, PROT_NONE);
  }
    
  bool forbidPage(const void* addr) {
    return protectPage(addr, 4, PROT_NONE);
  }
    
  bool protectPage(const void* addr, size_t objSize, int prot);
  
  bool restorePageProt(const void * addr);
  void sort();

  struct Entry {
    Entry(void* a, size_t l, int p, void* pl);
    void* addr;
    size_t lenProt; 
    int prot;
    void* leak;
    int restored;
  };

  typedef std::vector<Entry> protected_t;
  typedef protected_t::const_iterator const_iterator;
  const protected_t& protectedPtrs() const { return m_protected; }
  const_iterator beginProtectedPtrs() const { return m_protected.begin(); }
  const_iterator endProtectedPtrs() const { return m_protected.end(); }
  void reset() { m_protected.clear(); }

  bool accessed(const void* address) const;

private:

  procmaps m_pmaps;

  // can not preallocate map
  //  typedef std::map<void*, size_t, std::less<void*>,
  //           boost::pool_allocator<std::map<void*, size_t>::value_type > > protected_t;
  protected_t m_protected;
  bool m_protectedIsSorted;
};
inline
bool operator <(const PageAccessControl::Entry& lhs, const PageAccessControl::Entry& rhs) {
  return lhs.addr < rhs.addr;
}
#endif

---