dep/ACE_wrappers/ace/Mem_Map.h

   1 // -*- C++ -*-
   2
   3 //==========================================================================
   4 /**
   5  *  @file    Mem_Map.h
   6  *
   7  *  $Id: Mem_Map.h 80826 2008-03-04 14:51:23Z wotte $
   8  *
   9  *  @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
  10  */
  11 //==========================================================================
  12
  13 #ifndef ACE_MEM_MAP_H
  14 #define ACE_MEM_MAP_H
  15
  16 #include /**/ "ace/pre.h"
  17
  18 #include /**/ "ace/ACE_export.h"
  19
  20 #if !defined (ACE_LACKS_PRAGMA_ONCE)
  21 # pragma once
  22 #endif /* ACE_LACKS_PRAGMA_ONCE */
  23
  24 #include "ace/Global_Macros.h"
  25 #include "ace/os_include/sys/os_mman.h"
  26 #include "ace/os_include/os_limits.h"
  27 #include "ace/os_include/os_fcntl.h"
  28 #include "ace/Default_Constants.h"
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 /**
  33  * @class ACE_Mem_Map
  34  *
  35  * @brief C++ interface OS memory mapping system call.
  36  *
  37  * This class works with both the mmap(2) UNIX system and the
  38  * Win32 family of memory mapping system calls.
  39  */
  40 class ACE_Export ACE_Mem_Map
  41 {
  42 public:
  43   // = Initialization and termination methods.
  44
  45   /// Default constructor.
  46   ACE_Mem_Map (void);
  47
  48   /// Map a file from an open file descriptor @a handle.  This function
  49   /// will lookup the length of the file if it is not given.
  50   ACE_Mem_Map (ACE_HANDLE handle,
  51                size_t length = static_cast<size_t> (-1),
  52                int prot = PROT_RDWR,
  53                int share = ACE_MAP_PRIVATE,
  54                void *addr = 0,
  55                ACE_OFF_T offset = 0,
  56                LPSECURITY_ATTRIBUTES sa = 0);
  57
  58   /// Map a file specified by @a file_name.
  59   ACE_Mem_Map (const ACE_TCHAR *filename,
  60                size_t length = static_cast<size_t> (-1),
  61                int flags = O_RDWR | O_CREAT,
  62                mode_t mode = ACE_DEFAULT_FILE_PERMS,
  63                int prot = PROT_RDWR,
  64                int share = ACE_MAP_PRIVATE,
  65                void *addr = 0,
  66                ACE_OFF_T offset = 0,
  67                LPSECURITY_ATTRIBUTES sa = 0);
  68
  69   /// Map a file from an open file descriptor @a handle.  This function
  70   /// will lookup the length of the file if it is not given.
  71   int map (ACE_HANDLE handle,
  72            size_t length = static_cast<size_t> (-1),
  73            int prot = PROT_RDWR,
  74            int share = ACE_MAP_PRIVATE,
  75            void *addr = 0,
  76            ACE_OFF_T offset = 0,
  77            LPSECURITY_ATTRIBUTES sa = 0);
  78
  79   /// Remap the file associated with <handle_>.
  80   int map (size_t length = static_cast<size_t> (-1),
  81            int prot = PROT_RDWR,
  82            int share = ACE_MAP_PRIVATE,
  83            void *addr = 0,
  84            ACE_OFF_T offset = 0,
  85            LPSECURITY_ATTRIBUTES sa = 0);
  86
  87   /// Map a file specified by @a filename.
  88   int map (const ACE_TCHAR *filename,
  89            size_t length = static_cast<size_t> (-1),
  90            int flags = O_RDWR | O_CREAT,
  91            mode_t mode = ACE_DEFAULT_FILE_PERMS,
  92            int prot = PROT_RDWR,
  93            int share = ACE_MAP_PRIVATE,
  94            void *addr = 0,
  95            ACE_OFF_T offset = 0,
  96            LPSECURITY_ATTRIBUTES sa = 0);
  97
  98   /// Destructor.
  99   ~ACE_Mem_Map (void);
 100
 101   /// Open the file without mapping it.
 102   int open (const ACE_TCHAR *filename,
 103             int flags = O_RDWR | O_CREAT,
 104             mode_t perms = ACE_DEFAULT_FILE_PERMS,
 105             LPSECURITY_ATTRIBUTES sa = 0);
 106
 107   /// Close down the <handle_> if necessary and unmap the mapping.
 108   int close (void);
 109
 110   /// Close down the <handle_> if necessary.
 111   int close_handle (void);
 112
 113   /**
 114    * Close down the internal <file_mapping_> if necessary.  This is
 115    * mostly necessary on Win32, which has a different handle for
 116    * file-mapping kernel object.
 117    */
 118   int close_filemapping_handle (void);
 119
 120   /// This operator passes back the starting address of the mapped
 121   /// file.
 122   int operator () (void *&addr);
 123
 124   /// Return the base address.
 125   void *addr (void) const;
 126
 127   /// This function returns the number of bytes currently mapped in the
 128   /// file.
 129   size_t size (void) const;
 130
 131   /// Unmap the region starting at <base_addr_>.
 132   int unmap (ssize_t len = -1);
 133
 134   /// Unmap the region starting at <addr_>.
 135   int unmap (void *addr, ssize_t len);
 136
 137   /**
 138    * Sync @a len bytes of the memory region to the backing store
 139    * starting at <base_addr_>.  If @a len == -1 then sync the whole
 140    * region.
 141    */
 142   int sync (size_t len, int flags = MS_SYNC);
 143
 144   /**
 145    * Sync the whole memory region to the backing store
 146    * starting at <base_addr_>.
 147    */
 148   int sync (int flags = MS_SYNC);
 149
 150   /// Sync @a len bytes of the memory region to the backing store
 151   /// starting at <addr_>.
 152   int sync (void *addr, size_t len, int flags = MS_SYNC);
 153
 154   /**
 155    * Change the protection of the pages of the mapped region to @a prot
 156    * starting at <base_addr_> up to @a len bytes.
 157    */
 158   int protect (size_t len, int prot = PROT_RDWR);
 159
 160   /**
 161    * Change the protection of all the pages of the mapped region to @a prot
 162    * starting at <base_addr_>.
 163    */
 164   int protect (int prot = PROT_RDWR);
 165
 166   /// Change the protection of the pages of the mapped region to @a prot
 167   /// starting at @a addr up to @a len bytes.
 168   int protect (void *addr, size_t len, int prot = PROT_RDWR);
 169
 170   /// Close and remove the file from the file system.
 171   int remove (void);
 172
 173   /// Hook into the underlying VM system.
 174   int advise (int behavior, int len = -1);
 175
 176   /// Return the underlying <handle_>.
 177   ACE_HANDLE handle (void) const;
 178
 179   /// Return the name of file that is mapped (if any).
 180   const ACE_TCHAR *filename (void) const;
 181
 182   /// Dump the state of an object.
 183   void dump (void) const;
 184
 185   /// Declare the dynamic allocation hooks.
 186   ACE_ALLOC_HOOK_DECLARE;
 187
 188 private:
 189
 190   /// This method does the dirty work of actually calling ::mmap to map
 191   /// the file into memory.
 192   int map_it (ACE_HANDLE handle,
 193               size_t len = static_cast<size_t> (-1),
 194               int prot = PROT_RDWR,
 195               int share = MAP_SHARED,
 196               void *addr = 0,
 197               ACE_OFF_T offset = 0,
 198               LPSECURITY_ATTRIBUTES sa = 0);
 199
 200   // = Disallow copying and assignment.
 201   ACE_Mem_Map (const ACE_Mem_Map &);
 202   void operator = (const ACE_Mem_Map &);
 203
 204 private:
 205
 206   /// Base address of the memory-mapped file.
 207   void *base_addr_;
 208
 209   /// Name of the file that is mapped.
 210   ACE_TCHAR filename_[MAXPATHLEN + 1];
 211
 212   /// Length of the mapping.
 213   size_t length_;
 214
 215   /// HANDLE for the open file.
 216   ACE_HANDLE handle_;
 217
 218   /// HANDLE for the open mapping.
 219   ACE_HANDLE file_mapping_;
 220
 221   /// Keeps track of whether we need to close the handle.  This is set
 222   /// if we opened the file.
 223   bool close_handle_;
 224
 225 };
 226
 227 ACE_END_VERSIONED_NAMESPACE_DECL
 228
 229 #if defined (__ACE_INLINE__)
 230 #include "ace/Mem_Map.inl"
 231 #endif /* __ACE_INLINE__ */
 232
 233 #include /**/ "ace/post.h"
 234
 235 #endif /* ACE_MEM_MAP_H */