mirror of
https://github.com/Ryujinx/Ryujinx.git
synced 2024-08-20 15:48:43 +02:00
148 lines
6.8 KiB
C#
148 lines
6.8 KiB
C#
using Ryujinx.Memory.Range;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Ryujinx.Memory
|
|
{
|
|
public interface IVirtualMemoryManager
|
|
{
|
|
/// <summary>
|
|
/// Maps a virtual memory range into a physical memory range.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// Addresses and size must be page aligned.
|
|
/// </remarks>
|
|
/// <param name="va">Virtual memory address</param>
|
|
/// <param name="hostAddress">Pointer where the region should be mapped to</param>
|
|
/// <param name="size">Size to be mapped</param>
|
|
void Map(ulong va, nuint hostAddress, ulong size);
|
|
|
|
/// <summary>
|
|
/// Unmaps a previously mapped range of virtual memory.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the range to be unmapped</param>
|
|
/// <param name="size">Size of the range to be unmapped</param>
|
|
void Unmap(ulong va, ulong size);
|
|
|
|
/// <summary>
|
|
/// Reads data from CPU mapped memory.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of the data being read</typeparam>
|
|
/// <param name="va">Virtual address of the data in memory</param>
|
|
/// <returns>The data</returns>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
T Read<T>(ulong va) where T : unmanaged;
|
|
|
|
/// <summary>
|
|
/// Reads data from CPU mapped memory.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the data in memory</param>
|
|
/// <param name="data">Span to store the data being read into</param>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
void Read(ulong va, Span<byte> data);
|
|
|
|
/// <summary>
|
|
/// Writes data to CPU mapped memory.
|
|
/// </summary>
|
|
/// <typeparam name="T">Type of the data being written</typeparam>
|
|
/// <param name="va">Virtual address to write the data into</param>
|
|
/// <param name="value">Data to be written</param>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
void Write<T>(ulong va, T value) where T : unmanaged;
|
|
|
|
/// <summary>
|
|
/// Writes data to CPU mapped memory, with write tracking.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address to write the data into</param>
|
|
/// <param name="data">Data to be written</param>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
void Write(ulong va, ReadOnlySpan<byte> data);
|
|
|
|
void Fill(ulong va, 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);
|
|
|
|
using var writableRegion = GetWritableRegion(va + subOffset, copySize);
|
|
|
|
writableRegion.Memory.Span.Fill(0);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets a read-only span of data from CPU mapped memory.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the data</param>
|
|
/// <param name="size">Size of the data</param>
|
|
/// <param name="tracked">True if read tracking is triggered on the span</param>
|
|
/// <returns>A read-only span of the data</returns>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
ReadOnlySpan<byte> GetSpan(ulong va, int size, bool tracked = false);
|
|
|
|
/// <summary>
|
|
/// Gets a region of memory that can be written to.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the data</param>
|
|
/// <param name="size">Size of the data</param>
|
|
/// <returns>A writable region of memory containing the data</returns>
|
|
/// <exception cref="InvalidMemoryRegionException">Throw for unhandled invalid or unmapped memory accesses</exception>
|
|
WritableRegion GetWritableRegion(ulong va, int size);
|
|
|
|
/// <summary>
|
|
/// Gets a reference for the given type at the specified virtual memory address.
|
|
/// </summary>
|
|
/// <remarks>
|
|
/// The data must be located at a contiguous memory region.
|
|
/// </remarks>
|
|
/// <typeparam name="T">Type of the data to get the reference</typeparam>
|
|
/// <param name="va">Virtual address of the data</param>
|
|
/// <returns>A reference to the data in memory</returns>
|
|
/// <exception cref="MemoryNotContiguousException">Throw if the specified memory region is not contiguous in physical memory</exception>
|
|
ref T GetRef<T>(ulong va) where T : unmanaged;
|
|
|
|
/// <summary>
|
|
/// Gets the physical regions that make up the given virtual address region.
|
|
/// If any part of the virtual region is unmapped, null is returned.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the range</param>
|
|
/// <param name="size">Size of the range</param>
|
|
/// <returns>Array of physical regions</returns>
|
|
IEnumerable<HostMemoryRange> GetPhysicalRegions(ulong va, ulong size);
|
|
|
|
/// <summary>
|
|
/// Checks if the page at a given CPU virtual address is mapped.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address to check</param>
|
|
/// <returns>True if the address is mapped, false otherwise</returns>
|
|
bool IsMapped(ulong va);
|
|
|
|
/// <summary>
|
|
/// Checks if a memory range is mapped.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the range</param>
|
|
/// <param name="size">Size of the range in bytes</param>
|
|
/// <returns>True if the entire range is mapped, false otherwise</returns>
|
|
bool IsRangeMapped(ulong va, ulong size);
|
|
|
|
/// <summary>
|
|
/// Alerts the memory tracking that a given region has been read from or written to.
|
|
/// This should be called before read/write is performed.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address of the region</param>
|
|
/// <param name="size">Size of the region</param>
|
|
/// <param name="write">True if the region was written, false if read</param>
|
|
void SignalMemoryTracking(ulong va, ulong size, bool write);
|
|
|
|
/// <summary>
|
|
/// Reprotect a region of virtual memory for tracking.
|
|
/// </summary>
|
|
/// <param name="va">Virtual address base</param>
|
|
/// <param name="size">Size of the region to protect</param>
|
|
/// <param name="protection">Memory protection to set</param>
|
|
void TrackingReprotect(ulong va, ulong size, MemoryPermission protection);
|
|
}
|
|
}
|