Home | History | Annotate | Download | only in embedder
      1 // Copyright 2014 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 "mojo/edk/embedder/platform_shared_buffer.h"
      6 
      7 #include <stddef.h>
      8 
      9 #include <utility>
     10 
     11 #include "base/logging.h"
     12 #include "base/memory/ptr_util.h"
     13 #include "base/memory/shared_memory.h"
     14 #include "base/process/process_handle.h"
     15 #include "base/sys_info.h"
     16 #include "mojo/edk/embedder/platform_handle_utils.h"
     17 
     18 #if defined(OS_NACL)
     19 // For getpagesize() on NaCl.
     20 #include <unistd.h>
     21 #endif
     22 
     23 namespace mojo {
     24 namespace edk {
     25 
     26 namespace {
     27 
     28 // Takes ownership of |memory_handle|.
     29 ScopedPlatformHandle SharedMemoryToPlatformHandle(
     30     base::SharedMemoryHandle memory_handle) {
     31 #if defined(OS_POSIX) && !(defined(OS_MACOSX) && !defined(OS_IOS))
     32   return ScopedPlatformHandle(PlatformHandle(memory_handle.fd));
     33 #elif defined(OS_WIN)
     34   return ScopedPlatformHandle(PlatformHandle(memory_handle.GetHandle()));
     35 #else
     36   return ScopedPlatformHandle(PlatformHandle(memory_handle.GetMemoryObject()));
     37 #endif
     38 }
     39 
     40 }  // namespace
     41 
     42 // static
     43 PlatformSharedBuffer* PlatformSharedBuffer::Create(size_t num_bytes) {
     44   DCHECK_GT(num_bytes, 0u);
     45 
     46   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, false);
     47   if (!rv->Init()) {
     48     // We can't just delete it directly, due to the "in destructor" (debug)
     49     // check.
     50     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     51     return nullptr;
     52   }
     53 
     54   return rv;
     55 }
     56 
     57 // static
     58 PlatformSharedBuffer* PlatformSharedBuffer::CreateFromPlatformHandle(
     59     size_t num_bytes,
     60     bool read_only,
     61     ScopedPlatformHandle platform_handle) {
     62   DCHECK_GT(num_bytes, 0u);
     63 
     64   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, read_only);
     65   if (!rv->InitFromPlatformHandle(std::move(platform_handle))) {
     66     // We can't just delete it directly, due to the "in destructor" (debug)
     67     // check.
     68     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     69     return nullptr;
     70   }
     71 
     72   return rv;
     73 }
     74 
     75 // static
     76 PlatformSharedBuffer* PlatformSharedBuffer::CreateFromPlatformHandlePair(
     77     size_t num_bytes,
     78     ScopedPlatformHandle rw_platform_handle,
     79     ScopedPlatformHandle ro_platform_handle) {
     80   DCHECK_GT(num_bytes, 0u);
     81   DCHECK(rw_platform_handle.is_valid());
     82   DCHECK(ro_platform_handle.is_valid());
     83 
     84   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, false);
     85   if (!rv->InitFromPlatformHandlePair(std::move(rw_platform_handle),
     86                                       std::move(ro_platform_handle))) {
     87     // We can't just delete it directly, due to the "in destructor" (debug)
     88     // check.
     89     scoped_refptr<PlatformSharedBuffer> deleter(rv);
     90     return nullptr;
     91   }
     92 
     93   return rv;
     94 }
     95 
     96 // static
     97 PlatformSharedBuffer* PlatformSharedBuffer::CreateFromSharedMemoryHandle(
     98     size_t num_bytes,
     99     bool read_only,
    100     base::SharedMemoryHandle handle) {
    101   DCHECK_GT(num_bytes, 0u);
    102 
    103   PlatformSharedBuffer* rv = new PlatformSharedBuffer(num_bytes, read_only);
    104   rv->InitFromSharedMemoryHandle(handle);
    105 
    106   return rv;
    107 }
    108 
    109 size_t PlatformSharedBuffer::GetNumBytes() const {
    110   return num_bytes_;
    111 }
    112 
    113 bool PlatformSharedBuffer::IsReadOnly() const {
    114   return read_only_;
    115 }
    116 
    117 std::unique_ptr<PlatformSharedBufferMapping> PlatformSharedBuffer::Map(
    118     size_t offset,
    119     size_t length) {
    120   if (!IsValidMap(offset, length))
    121     return nullptr;
    122 
    123   return MapNoCheck(offset, length);
    124 }
    125 
    126 bool PlatformSharedBuffer::IsValidMap(size_t offset, size_t length) {
    127   if (offset > num_bytes_ || length == 0)
    128     return false;
    129 
    130   // Note: This is an overflow-safe check of |offset + length > num_bytes_|
    131   // (that |num_bytes >= offset| is verified above).
    132   if (length > num_bytes_ - offset)
    133     return false;
    134 
    135   return true;
    136 }
    137 
    138 std::unique_ptr<PlatformSharedBufferMapping> PlatformSharedBuffer::MapNoCheck(
    139     size_t offset,
    140     size_t length) {
    141   DCHECK(IsValidMap(offset, length));
    142   DCHECK(shared_memory_);
    143   base::SharedMemoryHandle handle;
    144   {
    145     base::AutoLock locker(lock_);
    146     handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
    147   }
    148   if (handle == base::SharedMemory::NULLHandle())
    149     return nullptr;
    150 
    151   std::unique_ptr<PlatformSharedBufferMapping> mapping(
    152       new PlatformSharedBufferMapping(handle, read_only_, offset, length));
    153   if (mapping->Map())
    154     return base::WrapUnique(mapping.release());
    155 
    156   return nullptr;
    157 }
    158 
    159 ScopedPlatformHandle PlatformSharedBuffer::DuplicatePlatformHandle() {
    160   DCHECK(shared_memory_);
    161   base::SharedMemoryHandle handle;
    162   {
    163     base::AutoLock locker(lock_);
    164     handle = base::SharedMemory::DuplicateHandle(shared_memory_->handle());
    165   }
    166   if (handle == base::SharedMemory::NULLHandle())
    167     return ScopedPlatformHandle();
    168 
    169   return SharedMemoryToPlatformHandle(handle);
    170 }
    171 
    172 ScopedPlatformHandle PlatformSharedBuffer::PassPlatformHandle() {
    173   DCHECK(HasOneRef());
    174 
    175   // The only way to pass a handle from base::SharedMemory is to duplicate it
    176   // and close the original.
    177   ScopedPlatformHandle handle = DuplicatePlatformHandle();
    178 
    179   base::AutoLock locker(lock_);
    180   shared_memory_->Close();
    181   return handle;
    182 }
    183 
    184 base::SharedMemoryHandle PlatformSharedBuffer::DuplicateSharedMemoryHandle() {
    185   DCHECK(shared_memory_);
    186 
    187   base::AutoLock locker(lock_);
    188   return base::SharedMemory::DuplicateHandle(shared_memory_->handle());
    189 }
    190 
    191 PlatformSharedBuffer* PlatformSharedBuffer::CreateReadOnlyDuplicate() {
    192   DCHECK(shared_memory_);
    193 
    194   if (ro_shared_memory_) {
    195     base::AutoLock locker(lock_);
    196     base::SharedMemoryHandle handle;
    197     handle = base::SharedMemory::DuplicateHandle(ro_shared_memory_->handle());
    198     if (handle == base::SharedMemory::NULLHandle())
    199       return nullptr;
    200     return CreateFromSharedMemoryHandle(num_bytes_, true, handle);
    201   }
    202 
    203   base::SharedMemoryHandle handle;
    204   bool success;
    205   {
    206     base::AutoLock locker(lock_);
    207     success = shared_memory_->ShareReadOnlyToProcess(
    208         base::GetCurrentProcessHandle(), &handle);
    209   }
    210   if (!success || handle == base::SharedMemory::NULLHandle())
    211       return nullptr;
    212 
    213   return CreateFromSharedMemoryHandle(num_bytes_, true, handle);
    214 }
    215 
    216 PlatformSharedBuffer::PlatformSharedBuffer(size_t num_bytes, bool read_only)
    217     : num_bytes_(num_bytes), read_only_(read_only) {}
    218 
    219 PlatformSharedBuffer::~PlatformSharedBuffer() {}
    220 
    221 bool PlatformSharedBuffer::Init() {
    222   DCHECK(!shared_memory_);
    223   DCHECK(!read_only_);
    224 
    225   base::SharedMemoryCreateOptions options;
    226   options.size = num_bytes_;
    227   // By default, we can share as read-only.
    228   options.share_read_only = true;
    229 
    230   shared_memory_.reset(new base::SharedMemory);
    231   return shared_memory_->Create(options);
    232 }
    233 
    234 bool PlatformSharedBuffer::InitFromPlatformHandle(
    235     ScopedPlatformHandle platform_handle) {
    236   DCHECK(!shared_memory_);
    237 
    238 #if defined(OS_WIN)
    239   base::SharedMemoryHandle handle(platform_handle.release().handle,
    240                                   base::GetCurrentProcId());
    241 #elif defined(OS_MACOSX) && !defined(OS_IOS)
    242   base::SharedMemoryHandle handle;
    243   handle = base::SharedMemoryHandle(platform_handle.release().port, num_bytes_,
    244                                     base::GetCurrentProcId());
    245 #else
    246   base::SharedMemoryHandle handle(platform_handle.release().handle, false);
    247 #endif
    248 
    249   shared_memory_.reset(new base::SharedMemory(handle, read_only_));
    250   return true;
    251 }
    252 
    253 bool PlatformSharedBuffer::InitFromPlatformHandlePair(
    254     ScopedPlatformHandle rw_platform_handle,
    255     ScopedPlatformHandle ro_platform_handle) {
    256 #if defined(OS_WIN) || defined(OS_MACOSX)
    257   NOTREACHED();
    258   return false;
    259 #else
    260   DCHECK(!shared_memory_);
    261 
    262   base::SharedMemoryHandle handle(rw_platform_handle.release().handle, false);
    263   shared_memory_.reset(new base::SharedMemory(handle, false));
    264 
    265   base::SharedMemoryHandle ro_handle(ro_platform_handle.release().handle,
    266                                      false);
    267   ro_shared_memory_.reset(new base::SharedMemory(ro_handle, true));
    268 
    269   return true;
    270 #endif
    271 }
    272 
    273 void PlatformSharedBuffer::InitFromSharedMemoryHandle(
    274     base::SharedMemoryHandle handle) {
    275   DCHECK(!shared_memory_);
    276 
    277   shared_memory_.reset(new base::SharedMemory(handle, read_only_));
    278 }
    279 
    280 PlatformSharedBufferMapping::~PlatformSharedBufferMapping() {
    281   Unmap();
    282 }
    283 
    284 void* PlatformSharedBufferMapping::GetBase() const {
    285   return base_;
    286 }
    287 
    288 size_t PlatformSharedBufferMapping::GetLength() const {
    289   return length_;
    290 }
    291 
    292 bool PlatformSharedBufferMapping::Map() {
    293   // Mojo shared buffers can be mapped at any offset. However,
    294   // base::SharedMemory must be mapped at a page boundary. So calculate what the
    295   // nearest whole page offset is, and build a mapping that's offset from that.
    296 #if defined(OS_NACL)
    297   // base::SysInfo isn't available under NaCl.
    298   size_t page_size = getpagesize();
    299 #else
    300   size_t page_size = base::SysInfo::VMAllocationGranularity();
    301 #endif
    302   size_t offset_rounding = offset_ % page_size;
    303   size_t real_offset = offset_ - offset_rounding;
    304   size_t real_length = length_ + offset_rounding;
    305 
    306   if (!shared_memory_.MapAt(static_cast<off_t>(real_offset), real_length))
    307     return false;
    308 
    309   base_ = static_cast<char*>(shared_memory_.memory()) + offset_rounding;
    310   return true;
    311 }
    312 
    313 void PlatformSharedBufferMapping::Unmap() {
    314   shared_memory_.Unmap();
    315 }
    316 
    317 }  // namespace edk
    318 }  // namespace mojo
    319