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