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/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                     STANDARD_RIGHTS_REQUIRED |
  64                     (read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS),
  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 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
  91   return CreateAnonymous(size) && Map(size);
  92 }
  93
  94 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
  95   // TODO(bsy,sehr): crbug.com/210609 NaCl forces us to round up 64k here,
  96   // wasting 32k per mapping on average.
  97   static const size_t kSectionMask = 65536 - 1;
  98   DCHECK(!options.executable);
  99   DCHECK(!mapped_file_);
 100   if (options.size == 0)
 101     return false;
 102
 103   // Check maximum accounting for overflow.
 104   if (options.size >
 105       static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
 106     return false;
 107
 108   size_t rounded_size = (options.size + kSectionMask) & ~kSectionMask;
 109   name_ = ASCIIToWide(options.name == NULL ? "" : *options.name);
 110   mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, NULL,
 111       PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size),
 112       name_.empty() ? NULL : name_.c_str());
 113   if (!mapped_file_)
 114     return false;
 115
 116   requested_size_ = options.size;
 117
 118   // Check if the shared memory pre-exists.
 119   if (GetLastError() == ERROR_ALREADY_EXISTS) {
 120     // If the file already existed, set requested_size_ to 0 to show that
 121     // we don't know the size.
 122     requested_size_ = 0;
 123     if (!options.open_existing) {
 124       Close();
 125       return false;
 126     }
 127   }
 128
 129   return true;
 130 }
 131
 132 bool SharedMemory::Delete(const std::string& name) {
 133   // intentionally empty -- there is nothing for us to do on Windows.
 134   return true;
 135 }
 136
 137 bool SharedMemory::Open(const std::string& name, bool read_only) {
 138   DCHECK(!mapped_file_);
 139
 140   name_ = ASCIIToWide(name);
 141   read_only_ = read_only;
 142   mapped_file_ = OpenFileMapping(
 143       read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS, false,
 144       name_.empty() ? NULL : name_.c_str());
 145   if (mapped_file_ != NULL) {
 146     // Note: size_ is not set in this case.
 147     return true;
 148   }
 149   return false;
 150 }
 151
 152 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
 153   if (mapped_file_ == NULL)
 154     return false;
 155
 156   if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
 157     return false;
 158
 159   memory_ = MapViewOfFile(mapped_file_,
 160                           read_only_ ? FILE_MAP_READ : FILE_MAP_ALL_ACCESS,
 161                           static_cast<uint64>(offset) >> 32,
 162                           static_cast<DWORD>(offset),
 163                           bytes);
 164   if (memory_ != NULL) {
 165     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
 166         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
 167     mapped_size_ = GetMemorySectionSize(memory_);
 168     return true;
 169   }
 170   return false;
 171 }
 172
 173 bool SharedMemory::Unmap() {
 174   if (memory_ == NULL)
 175     return false;
 176
 177   UnmapViewOfFile(memory_);
 178   memory_ = NULL;
 179   return true;
 180 }
 181
 182 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
 183                                         SharedMemoryHandle *new_handle,
 184                                         bool close_self) {
 185   *new_handle = 0;
 186   DWORD access = STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ;
 187   DWORD options = 0;
 188   HANDLE mapped_file = mapped_file_;
 189   HANDLE result;
 190   if (!read_only_)
 191     access |= FILE_MAP_WRITE;
 192   if (close_self) {
 193     // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
 194     options = DUPLICATE_CLOSE_SOURCE;
 195     mapped_file_ = NULL;
 196     Unmap();
 197   }
 198
 199   if (process == GetCurrentProcess() && close_self) {
 200     *new_handle = mapped_file;
 201     return true;
 202   }
 203
 204   if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
 205       &result, access, FALSE, options))
 206     return false;
 207   *new_handle = result;
 208   return true;
 209 }
 210
 211
 212 void SharedMemory::Close() {
 213   if (memory_ != NULL) {
 214     UnmapViewOfFile(memory_);
 215     memory_ = NULL;
 216   }
 217
 218   if (mapped_file_ != NULL) {
 219     CloseHandle(mapped_file_);
 220     mapped_file_ = NULL;
 221   }
 222 }
 223
 224 void SharedMemory::Lock() {
 225   Lock(INFINITE, NULL);
 226 }
 227
 228 bool SharedMemory::Lock(uint32 timeout_ms, SECURITY_ATTRIBUTES* sec_attr) {
 229   if (lock_ == NULL) {
 230     std::wstring name = name_;
 231     name.append(L"lock");
 232     lock_ = CreateMutex(sec_attr, FALSE, name.c_str());
 233     if (lock_ == NULL) {
 234       DPLOG(ERROR) << "Could not create mutex.";
 235       return false;  // there is nothing good we can do here.
 236     }
 237   }
 238   DWORD result = WaitForSingleObject(lock_, timeout_ms);
 239
 240   // Return false for WAIT_ABANDONED, WAIT_TIMEOUT or WAIT_FAILED.
 241   return (result == WAIT_OBJECT_0);
 242 }
 243
 244 void SharedMemory::Unlock() {
 245   DCHECK(lock_ != NULL);
 246   ReleaseMutex(lock_);
 247 }
 248
 249 SharedMemoryHandle SharedMemory::handle() const {
 250   return mapped_file_;
 251 }
 252
 253 }  // namespace base