Home | History | Annotate | Download | only in memory 
      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
    262