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