dep/ACE_wrappers/ace/OS_NS_sys_mman.inl

   1 // -*- C++ -*-
   2 //
   3 // $Id: OS_NS_sys_mman.inl 82171 2008-06-25 13:32:01Z jtc $
   4
   5 #include "ace/OS_NS_fcntl.h"
   6 #include "ace/OS_NS_unistd.h"
   7 #include "ace/OS_NS_stdio.h"
   8 #include "ace/OS_NS_macros.h"
   9 #include "ace/OS_NS_errno.h"
  10
  11 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  12
  13 #if defined (ACE_HAS_VOIDPTR_MMAP)
  14 // Needed for some odd OS's (e.g., SGI).
  15 typedef void *ACE_MMAP_TYPE;
  16 #else
  17 typedef char *ACE_MMAP_TYPE;
  18 #endif /* ACE_HAS_VOIDPTR_MMAP */
  19
  20 ACE_INLINE int
  21 ACE_OS::madvise (caddr_t addr, size_t len, int map_advice)
  22 {
  23   ACE_OS_TRACE ("ACE_OS::madvise");
  24 #if !defined (ACE_LACKS_MADVISE)
  25   ACE_OSCALL_RETURN (::madvise (addr, len, map_advice), int, -1);
  26 #else
  27   ACE_UNUSED_ARG (addr);
  28   ACE_UNUSED_ARG (len);
  29   ACE_UNUSED_ARG (map_advice);
  30   ACE_NOTSUP_RETURN (-1);
  31 #endif /* ACE_WIN32 */
  32 }
  33
  34 ACE_INLINE void *
  35 ACE_OS::mmap (void *addr,
  36               size_t len,
  37               int prot,
  38               int flags,
  39               ACE_HANDLE file_handle,
  40               ACE_OFF_T off,
  41               ACE_HANDLE *file_mapping,
  42               LPSECURITY_ATTRIBUTES sa,
  43               const ACE_TCHAR *file_mapping_name)
  44 {
  45   ACE_OS_TRACE ("ACE_OS::mmap");
  46 #if !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP)
  47   ACE_UNUSED_ARG (file_mapping_name);
  48 #endif /* !defined (ACE_WIN32) || defined (ACE_HAS_PHARLAP) */
  49
  50 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
  51
  52 #  if defined(ACE_HAS_WINCE)
  53   ACE_UNUSED_ARG (addr);
  54   if (ACE_BIT_ENABLED (flags, MAP_FIXED))     // not supported
  55   {
  56     errno = EINVAL;
  57     return MAP_FAILED;
  58   }
  59 #  else
  60   if (!ACE_BIT_ENABLED (flags, MAP_FIXED))
  61     addr = 0;
  62   else if (addr == 0)   // can not map to address 0
  63   {
  64     errno = EINVAL;
  65     return MAP_FAILED;
  66   }
  67 #  endif
  68
  69   int nt_flags = 0;
  70   ACE_HANDLE local_handle = ACE_INVALID_HANDLE;
  71
  72   // Ensure that file_mapping is non-zero.
  73   if (file_mapping == 0)
  74     file_mapping = &local_handle;
  75
  76   if (ACE_BIT_ENABLED (flags, MAP_PRIVATE))
  77     {
  78 #  if !defined(ACE_HAS_WINCE)
  79       prot = PAGE_WRITECOPY;
  80 #  endif  // ACE_HAS_WINCE
  81       nt_flags = FILE_MAP_COPY;
  82     }
  83   else if (ACE_BIT_ENABLED (flags, MAP_SHARED))
  84     {
  85       if (ACE_BIT_ENABLED (prot, PAGE_READONLY))
  86         nt_flags = FILE_MAP_READ;
  87       if (ACE_BIT_ENABLED (prot, PAGE_READWRITE))
  88         nt_flags = FILE_MAP_WRITE;
  89     }
  90
  91   // Only create a new handle if we didn't have a valid one passed in.
  92   if (*file_mapping == ACE_INVALID_HANDLE)
  93     {
  94       SECURITY_ATTRIBUTES sa_buffer;
  95       SECURITY_DESCRIPTOR sd_buffer;
  96       const LPSECURITY_ATTRIBUTES attr =
  97         ACE_OS::default_win32_security_attributes_r (sa,
  98                                                      &sa_buffer,
  99                                                      &sd_buffer);
 100
 101       *file_mapping = ACE_TEXT_CreateFileMapping (file_handle,
 102                                                   attr,
 103                                                   prot,
 104                                                   0,
 105                                                   0,
 106                                                   file_mapping_name);
 107     }
 108
 109   if (*file_mapping == 0)
 110     ACE_FAIL_RETURN (MAP_FAILED);
 111
 112 #  if defined (ACE_OS_EXTRA_MMAP_FLAGS)
 113   nt_flags |= ACE_OS_EXTRA_MMAP_FLAGS;
 114 #  endif /* ACE_OS_EXTRA_MMAP_FLAGS */
 115
 116   DWORD low_off  = ACE_LOW_PART (off);
 117   DWORD high_off = ACE_HIGH_PART (off);
 118
 119 #  if !defined (ACE_HAS_WINCE)
 120   void *addr_mapping = ::MapViewOfFileEx (*file_mapping,
 121                                           nt_flags,
 122                                           high_off,
 123                                           low_off,
 124                                           len,
 125                                           addr);
 126 #  else
 127   void *addr_mapping = ::MapViewOfFile (*file_mapping,
 128                                         nt_flags,
 129                                         high_off,
 130                                         low_off,
 131                                         len);
 132 #  endif /* ! ACE_HAS_WINCE */
 133
 134   // Only close this down if we used the temporary.
 135   if (file_mapping == &local_handle)
 136     ::CloseHandle (*file_mapping);
 137
 138   if (addr_mapping == 0)
 139     ACE_FAIL_RETURN (MAP_FAILED);
 140   else
 141     return addr_mapping;
 142 #elif !defined (ACE_LACKS_MMAP)
 143   ACE_UNUSED_ARG (sa);
 144
 145 #  if defined (ACE_OS_EXTRA_MMAP_FLAGS)
 146   flags |= ACE_OS_EXTRA_MMAP_FLAGS;
 147 #  endif /* ACE_OS_EXTRA_MMAP_FLAGS */
 148   ACE_UNUSED_ARG (file_mapping);
 149 #  if defined (ACE_OPENVMS)
 150   //FUZZ: disable check_for_lack_ACE_OS
 151   ::fsync(file_handle);
 152   //FUZZ: enable check_for_lack_ACE_OS
 153 #  endif
 154   //FUZZ: disable check_for_lack_ACE_OS
 155   ACE_OSCALL_RETURN ((void *) ::mmap ((ACE_MMAP_TYPE) addr,
 156                                       len,
 157                                       prot,
 158                                       flags,
 159                                       file_handle,
 160                                       off),
 161                      void *, MAP_FAILED);
 162   //FUZZ: enable check_for_lack_ACE_OS
 163 #else
 164   ACE_UNUSED_ARG (addr);
 165   ACE_UNUSED_ARG (len);
 166   ACE_UNUSED_ARG (prot);
 167   ACE_UNUSED_ARG (flags);
 168   ACE_UNUSED_ARG (file_handle);
 169   ACE_UNUSED_ARG (off);
 170   ACE_UNUSED_ARG (file_mapping);
 171   ACE_UNUSED_ARG (sa);
 172   ACE_NOTSUP_RETURN (MAP_FAILED);
 173 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
 174 }
 175
 176 // Implements simple read/write control for pages.  Affects a page if
 177 // part of the page is referenced.  Currently PROT_READ, PROT_WRITE,
 178 // and PROT_RDWR has been mapped in OS.h.  This needn't have anything
 179 // to do with a mmap region.
 180
 181 ACE_INLINE int
 182 ACE_OS::mprotect (void *addr, size_t len, int prot)
 183 {
 184   ACE_OS_TRACE ("ACE_OS::mprotect");
 185 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
 186   DWORD dummy; // Sigh!
 187   return ::VirtualProtect(addr, len, prot, &dummy) ? 0 : -1;
 188 #elif !defined (ACE_LACKS_MPROTECT)
 189   ACE_OSCALL_RETURN (::mprotect ((ACE_MMAP_TYPE) addr, len, prot), int, -1);
 190 #else
 191   ACE_UNUSED_ARG (addr);
 192   ACE_UNUSED_ARG (len);
 193   ACE_UNUSED_ARG (prot);
 194   ACE_NOTSUP_RETURN (-1);
 195 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
 196 }
 197
 198 ACE_INLINE int
 199 ACE_OS::msync (void *addr, size_t len, int sync)
 200 {
 201   ACE_OS_TRACE ("ACE_OS::msync");
 202 #if defined (ACE_WIN32) && !defined (ACE_HAS_PHARLAP)
 203   ACE_UNUSED_ARG (sync);
 204
 205   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::FlushViewOfFile (addr, len), ace_result_), int, -1);
 206 #elif !defined (ACE_LACKS_MSYNC)
 207   ACE_OSCALL_RETURN (::msync ((ACE_MMAP_TYPE) addr, len, sync), int, -1);
 208 #else
 209   ACE_UNUSED_ARG (addr);
 210   ACE_UNUSED_ARG (len);
 211   ACE_UNUSED_ARG (sync);
 212   ACE_NOTSUP_RETURN (-1);
 213 #endif /* ACE_WIN32 && !ACE_HAS_PHARLAP */
 214 }
 215
 216 ACE_INLINE int
 217 ACE_OS::munmap (void *addr, size_t len)
 218 {
 219   ACE_OS_TRACE ("ACE_OS::munmap");
 220 #if defined (ACE_WIN32)
 221   ACE_UNUSED_ARG (len);
 222
 223   ACE_WIN32CALL_RETURN (ACE_ADAPT_RETVAL (::UnmapViewOfFile (addr), ace_result_), int, -1);
 224 #elif !defined (ACE_LACKS_MMAP)
 225   ACE_OSCALL_RETURN (::munmap ((ACE_MMAP_TYPE) addr, len), int, -1);
 226 #else
 227   ACE_UNUSED_ARG (addr);
 228   ACE_UNUSED_ARG (len);
 229   ACE_NOTSUP_RETURN (-1);
 230 #endif /* ACE_WIN32 */
 231 }
 232
 233 ACE_INLINE ACE_HANDLE
 234 ACE_OS::shm_open (const ACE_TCHAR *filename,
 235                   int mode,
 236                   mode_t perms,
 237                   LPSECURITY_ATTRIBUTES sa)
 238 {
 239   ACE_OS_TRACE ("ACE_OS::shm_open");
 240 #if defined (ACE_HAS_SHM_OPEN)
 241   ACE_UNUSED_ARG (sa);
 242 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x650)
 243   // With VxWorks the file should just start with / and no other
 244   // slashes, so replace all other / by _
 245   ACE_TCHAR buf [MAXPATHLEN + 1];
 246   ACE_OS::sprintf (buf,
 247                    ACE_TEXT ("%s"),
 248                    filename);
 249   for (size_t i = 1; i < MAXPATHLEN + 1; i++)
 250     {
 251       if (buf[i] == '/')
 252         {
 253           buf[i] = '_';
 254         }
 255     }
 256   filename = buf;
 257 #endif
 258   ACE_OSCALL_RETURN (::shm_open (ACE_TEXT_ALWAYS_CHAR(filename), mode, perms), ACE_HANDLE, ACE_INVALID_HANDLE);
 259 #elif defined (ACE_OPENVMS)
 260   //FUZZ: disable check_for_lack_ACE_OS
 261   ACE_OSCALL_RETURN (::open (filename, mode, perms, ACE_TEXT("shr=get,put,upd")), ACE_HANDLE, ACE_INVALID_HANDLE);
 262   //FUZZ: enable check_for_lack_ACE_OS
 263 #else  /* ! ACE_HAS_SHM_OPEN */
 264   // Just use ::open.
 265   return ACE_OS::open (filename, mode, perms, sa);
 266 #endif /* ACE_HAS_SHM_OPEN */
 267 }
 268
 269 ACE_INLINE int
 270 ACE_OS::shm_unlink (const ACE_TCHAR *path)
 271 {
 272   ACE_OS_TRACE ("ACE_OS::shm_unlink");
 273 #if defined (ACE_HAS_SHM_OPEN)
 274 #if defined (ACE_VXWORKS) && (ACE_VXWORKS <= 0x650)
 275   // With VxWorks the file should just start with / and no other
 276   // slashes, so replace all other / by _
 277   ACE_TCHAR buf [MAXPATHLEN + 1];
 278   ACE_OS::sprintf (buf,
 279                    ACE_TEXT ("%s"),
 280                    path);
 281   for (size_t i = 1; i < MAXPATHLEN + 1; i++)
 282     {
 283       if (buf[i] == '/')
 284         {
 285           buf[i] = '_';
 286         }
 287     }
 288   path = buf;
 289 #endif
 290   ACE_OSCALL_RETURN (::shm_unlink (ACE_TEXT_ALWAYS_CHAR(path)), int, -1);
 291 #else  /* ! ACE_HAS_SHM_OPEN */
 292   // Just use ::unlink.
 293   return ACE_OS::unlink (path);
 294 #endif /* ACE_HAS_SHM_OPEN */
 295 }
 296
 297 ACE_END_VERSIONED_NAMESPACE_DECL