1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "mozilla/MathAlgorithms.h"
#include "nsDebug.h"
#include "SharedMemoryCursor.h"
namespace mozilla::ipc::shared_memory {
bool Cursor::Read(void* aBuffer, size_t aCount) {
return Consume(aBuffer, aCount, /* aWriteToShmem */ false);
}
bool Cursor::Write(const void* aBuffer, size_t aCount) {
return Consume(const_cast<void*>(aBuffer), aCount, /* aWriteToShmem */ true);
}
void Cursor::Seek(uint64_t aOffset) {
MOZ_ASSERT(aOffset <= Size());
// Update our offset, and invalidate `mMapping` if our current chunk changed.
uint64_t oldChunkStart = ChunkStart();
mOffset = aOffset;
if (mMapping && oldChunkStart != ChunkStart()) {
mMapping = nullptr;
}
}
MutableHandle Cursor::TakeHandle() {
mMapping = nullptr;
return std::move(mHandle);
}
void Cursor::SetChunkSize(size_t aChunkSize) {
MOZ_ASSERT(IsPowerOfTwo(aChunkSize),
"Cannot specify non power-of-two maximum chunk size");
MOZ_ASSERT(aChunkSize >= SystemAllocationGranularity(),
"Cannot specify a chunk size which is smaller than the system "
"allocation granularity");
mChunkSize = aChunkSize;
mMapping = nullptr; // Invalidate any existing mappings.
}
bool Cursor::Consume(void* aBuffer, size_t aCount, bool aWriteToShmem) {
if (aCount > Remaining()) {
NS_WARNING("count too large");
return false;
}
size_t consumed = 0;
while (consumed < aCount) {
// Ensure we have a valid mapping each trip through the loop. This will
// automatically back off on chunk size to avoid mapping failure.
if (!EnsureMapping()) {
return false;
}
// Determine how many of the requested bytes are available in mMapping, and
// perform the operation on them.
size_t mappingOffset = ChunkOffset();
size_t mappingRemaining = mMapping.Size() - mappingOffset;
size_t toCopy = std::min<size_t>(mappingRemaining, aCount - consumed);
void* shmemPtr = mMapping.DataAs<char>() + mappingOffset;
void* bufferPtr = static_cast<char*>(aBuffer) + consumed;
if (aWriteToShmem) {
memcpy(shmemPtr, bufferPtr, toCopy);
} else {
memcpy(bufferPtr, shmemPtr, toCopy);
}
// Seek and advance offsets. This will invalidate our mapping if it no
// longer applies to the current chunk.
Seek(mOffset + toCopy);
consumed += toCopy;
}
return true;
}
bool Cursor::EnsureMapping() {
MOZ_ASSERT(mHandle.IsValid());
while (!mMapping) {
// Attempt to map at the current chunk size.
uint64_t chunkStart = ChunkStart();
size_t chunkSize = std::min<uint64_t>(ChunkSize(), Size() - chunkStart);
mMapping = mHandle.MapSubregion(chunkStart, chunkSize);
if (MOZ_UNLIKELY(!mMapping)) {
// If we failed to map a single allocation granularity, we can't go
// smaller, so give up.
if (chunkSize <= SystemAllocationGranularity()) {
NS_WARNING(
"Failed to map the smallest allocation granularity of shared "
"memory region!");
return false;
}
// Try to allocate a smaller chunk next time.
mChunkSize = RoundUpPow2(chunkSize) >> 1;
}
}
return true;
}
} // namespace mozilla::ipc::shared_memory
|
