Home | History | Annotate | Download | only in memory 
      1 // Copyright 2018 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 #ifndef BASE_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
      6 #define BASE_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
      7 
      8 #include "base/macros.h"
      9 #include "base/memory/platform_shared_memory_region.h"
     10 #include "base/memory/read_only_shared_memory_region.h"
     11 #include "base/memory/shared_memory_mapping.h"
     12 #include "base/memory/unsafe_shared_memory_region.h"
     13 
     14 namespace base {
     15 
     16 // Scoped move-only handle to a region of platform shared memory. The instance
     17 // owns the platform handle it wraps. Mappings created by this region are
     18 // writable. These mappings remain valid even after the region handle is moved
     19 // or destroyed.
     20 //
     21 // This region can be locked to read-only access by converting it to a
     22 // ReadOnlySharedMemoryRegion. However, unlike ReadOnlySharedMemoryRegion and
     23 // UnsafeSharedMemoryRegion, ownership of this region (while writable) is unique
     24 // and may only be transferred, not duplicated.
     25 class BASE_EXPORT WritableSharedMemoryRegion {
     26  public:
     27   using MappingType = WritableSharedMemoryMapping;
     28   // Creates a new WritableSharedMemoryRegion instance of a given
     29   // size that can be used for mapping writable shared memory into the virtual
     30   // address space.
     31   static WritableSharedMemoryRegion Create(size_t size);
     32 
     33   // Returns a WritableSharedMemoryRegion built from a platform handle that was
     34   // taken from another WritableSharedMemoryRegion instance. Returns an invalid
     35   // region iff the |handle| is invalid. CHECK-fails if the |handle| isn't
     36   // writable.
     37   // This should be used only by the code passing handles across process
     38   // boundaries.
     39   static WritableSharedMemoryRegion Deserialize(
     40       subtle::PlatformSharedMemoryRegion handle);
     41 
     42   // Extracts a platform handle from the region. Ownership is transferred to the
     43   // returned region object.
     44   // This should be used only for sending the handle from the current
     45   // process to another.
     46   static subtle::PlatformSharedMemoryRegion TakeHandleForSerialization(
     47       WritableSharedMemoryRegion region);
     48 
     49   // Makes the region read-only. No new writable mappings of the region can be
     50   // created after this call. Returns an invalid region on failure.
     51   static ReadOnlySharedMemoryRegion ConvertToReadOnly(
     52       WritableSharedMemoryRegion region);
     53 
     54   // Makes the region unsafe. The region cannot be converted to read-only after
     55   // this call. Returns an invalid region on failure.
     56   static UnsafeSharedMemoryRegion ConvertToUnsafe(
     57       WritableSharedMemoryRegion region);
     58 
     59   // Default constructor initializes an invalid instance.
     60   WritableSharedMemoryRegion();
     61 
     62   // Move operations are allowed.
     63   WritableSharedMemoryRegion(WritableSharedMemoryRegion&&);
     64   WritableSharedMemoryRegion& operator=(WritableSharedMemoryRegion&&);
     65 
     66   // Destructor closes shared memory region if valid.
     67   // All created mappings will remain valid.
     68   ~WritableSharedMemoryRegion();
     69 
     70   // Maps the shared memory region into the caller's address space with write
     71   // access. The mapped address is guaranteed to have an alignment of
     72   // at least |subtle::PlatformSharedMemoryRegion::kMapMinimumAlignment|.
     73   // Returns a valid WritableSharedMemoryMapping instance on success, invalid
     74   // otherwise.
     75   WritableSharedMemoryMapping Map() const;
     76 
     77   // Same as above, but maps only |size| bytes of the shared memory block
     78   // starting with the given |offset|. |offset| must be aligned to value of
     79   // |SysInfo::VMAllocationGranularity()|. Returns an invalid mapping if
     80   // requested bytes are out of the region limits.
     81   WritableSharedMemoryMapping MapAt(off_t offset, size_t size) const;
     82 
     83   // Whether underlying platform handles are valid.
     84   bool IsValid() const;
     85 
     86   // Returns the maximum mapping size that can be created from this region.
     87   size_t GetSize() const {
     88     DCHECK(IsValid());
     89     return handle_.GetSize();
     90   }
     91 
     92   // Returns 128-bit GUID of the region.
     93   const UnguessableToken& GetGUID() const {
     94     DCHECK(IsValid());
     95     return handle_.GetGUID();
     96   }
     97 
     98  private:
     99   explicit WritableSharedMemoryRegion(
    100       subtle::PlatformSharedMemoryRegion handle);
    101 
    102   subtle::PlatformSharedMemoryRegion handle_;
    103 
    104   DISALLOW_COPY_AND_ASSIGN(WritableSharedMemoryRegion);
    105 };
    106 
    107 }  // namespace base
    108 
    109 #endif  // BASE_MEMORY_WRITABLE_SHARED_MEMORY_REGION_H_
    110