Added llvm into exceptions as we can't add README.chromium into 3rd party repository
[chromium-blink-merge.git] / base / memory / shared_memory_win.cc
blob20659ab97af7b1d3220c077d69435146db226f3e
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"
7 #include <aclapi.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"
15 namespace {
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));
26 } // namespace.
28 namespace base {
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) {
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) {
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) {
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);
73 SharedMemory::~SharedMemory() {
74 Unmap();
75 Close();
76 if (lock_ != NULL)
77 CloseHandle(lock_);
80 // static
81 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
82 return handle != NULL;
85 // static
86 SharedMemoryHandle SharedMemory::NULLHandle() {
87 return NULL;
90 // static
91 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
92 DCHECK(handle != NULL);
93 ::CloseHandle(handle);
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);
103 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
104 return CreateAnonymous(size) && Map(size);
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;
116 // Check maximum accounting for overflow.
117 if (options.size >
118 static_cast<size_t>(std::numeric_limits<int>::max()) - kSectionMask)
119 return false;
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;
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;
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]);
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;
151 requested_size_ = options.size;
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;
164 return true;
167 bool SharedMemory::Delete(const std::string& name) {
168 // intentionally empty -- there is nothing for us to do on Windows.
169 return true;
172 bool SharedMemory::Open(const std::string& name, bool read_only) {
173 DCHECK(!mapped_file_);
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;
184 return false;
187 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
188 if (mapped_file_ == NULL)
189 return false;
191 if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
192 return false;
194 if (memory_)
195 return false;
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;
209 return false;
212 bool SharedMemory::Unmap() {
213 if (memory_ == NULL)
214 return false;
216 UnmapViewOfFile(memory_);
217 memory_ = NULL;
218 return true;
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();
239 if (process == GetCurrentProcess() && close_self) {
240 *new_handle = mapped_file;
241 return true;
244 if (!DuplicateHandle(GetCurrentProcess(), mapped_file, process,
245 &result, access, FALSE, options))
246 return false;
247 *new_handle = result;
248 return true;
252 void SharedMemory::Close() {
253 if (mapped_file_ != NULL) {
254 CloseHandle(mapped_file_);
255 mapped_file_ = NULL;
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.
270 DWORD result = WaitForSingleObject(lock_, INFINITE);
271 DCHECK_EQ(result, WAIT_OBJECT_0);
274 void SharedMemory::UnlockDeprecated() {
275 DCHECK(lock_ != NULL);
276 ReleaseMutex(lock_);
279 SharedMemoryHandle SharedMemory::handle() const {
280 return mapped_file_;
283 } // namespace base