using System; using System.Runtime.CompilerServices; using System.Threading; namespace Ryujinx.Memory { /// /// Represents a block of contiguous physical guest memory. /// public sealed class MemoryBlock : IWritableBlock, IDisposable { private readonly bool _usesSharedMemory; private readonly bool _isMirror; private readonly bool _viewCompatible; private readonly bool _forJit; private IntPtr _sharedMemory; private IntPtr _pointer; /// /// Pointer to the memory block data. /// public IntPtr Pointer => _pointer; /// /// Size of the memory block. /// public ulong Size { get; } /// /// Creates a new instance of the memory block class. /// /// Size of the memory block in bytes /// Flags that controls memory block memory allocation /// Throw when there's no enough memory to allocate the requested size /// Throw when the current platform is not supported public MemoryBlock(ulong size, MemoryAllocationFlags flags = MemoryAllocationFlags.None) { if (flags.HasFlag(MemoryAllocationFlags.Mirrorable)) { _sharedMemory = MemoryManagement.CreateSharedMemory(size, flags.HasFlag(MemoryAllocationFlags.Reserve)); if (!flags.HasFlag(MemoryAllocationFlags.NoMap)) { _pointer = MemoryManagement.MapSharedMemory(_sharedMemory, size); } _usesSharedMemory = true; } else if (flags.HasFlag(MemoryAllocationFlags.Reserve)) { _viewCompatible = flags.HasFlag(MemoryAllocationFlags.ViewCompatible); _forJit = flags.HasFlag(MemoryAllocationFlags.Jit); _pointer = MemoryManagement.Reserve(size, _forJit, _viewCompatible); } else { _forJit = flags.HasFlag(MemoryAllocationFlags.Jit); _pointer = MemoryManagement.Allocate(size, _forJit); } Size = size; } /// /// Creates a new instance of the memory block class, with a existing backing storage. /// /// Size of the memory block in bytes /// Shared memory to use as backing storage for this block /// Throw when there's no enough address space left to map the shared memory /// Throw when the current platform is not supported private MemoryBlock(ulong size, IntPtr sharedMemory) { _pointer = MemoryManagement.MapSharedMemory(sharedMemory, size); Size = size; _usesSharedMemory = true; _isMirror = true; } /// /// Creates a memory block that shares the backing storage with this block. /// The memory and page commitments will be shared, however memory protections are separate. /// /// A new memory block that shares storage with this one /// Throw when the current memory block does not support mirroring /// Throw when there's no enough address space left to map the shared memory /// Throw when the current platform is not supported public MemoryBlock CreateMirror() { if (_sharedMemory == IntPtr.Zero) { throw new NotSupportedException("Mirroring is not supported on the memory block because the Mirrorable flag was not set."); } return new MemoryBlock(Size, _sharedMemory); } /// /// Commits a region of memory that has previously been reserved. /// This can be used to allocate memory on demand. /// /// Starting offset of the range to be committed /// Size of the range to be committed /// Throw when the operation was not successful /// Throw when the memory block has already been disposed /// Throw when either or are out of range public void Commit(ulong offset, ulong size) { MemoryManagement.Commit(GetPointerInternal(offset, size), size, _forJit); } /// /// Decommits a region of memory that has previously been reserved and optionally comitted. /// This can be used to free previously allocated memory on demand. /// /// Starting offset of the range to be decommitted /// Size of the range to be decommitted /// Throw when the operation was not successful /// Throw when the memory block has already been disposed /// Throw when either or are out of range public void Decommit(ulong offset, ulong size) { MemoryManagement.Decommit(GetPointerInternal(offset, size), size); } /// /// Maps a view of memory from another memory block. /// /// Memory block from where the backing memory will be taken /// Offset on of the region that should be mapped /// Offset to map the view into on this block /// Size of the range to be mapped /// Throw when the source memory block does not support mirroring /// Throw when the memory block has already been disposed /// Throw when either or are out of range public void MapView(MemoryBlock srcBlock, ulong srcOffset, ulong dstOffset, ulong size) { if (srcBlock._sharedMemory == IntPtr.Zero) { throw new ArgumentException("The source memory block is not mirrorable, and thus cannot be mapped on the current block."); } MemoryManagement.MapView(srcBlock._sharedMemory, srcOffset, GetPointerInternal(dstOffset, size), size, this); } /// /// Unmaps a view of memory from another memory block. /// /// Memory block from where the backing memory was taken during map /// Offset of the view previously mapped with /// Size of the range to be unmapped public void UnmapView(MemoryBlock srcBlock, ulong offset, ulong size) { MemoryManagement.UnmapView(srcBlock._sharedMemory, GetPointerInternal(offset, size), size, this); } /// /// Reprotects a region of memory. /// /// Starting offset of the range to be reprotected /// Size of the range to be reprotected /// New memory permissions /// True if a failed reprotect should throw /// Throw when the memory block has already been disposed /// Throw when either or are out of range /// Throw when is invalid public void Reprotect(ulong offset, ulong size, MemoryPermission permission, bool throwOnFail = true) { MemoryManagement.Reprotect(GetPointerInternal(offset, size), size, permission, _viewCompatible, throwOnFail); } /// /// Reads bytes from the memory block. /// /// Starting offset of the range being read /// Span where the bytes being read will be copied to /// Throw when the memory block has already been disposed /// Throw when the memory region specified for the the data is out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Read(ulong offset, Span data) { GetSpan(offset, data.Length).CopyTo(data); } /// /// Reads data from the memory block. /// /// Type of the data /// Offset where the data is located /// Data at the specified address /// Throw when the memory block has already been disposed /// Throw when the memory region specified for the the data is out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public T Read(ulong offset) where T : unmanaged { return GetRef(offset); } /// /// Writes bytes to the memory block. /// /// Starting offset of the range being written /// Span where the bytes being written will be copied from /// Throw when the memory block has already been disposed /// Throw when the memory region specified for the the data is out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Write(ulong offset, ReadOnlySpan data) { data.CopyTo(GetSpan(offset, data.Length)); } /// /// Writes data to the memory block. /// /// Type of the data being written /// Offset to write the data into /// Data to be written /// Throw when the memory block has already been disposed /// Throw when the memory region specified for the the data is out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public void Write(ulong offset, T data) where T : unmanaged { GetRef(offset) = data; } /// /// Copies data from one memory location to another. /// /// Destination offset to write the data into /// Source offset to read the data from /// Size of the copy in bytes /// Throw when the memory block has already been disposed /// Throw when , or is out of range public void Copy(ulong dstOffset, ulong srcOffset, ulong size) { const int MaxChunkSize = 1 << 24; for (ulong offset = 0; offset < size; offset += MaxChunkSize) { int copySize = (int)Math.Min(MaxChunkSize, size - offset); Write(dstOffset + offset, GetSpan(srcOffset + offset, copySize)); } } /// /// Fills a region of memory with . /// /// Offset of the region to fill with /// Size in bytes of the region to fill /// Value to use for the fill /// Throw when the memory block has already been disposed /// Throw when either or are out of range public void Fill(ulong offset, ulong size, byte value) { const int MaxChunkSize = 1 << 24; for (ulong subOffset = 0; subOffset < size; subOffset += MaxChunkSize) { int copySize = (int)Math.Min(MaxChunkSize, size - subOffset); GetSpan(offset + subOffset, copySize).Fill(value); } } /// /// Gets a reference of the data at a given memory block region. /// /// Data type /// Offset of the memory region /// A reference to the given memory region data /// Throw when the memory block has already been disposed /// Throw when either or are out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe ref T GetRef(ulong offset) where T : unmanaged { IntPtr ptr = _pointer; ObjectDisposedException.ThrowIf(ptr == IntPtr.Zero, this); int size = Unsafe.SizeOf(); ulong endOffset = offset + (ulong)size; if (endOffset > Size || endOffset < offset) { ThrowInvalidMemoryRegionException(); } return ref Unsafe.AsRef((void*)PtrAddr(ptr, offset)); } /// /// Gets the pointer of a given memory block region. /// /// Start offset of the memory region /// Size in bytes of the region /// The pointer to the memory region /// Throw when the memory block has already been disposed /// Throw when either or are out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public IntPtr GetPointer(ulong offset, ulong size) => GetPointerInternal(offset, size); [MethodImpl(MethodImplOptions.AggressiveInlining)] private IntPtr GetPointerInternal(ulong offset, ulong size) { IntPtr ptr = _pointer; ObjectDisposedException.ThrowIf(ptr == IntPtr.Zero, this); ulong endOffset = offset + size; if (endOffset > Size || endOffset < offset) { ThrowInvalidMemoryRegionException(); } return PtrAddr(ptr, offset); } /// /// Gets the of a given memory block region. /// /// Start offset of the memory region /// Size in bytes of the region /// Span of the memory region /// Throw when the memory block has already been disposed /// Throw when either or are out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe Span GetSpan(ulong offset, int size) { return new Span((void*)GetPointerInternal(offset, (ulong)size), size); } /// /// Gets the of a given memory block region. /// /// Start offset of the memory region /// Size in bytes of the region /// Memory of the memory region /// Throw when the memory block has already been disposed /// Throw when either or are out of range [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe Memory GetMemory(ulong offset, int size) { return new NativeMemoryManager((byte*)GetPointerInternal(offset, (ulong)size), size).Memory; } /// /// Gets a writable region of a given memory block region. /// /// Start offset of the memory region /// Size in bytes of the region /// Writable region of the memory region /// Throw when the memory block has already been disposed /// Throw when either or are out of range public WritableRegion GetWritableRegion(ulong offset, int size) { return new WritableRegion(null, offset, GetMemory(offset, size)); } /// /// Adds a 64-bits offset to a native pointer. /// /// Native pointer /// Offset to add /// Native pointer with the added offset private IntPtr PtrAddr(IntPtr pointer, ulong offset) { return (IntPtr)(pointer.ToInt64() + (long)offset); } /// /// Frees the memory allocated for this memory block. /// /// /// It's an error to use the memory block after disposal. /// public void Dispose() { FreeMemory(); GC.SuppressFinalize(this); } ~MemoryBlock() => FreeMemory(); private void FreeMemory() { IntPtr ptr = Interlocked.Exchange(ref _pointer, IntPtr.Zero); // If pointer is null, the memory was already freed or never allocated. if (ptr != IntPtr.Zero) { if (_usesSharedMemory) { MemoryManagement.UnmapSharedMemory(ptr, Size); } else { MemoryManagement.Free(ptr, Size); } } if (!_isMirror) { IntPtr sharedMemory = Interlocked.Exchange(ref _sharedMemory, IntPtr.Zero); if (sharedMemory != IntPtr.Zero) { MemoryManagement.DestroySharedMemory(sharedMemory); } } } /// /// Checks if the specified memory allocation flags are supported on the current platform. /// /// Flags to be checked /// True if the platform supports all the flags, false otherwise public static bool SupportsFlags(MemoryAllocationFlags flags) { if (flags.HasFlag(MemoryAllocationFlags.ViewCompatible)) { if (OperatingSystem.IsWindows()) { return OperatingSystem.IsWindowsVersionAtLeast(10, 0, 17134); } return OperatingSystem.IsLinux() || OperatingSystem.IsMacOS(); } return true; } public static ulong GetPageSize() { return (ulong)Environment.SystemPageSize; } private static void ThrowInvalidMemoryRegionException() => throw new InvalidMemoryRegionException(); } }