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.
GetMemorySectionSize(void * 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
SharedMemory()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
SharedMemory(const std::wstring & name)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
SharedMemory(SharedMemoryHandle handle,bool read_only)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
SharedMemory(SharedMemoryHandle handle,bool read_only,ProcessHandle process)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
~SharedMemory()68 SharedMemory::~SharedMemory() {
69 Close();
70 if (lock_ != NULL)
71 CloseHandle(lock_);
72 }
73
74 // static
IsHandleValid(const SharedMemoryHandle & handle)75 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
76 return handle != NULL;
77 }
78
79 // static
NULLHandle()80 SharedMemoryHandle SharedMemory::NULLHandle() {
81 return NULL;
82 }
83
84 // static
CloseHandle(const SharedMemoryHandle & handle)85 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
86 DCHECK(handle != NULL);
87 ::CloseHandle(handle);
88 }
89
90 // static
GetHandleLimit()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
CreateAndMapAnonymous(size_t size)97 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
98 return CreateAnonymous(size) && Map(size);
99 }
100
Create(const SharedMemoryCreateOptions & options)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
Delete(const std::string & name)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
Open(const std::string & name,bool read_only)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
MapAt(off_t offset,size_t bytes)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
Unmap()181 bool SharedMemory::Unmap() {
182 if (memory_ == NULL)
183 return false;
184
185 UnmapViewOfFile(memory_);
186 memory_ = NULL;
187 return true;
188 }
189
ShareToProcessCommon(ProcessHandle process,SharedMemoryHandle * new_handle,bool close_self,ShareMode share_mode)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
Close()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
Lock()233 void SharedMemory::Lock() {
234 Lock(INFINITE, NULL);
235 }
236
Lock(uint32 timeout_ms,SECURITY_ATTRIBUTES * sec_attr)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
Unlock()253 void SharedMemory::Unlock() {
254 DCHECK(lock_ != NULL);
255 ReleaseMutex(lock_);
256 }
257
handle() const258 SharedMemoryHandle SharedMemory::handle() const {
259 return mapped_file_;
260 }
261
262 } // namespace base
263