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