base/shared_memory_win.cc

   1 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/shared_memory.h"
   6
   7 #include "base/logging.h"
   8 #include "base/utf_string_conversions.h"
   9
  10 namespace base {
  11
  12 SharedMemory::SharedMemory()
  13     : mapped_file_(NULL),
  14       memory_(NULL),
  15       read_only_(false),
  16       created_size_(0),
  17       lock_(NULL) {
  18 }
  19
  20 SharedMemory::SharedMemory(const std::wstring& name)
  21     : mapped_file_(NULL),
  22       memory_(NULL),
  23       read_only_(false),
  24       created_size_(0),
  25       lock_(NULL),
  26       name_(name) {
  27 }
  28
  29 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
  30     : mapped_file_(handle),
  31       memory_(NULL),
  32       read_only_(read_only),
  33       created_size_(0),
  34       lock_(NULL) {
  35 }
  36
  37 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
  38                            ProcessHandle process)
  39     : mapped_file_(NULL),
  40       memory_(NULL),
  41       read_only_(read_only),
  42       created_size_(0),
  43       lock_(NULL) {
  44   ::DuplicateHandle(process, handle,
  45                     GetCurrentProcess(), &mapped_file_,
  46                     STANDARD_RIGHTS_REQUIRED |
  47                     (read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS),
  48                     FALSE, 0);
  49 }
  50
  51 SharedMemory::~SharedMemory() {
  52   Close();
  53   if (lock_ != NULL)
  54     CloseHandle(lock_);
  55 }
  56
  57 // static
  58 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
  59   return handle != NULL;
  60 }
  61
  62 // static
  63 SharedMemoryHandle SharedMemory::NULLHandle() {
  64   return NULL;
  65 }
  66
  67 // static
  68 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
  69   DCHECK(handle != NULL);
  70   ::CloseHandle(handle);
  71 }
  72
  73 bool SharedMemory::CreateAndMapAnonymous(uint32 size) {
  74   return CreateAnonymous(size) && Map(size);
  75 }
  76
  77 bool SharedMemory::CreateAnonymous(uint32 size) {
  78   return CreateNamed("", false, size);
  79 }
  80
  81 bool SharedMemory::CreateNamed(const std::string& name,
  82                                bool open_existing, uint32 size) {
  83   DCHECK(!mapped_file_);
  84   if (size == 0)
  85     return false;
  86
  87   // NaCl's memory allocator requires 0mod64K alignment and size for
  88   // shared memory objects.  To allow passing shared memory to NaCl,
  89   // therefore we round the size actually created to the nearest 64K unit.
  90   // To avoid client impact, we continue to retain the size as the
  91   // actual requested size.
  92   uint32 rounded_size = (size + 0xffff) & ~0xffff;
  93   name_ = ASCIIToWide(name);
  94   mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
  95       PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
  96       name_.empty() ? NULL : name_.c_str());
  97   if (!mapped_file_)
  98     return false;
  99
 100   created_size_ = size;
 101
 102   // Check if the shared memory pre-exists.
 103   if (GetLastError() == ERROR_ALREADY_EXISTS) {
 104     // If the file already existed, set created_size_ to 0 to show that
 105     // we don't know the size.
 106     created_size_ = 0;
 107     if (!open_existing) {
 108       Close();
 109       return false;
 110     }
 111   }
 112
 113   return true;
 114 }
 115
 116 bool SharedMemory::Delete(const std::string& name) {
 117   // intentionally empty -- there is nothing for us to do on Windows.
 118   return true;
 119 }
 120
 121 bool SharedMemory::Open(const std::string& name, bool read_only) {
 122   DCHECK(!mapped_file_);
 123
 124   name_ = ASCIIToWide(name);
 125   read_only_ = read_only;
 126   mapped_file_ = OpenFileMapping(
 127       read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS, false,
 128       name_.empty() ? NULL : name_.c_str());
 129   if (mapped_file_ != NULL) {
 130     // Note: size_ is not set in this case.
 131     return true;
 132   }
 133   return false;
 134 }
 135
 136 bool SharedMemory::Map(uint32 bytes) {
 137   if (mapped_file_ == NULL)
 138     return false;
 139
 140   memory_ = MapViewOfFile(mapped_file_,
 141       read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS, 0, 0, bytes);
 142   if (memory_ != NULL) {
 143     return true;
 144   }
 145   return false;
 146 }
 147
 148 bool SharedMemory::Unmap() {
 149   if (memory_ == NULL)
 150     return false;
 151
 152   UnmapViewOfFile(memory_);
 153   memory_ = NULL;
 154   return true;
 155 }
 156
 157 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
 158                                         SharedMemoryHandle *new_handle,
 159                                         bool close_self) {
 160   *new_handle = 0;
 161   DWORD access = STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ;
 162   DWORD options = 0;
 163   HANDLE mapped_file = mapped_file_;
 164   HANDLE result;
 165   if (!read_only_)
 166     access |= FILE_MAP_WRITE;
 167   if (close_self) {
 168     // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
 169     options = DUPLICATE_CLOSE_SOURCE;
 170     mapped_file_ = NULL;
 171     Unmap();
 172   }
 173
 174   if (process == GetCurrentProcess() && close_self) {
 175     *new_handle = mapped_file;
 176     return true;
 177   }
 178
 179   if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
 180       &result, access, FALSE, options))
 181     return false;
 182   *new_handle = result;
 183   return true;
 184 }
 185
 186
 187 void SharedMemory::Close() {
 188   if (memory_ != NULL) {
 189     UnmapViewOfFile(memory_);
 190     memory_ = NULL;
 191   }
 192
 193   if (mapped_file_ != NULL) {
 194     CloseHandle(mapped_file_);
 195     mapped_file_ = NULL;
 196   }
 197 }
 198
 199 void SharedMemory::Lock() {
 200   Lock(INFINITE, NULL);
 201 }
 202
 203 bool SharedMemory::Lock(uint32 timeout_ms, SECURITY_ATTRIBUTES* sec_attr) {
 204   if (lock_ == NULL) {
 205     std::wstring name = name_;
 206     name.append(L"lock");
 207     lock_ = CreateMutex(sec_attr, FALSE, name.c_str());
 208     if (lock_ == NULL) {
 209       PLOG(ERROR) << "Could not create mutex.";
 210       return false;  // there is nothing good we can do here.
 211     }
 212   }
 213   DWORD result = WaitForSingleObject(lock_, timeout_ms);
 214
 215   // Return false for WAIT_ABANDONED, WAIT_TIMEOUT or WAIT_FAILED.
 216   return (result == WAIT_OBJECT_0);
 217 }
 218
 219 void SharedMemory::Unlock() {
 220   DCHECK(lock_ != NULL);
 221   ReleaseMutex(lock_);
 222 }
 223
 224 SharedMemoryHandle SharedMemory::handle() const {
 225   return mapped_file_;
 226 }
 227
 228 }  // namespace base