Home | History | Annotate | Download | only in memory 
      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 
     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 
     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 
     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 
     48 SharedMemory::~SharedMemory() {
     49   Close();
     50 }
     51 
     52 // static
     53 bool SharedMemory::IsHandleValid(const SharedMemoryHandle& handle) {
     54   return handle.fd >= 0;
     55 }
     56 
     57 // static
     58 SharedMemoryHandle SharedMemory::NULLHandle() {
     59   return SharedMemoryHandle();
     60 }
     61 
     62 // static
     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 
     69 bool SharedMemory::CreateAndMapAnonymous(size_t size) {
     70   // Untrusted code can't create descriptors or handles.
     71   return false;
     72 }
     73 
     74 bool SharedMemory::Create(const SharedMemoryCreateOptions& options) {
     75   // Untrusted code can't create descriptors or handles.
     76   return false;
     77 }
     78 
     79 bool SharedMemory::Delete(const std::string& name) {
     80   return false;
     81 }
     82 
     83 bool SharedMemory::Open(const std::string& name, bool read_only) {
     84   return false;
     85 }
     86 
     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   if (memory_)
     95     return false;
     96 
     97   memory_ = mmap(NULL, bytes, PROT_READ | (read_only_ ? 0 : PROT_WRITE),
     98                  MAP_SHARED, mapped_file_, offset);
     99 
    100   bool mmap_succeeded = memory_ != MAP_FAILED && memory_ != NULL;
    101   if (mmap_succeeded) {
    102     mapped_size_ = bytes;
    103     DCHECK_EQ(0U, reinterpret_cast<uintptr_t>(memory_) &
    104         (SharedMemory::MAP_MINIMUM_ALIGNMENT - 1));
    105   } else {
    106     memory_ = NULL;
    107   }
    108 
    109   return mmap_succeeded;
    110 }
    111 
    112 bool SharedMemory::Unmap() {
    113   if (memory_ == NULL)
    114     return false;
    115 
    116   if (munmap(memory_, mapped_size_) < 0)
    117     DPLOG(ERROR) << "munmap";
    118   memory_ = NULL;
    119   mapped_size_ = 0;
    120   return true;
    121 }
    122 
    123 SharedMemoryHandle SharedMemory::handle() const {
    124   return FileDescriptor(mapped_file_, false);
    125 }
    126 
    127 void SharedMemory::Close() {
    128   Unmap();
    129   if (mapped_file_ > 0) {
    130     if (close(mapped_file_) < 0)
    131       DPLOG(ERROR) << "close";
    132     mapped_file_ = -1;
    133   }
    134 }
    135 
    136 void SharedMemory::LockDeprecated() {
    137   NOTIMPLEMENTED();
    138 }
    139 
    140 void SharedMemory::UnlockDeprecated() {
    141   NOTIMPLEMENTED();
    142 }
    143 
    144 bool SharedMemory::ShareToProcessCommon(ProcessHandle process,
    145                                         SharedMemoryHandle *new_handle,
    146                                         bool close_self,
    147                                         ShareMode share_mode) {
    148   if (share_mode == SHARE_READONLY) {
    149     // Untrusted code can't create descriptors or handles, which is needed to
    150     // drop permissions.
    151     return false;
    152   }
    153   const int new_fd = dup(mapped_file_);
    154   if (new_fd < 0) {
    155     DPLOG(ERROR) << "dup() failed.";
    156     return false;
    157   }
    158 
    159   new_handle->fd = new_fd;
    160   new_handle->auto_close = true;
    161 
    162   if (close_self)
    163     Close();
    164   return true;
    165 }
    166 
    167 }  // namespace base
    168