1 // Copyright (c) 2012 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 <errno.h>
8 #include <fcntl.h>
9 #include <sys/mman.h>
10 #include <sys/stat.h>
11 #include <unistd.h>
12
13 #include <limits>
14
15 #include "base/logging.h"
16
17 namespace base {
18
SharedMemory()19 SharedMemory::SharedMemory()
20 : mapped_file_(-1),
21 inode_(0),
22 mapped_size_(0),
23 memory_(NULL),
24 read_only_(false),
25 requested_size_(0) {
26 }
27
SharedMemory(SharedMemoryHandle handle,bool read_only)28 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only)
29 : mapped_file_(handle.fd),
30 inode_(0),
31 mapped_size_(0),
32 memory_(NULL),
33 read_only_(read_only),
34 requested_size_(0) {
35 }
36
SharedMemory(SharedMemoryHandle handle,bool read_only,ProcessHandle process)37 SharedMemory::SharedMemory(SharedMemoryHandle handle, bool read_only,
38 ProcessHandle process)
39 : mapped_file_(handle.fd),
40 inode_(0),
41 mapped_size_(0),
42 memory_(NULL),
43 read_only_(read_only),
44 requested_size_(0) {
45 NOTREACHED();
46 }
47
~SharedMemory()48 SharedMemory::~SharedMemory() {
49 Close();
50 }
51
52 // static
IsHandleValid(const SharedMemoryHandle & handle)53 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
54 return handle.fd >= 0;
55 }
56
57 // static
NULLHandle()58 SharedMemoryHandle SharedMemory::NULLHandle() {
59 return SharedMemoryHandle();
60 }
61
62 // static
CloseHandle(const SharedMemoryHandle & handle)63 void SharedMemory::CloseHandle(const SharedMemoryHandle& handle) {
64 DCHECK_GE(handle.fd, 0);
65 if (close(handle.fd) < 0)
66 DPLOG(ERROR) << "close";
67 }
68
CreateAndMapAnonymous(size_t size)69 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
70 // Untrusted code can't create descriptors or handles.
71 return false;
72 }
73
Create(const SharedMemoryCreateOptions & options)74 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
75 // Untrusted code can't create descriptors or handles.
76 return false;
77 }
78
Delete(const std::string & name)79 bool SharedMemory::Delete(const std::string& name) {
80 return false;
81 }
82
Open(const std::string & name,bool read_only)83 bool SharedMemory::Open(const std::string& name, bool read_only) {
84 return false;
85 }
86
MapAt(off_t offset,size_t bytes)87 bool SharedMemory::MapAt(off_t offset, size_t bytes) {
88 if (mapped_file_ == -1)
89 return false;
90
91 if (bytes > static_cast<size_t>(std::numeric_limits<int>::max()))
92 return false;
93
94 memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
95 MAP_SHARED, mapped_file_, offset);
96
97 bool mmap_succeeded = memory_ != MAP_FAILED && memory_ != NULL;
98 if (mmap_succeeded) {
99 mapped_size_ = bytes;
100 DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
101 (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
102 } else {
103 memory_ = NULL;
104 }
105
106 return mmap_succeeded;
107 }
108
Unmap()109 bool SharedMemory::Unmap() {
110 if (memory_ == NULL)
111 return false;
112
113 if (munmap(memory_, mapped_size_) < 0)
114 DPLOG(ERROR) << "munmap";
115 memory_ = NULL;
116 mapped_size_ = 0;
117 return true;
118 }
119
handle() const120 SharedMemoryHandle SharedMemory::handle() const {
121 return FileDescriptor(mapped_file_, false);
122 }
123
Close()124 void SharedMemory::Close() {
125 Unmap();
126 if (mapped_file_ > 0) {
127 if (close(mapped_file_) < 0)
128 DPLOG(ERROR) << "close";
129 mapped_file_ = -1;
130 }
131 }
132
Lock()133 void SharedMemory::Lock() {
134 NOTIMPLEMENTED();
135 }
136
Unlock()137 void SharedMemory::Unlock() {
138 NOTIMPLEMENTED();
139 }
140
ShareToProcessCommon(ProcessHandle process,SharedMemoryHandle * new_handle,bool close_self,ShareMode share_mode)141 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
142 SharedMemoryHandle *new_handle,
143 bool close_self,
144 ShareMode share_mode) {
145 if (share_mode == SHARE_READONLY) {
146 // Untrusted code can't create descriptors or handles, which is needed to
147 // drop permissions.
148 return false;
149 }
150 const int new_fd = dup(mapped_file_);
151 if (new_fd < 0) {
152 DPLOG(ERROR) << "dup() failed.";
153 return false;
154 }
155
156 new_handle->fd = new_fd;
157 new_handle->auto_close = true;
158
159 if (close_self)
160 Close();
161 return true;
162 }
163
164 } // namespace base
165