| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "base/memory/shared_memory_handle.h" |
| |
| #include <mach/mach_vm.h> |
| #include <sys/mman.h> |
| #include <unistd.h> |
| |
| #include "base/mac/mac_util.h" |
| #include "base/posix/eintr_wrapper.h" |
| |
| namespace base { |
| |
| static_assert(sizeof(SharedMemoryHandle::Type) <= |
| sizeof(SharedMemoryHandle::TypeWireFormat), |
| "Size of enum SharedMemoryHandle::Type exceeds size of type " |
| "transmitted over wire."); |
| |
| SharedMemoryHandle::SharedMemoryHandle() : type_(POSIX), file_descriptor_() {} |
| |
| SharedMemoryHandle::SharedMemoryHandle( |
| const base::FileDescriptor& file_descriptor) |
| : type_(POSIX), file_descriptor_(file_descriptor) {} |
| |
| SharedMemoryHandle::SharedMemoryHandle(int fd, bool auto_close) |
| : type_(POSIX), file_descriptor_(fd, auto_close) {} |
| |
| SharedMemoryHandle::SharedMemoryHandle(mach_vm_size_t size) { |
| type_ = MACH; |
| mach_port_t named_right; |
| kern_return_t kr = mach_make_memory_entry_64( |
| mach_task_self(), |
| &size, |
| 0, // Address. |
| MAP_MEM_NAMED_CREATE | VM_PROT_READ | VM_PROT_WRITE, |
| &named_right, |
| MACH_PORT_NULL); // Parent handle. |
| if (kr != KERN_SUCCESS) { |
| memory_object_ = MACH_PORT_NULL; |
| return; |
| } |
| |
| memory_object_ = named_right; |
| size_ = size; |
| pid_ = GetCurrentProcId(); |
| ownership_passes_to_ipc_ = false; |
| } |
| |
| SharedMemoryHandle::SharedMemoryHandle(mach_port_t memory_object, |
| mach_vm_size_t size, |
| base::ProcessId pid) |
| : type_(MACH), |
| memory_object_(memory_object), |
| size_(size), |
| pid_(pid), |
| ownership_passes_to_ipc_(false) {} |
| |
| SharedMemoryHandle::SharedMemoryHandle(const SharedMemoryHandle& handle) |
| : type_(handle.type_) { |
| CopyRelevantData(handle); |
| } |
| |
| SharedMemoryHandle& SharedMemoryHandle::operator=( |
| const SharedMemoryHandle& handle) { |
| if (this == &handle) |
| return *this; |
| |
| type_ = handle.type_; |
| CopyRelevantData(handle); |
| return *this; |
| } |
| |
| SharedMemoryHandle SharedMemoryHandle::Duplicate() const { |
| switch (type_) { |
| case POSIX: { |
| if (!IsValid()) |
| return SharedMemoryHandle(); |
| |
| int duped_fd = HANDLE_EINTR(dup(file_descriptor_.fd)); |
| if (duped_fd < 0) |
| return SharedMemoryHandle(); |
| return SharedMemoryHandle(duped_fd, true); |
| } |
| case MACH: { |
| if (!IsValid()) |
| return SharedMemoryHandle(MACH_PORT_NULL, 0, 0); |
| |
| // Increment the ref count. |
| kern_return_t kr = mach_port_mod_refs(mach_task_self(), memory_object_, |
| MACH_PORT_RIGHT_SEND, 1); |
| DCHECK_EQ(kr, KERN_SUCCESS); |
| return SharedMemoryHandle(*this); |
| } |
| } |
| } |
| |
| bool SharedMemoryHandle::operator==(const SharedMemoryHandle& handle) const { |
| if (!IsValid() && !handle.IsValid()) |
| return true; |
| |
| if (type_ != handle.type_) |
| return false; |
| |
| switch (type_) { |
| case POSIX: |
| return file_descriptor_ == handle.file_descriptor_; |
| case MACH: |
| return memory_object_ == handle.memory_object_ && size_ == handle.size_ && |
| pid_ == handle.pid_; |
| } |
| } |
| |
| bool SharedMemoryHandle::operator!=(const SharedMemoryHandle& handle) const { |
| return !(*this == handle); |
| } |
| |
| SharedMemoryHandle::Type SharedMemoryHandle::GetType() const { |
| return type_; |
| } |
| |
| bool SharedMemoryHandle::IsValid() const { |
| switch (type_) { |
| case POSIX: |
| return file_descriptor_.fd >= 0; |
| case MACH: |
| return memory_object_ != MACH_PORT_NULL; |
| } |
| } |
| |
| void SharedMemoryHandle::SetFileHandle(int fd, bool auto_close) { |
| DCHECK(!IsValid()); |
| file_descriptor_.fd = fd; |
| file_descriptor_.auto_close = auto_close; |
| type_ = POSIX; |
| } |
| |
| const FileDescriptor SharedMemoryHandle::GetFileDescriptor() const { |
| DCHECK_EQ(type_, POSIX); |
| return file_descriptor_; |
| } |
| |
| mach_port_t SharedMemoryHandle::GetMemoryObject() const { |
| DCHECK_EQ(type_, MACH); |
| return memory_object_; |
| } |
| |
| bool SharedMemoryHandle::GetSize(size_t* size) const { |
| if (!IsValid()) |
| return false; |
| |
| switch (type_) { |
| case SharedMemoryHandle::POSIX: |
| struct stat st; |
| if (fstat(file_descriptor_.fd, &st) != 0) |
| return false; |
| if (st.st_size < 0) |
| return false; |
| *size = st.st_size; |
| return true; |
| case SharedMemoryHandle::MACH: |
| *size = size_; |
| return true; |
| } |
| } |
| |
| bool SharedMemoryHandle::MapAt(off_t offset, |
| size_t bytes, |
| void** memory, |
| bool read_only) { |
| DCHECK(IsValid()); |
| switch (type_) { |
| case SharedMemoryHandle::POSIX: |
| *memory = mmap(nullptr, bytes, PROT_READ | (read_only ? 0 : PROT_WRITE), |
| MAP_SHARED, file_descriptor_.fd, offset); |
| |
| return *memory && *memory != reinterpret_cast<void*>(-1); |
| case SharedMemoryHandle::MACH: |
| // The flag VM_PROT_IS_MASK is only supported on OSX 10.7+. |
| DCHECK(mac::IsOSLionOrLater()); |
| |
| DCHECK_EQ(pid_, GetCurrentProcId()); |
| kern_return_t kr = mach_vm_map( |
| mach_task_self(), |
| reinterpret_cast<mach_vm_address_t*>(memory), // Output parameter |
| bytes, |
| 0, // Alignment mask |
| VM_FLAGS_ANYWHERE, |
| memory_object_, |
| offset, |
| FALSE, // Copy |
| VM_PROT_READ | (read_only ? 0 : VM_PROT_WRITE), // Current protection |
| VM_PROT_WRITE | VM_PROT_READ | VM_PROT_IS_MASK, // Maximum protection |
| VM_INHERIT_NONE); |
| return kr == KERN_SUCCESS; |
| } |
| } |
| |
| void SharedMemoryHandle::Close() const { |
| if (!IsValid()) |
| return; |
| |
| switch (type_) { |
| case POSIX: |
| if (IGNORE_EINTR(close(file_descriptor_.fd)) < 0) |
| DPLOG(ERROR) << "Error closing fd."; |
| break; |
| case MACH: |
| kern_return_t kr = mach_port_deallocate(mach_task_self(), memory_object_); |
| if (kr != KERN_SUCCESS) |
| DPLOG(ERROR) << "Error deallocating mach port: " << kr; |
| break; |
| } |
| } |
| |
| void SharedMemoryHandle::SetOwnershipPassesToIPC(bool ownership_passes) { |
| DCHECK_EQ(type_, MACH); |
| ownership_passes_to_ipc_ = ownership_passes; |
| } |
| |
| bool SharedMemoryHandle::OwnershipPassesToIPC() const { |
| DCHECK_EQ(type_, MACH); |
| return ownership_passes_to_ipc_; |
| } |
| |
| void SharedMemoryHandle::CopyRelevantData(const SharedMemoryHandle& handle) { |
| switch (type_) { |
| case POSIX: |
| file_descriptor_ = handle.file_descriptor_; |
| break; |
| case MACH: |
| memory_object_ = handle.memory_object_; |
| size_ = handle.size_; |
| pid_ = handle.pid_; |
| ownership_passes_to_ipc_ = handle.ownership_passes_to_ipc_; |
| break; |
| } |
| } |
| |
| } // namespace base |