OS_NS_sys_mman.inl

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // $Id: OS_NS_sys_mman.inl 79134 2007-07-31 18:23:50Z johnnyw $
00004 
00005 #include "ace/OS_NS_fcntl.h"
00006 #include "ace/OS_NS_unistd.h"
00007 #include "ace/OS_NS_stdio.h"
00008 #include "ace/OS_NS_macros.h"
00009 #include "ace/OS_NS_errno.h"
00010 
00011 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00012 
00013 #if defined (ACE_HAS_VOIDPTR_MMAP)
00014 // Needed for some odd OS's (e.g., SGI).
00015 typedef void *ACE_MMAP_TYPE;
00016 #else
00017 typedef char *ACE_MMAP_TYPE;
00018 #endif /* ACE_HAS_VOIDPTR_MMAP */
00019 
00020 ACE_INLINE int
00021 ACE_OS::madvise (caddr_t addr, size_t len, int map_advice)
00022 {
00023   ACE_OS_TRACE ("ACE_OS::madvise");
00024 #if !defined (ACE_LACKS_MADVISE)
00025   ACE_OSCALL_RETURN (::madvise (addr, len, map_advice), int, -1);
00026 #else
00027   ACE_UNUSED_ARG (addr);
00028   ACE_UNUSED_ARG (len);
00029   ACE_UNUSED_ARG (map_advice);
00030   ACE_NOTSUP_RETURN (-1);
00031 #endif /* ACE_WIN32 */
00032 }
00033 
00034 ACE_INLINE void *
00035 ACE_OS::mmap (void *addr,
00036               size_t len,
00037               int prot,
00038               int flags,
00039               ACE_HANDLE file_handle,
00040               ACE_OFF_T off,
00041               ACE_HANDLE *file_mapping,
00042               LPSECURITY_ATTRIBUTES sa,
00043               const ACE_TCHAR *file_mapping_name)
00044 {
00045   ACE_OS_TRACE ("ACE_OS::mmap");
00046 #if !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP)
00047   ACE_UNUSED_ARG (file_mapping_name);
00048 #endif /* !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP) */
00049 
00050 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
00051 
00052 #  if defined(ACE_HAS_WINCE)
00053   ACE_UNUSED_ARG (addr);
00054   if (ACE_BIT_ENABLED (flags, MAP_FIXED))     // not supported
00055   {
00056     errno = EINVAL;
00057     return MAP_FAILED;
00058   }
00059 #  else
00060   if (!ACE_BIT_ENABLED (flags, MAP_FIXED))
00061     addr = 0;
00062   else if (addr == 0)   // can not map to address 0
00063   {
00064     errno = EINVAL;
00065     return MAP_FAILED;
00066   }
00067 #  endif
00068 
00069   int nt_flags = 0;
00070   ACE_HANDLE local_handle = ACE_INVALID_HANDLE;
00071 
00072   // Ensure that file_mapping is non-zero.
00073   if (file_mapping == 0)
00074     file_mapping = &local_handle;
00075 
00076   if (ACE_BIT_ENABLED (flags, MAP_PRIVATE))
00077     {
00078 #  if !defined(ACE_HAS_WINCE)
00079       prot = PAGE_WRITECOPY;
00080 #  endif  // ACE_HAS_WINCE
00081       nt_flags = FILE_MAP_COPY;
00082     }
00083   else if (ACE_BIT_ENABLED (flags, MAP_SHARED))
00084     {
00085       if (ACE_BIT_ENABLED (prot, PAGE_READONLY))
00086         nt_flags = FILE_MAP_READ;
00087       if (ACE_BIT_ENABLED (prot, PAGE_READWRITE))
00088         nt_flags = FILE_MAP_WRITE;
00089     }
00090 
00091   // Only create a new handle if we didn't have a valid one passed in.
00092   if (*file_mapping == ACE_INVALID_HANDLE)
00093     {
00094       SECURITY_ATTRIBUTES sa_buffer;
00095       SECURITY_DESCRIPTOR sd_buffer;
00096       const LPSECURITY_ATTRIBUTES attr =
00097         ACE_OS::default_win32_security_attributes_r (sa,
00098                                                      &sa_buffer,
00099                                                      &sd_buffer);
00100 
00101       *file_mapping = ACE_TEXT_CreateFileMapping (file_handle,
00102                                                   attr,
00103                                                   prot,
00104                                                   0,
00105                                                   0,
00106                                                   file_mapping_name);
00107     }
00108 
00109   if (*file_mapping == 0)
00110     ACE_FAIL_RETURN (MAP_FAILED);
00111 
00112 #  if defined (ACE_OS_EXTRA_MMAP_FLAGS)
00113   nt_flags |= ACE_OS_EXTRA_MMAP_FLAGS;
00114 #  endif /* ACE_OS_EXTRA_MMAP_FLAGS */
00115 
00116   DWORD low_off  = ACE_LOW_PART (off);
00117   DWORD high_off = ACE_HIGH_PART (off);
00118 
00119 #  if !defined (ACE_HAS_WINCE)
00120   void *addr_mapping = ::MapViewOfFileEx (*file_mapping,
00121                                           nt_flags,
00122                                           high_off,
00123                                           low_off,
00124                                           len,
00125                                           addr);
00126 #  else
00127   void *addr_mapping = ::MapViewOfFile (*file_mapping,
00128                                         nt_flags,
00129                                         high_off,
00130                                         low_off,
00131                                         len);
00132 #  endif /* ! ACE_HAS_WINCE */
00133 
00134   // Only close this down if we used the temporary.
00135   if (file_mapping == &local_handle)
00136     ::CloseHandle (*file_mapping);
00137 
00138   if (addr_mapping == 0)
00139     ACE_FAIL_RETURN (MAP_FAILED);
00140   else
00141     return addr_mapping;
00142 #elif !defined (ACE_LACKS_MMAP)
00143   ACE_UNUSED_ARG (sa);
00144 
00145 #  if defined (ACE_OS_EXTRA_MMAP_FLAGS)
00146   flags |= ACE_OS_EXTRA_MMAP_FLAGS;
00147 #  endif /* ACE_OS_EXTRA_MMAP_FLAGS */
00148   ACE_UNUSED_ARG (file_mapping);
00149 #  if defined (ACE_OPENVMS)
00150   ::fsync(file_handle);
00151 #  endif
00152   ACE_OSCALL_RETURN ((void *) ::mmap ((ACE_MMAP_TYPE) addr,
00153                                       len,
00154                                       prot,
00155                                       flags,
00156                                       file_handle,
00157                                       off),
00158                      void *, MAP_FAILED);
00159 #else
00160   ACE_UNUSED_ARG (addr);
00161   ACE_UNUSED_ARG (len);
00162   ACE_UNUSED_ARG (prot);
00163   ACE_UNUSED_ARG (flags);
00164   ACE_UNUSED_ARG (file_handle);
00165   ACE_UNUSED_ARG (off);
00166   ACE_UNUSED_ARG (file_mapping);
00167   ACE_UNUSED_ARG (sa);
00168   ACE_NOTSUP_RETURN (MAP_FAILED);
00169 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
00170 }
00171 
00172 // Implements simple read/write control for pages.  Affects a page if
00173 // part of the page is referenced.  Currently PROT_READ, PROT_WRITE,
00174 // and PROT_RDWR has been mapped in OS.h.  This needn't have anything
00175 // to do with a mmap region.
00176 
00177 ACE_INLINE int
00178 ACE_OS::mprotect (void *addr, size_t len, int prot)
00179 {
00180   ACE_OS_TRACE ("ACE_OS::mprotect");
00181 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
00182   DWORD dummy; // Sigh!
00183   return ::VirtualProtect(addr, len, prot, &dummy) ? 0 : -1;
00184 #elif !defined (ACE_LACKS_MPROTECT)
00185   ACE_OSCALL_RETURN (::mprotect ((ACE_MMAP_TYPE) addr, len, prot), int, -1);
00186 #else
00187   ACE_UNUSED_ARG (addr);
00188   ACE_UNUSED_ARG (len);
00189   ACE_UNUSED_ARG (prot);
00190   ACE_NOTSUP_RETURN (-1);
00191 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
00192 }
00193 
00194 ACE_INLINE int
00195 ACE_OS::msync (void *addr, size_t len, int sync)
00196 {
00197   ACE_OS_TRACE ("ACE_OS::msync");
00198 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
00199   ACE_UNUSED_ARG (sync);
00200 
00201   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushViewOfFile (addr, len), ace_result_), int, -1);
00202 #elif !defined (ACE_LACKS_MSYNC)
00203 # if !defined (ACE_HAS_BROKEN_NETBSD_MSYNC)
00204   ACE_OSCALL_RETURN (::msync ((ACE_MMAP_TYPE) addr, len, sync), int, -1);
00205 # else
00206   ACE_OSCALL_RETURN (::msync ((ACE_MMAP_TYPE) addr, len), int, -1);
00207   ACE_UNUSED_ARG (sync);
00208 # endif /* ACE_HAS_BROKEN_NETBSD_MSYNC */
00209 #else
00210   ACE_UNUSED_ARG (addr);
00211   ACE_UNUSED_ARG (len);
00212   ACE_UNUSED_ARG (sync);
00213   ACE_NOTSUP_RETURN (-1);
00214 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
00215 }
00216 
00217 ACE_INLINE int
00218 ACE_OS::munmap (void *addr, size_t len)
00219 {
00220   ACE_OS_TRACE ("ACE_OS::munmap");
00221 #if defined (ACE_WIN32)
00222   ACE_UNUSED_ARG (len);
00223 
00224   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::UnmapViewOfFile (addr), ace_result_), int, -1);
00225 #elif !defined (ACE_LACKS_MMAP)
00226   ACE_OSCALL_RETURN (::munmap ((ACE_MMAP_TYPE) addr, len), int, -1);
00227 #else
00228   ACE_UNUSED_ARG (addr);
00229   ACE_UNUSED_ARG (len);
00230   ACE_NOTSUP_RETURN (-1);
00231 #endif /* ACE_WIN32 */
00232 }
00233 
00234 ACE_INLINE ACE_HANDLE
00235 ACE_OS::shm_open (const ACE_TCHAR *filename,
00236                   int mode,
00237                   mode_t perms,
00238                   LPSECURITY_ATTRIBUTES sa)
00239 {
00240   ACE_OS_TRACE ("ACE_OS::shm_open");
00241 #if defined (ACE_HAS_SHM_OPEN)
00242   ACE_UNUSED_ARG (sa);
00243 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x650)
00244   // With VxWorks the file should just start with / and no other
00245   // slashes, so replace all other / by _
00246   ACE_TCHAR buf [MAXPATHLEN + 1];
00247   ACE_OS::sprintf (buf,
00248                    ACE_TEXT ("%s"),
00249                    filename);
00250   for (size_t i = 1; i < MAXPATHLEN + 1; i++)
00251     {
00252       if (buf[i] == '/')
00253         {
00254           buf[i] = '_';
00255         }
00256     }
00257   filename = buf;
00258 #endif
00259   ACE_OSCALL_RETURN (::shm_open (ACE_TEXT_ALWAYS_CHAR(filename), mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE);
00260 #elif defined (ACE_OPENVMS)
00261   ACE_OSCALL_RETURN (::open (filename, mode, perms, ACE_TEXT("shr=get,put,upd")), ACE_HANDLE, ACE_INVALID_HANDLE);
00262 #else  /* ! ACE_HAS_SHM_OPEN */
00263   // Just use ::open.
00264   return ACE_OS::open (filename, mode, perms, sa);
00265 #endif /* ACE_HAS_SHM_OPEN */
00266 }
00267 
00268 ACE_INLINE int
00269 ACE_OS::shm_unlink (const ACE_TCHAR *path)
00270 {
00271   ACE_OS_TRACE ("ACE_OS::shm_unlink");
00272 #if defined (ACE_HAS_SHM_OPEN)
00273 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x650)
00274   // With VxWorks the file should just start with / and no other
00275   // slashes, so replace all other / by _
00276   ACE_TCHAR buf [MAXPATHLEN + 1];
00277   ACE_OS::sprintf (buf,
00278                    ACE_TEXT ("%s"),
00279                    path);
00280   for (size_t i = 1; i < MAXPATHLEN + 1; i++)
00281     {
00282       if (buf[i] == '/')
00283         {
00284           buf[i] = '_';
00285         }
00286     }
00287   path = buf;
00288 #endif
00289   ACE_OSCALL_RETURN (::shm_unlink (ACE_TEXT_ALWAYS_CHAR(path)), int, -1);
00290 #else  /* ! ACE_HAS_SHM_OPEN */
00291   // Just use ::unlink.
00292   return ACE_OS::unlink (path);
00293 #endif /* ACE_HAS_SHM_OPEN */
00294 }
00295 
00296 ACE_END_VERSIONED_NAMESPACE_DECL

Generated on Sun Jan 27 12:05:33 2008 for ACE by doxygen 1.3.6