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   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 
    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 
    120 SharedMemoryHandle SharedMemory::handle() const {
    121   return FileDescriptor(mapped_file_, false);
    122 }
    123 
    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 
    133 void SharedMemory::Lock() {
    134   NOTIMPLEMENTED();
    135 }
    136 
    137 void SharedMemory::Unlock() {
    138   NOTIMPLEMENTED();
    139 }
    140 
    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