/* 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/. */
#ifndef mozilla_ipc_SharedMemoryCursor_h
#define mozilla_ipc_SharedMemoryCursor_h
#include "mozilla/ipc/SharedMemoryHandle.h"
#include "mozilla/ipc/SharedMemoryMapping.h"
namespace mozilla::ipc::shared_memory {
// The `Cursor` is a similar type to a mutable `Mapping`, in that it
// provides read/write access to the contents of a shared memory region.
// However, it can recover from situations where address fragmentation means
// that mapping the full shared memory region fails, by instead mapping each
// page at a time, and seeking around the region.
//
// Because of this, the `Cursor` does not provide direct access to the shared
// memory region.
//
// NOTE: Cursor currently only operates on mutable mappings, even when reading.
// It can be generalized in the future if it would be found to be useful.
class Cursor {
public:
// Default constructor for invalid cursor. All reads and writes will fail.
Cursor() =
default;
// Construct a new Cursor which can be used to read from or write to the
// shared memory region indicated by aHandle.
explicit Cursor(MutableHandle&& aHandle) : mHandle(std::move(aHandle)) {}
bool IsValid()
const {
return mHandle.IsValid(); }
uint64_t Size()
const {
return mHandle.Size(); }
uint64_t Offset()
const {
return mOffset; }
uint64_t Remaining()
const {
return Size() - Offset(); }
// Read aCount bytes into aBuffer from the shared memory region, advancing the
// internal offset. Returns `false` if this fails for any reason.
bool Read(
void* aBuffer, size_t aCount);
// Write aCount bytes from aBuffer into the shared memory region, advancing
// the internal offset. Returns `false` if this fails for any reason.
bool Write(
const void* aBuffer, size_t aCount);
// Seek the Cursor to a given offset in the shared memory region.
// aOffset must be less than Size().
void Seek(uint64_t aOffset);
// Invalidate the Cursor, and return the underlying handle.
MutableHandle TakeHandle();
// Set the ChunkSize for the shared memory regions in this chunk. This is
// intended to be used for testing purposes.
// The chunk size must be a power of two, and at least
// SystemAllocationGranularity().
void SetChunkSize(size_t aChunkSize);
private:
// Default to mapping at most 1GiB/256MiB, depending on address space size.
#ifdef HAVE_64BIT_BUILD
static constexpr size_t kDefaultMaxChunkSize = size_t(
1) <<
30;
// 1GiB
#else
static constexpr size_t kDefaultMaxChunkSize = size_t(
1) <<
28;
// 256MiB
#endif
size_t ChunkSize()
const {
return mChunkSize; }
uint64_t ChunkOffsetMask()
const {
return uint64_t(ChunkSize()) -
1; }
uint64_t ChunkStartMask()
const {
return ~ChunkOffsetMask(); }
size_t ChunkOffset()
const {
return Offset() & ChunkOffsetMask(); }
uint64_t ChunkStart()
const {
return Offset() & ChunkStartMask(); }
bool Consume(
void* aBuffer, size_t aCount,
bool aWriteToShmem);
bool EnsureMapping();
// Shared memory handle this Cursor allows accessing.
MutableHandle mHandle;
// Memory map for the currently active chunk. Lazily initialized.
MutableMapping mMapping;
// Absolute offset into the shared memory handle.
uint64_t mOffset =
0;
// Current size of each chunk. Always a power of two. May be reduced in
// response to allocation failures.
size_t mChunkSize = kDefaultMaxChunkSize;
};
}
// namespace mozilla::ipc::shared_memory
#endif // mozilla_ipc_SharedMemoryCursor_h
