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_deprecated == NULL ? "" :
 117                           *options.name_deprecated);
 118   mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
 119       PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
 120       name_.empty() ? NULL : name_.c_str());
 121   if (!mapped_file_)
 122     return false;
 123
 124   requested_size_ = options.size;
 125
 126   // Check if the shared memory pre-exists.
 127   if (GetLastError() == ERROR_ALREADY_EXISTS) {
 128     // If the file already existed, set requested_size_ to 0 to show that
 129     // we don't know the size.
 130     requested_size_ = 0;
 131     if (!options.open_existing_deprecated) {
 132       Close();
 133       return false;
 134     }
 135   }
 136
 137   return true;
 138 }
 139
 140 bool SharedMemory::Delete(const std::string& name) {
 141   // intentionally empty -- there is nothing for us to do on Windows.
 142   return true;
 143 }
 144
 145 bool SharedMemory::Open(const std::string& name, bool read_only) {
 146   DCHECK(!mapped_file_);
 147
 148   name_ = ASCIIToWide(name);
 149   read_only_ = read_only;
 150   mapped_file_ = OpenFileMapping(
 151       read_only_ ? FILE_MAP_READ : FILE_MAP_READ | FILE_MAP_WRITE,
 152       false, name_.empty() ? NULL : name_.c_str());
 153   if (mapped_file_ != NULL) {
 154     // Note: size_ is not set in this case.
 155     return true;
 156   }
 157   return false;
 158 }
 159
 160 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
 161   if (mapped_file_ == NULL)
 162     return false;
 163
 164   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
 165     return false;
 166
 167   if (memory_)
 168     return false;
 169
 170   memory_ = MapViewOfFile(mapped_file_,
 171                           read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
 172                               FILE_MAP_WRITE,
 173                           static_cast<uint64>(offset) >> 32,
 174                           static_cast<DWORD>(offset),
 175                           bytes);
 176   if (memory_ != NULL) {
 177     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
 178         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
 179     mapped_size_ = GetMemorySectionSize(memory_);
 180     return true;
 181   }
 182   return false;
 183 }
 184
 185 bool SharedMemory::Unmap() {
 186   if (memory_ == NULL)
 187     return false;
 188
 189   UnmapViewOfFile(memory_);
 190   memory_ = NULL;
 191   return true;
 192 }
 193
 194 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
 195                                         SharedMemoryHandle *new_handle,
 196                                         bool close_self,
 197                                         ShareMode share_mode) {
 198   *new_handle = 0;
 199   DWORD access = FILE_MAP_READ;
 200   DWORD options = 0;
 201   HANDLE mapped_file = mapped_file_;
 202   HANDLE result;
 203   if (share_mode == SHARE_CURRENT_MODE && !read_only_)
 204     access |= FILE_MAP_WRITE;
 205   if (close_self) {
 206     // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
 207     options = DUPLICATE_CLOSE_SOURCE;
 208     mapped_file_ = NULL;
 209     Unmap();
 210   }
 211
 212   if (process == GetCurrentProcess() && close_self) {
 213     *new_handle = mapped_file;
 214     return true;
 215   }
 216
 217   if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
 218       &result, access, FALSE, options))
 219     return false;
 220   *new_handle = result;
 221   return true;
 222 }
 223
 224
 225 void SharedMemory::Close() {
 226   if (memory_ != NULL) {
 227     UnmapViewOfFile(memory_);
 228     memory_ = NULL;
 229   }
 230
 231   if (mapped_file_ != NULL) {
 232     CloseHandle(mapped_file_);
 233     mapped_file_ = NULL;
 234   }
 235 }
 236
 237 void SharedMemory::LockDeprecated() {
 238   if (lock_ == NULL) {
 239     std::wstring name = name_;
 240     name.append(L"lock");
 241     lock_ = CreateMutex(NULL, FALSE, name.c_str());
 242     if (lock_ == NULL) {
 243       DPLOG(ERROR) << "Could not create mutex.";
 244       NOTREACHED();
 245       return;  // There is nothing good we can do here.
 246     }
 247   }
 248   DWORD result = WaitForSingleObject(lock_, INFINITE);
 249   DCHECK_EQ(result, WAIT_OBJECT_0);
 250 }
 251
 252 void SharedMemory::UnlockDeprecated() {
 253   DCHECK(lock_ != NULL);
 254   ReleaseMutex(lock_);
 255 }
 256
 257 SharedMemoryHandle SharedMemory::handle() const {
 258   return mapped_file_;
 259 }
 260
 261 }  // namespace base