base/memory/shared_memory_win.cc

   1 // Copyright (c) 2011 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/memory/shared_memory.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/utf_string_conversions.h"
   9
  10 namespace {
  11
  12 // Returns the length of the memory section starting at the supplied address.
  13 size_t GetMemorySectionSize(void* address) {
  14   MEMORY_BASIC_INFORMATION memory_info;
  15   if (!::VirtualQuery(address, &memory_info, sizeof(memory_info)))
  16     return 0;
  17   return memory_info.RegionSize - (static_cast<char*>(address) -
  18          static_cast<char*>(memory_info.AllocationBase));
  19 }
  20
  21 }  // namespace.
  22
  23 namespace base {
  24
  25 SharedMemory::SharedMemory()
  26     : mapped_file_(NULL),
  27       memory_(NULL),
  28       read_only_(false),
  29       mapped_size_(0),
  30       requested_size_(0),
  31       lock_(NULL) {
  32 }
  33
  34 SharedMemory::SharedMemory(const std::wstring& name)
  35     : mapped_file_(NULL),
  36       memory_(NULL),
  37       read_only_(false),
  38       requested_size_(0),
  39       mapped_size_(0),
  40       lock_(NULL),
  41       name_(name) {
  42 }
  43
  44 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
  45     : mapped_file_(handle),
  46       memory_(NULL),
  47       read_only_(read_only),
  48       requested_size_(0),
  49       mapped_size_(0),
  50       lock_(NULL) {
  51 }
  52
  53 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
  54                            ProcessHandle process)
  55     : mapped_file_(NULL),
  56       memory_(NULL),
  57       read_only_(read_only),
  58       requested_size_(0),
  59       mapped_size_(0),
  60       lock_(NULL) {
  61   ::DuplicateHandle(process, handle,
  62                     GetCurrentProcess(), &mapped_file_,
  63                     read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
  64                         FILE_MAP_WRITE,
  65                     FALSE, 0);
  66 }
  67
  68 SharedMemory::~SharedMemory() {
  69   Close();
  70   if (lock_ != NULL)
  71     CloseHandle(lock_);
  72 }
  73
  74 // static
  75 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
  76   return handle != NULL;
  77 }
  78
  79 // static
  80 SharedMemoryHandle SharedMemory::NULLHandle() {
  81   return NULL;
  82 }
  83
  84 // static
  85 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
  86   DCHECK(handle != NULL);
  87   ::CloseHandle(handle);
  88 }
  89
  90 // static
  91 size_t SharedMemory::GetHandleLimit() {
  92   // Rounded down from value reported here:
  93   // http://blogs.technet.com/b/markrussinovich/archive/2009/09/29/3283844.aspx
  94   return static_cast<size_t>(1 << 23);
  95 }
  96
  97 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
  98   return CreateAnonymous(size) && Map(size);
  99 }
 100
 101 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
 102   // TODO(bsy,sehr): crbug.com/210609 NaCl forces us to round up 64k here,
 103   // wasting 32k per mapping on average.
 104   static const size_t kSectionMask = 65536 - 1;
 105   DCHECK(!options.executable);
 106   DCHECK(!mapped_file_);
 107   if (options.size == 0)
 108     return false;
 109
 110   // Check maximum accounting for overflow.
 111   if (options.size >
 112       static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
 113     return false;
 114
 115   size_t rounded_size = (options.size + kSectionMask) & ~kSectionMask;
 116   name_ = ASCIIToWide(options.name == NULL ? "" : *options.name);
 117   mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
 118       PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
 119       name_.empty() ? NULL : name_.c_str());
 120   if (!mapped_file_)
 121     return false;
 122
 123   requested_size_ = options.size;
 124
 125   // Check if the shared memory pre-exists.
 126   if (GetLastError() == ERROR_ALREADY_EXISTS) {
 127     // If the file already existed, set requested_size_ to 0 to show that
 128     // we don't know the size.
 129     requested_size_ = 0;
 130     if (!options.open_existing) {
 131       Close();
 132       return false;
 133     }
 134   }
 135
 136   return true;
 137 }
 138
 139 bool SharedMemory::Delete(const std::string& name) {
 140   // intentionally empty -- there is nothing for us to do on Windows.
 141   return true;
 142 }
 143
 144 bool SharedMemory::Open(const std::string& name, bool read_only) {
 145   DCHECK(!mapped_file_);
 146
 147   name_ = ASCIIToWide(name);
 148   read_only_ = read_only;
 149   mapped_file_ = OpenFileMapping(
 150       read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
 151       false, name_.empty() ? NULL : name_.c_str());
 152   if (mapped_file_ != NULL) {
 153     // Note: size_ is not set in this case.
 154     return true;
 155   }
 156   return false;
 157 }
 158
 159 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
 160   if (mapped_file_ == NULL)
 161     return false;
 162
 163   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
 164     return false;
 165
 166   memory_ = MapViewOfFile(mapped_file_,
 167                           read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
 168                               FILE_MAP_WRITE,
 169                           static_cast<uint64>(offset) >> 32,
 170                           static_cast<DWORD>(offset),
 171                           bytes);
 172   if (memory_ != NULL) {
 173     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
 174         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
 175     mapped_size_ = GetMemorySectionSize(memory_);
 176     return true;
 177   }
 178   return false;
 179 }
 180
 181 bool SharedMemory::Unmap() {
 182   if (memory_ == NULL)
 183     return false;
 184
 185   UnmapViewOfFile(memory_);
 186   memory_ = NULL;
 187   return true;
 188 }
 189
 190 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
 191                                         SharedMemoryHandle *new_handle,
 192                                         bool close_self,
 193                                         ShareMode share_mode) {
 194   *new_handle = 0;
 195   DWORD access = FILE_MAP_READ;
 196   DWORD options = 0;
 197   HANDLE mapped_file = mapped_file_;
 198   HANDLE result;
 199   if (share_mode == SHARE_CURRENT_MODE && !read_only_)
 200     access |= FILE_MAP_WRITE;
 201   if (close_self) {
 202     // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
 203     options = DUPLICATE_CLOSE_SOURCE;
 204     mapped_file_ = NULL;
 205     Unmap();
 206   }
 207
 208   if (process == GetCurrentProcess() && close_self) {
 209     *new_handle = mapped_file;
 210     return true;
 211   }
 212
 213   if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
 214       &result, access, FALSE, options))
 215     return false;
 216   *new_handle = result;
 217   return true;
 218 }
 219
 220
 221 void SharedMemory::Close() {
 222   if (memory_ != NULL) {
 223     UnmapViewOfFile(memory_);
 224     memory_ = NULL;
 225   }
 226
 227   if (mapped_file_ != NULL) {
 228     CloseHandle(mapped_file_);
 229     mapped_file_ = NULL;
 230   }
 231 }
 232
 233 void SharedMemory::Lock() {
 234   Lock(INFINITE, NULL);
 235 }
 236
 237 bool SharedMemory::Lock(uint32 timeout_ms, SECURITY_ATTRIBUTES* sec_attr) {
 238   if (lock_ == NULL) {
 239     std::wstring name = name_;
 240     name.append(L"lock");
 241     lock_ = CreateMutex(sec_attr, FALSE, name.c_str());
 242     if (lock_ == NULL) {
 243       DPLOG(ERROR) << "Could not create mutex.";
 244       return false;  // there is nothing good we can do here.
 245     }
 246   }
 247   DWORD result = WaitForSingleObject(lock_, timeout_ms);
 248
 249   // Return false for WAIT_ABANDONED, WAIT_TIMEOUT or WAIT_FAILED.
 250   return (result == WAIT_OBJECT_0);
 251 }
 252
 253 void SharedMemory::Unlock() {
 254   DCHECK(lock_ != NULL);
 255   ReleaseMutex(lock_);
 256 }
 257
 258 SharedMemoryHandle SharedMemory::handle() const {
 259   return mapped_file_;
 260 }
 261
 262 }  // namespace base