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