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.
5 #include "base/memory/shared_memory.h"
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"
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)))
22 return memory_info.RegionSize - (static_cast<char*>(address) -
23 static_cast<char*>(memory_info.AllocationBase));
30 SharedMemory::SharedMemory()
39 SharedMemory::SharedMemory(const std::wstring& name)
49 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
50 : mapped_file_(handle),
52 read_only_(read_only),
58 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
59 ProcessHandle process)
62 read_only_(read_only),
66 ::DuplicateHandle(process, handle,
67 GetCurrentProcess(), &mapped_file_,
68 read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
73 SharedMemory::~SharedMemory() {
80 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
81 return handle != NULL;
85 SharedMemoryHandle SharedMemory::NULLHandle() {
90 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
91 DCHECK(handle != NULL);
92 ::CloseHandle(handle);
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);
102 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
103 return CreateAnonymous(size) && Map(size);
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)
115 // Check maximum accounting for overflow.
117 static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
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;
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))
132 if (!InitializeSecurityDescriptor(&sd, SECURITY_DESCRIPTOR_REVISION))
134 if (!SetSecurityDescriptorDacl(&sd, TRUE, &dacl, FALSE))
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]);
145 mapped_file_ = CreateFileMapping(INVALID_HANDLE_VALUE, &sa,
146 PAGE_READWRITE, 0, static_cast<DWORD>(rounded_size), name_.c_str());
150 requested_size_ = options.size;
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.
157 if (!options.open_existing_deprecated) {
166 bool SharedMemory::Delete(const std::string& name) {
167 // intentionally empty -- there is nothing for us to do on Windows.
171 bool SharedMemory::Open(const std::string& name, bool read_only) {
172 DCHECK(!mapped_file_);
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.
186 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
187 if (mapped_file_ == NULL)
190 if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
196 memory_ = MapViewOfFile(mapped_file_,
197 read_only_ ? FILE_MAP_READ : FILE_MAP_READ |
199 static_cast<uint64>(offset) >> 32,
200 static_cast<DWORD>(offset),
202 if (memory_ != NULL) {
203 DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
204 (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
205 mapped_size_ = GetMemorySectionSize(memory_);
211 bool SharedMemory::Unmap() {
215 UnmapViewOfFile(memory_);
220 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
221 SharedMemoryHandle *new_handle,
223 ShareMode share_mode) {
225 DWORD access = FILE_MAP_READ;
227 HANDLE mapped_file = mapped_file_;
229 if (share_mode == SHARE_CURRENT_MODE && !read_only_)
230 access |= FILE_MAP_WRITE;
232 // DUPLICATE_CLOSE_SOURCE causes DuplicateHandle to close mapped_file.
233 options = DUPLICATE_CLOSE_SOURCE;
238 if (process == GetCurrentProcess() && close_self) {
239 *new_handle = mapped_file;
243 if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
244 &result, access, FALSE, options))
246 *new_handle = result;
251 void SharedMemory::Close() {
252 if (memory_ != NULL) {
253 UnmapViewOfFile(memory_);
257 if (mapped_file_ != NULL) {
258 CloseHandle(mapped_file_);
263 void SharedMemory::LockDeprecated() {
265 std::wstring name = name_;
266 name.append(L"lock");
267 lock_ = CreateMutex(NULL, FALSE, name.c_str());
269 DPLOG(ERROR) << "Could not create mutex.";
271 return; // There is nothing good we can do here.
274 DWORD result = WaitForSingleObject(lock_, INFINITE);
275 DCHECK_EQ(result, WAIT_OBJECT_0);
278 void SharedMemory::UnlockDeprecated() {
279 DCHECK(lock_ != NULL);
283 SharedMemoryHandle SharedMemory::handle() const {