ACE_Mem_Map Class Reference

C++ interface OS memory mapping system call. More...

#include <Mem_Map.h>

List of all members.

Public Member Functions

 ACE_Mem_Map (void)
 Default constructor.
 ACE_Mem_Map (ACE_HANDLE handle, size_t length=static_cast< size_t >(-1), int prot=PROT_RDWR, int share=ACE_MAP_PRIVATE, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
 ACE_Mem_Map (const ACE_TCHAR *filename, size_t length=static_cast< size_t >(-1), int flags=O_RDWR|O_CREAT, mode_t mode=ACE_DEFAULT_FILE_PERMS, int prot=PROT_RDWR, int share=ACE_MAP_PRIVATE, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
 Map a file specified by file_name.
int map (ACE_HANDLE handle, size_t length=static_cast< size_t >(-1), int prot=PROT_RDWR, int share=ACE_MAP_PRIVATE, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
int map (size_t length=static_cast< size_t >(-1), int prot=PROT_RDWR, int share=ACE_MAP_PRIVATE, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
 Remap the file associated with <handle_>.
int map (const ACE_TCHAR *filename, size_t length=static_cast< size_t >(-1), int flags=O_RDWR|O_CREAT, mode_t mode=ACE_DEFAULT_FILE_PERMS, int prot=PROT_RDWR, int share=ACE_MAP_PRIVATE, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
 Map a file specified by filename.
 ~ACE_Mem_Map (void)
 Destructor.
int open (const ACE_TCHAR *filename, int flags=O_RDWR|O_CREAT, mode_t perms=ACE_DEFAULT_FILE_PERMS, LPSECURITY_ATTRIBUTES sa=0)
 Open the file without mapping it.
int close (void)
 Close down the <handle_> if necessary and unmap the mapping.
int close_handle (void)
 Close down the <handle_> if necessary.
int close_filemapping_handle (void)
int operator() (void *&addr)
void * addr (void) const
 Return the base address.
size_t size (void) const
int unmap (ssize_t len=-1)
 Unmap the region starting at <base_addr_>.
int unmap (void *addr, ssize_t len)
 Unmap the region starting at <addr_>.
int sync (size_t len, int flags=MS_SYNC)
int sync (int flags=MS_SYNC)
int sync (void *addr, size_t len, int flags=MS_SYNC)
int protect (size_t len, int prot=PROT_RDWR)
int protect (int prot=PROT_RDWR)
int protect (void *addr, size_t len, int prot=PROT_RDWR)
int remove (void)
 Close and remove the file from the file system.
int advise (int behavior, int len=-1)
 Hook into the underlying VM system.
ACE_HANDLE handle (void) const
 Return the underlying <handle_>.
const ACE_TCHAR * filename (void) const
 Return the name of file that is mapped (if any).
void dump (void) const
 Dump the state of an object.

Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.

Private Member Functions

int map_it (ACE_HANDLE handle, size_t len=static_cast< size_t >(-1), int prot=PROT_RDWR, int share=MAP_SHARED, void *addr=0, ACE_OFF_T offset=0, LPSECURITY_ATTRIBUTES sa=0)
 ACE_Mem_Map (const ACE_Mem_Map &)
void operator= (const ACE_Mem_Map &)

Private Attributes

void * base_addr_
 Base address of the memory-mapped file.
ACE_TCHAR filename_ [MAXPATHLEN+1]
 Name of the file that is mapped.
size_t length_
 Length of the mapping.
ACE_HANDLE handle_
 HANDLE for the open file.
ACE_HANDLE file_mapping_
 HANDLE for the open mapping.
bool close_handle_

Detailed Description

C++ interface OS memory mapping system call.

This class works with both the mmap(2) UNIX system and the Win32 family of memory mapping system calls.

Definition at line 40 of file Mem_Map.h.

Constructor & Destructor Documentation

ACE_Mem_Map::ACE_Mem_Map ( void   ) 

Default constructor.

Definition at line 213 of file Mem_Map.cpp.

References ACE_TRACE, and ACE_OS::memset().

00214   : base_addr_ (MAP_FAILED),
00215     length_ (0),
00216     handle_ (ACE_INVALID_HANDLE),
00217     file_mapping_ (ACE_INVALID_HANDLE),
00218     close_handle_ (false)
00219 {
00220   ACE_TRACE ("ACE_Mem_Map::ACE_Mem_Map");
00221   ACE_OS::memset (this->filename_, 0, sizeof this->filename_);
00222 }

ACE_Mem_Map::ACE_Mem_Map ( ACE_HANDLE  handle,
size_t  length = static_cast< size_t >(-1),
int  prot = PROT_RDWR,
int  share = ACE_MAP_PRIVATE,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Map a file from an open file descriptor handle. This function will lookup the length of the file if it is not given.

Definition at line 259 of file Mem_Map.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TRACE, LM_ERROR, and ACE_OS::memset().

00266   : base_addr_ (MAP_FAILED),
00267     length_ (0),
00268     handle_ (ACE_INVALID_HANDLE),
00269     file_mapping_ (ACE_INVALID_HANDLE),
00270     close_handle_ (false)
00271 {
00272   ACE_TRACE ("ACE_Mem_Map::ACE_Mem_Map");
00273 
00274   ACE_OS::memset (this->filename_,
00275                   0,
00276                   sizeof this->filename_);
00277   if (this->map (handle,
00278                  len,
00279                  prot,
00280                  share,
00281                  addr,
00282                  offset,
00283                  sa) < 0)
00284     ACE_ERROR ((LM_ERROR,
00285                 ACE_TEXT ("%p\n"),
00286                 ACE_TEXT ("ACE_Mem_Map::ACE_Mem_Map")));
00287 }

ACE_Mem_Map::ACE_Mem_Map ( const ACE_TCHAR *  filename,
size_t  length = static_cast< size_t >(-1),
int  flags = O_RDWR|O_CREAT,
mode_t  mode = ACE_DEFAULT_FILE_PERMS,
int  prot = PROT_RDWR,
int  share = ACE_MAP_PRIVATE,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Map a file specified by file_name.

Definition at line 226 of file Mem_Map.cpp.

References ACE_ERROR, ACE_TEXT, ACE_TRACE, and LM_ERROR.

00235   : base_addr_ (MAP_FAILED),
00236     length_ (0),
00237     handle_ (ACE_INVALID_HANDLE),
00238     file_mapping_ (ACE_INVALID_HANDLE),
00239     close_handle_ (false)
00240 {
00241   ACE_TRACE ("ACE_Mem_Map::ACE_Mem_Map");
00242   if (this->map (file_name,
00243                  len,
00244                  flags,
00245                  mode,
00246                  prot,
00247                  share,
00248                  addr,
00249                  offset,
00250                  sa) < 0)
00251     ACE_ERROR ((LM_ERROR,
00252                 ACE_TEXT ("%p\n"),
00253                 ACE_TEXT ("ACE_Mem_Map::ACE_Mem_Map")));
00254 }

ACE_Mem_Map::~ACE_Mem_Map ( void   ) 

Destructor.

Definition at line 50 of file Mem_Map.cpp.

References ACE_TRACE, and close().

00051 {
00052   ACE_TRACE ("ACE_Mem_Map::~ACE_Mem_Map");
00053 
00054   this->close ();
00055 }

ACE_Mem_Map::ACE_Mem_Map ( const ACE_Mem_Map &   )  [private]

Member Function Documentation

ACE_INLINE void * ACE_Mem_Map::addr ( void   )  const

Return the base address.

Definition at line 81 of file Mem_Map.inl.

References ACE_TRACE, and base_addr_.

Referenced by ACE_Filecache_Object::address(), ACE_MMAP_Memory_Pool::init_acquire(), and ACE_MMAP_Memory_Pool::map_file().

00082 {
00083   ACE_TRACE ("ACE_Mem_Map::addr");
00084 
00085   return this->base_addr_;
00086 }

ACE_INLINE int ACE_Mem_Map::advise ( int  behavior,
int  len = -1 
)

Hook into the underlying VM system.

Definition at line 212 of file Mem_Map.inl.

References ACE_TRACE, length_, and ACE_OS::madvise().

00213 {
00214   ACE_TRACE ("ACE_Mem_Map::advise");
00215   const size_t advise_len =
00216     len < 0 ? this->length_ : static_cast<size_t> (len);
00217 
00218   return ACE_OS::madvise ((caddr_t) this->base_addr_,
00219                           advise_len,
00220                           behavior);
00221 }

int ACE_Mem_Map::close ( void   ) 

Close down the <handle_> if necessary and unmap the mapping.

Definition at line 41 of file Mem_Map.cpp.

References ACE_TRACE, close_handle(), and unmap().

Referenced by ACE_MMAP_Memory_Pool::release(), remove(), and ~ACE_Mem_Map().

00042 {
00043   ACE_TRACE ("ACE_Mem_Map::close");
00044 
00045   this->unmap ();
00046 
00047   return this->close_handle ();
00048 }

ACE_INLINE int ACE_Mem_Map::close_filemapping_handle ( void   ) 

Close down the internal <file_mapping_> if necessary. This is mostly necessary on Win32, which has a different handle for file-mapping kernel object.

Definition at line 99 of file Mem_Map.inl.

References ACE_OS::close(), and file_mapping_.

Referenced by map_it(), and unmap().

00100 {
00101   int result = 0;
00102 
00103   if (this->file_mapping_ != this->handle_
00104       && this->file_mapping_ != ACE_INVALID_HANDLE)
00105     {
00106       result = ACE_OS::close (this->file_mapping_);
00107       this->file_mapping_ = ACE_INVALID_HANDLE;
00108     }
00109 
00110   return result;
00111 }

ACE_INLINE int ACE_Mem_Map::close_handle ( void   ) 

Close down the <handle_> if necessary.

Definition at line 224 of file Mem_Map.inl.

References ACE_OS::close(), close_handle_, and handle_.

Referenced by close().

00225 {
00226   int result = 0;
00227 
00228   if (this->close_handle_)
00229     {
00230       this->close_handle_ = false;
00231       result = ACE_OS::close (this->handle_);
00232       this->handle_ = ACE_INVALID_HANDLE;
00233     }
00234 
00235   return result;
00236 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_Mem_Map::dump ( void   )  const

Dump the state of an object.

Definition at line 24 of file Mem_Map.cpp.

References ACE_BEGIN_DUMP, ACE_DEBUG, ACE_END_DUMP, ACE_TEXT, ACE_TRACE, and LM_DEBUG.

00025 {
00026 #if defined (ACE_HAS_DUMP)
00027   ACE_TRACE ("ACE_Mem_Map::dump");
00028 
00029   ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
00030   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("base_addr_ = %x"), this->base_addr_));
00031   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nfilename_ = %s"), this->filename_));
00032   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nlength_ = %d"), this->length_));
00033   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nhandle_ = %d"), this->handle_));
00034   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nfile_mapping_ = %d"), this->file_mapping_));
00035   ACE_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nclose_handle_ = %d"), this->close_handle_));
00036   ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
00037 #endif /* ACE_HAS_DUMP */
00038 }

ACE_INLINE const ACE_TCHAR * ACE_Mem_Map::filename ( void   )  const

Return the name of file that is mapped (if any).

Definition at line 21 of file Mem_Map.inl.

References filename_.

Referenced by ACE_Shared_Memory_MM::filename().

00022 {
00023   return this->filename_;
00024 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ACE_HANDLE ACE_Mem_Map::handle ( void   )  const

Return the underlying <handle_>.

Definition at line 12 of file Mem_Map.inl.

References ACE_TRACE, and handle_.

Referenced by ACE_MMAP_Memory_Pool::commit_backing_store_name(), and ACE_Shared_Memory_MM::get_id().

00013 {
00014   ACE_TRACE ("ACE_Mem_Map::handle");
00015   return this->handle_;
00016 }

int ACE_Mem_Map::map ( const ACE_TCHAR *  filename,
size_t  length = static_cast< size_t >(-1),
int  flags = O_RDWR|O_CREAT,
mode_t  mode = ACE_DEFAULT_FILE_PERMS,
int  prot = PROT_RDWR,
int  share = ACE_MAP_PRIVATE,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Map a file specified by filename.

Definition at line 185 of file Mem_Map.cpp.

References ACE_TRACE, length_, and map_it().

00194 {
00195   ACE_TRACE ("ACE_Mem_Map::map");
00196   this->length_ = 0;
00197 
00198   if (this->open (file_name,
00199                   flags,
00200                   mode,
00201                   sa) == -1)
00202     return -1;
00203   else
00204     return this->map_it (this->handle (),
00205                          len,
00206                          prot,
00207                          share,
00208                          addr,
00209                          offset,
00210                          sa);
00211 }

ACE_INLINE int ACE_Mem_Map::map ( size_t  length = static_cast< size_t >(-1),
int  prot = PROT_RDWR,
int  share = ACE_MAP_PRIVATE,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Remap the file associated with <handle_>.

Definition at line 42 of file Mem_Map.inl.

References ACE_TRACE, base_addr_, MAP_FAILED, and map_it().

00048 {
00049   ACE_TRACE ("ACE_Mem_Map::map");
00050   // If we're already mapped at a particular location then try to
00051   // remap the file using the same base address.
00052   if (addr == 0 && this->base_addr_ != 0 && this->base_addr_ != MAP_FAILED)
00053     {
00054       share |= MAP_FIXED;
00055       addr = this->base_addr_;
00056     }
00057 
00058   return this->map_it (this->handle (), length, prot,
00059                        share, addr, offset, sa);
00060 }

ACE_INLINE int ACE_Mem_Map::map ( ACE_HANDLE  handle,
size_t  length = static_cast< size_t >(-1),
int  prot = PROT_RDWR,
int  share = ACE_MAP_PRIVATE,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Map a file from an open file descriptor handle. This function will lookup the length of the file if it is not given.

Definition at line 27 of file Mem_Map.inl.

References ACE_TRACE, and map_it().

Referenced by ACE_Shared_Memory_MM::open().

00034 {
00035   ACE_TRACE ("ACE_Mem_Map::map");
00036   return this->map_it (handle, length, prot, share, addr, offset, sa);
00037 }

int ACE_Mem_Map::map_it ( ACE_HANDLE  handle,
size_t  len = static_cast< size_t >(-1),
int  prot = PROT_RDWR,
int  share = MAP_SHARED,
void *  addr = 0,
ACE_OFF_T  offset = 0,
LPSECURITY_ATTRIBUTES  sa = 0 
) [private]

This method does the dirty work of actually calling mmap to map the file into memory.

Definition at line 61 of file Mem_Map.cpp.

References ACE_TRACE, base_addr_, close_filemapping_handle(), ACE_OS::filesize(), handle_, length_, MAP_FAILED, ACE_OS::mmap(), ACE_OS::pwrite(), and unmap().

Referenced by map().

00068 {
00069   ACE_TRACE ("ACE_Mem_Map::map_it");
00070 
00071 #if defined (ACE_LACKS_AUTO_MMAP_REPLACEMENT)
00072   // If the system does not replace any previous mappings, then
00073   // unmap() before (potentially) mapping to the same location.
00074   int const unmap_result = this->unmap ();
00075   if (unmap_result != 0)
00076     return unmap_result;
00077 #endif /* ACE_LACKS_AUTO_MMAP_REPLACEMENT */
00078 
00079   this->base_addr_ = addr;
00080   this->handle_ = handle;
00081 
00082   // Get the current filesize
00083   ACE_OFF_T const current_file_length = ACE_OS::filesize (this->handle_);
00084 
00085   // Flag to indicate if we need to extend the back store
00086   bool extend_backing_store = false;
00087 
00088   // File length requested by user
00089   ACE_OFF_T requested_file_length = 0;
00090 
00091   // Check <length_request>
00092   if (length_request == static_cast<size_t> (-1))
00093     {
00094       // Set length to file_request or size_t max.
00095       this->length_ = ACE_Utils::truncate_cast<size_t> (current_file_length - offset);
00096     }
00097   else
00098     {
00099       // Make sure that we have not been asked to do the impossible.
00100       if (static_cast<ACE_UINT64> (length_request)
00101           + static_cast<ACE_UINT64> (offset)
00102           > static_cast<ACE_UINT64> (ACE_Numeric_Limits<ACE_OFF_T>::max ()))
00103         return -1;
00104 
00105       // File length implicitly requested by user
00106       requested_file_length = static_cast<ACE_OFF_T> (length_request) + offset;
00107 
00108       // Check to see if we need to extend the backing store
00109       if (requested_file_length > current_file_length)
00110         {
00111           // If the length of the mapped region is less than the
00112           // length of the file then we force a complete new remapping
00113           // by setting the descriptor to ACE_INVALID_HANDLE (closing
00114           // down the descriptor if necessary).
00115           this->close_filemapping_handle ();
00116 
00117           // Remember to extend the backing store
00118           extend_backing_store = true;
00119         }
00120 
00121       // Set length to length_request
00122       this->length_ = length_request;
00123     }
00124 
00125   // Check if we need to extend the backing store.
00126   if (extend_backing_store)
00127     {
00128       // Remember than write increases the size by one.
00129       ACE_OFF_T null_byte_position = 0;
00130       if (requested_file_length > 0)
00131         {
00132           // This will make the file size <requested_file_length>
00133           null_byte_position = requested_file_length - 1;
00134         }
00135 
00136       if (ACE_OS::pwrite (this->handle_,
00137                           "",
00138                           1,
00139                           null_byte_position) == -1)
00140         return -1;
00141     }
00142 
00143     this->base_addr_ = ACE_OS::mmap (this->base_addr_,
00144                                      this->length_,
00145                                      prot,
00146                                      share,
00147                                      this->handle_,
00148                                      offset,
00149                                      &this->file_mapping_,
00150                                      sa);
00151 
00152   return this->base_addr_ == MAP_FAILED ? -1 : 0;
00153 }

int ACE_Mem_Map::open ( const ACE_TCHAR *  filename,
int  flags = O_RDWR|O_CREAT,
mode_t  perms = ACE_DEFAULT_FILE_PERMS,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Open the file without mapping it.

Definition at line 156 of file Mem_Map.cpp.

References ACE_TRACE, close_handle_, handle_, MAXPATHLEN, ACE_OS::open(), ACE_OS::shm_open(), and ACE_OS::strsncpy().

00160 {
00161   ACE_TRACE ("ACE_Mem_Map::open");
00162 
00163 #if defined (INTEGRITY)  || defined (__QNXNTO__) || defined (ACE_VXWORKS)
00164   this->handle_ = ACE_OS::shm_open (file_name, flags, perms, sa);
00165 #elif defined (ACE_OPENVMS)
00166   ACE_OSCALL (::open (file_name, flags, perms, "shr=get,put,upd"), ACE_HANDLE, -1, this->handle_);
00167 #else
00168   this->handle_ = ACE_OS::open (file_name, flags, perms, sa);
00169 #endif /* INTEGRITY */
00170 
00171   if (this->handle_ == ACE_INVALID_HANDLE)
00172     return -1;
00173   else
00174     {
00175       ACE_OS::strsncpy (this->filename_,
00176                         file_name,
00177                         MAXPATHLEN);
00178 
00179       this->close_handle_ = true;
00180       return 0;
00181     }
00182 }

ACE_INLINE int ACE_Mem_Map::operator() ( void *&  addr  ) 

This operator passes back the starting address of the mapped file.

Definition at line 65 of file Mem_Map.inl.

References ACE_TRACE, base_addr_, and MAP_FAILED.

00066 {
00067   ACE_TRACE ("ACE_Mem_Map::operator");
00068 
00069   if (this->base_addr_ == MAP_FAILED)
00070     return -1;
00071   else
00072     {
00073       addr = this->base_addr_;
00074       return 0;
00075     }
00076 }

void ACE_Mem_Map::operator= ( const ACE_Mem_Map &   )  [private]

ACE_INLINE int ACE_Mem_Map::protect ( void *  addr,
size_t  len,
int  prot = PROT_RDWR 
)

Change the protection of the pages of the mapped region to prot starting at addr up to len bytes.

Definition at line 203 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::mprotect().

00204 {
00205   ACE_TRACE ("ACE_Mem_Map::protect");
00206   return ACE_OS::mprotect (addr, len, prot);
00207 }

ACE_INLINE int ACE_Mem_Map::protect ( int  prot = PROT_RDWR  ) 

Change the protection of all the pages of the mapped region to prot starting at <base_addr_>.

Definition at line 193 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::mprotect().

00194 {
00195   ACE_TRACE ("ACE_Mem_Map::protect");
00196   return ACE_OS::mprotect (this->base_addr_, this->length_, prot);
00197 }

ACE_INLINE int ACE_Mem_Map::protect ( size_t  len,
int  prot = PROT_RDWR 
)

Change the protection of the pages of the mapped region to prot starting at <base_addr_> up to len bytes.

Definition at line 182 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::mprotect().

Referenced by ACE_MMAP_Memory_Pool::protect().

00183 {
00184   ACE_TRACE ("ACE_Mem_Map::protect");
00185   return ACE_OS::mprotect (this->base_addr_, len, prot);
00186 }

int ACE_Mem_Map::remove ( void   ) 

Close and remove the file from the file system.

Definition at line 292 of file Mem_Map.cpp.

References ACE_TRACE, close(), ACE_OS::ftruncate(), ACE_OS::shm_unlink(), and ACE_OS::unlink().

Referenced by ACE_MMAP_Memory_Pool::release(), and ACE_Shared_Memory_MM::remove().

00293 {
00294   ACE_TRACE ("ACE_Mem_Map::remove");
00295 
00296   ACE_OS::ftruncate (this->handle_, 0);
00297   this->close ();
00298 
00299   if (this->filename_[0] != '\0')
00300 #if defined (INTEGRITY) || defined (__QNXNTO__) || defined (ACE_VXWORKS)
00301   return ACE_OS::shm_unlink (this->filename_);
00302 #else
00303   return ACE_OS::unlink (this->filename_);
00304 #endif /* __QNXNTO__ */
00305 
00306   else
00307     return 0;
00308 }

ACE_INLINE size_t ACE_Mem_Map::size ( void   )  const

This function returns the number of bytes currently mapped in the file.

Definition at line 92 of file Mem_Map.inl.

References ACE_TRACE, and length_.

Referenced by ACE_MMAP_Memory_Pool::acquire(), ACE_Shared_Memory_MM::get_segment_size(), and ACE_MMAP_Memory_Pool::init_acquire().

00093 {
00094   ACE_TRACE ("ACE_Mem_Map::size");
00095   return this->length_;
00096 }

ACE_INLINE int ACE_Mem_Map::sync ( void *  addr,
size_t  len,
int  flags = MS_SYNC 
)

Sync len bytes of the memory region to the backing store starting at <addr_>.

Definition at line 172 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::msync().

00173 {
00174   ACE_TRACE ("ACE_Mem_Map::sync");
00175   return ACE_OS::msync (addr, len, flags);
00176 }

ACE_INLINE int ACE_Mem_Map::sync ( int  flags = MS_SYNC  ) 

Sync the whole memory region to the backing store starting at <base_addr_>.

Definition at line 160 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::msync().

00161 {
00162   ACE_TRACE ("ACE_Mem_Map::sync");
00163   return ACE_OS::msync (this->base_addr_,
00164                         this->length_,
00165                         flags);
00166 }

ACE_INLINE int ACE_Mem_Map::sync ( size_t  len,
int  flags = MS_SYNC 
)

Sync len bytes of the memory region to the backing store starting at <base_addr_>. If len == -1 then sync the whole region.

Definition at line 150 of file Mem_Map.inl.

References ACE_TRACE, and ACE_OS::msync().

Referenced by ACE_MMAP_Memory_Pool::sync().

00151 {
00152   ACE_TRACE ("ACE_Mem_Map::sync");
00153   return ACE_OS::msync (this->base_addr_,
00154                         len,
00155                         flags);
00156 }

ACE_INLINE int ACE_Mem_Map::unmap ( void *  addr,
ssize_t  len 
)

Unmap the region starting at <addr_>.

Definition at line 136 of file Mem_Map.inl.

References ACE_TRACE, close_filemapping_handle(), length_, and ACE_OS::munmap().

00137 {
00138   ACE_TRACE ("ACE_Mem_Map::unmap");
00139 
00140   this->close_filemapping_handle ();
00141 
00142   return ACE_OS::munmap (addr,
00143                          len < 0 ? this->length_ : len);
00144 }

ACE_INLINE int ACE_Mem_Map::unmap ( ssize_t  len = -1  ) 

Unmap the region starting at <base_addr_>.

Definition at line 116 of file Mem_Map.inl.

References ACE_TRACE, base_addr_, close_filemapping_handle(), length_, MAP_FAILED, and ACE_OS::munmap().

Referenced by ACE_Shared_Memory_MM::close(), close(), ACE_MMAP_Memory_Pool::map_file(), map_it(), ACE_Filecache_Object::release(), and ACE_Filecache_Object::~ACE_Filecache_Object().

00117 {
00118   ACE_TRACE ("ACE_Mem_Map::unmap");
00119 
00120   this->close_filemapping_handle ();
00121 
00122   if (this->base_addr_ != MAP_FAILED)
00123     {
00124       int const result = ACE_OS::munmap (this->base_addr_,
00125                                          len < 0 ? this->length_ : len);
00126       this->base_addr_ = MAP_FAILED;
00127       return result;
00128     }
00129   else
00130     return 0;
00131 }

Member Data Documentation

ACE_Mem_Map::ACE_ALLOC_HOOK_DECLARE

Declare the dynamic allocation hooks.

Definition at line 186 of file Mem_Map.h.

void* ACE_Mem_Map::base_addr_ [private]

Base address of the memory-mapped file.

Definition at line 207 of file Mem_Map.h.

Referenced by addr(), map(), map_it(), operator()(), and unmap().

bool ACE_Mem_Map::close_handle_ [private]

Keeps track of whether we need to close the handle. This is set if we opened the file.

Definition at line 223 of file Mem_Map.h.

Referenced by close_handle(), and open().

ACE_HANDLE ACE_Mem_Map::file_mapping_ [private]

HANDLE for the open mapping.

Definition at line 219 of file Mem_Map.h.

Referenced by close_filemapping_handle().

ACE_TCHAR ACE_Mem_Map::filename_[MAXPATHLEN+1] [private]

Name of the file that is mapped.

Definition at line 210 of file Mem_Map.h.

Referenced by filename().

ACE_HANDLE ACE_Mem_Map::handle_ [private]

HANDLE for the open file.

Definition at line 216 of file Mem_Map.h.

Referenced by close_handle(), handle(), map_it(), and open().

size_t ACE_Mem_Map::length_ [private]

Length of the mapping.

Definition at line 213 of file Mem_Map.h.

Referenced by advise(), map(), map_it(), size(), and unmap().

The documentation for this class was generated from the following files:
Generated on Tue Feb 2 17:35:19 2010 for ACE by  doxygen 1.4.7