OLD | NEW |
---|---|
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/memory/shared_memory_handle.h" | 5 #include "base/memory/shared_memory_handle.h" |
6 | 6 |
7 #include <mach/mach_vm.h> | 7 #include <mach/mach_vm.h> |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 #include <sys/mman.h> | 9 #include <sys/mman.h> |
10 #include <unistd.h> | 10 #include <unistd.h> |
11 | 11 |
12 #include "base/mac/mac_util.h" | 12 #include "base/mac/mac_util.h" |
13 #include "base/posix/eintr_wrapper.h" | 13 #include "base/posix/eintr_wrapper.h" |
14 | 14 |
15 namespace base { | 15 namespace base { |
16 | 16 |
17 SharedMemoryHandle::SharedMemoryHandle() {} | 17 SharedMemoryHandle::SharedMemoryHandle() |
18 : type_(MACH), memory_object_(MACH_PORT_NULL) {} | |
19 | |
20 SharedMemoryHandle::SharedMemoryHandle( | |
21 const base::FileDescriptor& file_descriptor) | |
22 : type_(POSIX), file_descriptor_(file_descriptor) {} | |
18 | 23 |
19 SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) { | 24 SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) { |
25 type_ = MACH; | |
20 mach_port_t named_right; | 26 mach_port_t named_right; |
21 kern_return_t kr = mach_make_memory_entry_64( | 27 kern_return_t kr = mach_make_memory_entry_64( |
22 mach_task_self(), | 28 mach_task_self(), |
23 &size, | 29 &size, |
24 0, // Address. | 30 0, // Address. |
25 MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE, | 31 MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE, |
26 &named_right, | 32 &named_right, |
27 MACH_PORT_NULL); // Parent handle. | 33 MACH_PORT_NULL); // Parent handle. |
28 if (kr != KERN_SUCCESS) { | 34 if (kr != KERN_SUCCESS) { |
29 memory_object_ = MACH_PORT_NULL; | 35 memory_object_ = MACH_PORT_NULL; |
30 return; | 36 return; |
31 } | 37 } |
32 | 38 |
33 memory_object_ = named_right; | 39 memory_object_ = named_right; |
34 size_ = size; | 40 size_ = size; |
35 pid_ = GetCurrentProcId(); | 41 pid_ = GetCurrentProcId(); |
36 ownership_passes_to_ipc_ = false; | 42 ownership_passes_to_ipc_ = false; |
37 } | 43 } |
38 | 44 |
39 SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object, | 45 SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object, |
40 mach_vm_size_t size, | 46 mach_vm_size_t size, |
41 base::ProcessId pid) | 47 base::ProcessId pid) |
42 : memory_object_(memory_object), | 48 : type_(MACH), |
49 memory_object_(memory_object), | |
43 size_(size), | 50 size_(size), |
44 pid_(pid), | 51 pid_(pid), |
45 ownership_passes_to_ipc_(false) {} | 52 ownership_passes_to_ipc_(false) {} |
46 | 53 |
47 SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) { | 54 SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) |
55 : type_(handle.type_) { | |
48 CopyRelevantData(handle); | 56 CopyRelevantData(handle); |
49 } | 57 } |
50 | 58 |
51 SharedMemoryHandle& SharedMemoryHandle::operator=( | 59 SharedMemoryHandle& SharedMemoryHandle::operator=( |
52 const SharedMemoryHandle& handle) { | 60 const SharedMemoryHandle& handle) { |
53 if (this == &handle) | 61 if (this == &handle) |
54 return *this; | 62 return *this; |
55 | 63 |
64 type_ = handle.type_; | |
56 CopyRelevantData(handle); | 65 CopyRelevantData(handle); |
57 return *this; | 66 return *this; |
58 } | 67 } |
59 | 68 |
60 SharedMemoryHandle SharedMemoryHandle::Duplicate() const { | 69 SharedMemoryHandle SharedMemoryHandle::Duplicate() const { |
61 if (!IsValid()) | 70 switch (type_) { |
62 return SharedMemoryHandle(MACH_PORT_NULL, 0, 0); | 71 case POSIX: { |
72 if (!IsValid()) | |
73 return SharedMemoryHandle(); | |
63 | 74 |
64 // Increment the ref count. | 75 int duped_fd = HANDLE_EINTR(dup(file_descriptor_.fd)); |
65 kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_, | 76 if (duped_fd < 0) |
66 MACH_PORT_RIGHT_SEND, 1); | 77 return SharedMemoryHandle(); |
67 DCHECK_EQ(kr, KERN_SUCCESS); | 78 return SharedMemoryHandle(duped_fd); |
68 SharedMemoryHandle handle(*this); | 79 } |
69 handle.SetOwnershipPassesToIPC(true); | 80 case MACH: { |
70 return handle; | 81 if (!IsValid()) |
82 return SharedMemoryHandle(MACH_PORT_NULL, 0, 0); | |
83 | |
84 // Increment the ref count. | |
85 kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_, | |
86 MACH_PORT_RIGHT_SEND, 1); | |
87 DCHECK_EQ(kr, KERN_SUCCESS); | |
Robert Sesek
2016/12/06 21:45:55
Can't this create an invalid handle, since this is
Robert Sesek
2016/12/06 21:45:55
Should there be logging here, similar to ::Close()
lawrencewu
2016/12/06 22:33:24
Yes, I suppose so. I added a CHECK(false) here.
lawrencewu
2016/12/06 22:33:24
Added logging.
| |
88 SharedMemoryHandle handle(*this); | |
89 handle.SetOwnershipPassesToIPC(true); | |
90 return handle; | |
91 } | |
92 } | |
71 } | 93 } |
72 | 94 |
73 bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const { | 95 bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const { |
74 if (!IsValid() && !handle.IsValid()) | 96 if (!IsValid() && !handle.IsValid()) |
75 return true; | 97 return true; |
76 | 98 |
77 return memory_object_ == handle.memory_object_ && size_ == handle.size_ && | 99 if (type_ != handle.type_) |
78 pid_ == handle.pid_; | 100 return false; |
101 | |
102 switch (type_) { | |
103 case POSIX: | |
104 return file_descriptor_ == handle.file_descriptor_; | |
105 case MACH: | |
106 return memory_object_ == handle.memory_object_ && size_ == handle.size_ && | |
107 pid_ == handle.pid_; | |
108 } | |
79 } | 109 } |
80 | 110 |
81 bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const { | 111 bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const { |
82 return !(*this == handle); | 112 return !(*this == handle); |
83 } | 113 } |
84 | 114 |
85 bool SharedMemoryHandle::IsValid() const { | 115 bool SharedMemoryHandle::IsValid() const { |
86 return memory_object_ != MACH_PORT_NULL; | 116 switch (type_) { |
117 case POSIX: | |
118 return file_descriptor_.fd >= 0; | |
119 case MACH: | |
120 return memory_object_ != MACH_PORT_NULL; | |
121 } | |
122 } | |
123 | |
124 void SharedMemoryHandle::SetFileHandle(int fd, bool auto_close) { | |
125 DCHECK(!IsValid()); | |
126 file_descriptor_.fd = fd; | |
127 file_descriptor_.auto_close = auto_close; | |
128 type_ = POSIX; | |
129 } | |
130 | |
131 const FileDescriptor SharedMemoryHandle::GetFileDescriptor() const { | |
132 DCHECK_EQ(type_, POSIX); | |
133 return file_descriptor_; | |
87 } | 134 } |
88 | 135 |
89 mach_port_t SharedMemoryHandle::GetMemoryObject() const { | 136 mach_port_t SharedMemoryHandle::GetMemoryObject() const { |
137 DCHECK_EQ(type_, MACH); | |
90 return memory_object_; | 138 return memory_object_; |
91 } | 139 } |
92 | 140 |
93 bool SharedMemoryHandle::GetSize(size_t* size) const { | 141 bool SharedMemoryHandle::GetSize(size_t* size) const { |
94 if (!IsValid()) { | 142 if (!IsValid()) { |
95 *size = 0; | 143 *size = 0; |
96 return true; | 144 return true; |
97 } | 145 } |
98 | 146 |
99 *size = size_; | 147 switch (type_) { |
100 return true; | 148 case SharedMemoryHandle::POSIX: |
149 struct stat st; | |
150 if (fstat(file_descriptor_.fd, &st) != 0) | |
151 return false; | |
152 if (st.st_size < 0) | |
153 return false; | |
154 *size = st.st_size; | |
155 return true; | |
156 case SharedMemoryHandle::MACH: | |
157 *size = size_; | |
158 return true; | |
159 } | |
101 } | 160 } |
102 | 161 |
103 bool SharedMemoryHandle::MapAt(off_t offset, | 162 bool SharedMemoryHandle::MapAt(off_t offset, |
104 size_t bytes, | 163 size_t bytes, |
105 void** memory, | 164 void** memory, |
106 bool read_only) { | 165 bool read_only) { |
107 DCHECK(IsValid()); | 166 DCHECK(IsValid()); |
108 DCHECK_EQ(pid_, GetCurrentProcId()); | 167 switch (type_) { |
109 kern_return_t kr = mach_vm_map( | 168 case SharedMemoryHandle::POSIX: |
110 mach_task_self(), | 169 *memory = mmap(nullptr, bytes, PROT_READ | (read_only ? 0 : PROT_WRITE), |
111 reinterpret_cast<mach_vm_address_t*>(memory), // Output parameter | 170 MAP_SHARED, file_descriptor_.fd, offset); |
112 bytes, | 171 |
113 0, // Alignment mask | 172 return *memory && *memory != reinterpret_cast<void*>(-1); |
114 VM_FLAGS_ANYWHERE, memory_object_, offset, | 173 case SharedMemoryHandle::MACH: |
115 FALSE, // Copy | 174 DCHECK_EQ(pid_, GetCurrentProcId()); |
116 VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE), // Current protection | 175 kern_return_t kr = mach_vm_map( |
117 VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK, // Maximum protection | 176 mach_task_self(), |
118 VM_INHERIT_NONE); | 177 reinterpret_cast<mach_vm_address_t*>(memory), // Output parameter |
119 return kr == KERN_SUCCESS; | 178 bytes, |
179 0, // Alignment mask | |
180 VM_FLAGS_ANYWHERE, | |
181 memory_object_, | |
182 offset, | |
183 FALSE, // Copy | |
184 VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE), // Current protection | |
185 VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK, // Maximum protection | |
186 VM_INHERIT_NONE); | |
187 return kr == KERN_SUCCESS; | |
188 } | |
120 } | 189 } |
121 | 190 |
122 void SharedMemoryHandle::Close() const { | 191 void SharedMemoryHandle::Close() const { |
123 if (!IsValid()) | 192 if (!IsValid()) |
124 return; | 193 return; |
125 | 194 |
126 kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_); | 195 switch (type_) { |
127 if (kr != KERN_SUCCESS) | 196 case POSIX: |
128 DPLOG(ERROR) << "Error deallocating mach port: " << kr; | 197 if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0) |
198 DPLOG(ERROR) << "Error closing fd."; | |
199 break; | |
200 case MACH: | |
201 kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_); | |
202 if (kr != KERN_SUCCESS) | |
203 DPLOG(ERROR) << "Error deallocating mach port: " << kr; | |
Robert Sesek
2016/12/06 21:45:55
DPLOG isn't appropriate here. MACH_LOG is.
lawrencewu
2016/12/06 22:33:24
Fixed.
| |
204 break; | |
205 } | |
129 } | 206 } |
130 | 207 |
131 void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) { | 208 void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) { |
209 DCHECK_EQ(type_, MACH); | |
132 ownership_passes_to_ipc_ = ownership_passes; | 210 ownership_passes_to_ipc_ = ownership_passes; |
133 } | 211 } |
134 | 212 |
135 bool SharedMemoryHandle::OwnershipPassesToIPC() const { | 213 bool SharedMemoryHandle::OwnershipPassesToIPC() const { |
214 DCHECK_EQ(type_, MACH); | |
136 return ownership_passes_to_ipc_; | 215 return ownership_passes_to_ipc_; |
137 } | 216 } |
138 | 217 |
139 void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) { | 218 void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) { |
140 memory_object_ = handle.memory_object_; | 219 switch (type_) { |
141 size_ = handle.size_; | 220 case POSIX: |
142 pid_ = handle.pid_; | 221 file_descriptor_ = handle.file_descriptor_; |
143 ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_; | 222 break; |
223 case MACH: | |
224 memory_object_ = handle.memory_object_; | |
225 size_ = handle.size_; | |
226 pid_ = handle.pid_; | |
227 ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_; | |
228 break; | |
229 } | |
144 } | 230 } |
145 | 231 |
146 } // namespace base | 232 } // namespace base |
OLD | NEW |