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
10namespace {
11
12// Returns the length of the memory section starting at the supplied address.
13size_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
23namespace base {
24
25SharedMemory::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
34SharedMemory::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
44SharedMemory::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
53SharedMemory::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
68SharedMemory::~SharedMemory() {
69  Close();
70  if (lock_ != NULL)
71    CloseHandle(lock_);
72}
73
74// static
75bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
76  return handle != NULL;
77}
78
79// static
80SharedMemoryHandle SharedMemory::NULLHandle() {
81  return NULL;
82}
83
84// static
85void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
86  DCHECK(handle != NULL);
87  ::CloseHandle(handle);
88}
89
90// static
91size_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
97bool SharedMemory::CreateAndMapAnonymous(size_t size) {
98  return CreateAnonymous(size) && Map(size);
99}
100
101bool 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
139bool SharedMemory::Delete(const std::string& name) {
140  // intentionally empty -- there is nothing for us to do on Windows.
141  return true;
142}
143
144bool 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
159bool 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
181bool SharedMemory::Unmap() {
182  if (memory_ == NULL)
183    return false;
184
185  UnmapViewOfFile(memory_);
186  memory_ = NULL;
187  return true;
188}
189
190bool 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
221void 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
233void SharedMemory::Lock() {
234  Lock(INFINITE, NULL);
235}
236
237bool 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
253void SharedMemory::Unlock() {
254  DCHECK(lock_ != NULL);
255  ReleaseMutex(lock_);
256}
257
258SharedMemoryHandle SharedMemory::handle() const {
259  return mapped_file_;
260}
261
262}  // namespace base
263