ACE/ace/Mem_Map.inl

   1 // -*- C++ -*-
   2 #include "ace/OS_NS_unistd.h"
   3 #include "ace/OS_NS_sys_mman.h"
   4 #include "ace/OS_NS_sys_stat.h"
   5
   6 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
   7
   8 ACE_INLINE ACE_HANDLE
   9 ACE_Mem_Map::handle () const
  10 {
  11   ACE_TRACE ("ACE_Mem_Map::handle");
  12   return this->handle_;
  13 }
  14
  15 // Return the name of file that is mapped (if any).
  16
  17 ACE_INLINE const ACE_TCHAR *
  18 ACE_Mem_Map::filename () const
  19 {
  20   return this->filename_;
  21 }
  22
  23 ACE_INLINE int
  24 ACE_Mem_Map::map (ACE_HANDLE handle,
  25                   size_t length,
  26                   int prot,
  27                   int share,
  28                   void *addr,
  29                   ACE_OFF_T offset,
  30                   LPSECURITY_ATTRIBUTES sa)
  31 {
  32   ACE_TRACE ("ACE_Mem_Map::map");
  33   return this->map_it (handle, length, prot, share, addr, offset, sa);
  34 }
  35
  36 // Remap the file associated with <this->handle_>.
  37
  38 ACE_INLINE int
  39 ACE_Mem_Map::map (size_t length,
  40                   int prot,
  41                   int share,
  42                   void *addr,
  43                   ACE_OFF_T offset,
  44                   LPSECURITY_ATTRIBUTES sa)
  45 {
  46   ACE_TRACE ("ACE_Mem_Map::map");
  47   // If we're already mapped at a particular location then try to
  48   // remap the file using the same base address.
  49   if (addr == 0 && this->base_addr_ != 0 && this->base_addr_ != MAP_FAILED)
  50     {
  51       share |= MAP_FIXED;
  52       addr = this->base_addr_;
  53     }
  54
  55   return this->map_it (this->handle (), length, prot,
  56                        share, addr, offset, sa);
  57 }
  58
  59 // This operator passes back the starting address of the mapped file.
  60
  61 ACE_INLINE int
  62 ACE_Mem_Map::operator () (void *&addr)
  63 {
  64   ACE_TRACE ("ACE_Mem_Map::operator");
  65
  66   if (this->base_addr_ == MAP_FAILED)
  67     return -1;
  68   else
  69     {
  70       addr = this->base_addr_;
  71       return 0;
  72     }
  73 }
  74
  75 // Return the base address.
  76
  77 ACE_INLINE void *
  78 ACE_Mem_Map::addr () const
  79 {
  80   ACE_TRACE ("ACE_Mem_Map::addr");
  81
  82   return this->base_addr_;
  83 }
  84
  85 // This function returns the number of bytes currently mapped in the
  86 // file.
  87
  88 ACE_INLINE size_t
  89 ACE_Mem_Map::size () const
  90 {
  91   ACE_TRACE ("ACE_Mem_Map::size");
  92   return this->length_;
  93 }
  94
  95 ACE_INLINE int
  96 ACE_Mem_Map::close_filemapping_handle ()
  97 {
  98   int result = 0;
  99
 100   if (this->file_mapping_ != this->handle_
 101       && this->file_mapping_ != ACE_INVALID_HANDLE)
 102     {
 103       result = ACE_OS::close (this->file_mapping_);
 104       this->file_mapping_ = ACE_INVALID_HANDLE;
 105     }
 106
 107   return result;
 108 }
 109
 110 // Unmap the region starting at <this->base_addr_>.
 111
 112 ACE_INLINE int
 113 ACE_Mem_Map::unmap (ssize_t len)
 114 {
 115   ACE_TRACE ("ACE_Mem_Map::unmap");
 116
 117   this->close_filemapping_handle ();
 118
 119   if (this->base_addr_ != MAP_FAILED)
 120     {
 121       int const result = ACE_OS::munmap (this->base_addr_,
 122                                          len < 0 ? this->length_ : (size_t)len);
 123       this->base_addr_ = MAP_FAILED;
 124       return result;
 125     }
 126   else
 127     return 0;
 128 }
 129
 130 // Unmap the region starting at <addr_>.
 131
 132 ACE_INLINE int
 133 ACE_Mem_Map::unmap (void *addr, ssize_t len)
 134 {
 135   ACE_TRACE ("ACE_Mem_Map::unmap");
 136
 137   this->close_filemapping_handle ();
 138
 139   return ACE_OS::munmap (addr,
 140                          len < 0 ? this->length_ : (size_t)len);
 141 }
 142
 143 // Sync <len> bytes of the memory region to the backing store starting
 144 // at <this->base_addr_>.
 145
 146 ACE_INLINE int
 147 ACE_Mem_Map::sync (size_t len, int flags)
 148 {
 149   ACE_TRACE ("ACE_Mem_Map::sync");
 150   return ACE_OS::msync (this->base_addr_,
 151                         len,
 152                         flags);
 153 }
 154
 155 // Sync the whole mapped region.
 156 ACE_INLINE int
 157 ACE_Mem_Map::sync (int flags)
 158 {
 159   ACE_TRACE ("ACE_Mem_Map::sync");
 160   return ACE_OS::msync (this->base_addr_,
 161                         this->length_,
 162                         flags);
 163 }
 164
 165 // Sync <len> bytes of the memory region to the backing store starting
 166 // at <addr_>.
 167
 168 ACE_INLINE int
 169 ACE_Mem_Map::sync (void *addr, size_t len, int flags)
 170 {
 171   ACE_TRACE ("ACE_Mem_Map::sync");
 172   return ACE_OS::msync (addr, len, flags);
 173 }
 174
 175 // Change the protection of the pages of the mapped region to <prot>
 176 // starting at <this->base_addr_> up to <len> bytes.
 177
 178 ACE_INLINE int
 179 ACE_Mem_Map::protect (size_t len, int prot)
 180 {
 181   ACE_TRACE ("ACE_Mem_Map::protect");
 182   return ACE_OS::mprotect (this->base_addr_, len, prot);
 183 }
 184
 185
 186 // Change the protection of all the pages of the mapped region to <prot>
 187 // starting at <this->base_addr_>.
 188
 189 ACE_INLINE int
 190 ACE_Mem_Map::protect (int prot)
 191 {
 192   ACE_TRACE ("ACE_Mem_Map::protect");
 193   return ACE_OS::mprotect (this->base_addr_, this->length_, prot);
 194 }
 195
 196 // Change the protection of the pages of the mapped region to <prot>
 197 // starting at <addr> up to <len> bytes.
 198
 199 ACE_INLINE int
 200 ACE_Mem_Map::protect (void *addr, size_t len, int prot)
 201 {
 202   ACE_TRACE ("ACE_Mem_Map::protect");
 203   return ACE_OS::mprotect (addr, len, prot);
 204 }
 205
 206 // Hook into the underlying VM system.
 207
 208 ACE_INLINE int
 209 ACE_Mem_Map::advise (int behavior, int len)
 210 {
 211   ACE_TRACE ("ACE_Mem_Map::advise");
 212   const size_t advise_len =
 213     len < 0 ? this->length_ : static_cast<size_t> (len);
 214
 215   return ACE_OS::madvise ((caddr_t) this->base_addr_,
 216                           advise_len,
 217                           behavior);
 218 }
 219
 220 ACE_INLINE int
 221 ACE_Mem_Map::close_handle ()
 222 {
 223   int result = 0;
 224
 225   if (this->close_handle_)
 226     {
 227       this->close_handle_ = false;
 228       result = ACE_OS::close (this->handle_);
 229       this->handle_ = ACE_INVALID_HANDLE;
 230     }
 231
 232   return result;
 233 }
 234
 235 ACE_END_VERSIONED_NAMESPACE_DECL