1 // Copyright 2021 The Chromium Authors
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/unsafe_shared_memory_pool.h"
6
7 #include "base/logging.h"
8
9 namespace {
10 constexpr size_t kMaxStoredBuffers = 32;
11 } // namespace
12
13 namespace base {
14
15 UnsafeSharedMemoryPool::UnsafeSharedMemoryPool() = default;
16
17 UnsafeSharedMemoryPool::~UnsafeSharedMemoryPool() = default;
18
Handle(PassKey<UnsafeSharedMemoryPool>,UnsafeSharedMemoryRegion region,WritableSharedMemoryMapping mapping,scoped_refptr<UnsafeSharedMemoryPool> pool)19 UnsafeSharedMemoryPool::Handle::Handle(
20 PassKey<UnsafeSharedMemoryPool>,
21 UnsafeSharedMemoryRegion region,
22 WritableSharedMemoryMapping mapping,
23 scoped_refptr<UnsafeSharedMemoryPool> pool)
24 : region_(std::move(region)),
25 mapping_(std::move(mapping)),
26 pool_(std::move(pool)) {
27 CHECK(pool_);
28 DCHECK(region_.IsValid());
29 DCHECK(mapping_.IsValid());
30 }
31
~Handle()32 UnsafeSharedMemoryPool::Handle::~Handle() {
33 pool_->ReleaseBuffer(std::move(region_), std::move(mapping_));
34 }
35
GetRegion() const36 const UnsafeSharedMemoryRegion& UnsafeSharedMemoryPool::Handle::GetRegion()
37 const {
38 return region_;
39 }
40
GetMapping() const41 const WritableSharedMemoryMapping& UnsafeSharedMemoryPool::Handle::GetMapping()
42 const {
43 return mapping_;
44 }
45
46 std::unique_ptr<UnsafeSharedMemoryPool::Handle>
MaybeAllocateBuffer(size_t region_size)47 UnsafeSharedMemoryPool::MaybeAllocateBuffer(size_t region_size) {
48 AutoLock lock(lock_);
49
50 DCHECK_GE(region_size, 0u);
51 if (is_shutdown_)
52 return nullptr;
53
54 // Only change the configured size if bigger region is requested to avoid
55 // unncecessary reallocations.
56 if (region_size > region_size_) {
57 regions_.clear();
58 region_size_ = region_size;
59 }
60 if (!regions_.empty()) {
61 auto region = std::move(regions_.back());
62 regions_.pop_back();
63 DCHECK_GE(region.first.GetSize(), region_size_);
64 auto handle = std::make_unique<Handle>(PassKey<UnsafeSharedMemoryPool>(),
65 std::move(region.first),
66 std::move(region.second), this);
67 return handle;
68 }
69
70 auto region = UnsafeSharedMemoryRegion::Create(region_size_);
71 if (!region.IsValid())
72 return nullptr;
73
74 WritableSharedMemoryMapping mapping = region.Map();
75 if (!mapping.IsValid())
76 return nullptr;
77
78 return std::make_unique<Handle>(PassKey<UnsafeSharedMemoryPool>(),
79 std::move(region), std::move(mapping), this);
80 }
81
Shutdown()82 void UnsafeSharedMemoryPool::Shutdown() {
83 AutoLock lock(lock_);
84 DCHECK(!is_shutdown_);
85 is_shutdown_ = true;
86 regions_.clear();
87 }
88
ReleaseBuffer(UnsafeSharedMemoryRegion region,WritableSharedMemoryMapping mapping)89 void UnsafeSharedMemoryPool::ReleaseBuffer(
90 UnsafeSharedMemoryRegion region,
91 WritableSharedMemoryMapping mapping) {
92 AutoLock lock(lock_);
93 // Only return regions which are at least as big as the current configuration.
94 if (is_shutdown_ || regions_.size() >= kMaxStoredBuffers ||
95 !region.IsValid() || region.GetSize() < region_size_) {
96 DLOG(WARNING) << "Not returning SharedMemoryRegion to the pool:"
97 << " is_shutdown: " << (is_shutdown_ ? "true" : "false")
98 << " stored regions: " << regions_.size()
99 << " configured size: " << region_size_
100 << " this region size: " << region.GetSize()
101 << " valid: " << (region.IsValid() ? "true" : "false");
102 return;
103 }
104 regions_.emplace_back(std::move(region), std::move(mapping));
105 }
106
107 } // namespace base
108